OpenGL drawing simple triangles

OpenGL Draw simple triangles

I was busy a while ago , I went to study something else , I just remembered recently , About OpenGL The practical application of has not been written , Make it up now .

Get ready

Whatever stay Android Environmental use OpenGL, First you need a GLSurfaceView example . The next step is roughly divided into two steps ：

• Set up OpenGL Version number , Usually use 2.0 Best compatibility , The specific version is different from Baidu .

  glSurfaceView.setEGLContextClientVersion(2);

• Set up Renderer.

  • seeing the name of a thing one thinks of its function Renderer For the renderer , Its essence is an interface , There are three methods, namely onSurfaceCreated、onSurfaceChanged and onDrawFrame. be-all OpenGL The relevant operations of rendering and display need to be carried out in these methods , That is, the main body of the whole rendering process .
  • Rendering is divided into two modes according to the refresh logic , adopt glSurfaceView.setRenderMode() Set up , Namely RENDERMODE_WHEN_DIRTY and RENDERMODE_CONTINUOUSLY. The former is a reminder refresh , The latter is constantly refreshed , It's easy to understand , Simply speaking OpenGL Rendering is done by constantly calling onDrawFrame Method to refresh , When it comes to RENDERMODE_WHEN_DIRTY Mode requires manual invocation glSurfaceView.requestRender() The next refresh will be performed when , And the other one will constantly refresh automatically . Considering performance , Usually choose the first refresh method .

draw

Here, according to Renderer Three methods of interface , Divide the drawing into three steps .

onSurfaceCreated

The method will be in OpenGL Called after preparation , Will only be called once , Therefore, the parameters required for drawing need to be initialized here . take OpenGL The rendering of is compared to painting ,onSurfaceCreated Prepare paper for painting , Next, you need to trace the image at a fixed point , Then prepare the color of the painting .

• Fixed point stroke

  Any figure is made of The vertices Connected by , stay OpenGL It's the same in China , First, you need to determine the position of the vertex , Because its coordinate axis is Cartesian coordinate and extremum by 1, Therefore, the floating-point type float For storage .

  float triangleVertex[] = {
            0f, 0.5f, 0.0f, // top
            -0.5f, -0.25f, 0.0f, // bottom left
            0.5f, -0.25f, 0.0f  // bottom right };

  After the coordinates are determined , In order to be able to transmit to OpenGL Use , It needs to be installed and replaced with something recognizable at the bottom Buffer object .

                // To apply for space   Because a float Occupy 4 Bytes 
                ByteBuffer bb = ByteBuffer.allocateDirect(triangleVertex.length * 4);
                // Convert data types recognized by local memory 
                bb.order(ByteOrder.nativeOrder());
                // Convert coordinate data to FloatBuffer, To pass in to OpenGL
                mVertexBuffer = bb.asFloatBuffer();
                mVertexBuffer.put(triangleVertex);
                mVertexBuffer.position(0);

• Prepare paint

  When the outline has been determined , The next step is to color and fill it , We're going to introduce Shaders . Those who don't understand the colorimeter can go to see it OpenGL Or read my previous blog posts . Shaders are divided into Vertex shader and Chip shader , After writing the Shader Language, create and get the corresponding shader handle .

    public static int uLoadShader(int shaderType, String source) {
        // Distribute Shader Handle 
        int shader = GLES20.glCreateShader(shaderType);
        if (0 != shader) {
            // by Shader Binding source code 
            GLES20.glShaderSource(shader, source);
            // compile 
            GLES20.glCompileShader(shader);
            int[] compiled = new int[1];
            // get Shader The compilation of 
            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
            if (compiled[0] == 0) {
                glError(1, "Could not compile shader:" + shaderType);
                glError(1, "GLES20 Error:" + GLES20.glGetShaderInfoLog(shader));
                GLES20.glDeleteShader(shader);
                shader = 0;
            }
        }
        return shader;
    }
    // establish Shader
    int vertexShader = uLoadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
    int fragmentShader = uLoadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

  Finally, create an empty Program object , And set the shader to the object .

    // Create an empty Program
    mProgram = GLES20.glCreateProgram();
    // Set shader to program 
    GLES20.glAttachShader(mProgram, vertexShader);
    GLES20.glAttachShader(mProgram, fragmentShader);
    // Connect to the program 
    GLES20.glLinkProgram(mProgram);

onSurfaceChanged

This method is relatively simple , It will be called when the screen size changes , It is usually used to update and set the display size .

      public void onSurfaceChanged(GL10 gl10, int width, int height) {
      // Set view size 
      GLES20.glViewport(0, 0, width, height);
      }

onDrawFrame

similar View Of onDraw Method , The specific drawing is carried out here . Because this method is responsible for refreshing the dynamic graph , So the first step is usually to Clear the screen , Erase the last painting , And then use onSurfaceCreated Prepare parameters for specific painting .

        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
        // Add the program to OpenGLES2.0 Environmental Science 
        GLES20.glUseProgram(mProgram);

        // Get the vPosition Member handle 
        int mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
        // Get the vColor Handle to member 
        int mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");

        // Enable handle to triangle vertices 
        GLES20.glEnableVertexAttribArray(mPositionHandle);
        // Prepare coordinate data of triangle 
        GLES20.glVertexAttribPointer(mPositionHandle, COORS_PER_VERTEX,
        GLES20.GL_FLOAT, false,
        vertexStride, mVertexBuffer);

        // Set the color of the triangle 
        GLES20.glUniform4fv(mColorHandle, 1, color, 0);
        // Draw triangle 
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
        // Prohibit handles to vertex arrays 
        GLES20.glDisableVertexAttribArray(mPositionHandle);

I have written the notes in great detail , Some people here may not understand that since shaders are already pigments , Then why is there a step to set paint in the code . That's because shaders are actually similar C Programming language , It also has its own constants and variables , The color set here is actually a color variable defined in our Shader Language . If you are interested, you can read what I wrote GLSL Related articles . Here are the specific shader languages ：

    private String vertexShaderCode =
            "attribute vec4 vPosition;" +
                    "void main() {" +
                    " gl_Position = vPosition;" +
                    "}";

    private String fragmentShaderCode =
            "precision mediump float;" +
                    "uniform vec4 vColor;" +
                    "void main() {" +
                    " gl_FragColor = vColor;" +
                    "}";

private String vertexShaderCode =
        "attribute vec4 vPosition;" +
                "void main() {" +
                " gl_Position = vPosition;" +
                "}";

private String fragmentShaderCode =
        "precision mediump float;" +
                "uniform vec4 vColor;" +
                "void main() {" +
                " gl_FragColor = vColor;" +
                "}";

Conclusion

The above is the specific process of drawing a simple graph , All of them are analyzed and elaborated according to my personal experience , If there is something wrong, please give me some advice .