OpenGL learning (4) – front & back culling and depth testing
OpenGL Learning (5) – Cropping and Blending
OpenGL Learning (6) – Base textures
OpenGL Learning (7) — Summary of basic change Comprehensive Exercise practice
OpenGL ES Learning (8)
OpenGL learning (nine) — OpenGL ES preliminary exploration (next) GLKit
OpenGL learning (10) – GLSL syntax introduction
OpenGL learning (11) – using GLSL to load pictures
OpenGL learning (12) — OpenGL ES texture flipping strategy comparison
One, foreword
The following I summarized some recent learning OpenGL commonly used in some functions, add more comments, not only to their own learning a consolidated summary, but also to prevent the future forgotten can quickly view the record, at the same time, I hope to help more friends in learning OpenGL.
Xcode has not yet built an OpenGL environment for friends can refer to my article to build OpenGL learning (2) — Xcode built OpenGL environment. There are also some basic OpenGL articles that I summarized earlier, which can be viewed in the table of contents at the top of the article.
Second, code + comments summary
1. Imported header files:
#include"GLTools.h"// OpenGL toolkit#include"GLMatrixStack.h"#include"GLFrame.h"#include"GLFrustum.h"#include"GLBatch.h"#include"GLGeometryTransform.h"#include"StopWatch.h"#include<math.h>#ifdef __APPLE__#include<glut/glut.h>#else#define FREEGLUT_STATIC#include<GL/glut.h>#endifCopy the code
2, some common global variable declaration:
GLShaderManager shaderManager;// Fix the pipeline manager
GLMatrixStack modelViewMatrix;// Model view matrix stack
GLMatrixStack projectionMatrix;// Projection view matrix stack
GLFrame cameraFrame;// Observer position
GLFrame objectFrame;// World coordinates
GLFrustum viewFrustum;// Projection mode, technical name: viewframe. To construct the projection matrix.
GLBatch triangleBatch;// A simple batch container is a simple container class for GLTools.
GLTriangleBatch CC_Triangle;// Triangle batch class
GLTriangleBatch sphereBatch;/ / the ball
GLTriangleBatch torusBatch;/ / ring
GLTriangleBatch cylinderBatch;/ / cylindrical
GLTriangleBatch coneBatch;/ / cone
GLTriangleBatch diskBatch;/ / disk
GLGeometryTransform transformPipeline; // Transform pipe is used to manage projection and model matrix
GLfloat vGreen[] = {0.0 f.1.0 f.0.0 f.1.0 f };// Define a color value, greenCopy the code
3, main function: program entry Settings
intmain(int argc,char *argv[]){
// Set the current working directory for MAC OS X/* 'GLTools' function' glSetWorkingDrectory 'sets the current working directory. In fact, this is not necessary in Windows because the working directory is the same directory as the program executable by default. But on Mac OS X, this program changes the current working folder to the '/Resource' folder in the application bundle. The 'GLUT' priority setting does this automatically, but the method is more secure. * /
gltSetWorkingDirectory(argv[0]);
// Initialize GLUT library. This function simply passes command arguments and initializes GLUT library
glutInit(&argc, argv);
/* Initialize the double buffer window, where GLUT_DOUBLE, GLUT_RGBA, GLUT_DEPTH, GLUT_STENCIL indicate the double buffer window, RGBA color mode, depth test, and template buffer, respectively. Double-cached Windows, where a drawing command is actually executed off-screen from the cache and then quickly converted to a window view, are often used to generate animation effects; --GLUT_DEPTH ': flag allocates a depth cache as part of the display, so we can perform a depth test; GLUT_STENCIL: Make sure we also have a template cache available. Depth and template testing will be covered in more detail */
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);
//GLUT window size, window title
glutInitWindowSize(800.600);
glutCreateWindow("Triangle");
/* GLUT internally runs a local message loop that intercepts the appropriate message. Then call the callback function that we registered at different times. We registered two callback functions: 1) a callback for window resizing and 2) a callback that contains OpenGL rendering */// Register the remodeling function
glutReshapeFunc(changeSize);
// Register the display function
glutDisplayFunc(RenderScene);
glutSpecialFunc(SpeacialKeys);
/* Initialize a GLEW library to ensure that the OpenGL API is fully available to the program. Before attempting to do any rendering, check to make sure there are no problems with driver initialization */
GLenum status = glewInit();
if(GLEW_OK ! = status) {printf("GLEW Error:%s\n",glewGetErrorString(status));
return1;
}
// Set up our render environment
setupRC();
glutMainLoop();
return0;
}
Copy the code
ChangeSize (int w, int h);
Resize function, a callback function set for window resizing to receive new width & height when the window resizes. The glutReshapeFunc function is registered in the main function: glutReshapeFunc(changeSize); // Register the remodeling function
/* Receives new width & height when the window size changes. * /voidchangeSize(int w,int h){
/* 1. Set the window coordinate x,y parameter represents the coordinate of the lower left corner of the view in the window, width and height are represented by pixels, usually x and y are 0 */// Prevent h from going to 0if(h == 0){
h = 1;
}
glViewport(0.0, w, h);
/ / 2,// If you are drawing a solid shape, you also need to set perspective projection// Perspective projection// Parameter 1: Field of view Angle from vertex direction (Angle value)// Parameter 2: aspect ratio of width and height// Parameter 3: fNear// Parameter 4: fFar
viewFrustum.SetPerspective(35.0 f.float(w) / float(h), 1.0 f.500.0 f);
/ / 3.// We just set it up but it doesn't work, we need to convert it to a matrix and take the result back.// load a matrix into the projectionMatrix stack projectionMatrix, and get the projectionMatrix GetProjectionMatrix() from our viewbody viewFrustum
projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
/ / 4.// The model view matrix is used for rotation, translation, etc. There is no change here, so just load a element matrix.// Add a cell matrix to the modelViewMatrix stack
modelViewMatrix.LoadIdentity();
}
Copy the code
5, KeyPressFunc click the space function:
Each time you click on a space, switch the title of the window and re-render the graphics
// Click space to toggle rendering graphicsvoidKeyPressFunc(unsignedchar key, int x, int y){
if(key == 32) {
nStep++;
if(nStep > 4)
nStep = 0;
}
switch(nStep) {
case0:
glutSetWindowTitle("Sphere");
break;
case1:
glutSetWindowTitle("Torus");
break;
case2:
glutSetWindowTitle("Cylinder");
break;
case3:
glutSetWindowTitle("Cone");
break;
case4:
glutSetWindowTitle("Disk");
break;
}
glutPostRedisplay();
}
Copy the code
SpecialKeys function
Click up, down, left, and right on the keyboard to change the world coordinate system (not the object itself)
// Move the world coordinate system up, down, left, and rightvoidSpecialKeys(int key, int x, int y){
if(key == GLUT_KEY_UP)
// Move the world coordinate system instead of moving objects.// Move the world coordinate system to -5.0 in the X direction
objectFrame.RotateWorld(m3dDegToRad(5.0 f), 1.0 f.0.0 f.0.0 f);
if (key == GLUT_KEY_DOWN)
objectFrame.RotateWorld(m3dDegToRad(5.0 f), 1.0 f.0.0 f.0.0 f);
if (key == GLUT_KEY_LEFT)
objectFrame.RotateWorld(m3dDegToRad(5.0 f), 0.0 f.1.0 f.0.0 f);
if (key == GLUT_KEY_RIGHT)
objectFrame.RotateWorld(m3dDegToRad(5.0 f), 0.0 f.1.0 f.0.0 f);
glutPostRedisplay();
}
Copy the code
SetupRC()
Do the necessary initialization to set up our render environment, called in the main function. This is usually used to describe what the shape we want to render looks like. The real time to draw is not here, but in the RenderScene() function, which WE’ll talk about later.
// Place the necessary initialization in the contextvoidSetupRC(a){
// 1. Set the background color
glClearColor(0.7 f.0.7 f.0.7 f.1.0 f );
// 2. Initialize the fixed shader manager
shaderManager.InitializeStockShaders();
// 3. Enable depth testing when drawing stereo graphics
glEnable(GL_DEPTH_TEST);
// Manage matrix stack with GLGeometryTransform// Manage the model view matrix stack and projection matrix stack using transformPipeline.
transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
// 5. For obvious effect, move the observer position Z 15 units to the screen// Parameter: indicates the distance from the screen. Negative numbers are moving behind the screen; Positive, move to the front of the screen
cameraFrame.MoveForward(15.0 f);
/ / -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- GLTriangleBatch type -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -// Use the triangle batch class of type "GLTriangleBatch" to construct the graphics object. The GLTriangleBatch type encapsulates many commonly used stereo graphics./ / 1, the ball/* gltMakeSphere(GLTriangleBatch& sphereBatch, GLfloat fRadius, GLint iSlices, GLint iStacks); Parameter 1: sphereBatch, triangle batch class object parameter 2: fRadius, sphere radius parameter 3: iSlices, the number of triangle strips stacked from the bottom of the sphere to the top; It is suggested that the number of fragments of a sphere with good symmetry is twice the number of stacked fragments, that is, iStacks = 2 * iSlices. Parameter 4 is twice the number of parameter 3. The spheres are drawn around the z-axis so that + Z is the vertex of the sphere and -z is the bottom of the sphere. * /
gltMakeSphere(sphereBatch, 3.0.10.20);
// 2, torus/* gltMakeTorus(GLTriangleBatch& torusBatch, GLfloat majorRadius, GLfloat minorRadius, GLint numMajor, GLint numMinor); Parameter 1: torusBatch, triangle batch class object parameter 2: majorRadius, the radius from the center of the doughnut to the outer edge parameter 3: minorRadius, the radius from the center of the doughnut to the inner edge parameter 4: numMajor, the number of triangles along the main radius parameter 5: NumMinor, the number of triangles along the inner smaller radius */
gltMakeTorus(torusBatch, 3.0 f.0.75 f.15.15);
// 3/* void gltMakeCylinder(GLTriangleBatch& cylinderBatch, GLfloat baseRadius, GLfloat topRadius, GLfloat fLength, GLint numSlices, GLint numStacks); Parameter 1: cylinderBatch, triangle batch class object parameter 2: baseRadius, baseRadius parameter 3: topRadius, head radius parameter 4: fLength, circular length parameter 5: numSlices, number of triangle pairs around the z-axis parameter 6: NumStacks, the number of triangles that stack the bottom of a cylinder into the top ring */
gltMakeCylinder(cylinderBatch, 2.0 f.2.0 f.3.0 f.15.2);
/ / 4, cone/* void gltMakeCylinder(GLTriangleBatch& cylinderBatch, GLfloat baseRadius, GLfloat topRadius, GLfloat fLength, GLint numSlices, GLint numStacks); Parameter 1: cylinderBatch, triangle batch class object parameter 2: baseRadius, baseRadius parameter 3: topRadius, head radius parameter 4: fLength, circular length parameter 5: numSlices, number of triangle pairs around the z-axis parameter 6: NumStacks, the number of triangles that stack the bottom of a cylinder into the top ring */// A cylinder extends from 0 to the positive direction of the Z axis.// The radius of one end is 0, and the radius of the other end can be specified.
gltMakeCylinder(coneBatch, 2.0 f.0.0 f.3.0 f.13.2);
// 5/* void gltMakeDisk(GLTriangleBatch& diskBatch, GLfloat innerRadius, GLfloat outerRadius, GLint nSlices, GLint nStacks); Parameter 1:diskBatch, triangle batch object parameter 2:innerRadius, innerRadius parameter 3:outerRadius, outerRadius parameter 4:nSlices, number of triangle pairs around the Z axis of the disk 5:nStacks, number of triangles from the outer network to the inner circle of the disk */
gltMakeDisk(diskBatch, 1.5 f.3.0 f.13.3);
/ / -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- GLBatch type -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -// When using GLTriangleBatch code above, comment out the following code before running. The two pieces of code were originally separate, but were written together for convenience.// Above is the triangle batch class of type "GLTriangleBatch", below we use the most basic triangle batch class of type "GLBatch" to draw the pyramid.// First create the triangle batch class and tell it how many vertices we need,The function BeginMesh(GLuint nMaxVerts)// specifies how many vertices there are
CC_Triangle.BeginMesh(300);// Specify 300 vertices// 2. Create a vertex
M3DVector3f m[] = {
0.5.0.0.0.0.0.5.0.0.0.0.0.0.0.5.0.0
};
// 3. Copy the vertices to add them// Parameter 1: indicates the vertex coordinate value// parameter 2: indicates the normal coordinate value, NULL if no// Parameter 3: indicates the texture coordinate value, NULL if no
CC_Triangle.AddTriangle(m, NULL.NULL);
//CC_Triangle.CopyVertexData3f
CC_Triangle.End();
CC_Triangle.Draw();
// --------------------------------------------------------------
}
Copy the code
RenderScene() :
The function RenderScene() is called when the glutPostRedisplay() method is called for any change. GlutDisplayFunc (RenderScene) is registered in the main function.
Let me explain the code in detail:
(1) PushMatrix();
modelViewMatrix.PushMatrix(); If the parentheses of PushMatix() are empty, the matrix at the top of the stack is copied and pushed to the top. If it is not empty, such as the element matrix in parentheses, then it means pushing a element matrix to the top of the stack.
The matrix in the modelViewMatrix stack is multiplied by the mOjbectFrame matrix and stored in the modelViewMatrix matrix stack. modelViewMatrix.MultMatrix(mObjectFrame); Copy the top matrix of the modelview matrix stack, multiply it by the new matrix, and assign the result to the top matrix.
(3) PopMatrix();
modelViewMatrix.PopMatrix(); Take the top matrix off the stack and restore it to the original matrix stack so that it does not affect subsequent operations.
Here is a flow chart of “Matrix loading, multiplying, and unloading” summarized by myself:
(4) cameraFrame. GetCameraMatrix (mCamera) :
cameraFrame.GetCameraMatrix(mCamera); This syntax is a little different from OC, which means that the matrix is taken from the observer frame cameraFrame and assigned to mCamera. Objectframe.getmatrix (mObjectFrame); . CameraFrame and mCamera are structures of type GLFrame.
Let’s look at the RenderScene() code:
// Call scenevoidRenderScene(void){
//1. Clear a specific cache or group of caches/* A buffer is a block of storage space containing image information. The red, green, blue, and alpha components are often referenced together as color caches or pixel caches. More than one buffer in OpenGL (color cache, depth cache, and template cache) clears the cache to preset values: GL_COLOR_BUFFER_BIT: indicates the currently active buffer for color writing GL_DEPTH_BUFFER_BIT: indicates the depth buffer GL_STENCIL_BUFFER_BIT: indicates the template buffer */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// Model view matrix stack stack
modelViewMatrix.PushMatrix();
// Get the camera matrix
M3DMatrix44f mCamera;
// Get the matrix from camereaFrame to mCamera
cameraFrame.GetCameraMatrix(mCamera);
// The matrix of the modelview stack is multiplied by the mCamera matrix and stored in the modelViewMatrix matrix stack
modelViewMatrix.MultMatrix(mCamera);
// Create the matrix mObjectFrame
M3DMatrix44f mObjectFrame;
// Get the matrix from ObjectFrame into mOjectFrame
objectFrame.GetMatrix(mObjectFrame);
// Multiply the matrix in the modelViewMatrix stack by the mOjbectFrame matrix and store it in the modelViewMatrix stack
modelViewMatrix.MultMatrix(mObjectFrame);
// Use a flat shader// Parameter 1: type// Parameter 2: Obtain the model view matrix via transformPipeline// Parameter 3: color
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
// Determine which graph you are currently drawing// Note that the address passed here is &sphereBatchswitch(nStep) {
case0:
DrawWireFramedBatch(&sphereBatch);/ / the ballbreak;
case1:
DrawWireFramedBatch(&torusBatch);/ / torusbreak;
case2:
DrawWireFramedBatch(&cylinderBatch);/ / cylindricalbreak;
case3:
DrawWireFramedBatch(&coneBatch);/ / conebreak;
case4:
DrawWireFramedBatch(&diskBatch);/ / diskbreak;
}
// When I'm done drawing, I need to pop out the matrix at the top of the stack
modelViewMatrix.PopMatrix();
// Flush drawing commands
glutSwapBuffers();
}
Copy the code
DrawWireFramedBatch ();
voidDrawWireFramedBatch(GLTriangleBatch* pBatch){
// Flat shader, draw triangle
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGreen);
// The parameters to be passed correspond to different graphs Batch
pBatch->Draw();
// Draw the black outline
glPolygonOffset(1.0 f.1.0 f);
// Enable line segment smoothing
glEnable(GL_LINE_SMOOTH);
// Enable the blending function
glEnable(GL_BLEND);
// Color mix// The source color is multiplied by its alpha value, and the target color is multiplied by 1.0 minus the alpha value of the source color, so that the larger the alpha value of the source color is, the larger the proportion of the source color is, and the smaller the proportion of the target color is. In this case, we can simply interpret the alpha value of the source color as "opacity". This is the most common way to mix.
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Use the program point size mode to set the point size
glEnable(GL_POLYGON_OFFSET_LINE);
// Set the back of the polygon to wireframe mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Line width
glLineWidth(2.5 f);
// Flat shader draws lines
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
pBatch->Draw();
// Restore polygon mode and depth test
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_POLYGON_OFFSET_LINE);
glLineWidth(1.0 f);
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
}
Copy the code
The above summary refers to and partly extracts the following articles, thanks very much to the following authors for sharing! :
1. OpenGL Super Dictionary 5th Edition
2. OpenGL Programming Guide (Eighth Edition)
Reprint please note the original source, shall not be used for commercial communication – any more
