4. OpenGl DrawElements - Polygonen Farben zuweisen.

OpenGl DrawElements - Polygonen Farben zuweisen.

  • C

    Hallo zusammen,

    angenommen, ich habe die Vertices eines Tetrahedrons fertig zum Rendern in einem Puffer stehen so in der Art

    v_buffer = { v0, v1, v2
                 v0, v2, v3
                 v0, v3, v1
                 v1, v3, v2}

    .

    Die Farben stehen auch in für jedes Vertex einem Buffer:

    c_buffer = {r0, g0, b0, a0, r1, g1, b1, a1, r2, g2, b2, a2, r3, g3, b3, a3, }

    Aus den Vertices werden in dieser Reihenfolge 4 GL_TRIANGLEs mittels DrawElements gerendert.
    Ich möchte den 4 Dreiecken jetzt jeweils eine andere Farbe zuweisen. Mit dem o.g. c_buffer erhalte ich aber zwei Dreiecke mit der ersten Farbe r0-a0.

    Wie muß ich den color_buffer zusammensetzen?

    Danke für Eure Hilfe!

    0

  • Was genau ist v_buffer? Sind das deine Indices?

    0
  • C

    Sorry, ja genau, das sind die Indizes des Vertexbuffers.

    0

  • Ok. Und wo genau liegt jetzt das Problem? Dein Color Buffer schaut ganz gut aus würd ich jetzt mal sagen...

    0
  • C

    Hi,

    das Problem ist hier zu sehen: http://i43.tinypic.com/r8xjbn.png
    Von den vier Seiten eines Tetrahedrons werden zwei blau gerendert. Es sollten aber 4 unterschiedliche Farben auf den Seiten zu sehen sein. Liegt das an der Anordnung der Farben im buffer?

    0

  • Schwer zu sagen, dafür haben wir leider viel zu wenig Information...

    0
  • C

    Dann mal los. Das ganze ist OpenGL ES in Java für Android, also jetzt nicht gleich vollkommen durchdrehen.

    Zuerst werden die Vertex-Koordinaten und Farben initialisiert:

    // initialize the vertices of the tetrahedron
m_vertices[0].setPosition(m_side_length/2.0f, m_tetrahedronHeight, -m_triangleBalancePoint, 1);
m_vertices[1].setPosition(0.0f, 0.0f, 0.0f, 1);
m_vertices[2].setPosition(m_side_length, 0.0f, 0.0f, 1);
m_vertices[3].setPosition(m_side_length/2.0f, 0.0f, -m_triangleHeight, 1);

// set vertices colors
m_vertices[0].setColor(1.0f, 0.0f, 0.0f, 0.0f); // red
m_vertices[1].setColor(0.0f, 1.0f, 0.0f, 0.0f); // green
m_vertices[2].setColor(0.0f, 0.0f, 1.0f, 0.0f); // blue
m_vertices[3].setColor(1.0f, 1.0f, 0.0f, 0.0f); // yellow

    DrawElements will das in FloatBuffern haben, also:

    // fill the FloatBuffers with vertex data
ByteBuffer bb = ByteBuffer.allocateDirect(4 * 3 * 4);
bb.order(ByteOrder.nativeOrder());
m_float_buffer = bb.asFloatBuffer();

for(int i=0; i<m_vertices.length; i++) {
	for(int j=0; j<3; j++) {
		m_float_buffer.put(m_vertices[i].getPosition()[j]);
	}			
}

m_float_buffer.position(0);			

// fill the FloatBuffer with color data
ByteBuffer cb = ByteBuffer.allocateDirect(16 * 4 * 4);
cb.order(ByteOrder.nativeOrder());
m_color_buffer = cb.asFloatBuffer();

for(int i=0; i<m_vertices.length;i++) {
	for(int j=0; j<4; j++) {
		m_color_buffer.put(m_vertices[i].getColor()[j]);
	}			
}

m_color_buffer.position(0);

    Jetzt noch den Index-Buffer füllen:

    // initialize indices counterclockwise
m_indices = new short[12];

m_indices[0] = 0;		
m_indices[1] = 1;
m_indices[2] = 2;

m_indices[3] = 0;
m_indices[4] = 2;		
m_indices[5] = 3;

m_indices[6] = 0;		
m_indices[7] = 3;
m_indices[8] = 1;

m_indices[9] = 1;
m_indices[10] = 3;
m_indices[11] = 2;

ByteBuffer ibb = ByteBuffer.allocateDirect(m_indices.length * 2);
ibb.order(ByteOrder.nativeOrder());
m_index_buffer = ibb.asShortBuffer();
m_index_buffer.put(m_indices);
m_index_buffer.position(0);

    Dann der glDrawELements-Aufruf:

    gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);	 

gl.glColorPointer(4, GL10.GL_FLOAT, 0, m_color_buffer);
gl.glVertexPointer(3, GL10.GL_FLOAT, 0, m_float_buffer);
gl.glDrawElements(GL10.GL_TRIANGLES, 12, GL10.GL_UNSIGNED_SHORT, m_index_buffer);

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
gl.glDisableClientState(GL10.GL_COLOR_ARRAY);

    Wie genau funktioniert denn die Zuordnung der Farben zu den vertices?
    Eigentlich müsste ich doch den Vertices eines Dreiecks die gleiche Frabe zuweisen, und das dann für jedes der vier Dreiecke würde 12 Farben im color_buffer bedeuten.

    Wo liegt der Hund begraben?

    0

  • curry-king schrieb:

    Wie genau funktioniert denn die Zuordnung der Farben zu den vertices?

    Genau so wie du sie machst. Das Problem ist, dass du ja willst dass ein ganzes Dreieck die selbe Farbe hat.

    curry-king schrieb:

    Eigentlich müsste ich doch den Vertices eines Dreiecks die gleiche Frabe zuweisen, und das dann für jedes der vier Dreiecke würde 12 Farben im color_buffer bedeuten.

    Exakt. Die Farben gehören aber wie die Position zum Vertex, es sind eben Vertexattribute. Im Allgemeinen willst du also nicht einfach nur mehr Farben, du willst mehr Vertices, wobei einige eben die gleiche Position aber verschiedene Farben haben...

    Im Falle deines Tetraeders könntest du aber einfach Flat Shading verwenden (was du deinen Screenshots nach eh schon tust). Damit wird die Farbe des ganzen Dreiecks vom ersten Vertex bestimmt und du musst nur aufpassen, dass deine Dreiecke mit dem richtigen Vertex beginnen, was sich beim Tetraeder ausgehen sollte wenn ich mich nicht täusche.

    0
Anmelden zum Antworten