OpenGL 3 und glDrawElements(GL_LINES funktioniert nicht

Java-Forum Spiele- und Multimedia-Programmierung
1

Hallo,
ich möchte die Axen malen…
###Ausgangssituation:

axis1.PNG802×832 13.5 KB

Die Axen werden zwar korrekt gemalt, aber die Farben stimmen nicht, 2x rot, rot und grün, rot und grün.

###Render-Code:

        if (filename.equals("axis")) {
            float[] vertices = new float[]{
                0.f, 0.f, 0.f,
                20.f, 0.f, 0.f,
                0.f, 20.f, 0.f,
                0.f, 0.f, 20.f
            };

            FloatBuffer verticesBuffer = BufferUtils.createFloatBuffer(vertices.length);
            verticesBuffer.put(vertices).flip();
            vbo1 = glGenBuffers();
            glBindBuffer(GL_ARRAY_BUFFER, vbo1);
            glBufferData(GL_ARRAY_BUFFER, verticesBuffer, GL_STATIC_DRAW);
            glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0); // ?

            float[] colors = new float[]{
                1f, 0f, 0f,
                1f, 0f, 0f,
                0f, 1f, 0f,
                0f, 1f, 0f,
                0f, 0f, 1f,
                0f, 0f, 1f};
            FloatBuffer colourBuffer = BufferUtils.createFloatBuffer(colors.length);
            colourBuffer.put(colors).flip();
            vbo2 = glGenBuffers();
            glBindBuffer(GL_ARRAY_BUFFER, vbo2);
            glBufferData(GL_ARRAY_BUFFER, colourBuffer, GL_STATIC_DRAW);
            glVertexAttribPointer(1, 3, GL_FLOAT, false, 0, 0); // ?

            int[] indexes = new int[]{
                0, 1, 0, 2, 0, 3
            };
            IntBuffer indexesBuffer = BufferUtils.createIntBuffer(indexes.length);
            indexesBuffer.put(indexes).flip();
            vbo3 = glGenBuffers();
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo3);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexesBuffer, GL_STATIC_DRAW);

            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glBindVertexArray(0);

            modelLoc = -1;
            viewLoc = glGetUniformLocation(programID, "V");
            projectionLoc = glGetUniformLocation(programID, "P");
            withModel = false;
        }

// ...

            v.get(fb);
            glUniformMatrix4fv(viewLoc, false, fb);
            p.get(fb);
            glUniformMatrix4fv(projectionLoc, false, fb);

            glEnableVertexAttribArray(0);
            glBindBuffer(GL_ARRAY_BUFFER, vbo1);
            glVertexAttribPointer(
                    0, // attribute. No particular reason for 0, but must match the layout in the shader.
                    3, // size ????
                    GL_FLOAT, // type
                    false, // normalized?
                    0, // stride
                    0 // array buffer offset
            );

            glEnableVertexAttribArray(1);
            glBindBuffer(GL_ARRAY_BUFFER, vbo2);
            glVertexAttribPointer(
                    1, // attribute. No particular reason for 0, but must match the layout in the shader.
                    3, // size ????
                    GL_FLOAT, // type
                    false, // normalized?
                    0, // stride
                    0 // array buffer offset
            );

            // Index buffer
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo3);

            glDrawElements(GL_LINES, 2 * 3, GL_UNSIGNED_INT, 0); // ????

            // Disable our location
            glDisableVertexAttribArray(0);
            glBindVertexArray(0);

Stellen, wo ich mir unsicher bin, wegen size usw., hab ich mit ? versehen.

Danke wer mir da einen Tipp gibt
Ich wäre auch für allgemeine Tipps dankbar

2

Das Problem ist gewesen: Jeder Vertex bekommt nur eine Farbe. Was sonst noch im Color Buffer Object steht, wird ignoriert.
Deswegen musste folgendes geändert werden:

            float[] vertices = new float[]{
                0.f, 0.f, 0.f,
                20.f, 0.f, 0.f,
                0.f, 0.f, 0.f,
                0.f, 20.f, 0.f,
                0.f, 0.f, 0.f,
                0.f, 0.f, 20.f
            };

            float[] colors = new float[]{
                1f, 0f, 0f,
                1f, 0f, 0f,
                0f, 1f, 0f,
                0f, 1f, 0f,
                0f, 0f, 1f,
                0f, 0f, 1f};

            int[] indexes = new int[]{
                0, 1, 2, 3, 4, 5
            };

Ich finde das nicht so toll, aber gut.

Ein zweites Problem, was ich hätte, ich möchte das Dreieck um 360/3 Grad auf eine Seite kippen, allerdings wird es um den Was ist ein Umkreismittelpunkt? gezeichnet, und nicht durch den Schwerpunkt:

            float[] vertices = new float[]{
                +0.0f, +5.0f, +0.0f, // Top coordinate
                -5.0f, -5.0f, +0.0f, // Bottom-left coordinate
                +5.0f, -5.0f + 0.0f // Bottom-right coordinate
            };

Meine Frage wäre jetzt, wie man ein Dreieck um den Schwerpunkt zeichnet, damit es um 360/3 Grad gekippt werden kann, und auf einer Seite liegt.

#*push*
Wie bestimmt man die Koordinaten eines gleichseitigen Dreiecks mit der Seitenlänge a=10, dessen Schwerpunkt im Ursprung liegt?
Vielleicht Brett vor dem Kopf, aber mir fällt es absolut nicht ein. :frowning: