EGL(Embedded Graphics Library)

• Required by the OpenGL ES commandRender contextandDrawing on the surface ofTo complete the graphics image drawing
• Render context: Stores the relevant OpenGL ES state and is a state machine
• Draw surface: The surface used to draw primions. You need to specify the cache area for rendering, such as color buffer, depth, and template
• The OpenGL ES API does not provide information on how to create a rendering context or how a context is connected to a native windowed system. EGL is the interface between Khronos rendering apis (such as OpenGL ES) and the native window system.The only platform that supports OpenGL ES but does not support EGL is iOS. Apple provides its own iOS implementation of the EGL API, called EAGL
• Because each window-system has a different definition, EGL provides a basic opaque type, EGLDisplay, which encapsulates all system dependencies and is used to interface with native window-systems

The main function

• Talk to native Windowing systems
• Query available configurations
• Create “Drawing surfaces” available in OpenGL ES
• Synchronize rendering between different classes of apis, such as between OpenGL ES and OpenVG, or between OpenGL and local window drawing commands
• Manage “Rendering resources”, such as Rendering map.

GLSL language

• GLSL compilation and concatenation of vertex/slice shaders is not supported in Xcode, so you need to create two empty files in your project namedshader.vshandshaderv.fsh
  • useVSH, FSHThe reason for the suffix is to distinguish between shaders, which is essentially a string
  • Can I just use NSString? This is not recommended because the code structure is not clear and easy to read
  • Can Chinese annotations be added to these two files? It is not recommended to add Chinese annotations, which will lead to strange errors. Since GLSL is written in Xcode, it is completely handwritten without any hint, so it is not easy to troubleshoot problems

Here is a summary of some of the types and apis

Vector data type

Vec2, VEC3, and VEC4 are commonly used, and the default is floating point

Matrix data type

The most common ones are MAT3 and MAT4

Variables store qualifiers

Varying, attribute, and Uniform are commonly used

• Varying modifier: When data from the vertex shader is passed to the chip shader, it is required to modify the identical texture coordinate variables of the two shaders
• Attribute: Data can only be passed from the client to the vertex shader and can only be used in the vertex shader
  • Modified data: vertices, textures, colors, normals, etc
  • API normally withglVertex...Beginning, for exampleglVertexAttribPointer
  • The texture coordinates need to be passed indirectly to the slice shader by the vertex shader. The texture coordinates need to be defined exactly the same in the vertex and slice shader. The texture coordinate data is passed indirectly to the slice shader through this variable.varying lowp vec2 varyTextCoord;
  • The vertex results computed by the vertex shader need to be assigned to GLSL’s built-in variablesgl_Position

attribute vec4 position;
attribute vec2 textCoordinate;
varying lowp vec2 varyTextCoord;

void main()
{
    varyTextCoord = textCoordinate;
    gl_Position = position;
}

Copy the code

• Uniform: Variables passed from APP code to vertex, fragment
  • Uniform is a constant in Vertex, fragment
  • Uniform Passable data: view matrix, projection matrix, projection view matrix
  • API normally withglUniform...At the beginning
  • The final color in the pixel shader, that is, the grain elements corresponding to the texture coordinates. The stripper is the color value of the texture’s corresponding pixels, which needs to be used by the built-in functionTexture2D (Texture, texture coordinates)Calculates and assigns the final returned color value to the built-in variablegl_FragColor

Precsion highp float; // The texture coordinates must be exactly the same as those in the vertex shader. // Texture Uniform sampler2D colorMap; Void main(){//1. Lowp vec4 temp = texture2D(colorMap, varyTextCoord); //2, very important and necessary built-in variable: gl_FragColor gl_FragColor = temp; }Copy the code

OpenGL ES error handling

If the OpenGL ES command is used incorrectly, the application generates an error code, which is logged, and can be queried with glGetError. Once the error code is queried, the current error code is reset to GL_NO_ERROR

OpenGL ES common API for custom shaders

Custom shaders

Custom shaders generally have the following steps:

• Create vertex shader/slice shaderglCreateShader
• Specify shader’s source —glShaderSource
• Compile the shader,glCompileShader

Here are the apis for creating and compiling a shader

Custom program

A custom program generally has the following steps:

• Create a program objectglCreateProgram
• Shader attached to program —glAttachShader
• Link program —glLinkProgram
• Use program —glUseProgram

Here are the apis for creating linked programs

Shader and program compiler & link

• You need to create two basic objects to infect with a shader: a shader object and a program object
• The general compilation & linking of the shader object after obtaining the link is divided into 6 steps:
  • Create a vertex shader object and a slice shader object
  • Link the source code to each shader object
  • Compile the shader object
  • Create a program object
  • Connects the compiled shader object to the program object
  • Linker object