Hoe teken je een lijn in OpenGl?

Ik wil een lijn tekenen in opengl.

glBegin(GL_LINES);
    glVertex2f(.25,0.25);
    glVertex2f(.75,.75);
glEnd();

deze code tekent een lijn, maar als ik een lijn wil trekken van coördinaat(10,10) naar coördinaat(20,20), wat moet ik dan doen?

wat het betekent (.25,.25) en (.75, .75) ?


Antwoord 1, autoriteit 100%

(.25, .25) en (.75,.75) zijn het begin- en eindpunt van de lijn.

Een lijn trekken van (10,10) naar (20,20):

glBegin(GL_LINES);
    glVertex2f(10, 10);
    glVertex2f(20, 20);
glEnd();

Antwoord 2, autoriteit 43%

Met OpenGL2:

Elke puntwaarde in glVertex2fligt tussen -1 en 1, linksonder is (-1, -1), rechtsboven is (1,1) en het midden is (0, 0).

Een absoluut punt toewijzen aan een genormaliseerde ruimte:

  • Verdeel xdoor de vensterbreedte, w, om het punt in het bereik van 0 tot 1 te krijgen.

  • Vermenigvuldig het met 2 om het bereik van 0 tot 2 te krijgen.

  • Trek 1 af om het gewenste bereik van -1 tot 1 te krijgen.

  • Herhaal voor ywaarde en vensterhoogte ,h.

Bijvoorbeeld:

double x1 = 10;
double y1 = 10;
double x2 = 20;
double y2 = 20;
x1 = 2*x1 / w - 1;
y1 = 2*y1 / h - 1;
x2 = 2*x2 / w - 1;
y2 = 2*y2 / h - 1;
glBegin(GL_LINES);
    glVertex2f(x1, y1);
    glVertex2f(x2, y2);
glEnd();

Met OpenGL3+ :
Het gebruik van de programmeerbare pijplijn om een lijn te trekken is iets ingewikkelder. U kunt een klasse Linemaken die twee punten neemt en deze naar de GPU stuurt, en ze tekent met een eenvoudig shader-programma. Alle instellingen kunnen in de constructor worden gedaan en kunnen worden gewijzigd met een paar toegangsfuncties:

class Line {
    int shaderProgram;
    unsigned int VBO, VAO;
    vector<float> vertices;
    vec3 startPoint;
    vec3 endPoint;
    mat4 MVP;
    vec3 lineColor;
public:
    Line(vec3 start, vec3 end) {
        startPoint = start;
        endPoint = end;
        lineColor = vec3(1,1,1);
        const char *vertexShaderSource = "#version 330 core\n"
            "layout (location = 0) in vec3 aPos;\n"
            "uniform mat4 MVP;\n"
            "void main()\n"
            "{\n"
            "   gl_Position = MVP * vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
            "}\0";
        const char *fragmentShaderSource = "#version 330 core\n"
            "out vec4 FragColor;\n"
            "uniform vec3 color;\n"
            "void main()\n"
            "{\n"
            "   FragColor = vec4(color, 1.0f);\n"
            "}\n\0";
        // vertex shader
        int vertexShader = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
        glCompileShader(vertexShader);
        // check for shader compile errors
        // fragment shader
        int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
        glCompileShader(fragmentShader);
        // check for shader compile errors
        // link shaders
        shaderProgram = glCreateProgram();
        glAttachShader(shaderProgram, vertexShader);
        glAttachShader(shaderProgram, fragmentShader);
        glLinkProgram(shaderProgram);
        // check for linking errors
        glDeleteShader(vertexShader);
        glDeleteShader(fragmentShader);
        vertices = {
             start.x, start.y, start.z,
             end.x, end.y, end.z,
        };
        glGenVertexArrays(1, &VAO);
        glGenBuffers(1, &VBO);
        glBindVertexArray(VAO);
        glBindBuffer(GL_ARRAY_BUFFER, VBO);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0); 
        glBindVertexArray(0); 
    }
    int setMVP(mat4 mvp) {
        MVP = mvp;
    }
    int setColor(vec3 color) {
        lineColor = color;
    }
    int draw() {
        glUseProgram(shaderProgram);
        glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "MVP"), 1, GL_FALSE, &MVP[0][0]);
        glUniform3fv(glGetUniformLocation(shaderProgram, "color"), 1, &lineColor[0]);
        glBindVertexArray(VAO);
        glDrawArrays(GL_LINES, 0, 2);
        return 0;
    }
    ~Line() {
        glDeleteVertexArrays(1, &VAO);
        glDeleteBuffers(1, &VBO);
        glDeleteProgram(shaderProgram);
    }
};

Sommige 3D-lijnen initialiseren met Line line(vec3 ..., vec3 ...), de model-view-projection matrix instellen line.setMVP(projection * view * model)en line.draw()en het draaien van de camera zal zoiets als dit produceren:

Voorbeeldcode

Opmerking:Als u alleen 2D-lijnen nodig hebt, hoeft u alleen de vec3-eindpuntcoördinaten op te geven met de z-waarde ingesteld op 0, en de projectiematrix te verwijderen uit de setMVPbellen en camerapositie instellen op (0,0,0). Hetzelfde geldt voor het tekenen van 2D-lijnen zoals hierboven uitgelegd voor OpenGL2, dus coördinaten moeten naar OpenGL worden verzonden in de NDC-ruimte.

Other episodes