OpenGL ES课程II之创建多边形(原文对照)

www.myexceptions.net  网友分享于：2013-07-03  浏览：12次
OpenGL ES教程II之创建多边形(原文对照)

OpenGL ES Tutorial for Android – Part II – Building a polygon

December 4th, 2009 by Per-Erik BergmanAndroid, Embedded

Previous tutorial was all about setting up the GLSurfaceView. Be sure to read it beacuse it's a really importent one to be able to continue.

Building a polygon

In this tutorial we will render our first polygon.

3D models are built up with smaller elements (vertices, edges, faces, and polygons) which can be manipulated individually.

3D模型是由一组可独立操纵的更小元素（点，线，面及多边形）组成。

Vertex

A vertex (vertices in plural) is the smallest building block of 3D model. A vertex is a point where two or more edges meet. In a 3D model a vertex can be shared between all connected edges, paces and polygons. A vertex can also be a represent for the position of a camera or a light source. You can see a vertex in the image below marked in yellow.

 To define the vertices on android we define them as a float array that we put into a byte buffer to gain better performance. Look at the image to the right and the code below to match the vertices marked on the image to the code. 在android上，使用一个浮点数组来定义顶点，为提高性能，将它放入一个字节缓冲中（java5新特性，NIO）。右图中标记了四个顶点，下面的代码是对它们的定义。

private float vertices[] = {

-1.0f,  1.0f, 0.0f,  // 0, Top Left

-1.0f, -1.0f, 0.0f,  // 1, Bottom Left

1.0f, -1.0f, 0.0f,  // 2, Bottom Right

1.0f,  1.0f, 0.0f,  // 3, Top Right

};

// a float is 4 bytes, therefore we multiply the number if vertices with 4.一个浮点占用4个字节，所以字节缓冲的大小为x4（字节）

ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);

vbb.order(ByteOrder.nativeOrder());

FloatBuffer vertexBuffer = vbb.asFloatBuffer();

vertexBuffer.put(vertices);

vertexBuffer.position(0);

Don't forget that a float is 4 bytes and to multiply it with the number of vertices to get the right size on the allocated buffer.

OpenGL ES have a pipeline with functions to apply when you tell it to render. Most of these functions are not enabled by default so you have to remember to turn the ones you like to use on. You might also need to tell these functions what to work with. So in the case of our vertices we need to tell OpenGL ES that it’s okay to work with the vertex buffer we created we also need to tell where it is.

OpenGL Es管道可以理解为拥有一组开关控制功能的函数，而且许多控制函数默认是不开启的，如果你需要某项功能，请记得先告诉先打开这些功能。在某些情况下，你可能还需要指出这些函数的用途。以上面定义的顶点为例，我们需要告诉OpenGL ES启用顶点缓冲，并且设置顶点缓冲。

// Enabled the vertex buffer for writing and to be used during rendering.启用顶点缓冲

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);// OpenGL docs.

// Specifies the location and data format of an array of vertex

// coordinates to use when rendering.指定顶点位置

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer); // OpenGL docs.

When you are done with the buffer don't forget to disable it.

// Disable the vertices buffer.

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);// OpenGL docs.

Edge

Edge is a line between two vertices. They are border lines of faces and polygons. In a 3D model an edge can be shared between two adjacent faces or polygons. Transforming an edge affects all connected vertices, faces and polygons. In OpenGL ES you don't define the edges, you rather define the face by giving them the vertices that would build up the three edges. If you would like modify an edge you change the two vertices that makes the edge. You can see an edge in the image below marked in yellow.

Face

Face is a triangle. Face is a surface between three corner vertices and three surrounding edges. Transforming a face affects all connected vertices, edges and polygons.

The order does matter.

When winding up the faces it's important to do it in the right direction because the direction defines what side will be the front face and what side will be the back face. Why this is important is because to gain performance we don't want to draw both sides so we turn off the back face. So it's a good idea to use the same winding all over your project. It is possible to change what direction that defines the front face with glFrontFace.

gl.glFrontFace(GL10.GL_CCW); // OpenGL docs

To make OpenGL skip the faces that are turned into the screen you can use something called back-face culling. What is does is determines whether a polygon of a graphical object is visible by checking if the face is wind up in the right order.

gl.glEnable(GL10.GL_CULL_FACE); // OpenGL docs

It's ofcource possible to change what face side should be drawn or not.

gl.glCullFace(GL10.GL_BACK); // OpenGL docs

Polygon

 Time to wind the faces, remember we have decided to go with the default winding meaning counter-clockwise. Look at the image to the right and the code below to see how to wind up this square. 请看右边的图，我们使用下面的代码来定义顶点顺序数组以构造图中的面（默认方面是逆时针） wind该如何翻译？

private short[] indices = { 0, 1, 2, 0, 2, 3 };

To gain some performance we also put this ones in a byte buffer.

// short is 2 bytes, therefore we multiply the number if vertices with 2.字节缓冲长度为数组大小x2.（一个short占用2字节）

ByteBuffer ibb = ByteBuffer.allocateDirect(indices.length * 2);

ibb.order(ByteOrder.nativeOrder());

ShortBuffer indexBuffer = ibb.asShortBuffer();

indexBuffer.put(indices);

indexBuffer.position(0);

Don't forget that a short is 2 bytes and to multiply it with the number of indices to get the right size on the allocated buffer.

Render

Time to get something on the screen, there is two functions used to draw and we have to decide which one to use.

The two functions are:

public abstract void glDrawArrays(int mode, int first, int count) // OpenGL docs

glDrawArrays draws the vertices in that order they are specified in the construction of our verticesBuffer.

