OpenGL顶点数组归一化方法及三角形绘制坐标转换问题

Let’s tackle your OpenGL triangle and vertex normalization issues step by step—this is a common gotcha when moving from custom coordinates to normalized device coordinates (NDC), so let’s break it down clearly.

First: What Are Normalized Device Coordinates (NDC)? #

OpenGL expects vertices in NDC for final rendering. This coordinate space ranges from (-1, -1) (bottom-left corner of the window) to (1, 1) (top-right). Any vertex outside this range gets clipped and won’t appear on screen. Critical note: the Y-axis here points upward, which is opposite to typical window pixel coordinates where Y increases downward.

Step 1: Convert Custom Vertex Coordinates to NDC #

Assuming your input vertices are in window pixel coordinates (X from 0 to window width, Y from 0 to window height), use this formula for each (X,Y) pair:

ndc_x = (2.0 * pixel_x) / window_width - 1.0;
ndc_y = 1.0 - (2.0 * pixel_y) / window_height;

The 1.0 - ... flips the Y-axis to match OpenGL’s upward-pointing NDC space.

Step 2: Normalize an Entire Vertex Array #

Here’s a practical example of a function to process a full array of vertices (using C++ and GLM for vector math—adapt to your language as needed):

#include <vector>
#include <glm/vec2.hpp>

void normalizeToNDC(std::vector<glm::vec2>& vertices, int windowWidth, int windowHeight) {
    for (auto& vertex : vertices) {
        // Convert X coordinate to NDC range
        vertex.x = (2.0f * vertex.x) / windowWidth - 1.0f;
        // Convert Y coordinate (flip axis to match OpenGL's orientation)
        vertex.y = 1.0f - (2.0f * vertex.y) / windowHeight;
    }
}

If you’re using raw float arrays instead of GLM vectors, the logic is identical—loop through each (X,Y) pair and apply the formula.

Fixing Your Red Vertex Conversion Issue #

If your red vertex is distorted or missing, these are the most likely culprits:

• Forgot the Y-axis flip: Without inverting the Y coordinate, your vertex will be mirrored vertically or even fall outside the NDC range entirely.
• Out-of-range coordinates: Print your converted NDC values—if any X/Y is outside [-1, 1], OpenGL will clip that vertex, breaking the triangle.
• Incorrect projection matrix:
  • For modern OpenGL (core profile): Ensure your vertex shader isn’t applying an unintended perspective projection. For direct NDC rendering, pass the vertex position directly (with Z=0, W=1):

    #version 330 core
    layout (location = 0) in vec2 aPos;
    
    void main() {
        gl_Position = vec4(aPos, 0.0, 1.0);
    }
    

  • For legacy fixed-function OpenGL: Verify you’ve set an identity projection matrix with glMatrixMode(GL_PROJECTION); glLoadIdentity();—a stray perspective matrix will warp your NDC vertices.
• Z-coordinate oversight: OpenGL’s NDC includes a Z-axis (range [-1, 1]). If your vertex has a Z value outside this range (or you’re using a perspective projection with a near clip plane >0 and your Z is 0), it will get clipped.

Quick Working Example #

Say you have an 800x600 window, and your three vertices are (400, 500), (200, 100), (600, 100) (window pixels):

1. Run them through the normalization function:
   • (400,500) → (0.0, -0.666...)
   • (200,100) → (-0.5, 0.666...)
   • (600,100) → (0.5, 0.666...)
2. Pass these NDC values to your shader, and you’ll get a triangle centered in the upper half of your window.

内容的提问来源于stack exchange，提问作者Ruks