glDrawArrays按照构造verticesBuffer指定的顺序来画

public abstract void glDrawElements(int mode, int count, int type, // OpenGL docs

Buffer indices)

glDrawElements need a little bit more to be able to draw. It needs to know the order which to draw the vertices, it needs the indicesBuffer.

glDrawElements可能用得更多，它需要知道绘画顶点的顺序，所以需要顶点顺序数组。

Since we already created the indicesBuffer I'm guessing that you figured out that's the way we are going.

What is common for this functions is that they both need to know what it is they should draw, what primitives to render. Since there is some various ways to render this indices and some of them are good to know about for debugging reasons. I'll go through them all.

What primitives to render

GL_POINTS

Draws individual points on the screen.

GL_LINE_STRIP

Series of connected line segments.画线

GL_LINE_LOOP

Same as above, with a segment added between last and first vertices.画线，与上面不同的时，多画了一条由首尾顶点的连线。

GL_LINES

Pairs of vertices interpreted as individual line segments.画由两个顶点对组成的线

GL_TRIANGLES

Triples of vertices interpreted as triangles.画三角形

GL_TRIANGLE_STRIP

Draws a series of triangles (three-sided polygons) using vertices v0, v1, v2, then v2, v1, v3 (note the order), then v2, v3, v4, and so on. The ordering is to ensure that the triangles are all drawn with the same orientation so that the strip can correctly form part of a surface.画一系列三角形，先v0,v1,v2,v2,v1,v3（注意顺序），再v2,v3,v4依此类推下去。顺序是为了确保三角形在同一个方向上绘画，使得可以正确的形成一个平面的一部分。

GL_TRIANGLE_FAN

Same as GL_TRIANGLE_STRIP, except that the vertices are drawn v0, v1, v2, then v0, v2, v3, then v0, v3, v4, and so on.

I think the GL_TRIANGLES is the easiest to use so we go with that one for now.

Putting it all togetter

So let's putting our square together in a class.

package se.jayway.opengl.tutorial;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.nio.ShortBuffer;

import javax.microedition.khronos.opengles.GL10;

public class Square {

// Our vertices.

private float vertices[] = {

-1.0f,  1.0f, 0.0f,  // 0, Top Left

-1.0f, -1.0f, 0.0f,  // 1, Bottom Left

1.0f, -1.0f, 0.0f,  // 2, Bottom Right

1.0f,  1.0f, 0.0f,  // 3, Top Right

};

// The order we like to connect them.

private short[] indices = { 0, 1, 2, 0, 2, 3 };

// Our vertex buffer.

private FloatBuffer vertexBuffer;

// Our index buffer.

private ShortBuffer indexBuffer;

public Square() {

// a float is 4 bytes, therefore we multiply the number if

// vertices with 4.

ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);

vbb.order(ByteOrder.nativeOrder());

vertexBuffer = vbb.asFloatBuffer();

vertexBuffer.put(vertices);

vertexBuffer.position(0);

// short is 2 bytes, therefore we multiply the number if

// vertices with 2.

ByteBuffer ibb = ByteBuffer.allocateDirect(indices.length * 2);

ibb.order(ByteOrder.nativeOrder());

indexBuffer = ibb.asShortBuffer();

indexBuffer.put(indices);

indexBuffer.position(0);

}

/**

* This function draws our square on screen.

* @param gl

*/

public void draw(GL10 gl) {

// Counter-clockwise winding.

gl.glFrontFace(GL10.GL_CCW); // OpenGL docs

// Enable face culling.

gl.glEnable(GL10.GL_CULL_FACE); // OpenGL docs

// What faces to remove with the face culling.

gl.glCullFace(GL10.GL_BACK); // OpenGL docs

// Enabled the vertices buffer for writing and to be used during

// rendering.

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);// OpenGL docs.

// Specifies the location and data format of an array of vertex

// coordinates to use when rendering.

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, // OpenGL docs

vertexBuffer);

gl.glDrawElements(GL10.GL_TRIANGLES, indices.length,// OpenGL docs

GL10.GL_UNSIGNED_SHORT, indexBuffer);

// Disable the vertices buffer.

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); // OpenGL docs

// Disable face culling.

gl.glDisable(GL10.GL_CULL_FACE); // OpenGL docs

}

}

We have to initialize our square in the OpenGLRenderer class.

// Initialize our square.

Square square = new Square();

And in the draw function call on the square to draw.

public void onDrawFrame(GL10 gl) {

// Clears the screen and depth buffer.

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | // OpenGL docs.

GL10.GL_DEPTH_BUFFER_BIT);

// Draw our square.

square.draw(gl); // ( NEW )

}

If you run the application now the screen is still black. Why? Because OpenGL ES render from where the current position is, that by default is at point: 0, 0, 0 the same position that the view port is located. And OpenGL ES don’t render the things that are too close to the view port. The solution to this is to move the draw position a few steps into the screen before rendering the square:

// Translates 4 units into the screen.

gl.glTranslatef(0, 0, -4); // OpenGL docs

I will talk about the different transformations in the next tutorial.

Run the application again and you will see that the square is drawn but quickly moves further and further into the screen. OpenGL ES doesn’t reset the drawing point between the frames that you will have to do yourself:

// Replace the current matrix with the identity matrix

Now if you run the application you will see the square on a fixed position.

References

The info used in this tutorial is collected from:
Android Developers

OpenGL ES 1.1 Reference Pages

You can also checkout the code from:

Previous tutorial: OpenGL ES Tutorial for Android – Part I – Setting up the view
Next tutorial:
OpenGL ES Tutorial for Android – Part III – Transformations

Per-Erik Bergman
Consultant at
Jayway