opengl将画面渲染到屏幕的指定区域和多屏渲染

最新推荐文章于 2021-12-29 14:02:24 发布
最新推荐文章于 2021-12-29 14:02:24 发布
阅读量6.1k 收藏 9
点赞数
分类专栏： 3D效果bloom

分别将画面渲染到屏幕的左上，坐下，右上，右下区域   效果图：




多屏渲染效果图：


原理见代码注释


[cpp]  view plain  copy
  1. #include "FullScreenQuad.h"  
  2.   
  3.   
  4. void FullScreenQuad::Init()  
  5. {  
  6.     glGenBuffers(1, &mVBO);  
  7.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  8.     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 20, nullptr, GL_STATIC_DRAW);  
  9.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  10. }  
  11.   
  12. //绘制一个铺满屏幕的四边形  
  13. void FullScreenQuad::Draw(GLint posLoc, GLint texcoordLoc)  
  14. {  
  15.     //draw fullscreen  
  16.     float vertices[] = {  
  17.         -0.5f,-0.5f,-1.0f,0.0f,0.0f,  
  18.         0.5f,-0.5f,-1.0f,1.0f,0.0f,  
  19.         0.5f,0.5f,-1.0f,1.0f,1.0f,  
  20.         -0.5f,0.5f,-1.0f,0.0f,1.0f  
  21.     };  
  22.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);//绑定到vbo  
  23.     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 20, vertices, GL_STATIC_DRAW);//顶点数据上传至显卡  
  24.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  25.   
  26.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  27.     glEnableVertexAttribArray(posLoc);//启用顶点坐标属性  
  28.     //指定顶点数据在VBO中的入口地址  
  29.     glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);  
  30.     glEnableVertexAttribArray(texcoordLoc);//启用顶点纹理坐标属性  
  31.     //指定顶点纹理坐标在VBO中的入口地址  
  32.     glVertexAttribPointer(texcoordLoc, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float)*3));  
  33.     glDrawArrays(GL_QUADS, 0, 4);  
  34.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  35. }  
  36.   
  37.   
  38. //绘制左上角四分之一的矩形   
  39. void FullScreenQuad::DrawToLeftTop(GLint posLoc, GLint texcoordLoc)  
  40. {  
  41.        
  42.     float vertices[] = {  
  43.         -0.5f,0.0f,-1.0f,0.0f,0.0f,  
  44.         0.0f,0.0f,-1.0f,1.0f,0.0f,  
  45.         0.0f,0.5f,-1.0f,1.0f,1.0f,  
  46.         -0.5f,0.5f,-1.0f,0.0f,1.0f  
  47.     };  
  48.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  49.     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 20, vertices, GL_STATIC_DRAW);  
  50.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  51.   
  52.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  53.     glEnableVertexAttribArray(posLoc);  
  54.     glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);  
  55.   
  56.     glEnableVertexAttribArray(texcoordLoc);  
  57.     glVertexAttribPointer(texcoordLoc, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3));  
  58.     glDrawArrays(GL_QUADS, 0, 4);  
  59.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  60. }  
  61.   
  62.   
  63. //绘制左下角四分之的矩形  
  64. void FullScreenQuad::DrawToLeftBottom(GLint posLoc, GLint texcoordLoc)  
  65. {  
  66.       
  67.     float vertices[] = {  
  68.         -0.5f,-0.5f,-1.0f,0.0f,0.0f,  
  69.         0.0f,-0.5f,-1.0f,1.0f,0.0f,  
  70.         0.0f,0.0f,-1.0f,1.0f,1.0f,  
  71.         -0.5f,0.0f,-1.0f,0.0f,1.0f  
  72.     };  
  73.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  74.     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 20, vertices, GL_STATIC_DRAW);  
  75.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  76.   
  77.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  78.     glEnableVertexAttribArray(posLoc);  
  79.     glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);  
  80.     glEnableVertexAttribArray(texcoordLoc);  
  81.     glVertexAttribPointer(texcoordLoc, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3));  
  82.     glDrawArrays(GL_QUADS, 0, 4);  
  83.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  84. }  
  85.   
  86.   
  87. //绘制右上角四分之一的矩形  
  88. void FullScreenQuad::DrawToRightTop(GLint posLoc, GLint texcoordLoc)  
  89. {  
  90.       
  91.     float vertices[] = {  
  92.         0.0f,-0.0f,-1.0f,0.0f,0.0f,  
  93.         0.5f,-0.0f,-1.0f,1.0f,0.0f,  
  94.         0.5f,0.5f,-1.0f,1.0f,1.0f,  
  95.         0.0f,0.5f,-1.0f,0.0f,1.0f  
  96.     };  
  97.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  98.     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 20, vertices, GL_STATIC_DRAW);  
  99.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  100.   
  101.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  102.     glEnableVertexAttribArray(posLoc);  
  103.     glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);  
  104.     glEnableVertexAttribArray(texcoordLoc);  
  105.     glVertexAttribPointer(texcoordLoc, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3));  
  106.     glDrawArrays(GL_QUADS, 0, 4);  
  107.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  108. }  
  109.   
  110. //绘制右下角四分之的矩形  
  111. void FullScreenQuad::DrawToRightBottom(GLint posLoc, GLint texcoordLoc)  
  112. {  
  113.   
  114.     float vertices[] = {  
  115.         0.0f,-0.5f,-1.0f,0.0f,0.0f,  
  116.         0.5f,-0.5f,-1.0f,1.0f,0.0f,  
  117.         0.5f,0.0f,-1.0f,1.0f,1.0f,  
  118.         0.0f,0.0f,-1.0f,0.0f,1.0f  
  119.     };  
  120.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  121.     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 20, vertices, GL_STATIC_DRAW);  
  122.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  123.   
  124.     glBindBuffer(GL_ARRAY_BUFFER, mVBO);  
  125.     glEnableVertexAttribArray(posLoc);  
  126.     glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 5, 0);  
  127.     glEnableVertexAttribArray(texcoordLoc);  
  128.     glVertexAttribPointer(texcoordLoc, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3));  
  129.     glDrawArrays(GL_QUADS, 0, 4);  
  130.     glBindBuffer(GL_ARRAY_BUFFER, 0);  
  131. }  

渲染入口

渲染步骤

一，使用带光照效果的shader

1,首先创建一个fbo

2,在此fbo中绘制三个带光照效果的立方体(每个立方体都有各自的模型矩阵和法线矩阵)

3,分别设置三个立方体的光源并绘制

二，切换shader，使用绘制四边形的shader

4,分别在屏幕的左上，左下，右上，右下绘制四个四边形

5,将此前绘制在fbo中的内容作为纹理贴在绘制的四个四边形中


[cpp]  view plain  copy
  1. #include <windows.h>  
  2. #include "glew.h"  
  3. #include <stdio.h>  
  4. #include <math.h>  
  5. #include "utils.h"  
  6. #include "GPUProgram.h"  
  7. #include "ObjModel.h"  
  8. #include "FBO.h"  
  9. #include "FullScreenQuad.h"  
  10. #include "Glm/glm.hpp"  
  11. #include "Glm/ext.hpp"  
  12. #pragma comment(lib,"opengl32.lib")  
  13. #pragma comment(lib,"glew32.lib")  
  14.   
  15. LRESULT CALLBACK GLWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)  
  16. {  
  17.     switch (msg)  
  18.     {  
  19.     case WM_CLOSE:  
  20.         PostQuitMessage(0);  
  21.         break;  
  22.     }  
  23.     return DefWindowProc(hwnd,msg,wParam,lParam);  
  24. }  
  25.   
  26.   
  27. INT WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)  
  28. {  
  29.     WNDCLASSEX wndClass;  
  30.     wndClass.cbClsExtra = 0;  
  31.     wndClass.cbSize = sizeof(WNDCLASSEX);  
  32.     wndClass.cbWndExtra = 0;  
  33.     wndClass.hbrBackground = NULL;  
  34.     wndClass.hCursor = LoadCursor(NULL,IDC_ARROW);  
  35.     wndClass.hIcon = NULL;  
  36.     wndClass.hIconSm = NULL;  
  37.     wndClass.hInstance = hInstance;  
  38.     wndClass.lpfnWndProc=GLWindowProc;  
  39.     wndClass.lpszClassName = L"OpenGL";  
  40.     wndClass.lpszMenuName = NULL;  
  41.     wndClass.style = CS_VREDRAW | CS_HREDRAW;  
  42.     ATOM atom = RegisterClassEx(&wndClass);  
  43.   
  44.     RECT rect;  
  45.     rect.left = 0;  
  46.     rect.top = 0;  
  47.     rect.right = 800;  
  48.     rect.bottom = 600;  
  49.     AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);  
  50.     HWND hwnd = CreateWindowEx(NULL, L"OpenGL", L"RenderWindow", WS_OVERLAPPEDWINDOW, 100, 100, rect.right-rect.left, rect.bottom-rect.top, NULL, NULL, hInstance, NULL);  
  51.     HDC dc = GetDC(hwnd);  
  52.     PIXELFORMATDESCRIPTOR pfd;  
  53.     memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));  
  54.     pfd.nVersion = 1;  
  55.     pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_TYPE_RGBA | PFD_DOUBLEBUFFER;  
  56.     pfd.iLayerType = PFD_MAIN_PLANE;  
  57.     pfd.iPixelType = PFD_TYPE_RGBA;  
  58.     pfd.cColorBits = 32;  
  59.     pfd.cDepthBits = 24;  
  60.     pfd.cStencilBits = 8;  
  61.   
  62.     int pixelFormatID = ChoosePixelFormat(dc, &pfd);  
  63.   
  64.     SetPixelFormat(dc,pixelFormatID,&pfd);  
  65.   
  66.     HGLRC rc = wglCreateContext(dc);  
  67.     wglMakeCurrent(dc, rc);  
  68.     GetClientRect(hwnd, &rect);  
  69.     int viewportWidth = rect.right - rect.left, viewportHeight = rect.bottom - rect.top;  
  70.     glewInit();  
  71.   
  72.     GPUProgram fsqProgram;  
  73.     fsqProgram.AttachShader(GL_VERTEX_SHADER, "Debug/res/shader/fullscreenquad.vs");  
  74.     fsqProgram.AttachShader(GL_FRAGMENT_SHADER, "Debug/res/shader/fullscreenquad.fs");  
  75.     fsqProgram.Link();  
  76.   
  77.     fsqProgram.DetectAttribute("pos");  
  78.     fsqProgram.DetectAttribute("texcoord");  
  79.     fsqProgram.DetectUniform("U_MainTexture");  
  80.   
  81.     GPUProgram gpuProgram;  
  82.     gpuProgram.AttachShader(GL_VERTEX_SHADER, "Debug/res/shader/Light.vs");  
  83.     gpuProgram.AttachShader(GL_FRAGMENT_SHADER, "Debug/res/shader/Light.fs");  
  84.     gpuProgram.Link();  
  85.   
  86.     gpuProgram.DetectAttribute("pos");  
  87.     gpuProgram.DetectAttribute("texcoord");  
  88.     gpuProgram.DetectAttribute("normal");  
  89.     gpuProgram.DetectUniform("M");  
  90.     gpuProgram.DetectUniform("V");  
  91.     gpuProgram.DetectUniform("P");  
  92.     gpuProgram.DetectUniform("NM");  
  93.     gpuProgram.DetectUniform("U_AmbientLightColor");  
  94.     gpuProgram.DetectUniform("U_AmbientMaterial");  
  95.     gpuProgram.DetectUniform("U_DiffuseLightColor");  
  96.     gpuProgram.DetectUniform("U_DiffuseMaterial");  
  97.     gpuProgram.DetectUniform("U_SpecularLightColor");  
  98.     gpuProgram.DetectUniform("U_SpecularMaterial");  
  99.     gpuProgram.DetectUniform("U_LightPos");  
  100.     gpuProgram.DetectUniform("U_EyePos");  
  101.     gpuProgram.DetectUniform("U_LightDirection");  
  102.     gpuProgram.DetectUniform("U_Cutoff");  
  103.     gpuProgram.DetectUniform("U_DiffuseIntensity");  
  104.     //init 3d model  
  105.     ObjModel cube;  
  106.     cube.Init("Debug/res/model/Cube.obj");  
  107.   
  108.     //摄像机矩阵的单位矩阵  
  109.     float identity[] = {  
  110.         1.0f,0,0,0,  
  111.         0,1.0f,0,0,  
  112.         0,0,1.0f,0,  
  113.         0,0,0,1.0f  
  114.     };  
  115.     float ambientLightColor[] = { 0.4f,0.4f,0.4f,1.0f };//环境光颜色  
  116.     float ambientMaterial[] = { 0.2f,0.2f,0.2f,1.0f };//环境光材质  
  117.     float diffuseLightColor[] = { 1.0f,1.0f,1.0f,1.0f };//漫反射光颜色  
  118.     float diffuseMaterial[] = { 0.6f,0.6f,0.6f,1.0f };//漫反射光材质  
  119.     float diffuseIntensity = 1.0f;//漫反射光强度  
  120.     float specularLightColor[] = { 1.0f,1.0f,1.0f,1.0f };//环境光颜色  
  121.     float specularMaterial[] = { 1.0f,1.0f,1.0f,1.0f };//环境光材质  
  122.     float lightPos[] = { 0.0f,1.5f,0.0f,0.0f };//光源位置  
  123.     float spotLightDirection[] = { 0.0f,-1.0f,0.0f,128.0f };//聚光灯中心线向量  
  124.     float spotLightCutoff = 0.0f;// 聚光灯中心线向量和入射光线最大夹角  
  125.     float eyePos[] = { 0.0f,0.0f,0.0f };//眼睛的位置  
  126.   
  127.     //模型矩阵  
  128.     glm::mat4 model1 = glm::translate<float>(-2.0f, 0.0f, -6.0f)*glm::rotate(-30.0f,1.0f,1.0f,1.0f);  
  129.     glm::mat4 model2 = glm::translate<float>(0.0f, 0.0f, -6.0f)*glm::rotate(-30.0f,1.0f,1.0f,1.0f);  
  130.     glm::mat4 model3 = glm::translate<float>(2.0f, 0.0f, -6.0f)*glm::rotate(-30.0f,1.0f,1.0f,1.0f);  
  131.     //投影矩阵  
  132.     glm::mat4 projectionMatrix = glm::perspective(50.0f, (float)viewportWidth / (float)viewportHeight, 0.1f, 1000.0f);  
  133.   
  134.     //将法线转换到世界空间的变换矩阵  
  135.     glm::mat4 normalMatrix1 = glm::inverseTranspose(model1);  
  136.     glm::mat4 normalMatrix2 = glm::inverseTranspose(model2);  
  137.     glm::mat4 normalMatrix3 = glm::inverseTranspose(model3);  
  138.   
  139.   
  140.     FullScreenQuad fsq;  
  141.     fsq.Init();  
  142.     FBO fbo;  
  143.     fbo.AttachColorBuffer("color", GL_COLOR_ATTACHMENT0, GL_RGBA, viewportWidth, viewportHeight);  
  144.     fbo.AttachDepthBuffer("depth", viewportWidth, viewportHeight);  
  145.     fbo.Finish();  
  146.   
  147.     //glClearColor(41.0f/255.0f,  71.0f/255.0f, 121.0f / 255.0f, 1.0f);  
  148.     ShowWindow(hwnd, SW_SHOW);  
  149.     UpdateWindow(hwnd);  
  150.   
  151.     bool isFullScreen = true;  
  152.     MSG msg;  
  153.     while (true)  
  154.     {  
  155.         if (PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE))  
  156.         {  
  157.             if (msg.message==WM_QUIT)  
  158.             {  
  159.                 break;  
  160.             }  
  161.             TranslateMessage(&msg);  
  162.             DispatchMessage(&msg);  
  163.         }  
  164.         //绑定fbo----将绘制的场景绑定到FBO  
  165.         fbo.Bind();  
  166.   
  167.         glClearColor(0.0f,0.0f,0.0f,1.0f);  
  168.         //这步很重要  
  169.         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
  170.         glEnable(GL_DEPTH_TEST);  
  171.   
  172.         glUseProgram(gpuProgram.mProgram);  
  173.         //设置shader中变量的值  
  174.         glUniformMatrix4fv(gpuProgram.GetLocation("V"), 1, GL_FALSE, identity);  
  175.         glUniformMatrix4fv(gpuProgram.GetLocation("P"), 1, GL_FALSE, glm::value_ptr(projectionMatrix));  
  176.         glUniform4fv(gpuProgram.GetLocation("U_AmbientLightColor"), 1, ambientLightColor);  
  177.         glUniform4fv(gpuProgram.GetLocation("U_AmbientMaterial"), 1, ambientMaterial);  
  178.         glUniform4fv(gpuProgram.GetLocation("U_DiffuseLightColor"), 1, diffuseLightColor);  
  179.         glUniform4fv(gpuProgram.GetLocation("U_DiffuseMaterial"), 1, diffuseMaterial);  
  180.         glUniform4fv(gpuProgram.GetLocation("U_SpecularLightColor"), 1, specularLightColor);  
  181.         glUniform4fv(gpuProgram.GetLocation("U_SpecularMaterial"), 1, specularMaterial);  
  182.         glUniform3fv(gpuProgram.GetLocation("U_EyePos"), 1, eyePos);  
  183.         glUniform4fv(gpuProgram.GetLocation("U_LightDirection"), 1, spotLightDirection);  
  184.         glUniform1f(gpuProgram.GetLocation("U_DiffuseIntensity"), diffuseIntensity);  
  185.         //设置方向光光源的位置  
  186.         lightPos[0] = 0.0f;  
  187.         lightPos[1] = 1.5f;  
  188.         lightPos[2] = 0.0f;  
  189.         lightPos[3] = 0.0f;  
  190.         //漫反射光照强度  
  191.         diffuseIntensity = 1.0f;  
  192.         //聚光灯中心线和入射光线最大夹角  
  193.         spotLightCutoff = 0.0f;  
  194.         //设置shader中变量的值  
  195.         glUniform4fv(gpuProgram.GetLocation("U_LightPos"), 1, lightPos);  
  196.         glUniform1f(gpuProgram.GetLocation("U_DiffuseIntensity"), diffuseIntensity);  
  197.         glUniform1f(gpuProgram.GetLocation("U_Cutoff"), spotLightCutoff);  
  198.         glUniformMatrix4fv(gpuProgram.GetLocation("M"), 1, GL_FALSE, glm::value_ptr(model1));  
  199.         glUniformMatrix4fv(gpuProgram.GetLocation("NM"), 1, GL_FALSE, glm::value_ptr(normalMatrix1));  
  200.         //绘制被方向光照射的立方体  
  201.         cube.Bind(gpuProgram.GetLocation("pos"), gpuProgram.GetLocation("texcoord"), gpuProgram.GetLocation("normal"));  
  202.         cube.Draw();  
  203.         //设置点光源的位置  
  204.         lightPos[0] = 0.0f;  
  205.         lightPos[1] = 3.0f;  
  206.         lightPos[2] = -6.0f;  
  207.         lightPos[3] = 1.0f;  
  208.         diffuseIntensity = 3.0f;  
  209.         //设置shader中变量的值  
  210.         glUniform4fv(gpuProgram.GetLocation("U_LightPos"), 1, lightPos);  
  211.         glUniform1f(gpuProgram.GetLocation("U_DiffuseIntensity"), diffuseIntensity);  
  212.         glUniformMatrix4fv(gpuProgram.GetLocation("M"), 1, GL_FALSE, glm::value_ptr(model2));  
  213.         glUniformMatrix4fv(gpuProgram.GetLocation("NM"), 1, GL_FALSE, glm::value_ptr(normalMatrix2));  
  214.         //绘制被点光源照射的立方体  
  215.         cube.Bind(gpuProgram.GetLocation("pos"), gpuProgram.GetLocation("texcoord"), gpuProgram.GetLocation("normal"));  
  216.         cube.Draw();  
  217.         //设置聚光灯的位置  
  218.         lightPos[0] = 2.0f;  
  219.         lightPos[1] = 3.0f;  
  220.         lightPos[2] = -6.0f;  
  221.         lightPos[3] = 1.0f;  
  222.         diffuseIntensity = 4.0f;  
  223.         spotLightCutoff = 15.0f;//degree  
  224.         glUniform4fv(gpuProgram.GetLocation("U_LightPos"), 1, lightPos);  
  225.         glUniform1f(gpuProgram.GetLocation("U_DiffuseIntensity"), diffuseIntensity);  
  226.         glUniform1f(gpuProgram.GetLocation("U_Cutoff"), spotLightCutoff);  
  227.         glUniformMatrix4fv(gpuProgram.GetLocation("M"), 1, GL_FALSE, glm::value_ptr(model3));  
  228.         glUniformMatrix4fv(gpuProgram.GetLocation("NM"), 1, GL_FALSE, glm::value_ptr(normalMatrix3));  
  229.         //绘制被聚光灯照射的立方体  
  230.         cube.Bind(gpuProgram.GetLocation("pos"), gpuProgram.GetLocation("texcoord"), gpuProgram.GetLocation("normal"));  
  231.         cube.Draw();  
  232.         glUseProgram(0);  
  233.         glFlush();  
  234.         fbo.Unbind();  
  235.   
  236.   
  237.         glClearColor(0.1f, 0.4f, 0.7f, 1.0f);  
  238.         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//这步很重要  
  239.         glUseProgram(fsqProgram.mProgram);  
  240.   
  241.         glActiveTexture(GL_TEXTURE0);  
  242.         //将fbo中的内容作为纹理  
  243.         glBindTexture(GL_TEXTURE_2D,fbo.GetBuffer("color"));  
  244.         glUniform1i(fsqProgram.GetLocation("U_MainTexture"), 0);  
  245.   
  246.         if (isFullScreen){ //分屏渲染  
  247.             fsq.DrawToLeftTop(fsqProgram.GetLocation("pos"), fsqProgram.GetLocation("texcoord"));  
  248.             fsq.DrawToLeftBottom(fsqProgram.GetLocation("pos"), fsqProgram.GetLocation("texcoord"));  
  249.             fsq.DrawToRightTop(fsqProgram.GetLocation("pos"), fsqProgram.GetLocation("texcoord"));  
  250.             fsq.DrawToRightBottom(fsqProgram.GetLocation("pos"), fsqProgram.GetLocation("texcoord"));  
  251.         }  
  252.         else //绘制一个充满屏幕的四边形  
  253.         {  
  254.             fsq.Draw(fsqProgram.GetLocation("pos"), fsqProgram.GetLocation("texcoord"));  
  255.         }  
  256.         glUseProgram(0);  
  257.         glFlush();  
  258.         SwapBuffers(dc);  
  259.     }  
  260.     return 0;  
  261. }  
linuxheik
关注
专栏目录
模仿unity引擎中的渲染模块绑定帧缓冲区功能给出商业化级具体代码实现
听老罗娓娓道来
07-31 25
通过上述步骤，我们实现了一个商业化级别的离屏渲染和后处理功能。我们使用了作为帧缓冲区，并通过将渲染命令发送到该缓冲区。最后，我们使用一个简单的后处理着色器对渲染结果进行处理，并在屏幕上显示。这个示例展示了如何在Unity中实现复杂的渲染管线，适用于各种高级渲染效果和后处理技术。在Unity引擎中，是一个非常强大的工具，用于在渲染管线中插入自定义的渲染命令。它允许开发者在特定的渲染事件（如在渲染阴影之前或之后）中执行自定义的渲染操作。以下是一个商业化级别的具体代码实现示例，展示如何在Unity中使用。
OpenGL之深入解析屏幕成像和渲染原理
╰つ栺尖篴夢ゞ
04-10 610
PU 和 GPU 因为设计之初需求就不一样，所以它们的组成不同，在计算机中的分工也不同。可以看到，GPU 有更多的 ALU，而 CPU 有 Control 单元和 Cache 单元，普通的业务代码因为逻辑复杂，数据类型复杂，跳转复杂，依赖性高等，就更适合 CPU 来做。而 GPU 不擅长处理这些复杂的逻辑，它更擅长处理单一的运算，大量的算术逻辑单元可以保证做到真正的高并发，所以大量的计算任务是适合它的工作，就比如 GLSL 代码。
linux opengl 多窗口,多个OpenGL上下文,多个窗口,多线程和vsync
weixin_29011667的博客
05-13 1061
我正在使用OpenGL创建一个图形用户界面应用程序,其中可以有任意数量的窗口 – “多文档界面”样式.如果有一个窗口,主循环可能如下所示：>处理事件> draw()>交换缓冲区(vsync导致阻塞,直到垂直监视器刷新)但是当有3个窗口时,请考虑主循环：>每个窗口处理事件>每个窗口draw()>窗口1交换缓冲区(块直到vsync)>(一段时间后)窗口2交换缓...
深度剖析OpenGL ES中的多线程和多窗口渲染技术
热门推荐
Ben_OnceMore
08-23 1万+
移动设备中的CPU和GPU已经变得很强大，到处都是配备一个或多个高分辨率屏幕的设备，需要使用带有图形驱动器的复杂交互也日益增加。在这篇博客文章中，我将讨论多线程和多窗口渲染对开发人员来讲意味着什么，同时我将介绍将这些技术应用您设计当中的条件和时机。 什么是多线程渲染？ 传统上，OpenGL ES应用程序只从一个线程渲染到一个图层。然而，由于3D渲染引擎的复杂性有所增加，图形API操作的CP
（01）OpenGL es中只在指定区域渲染view
Rexinx博客
12-29 2219
OpenGL es中使用屏幕的一定（指定区域显示view），而不是全屏
opengl 多窗口渲染 mac_Mac天文模拟软件----Starry Night Pro Plus 8
weixin_39639622的博客
11-08 160
世界最强的天文软件。它可以模拟公元前99999年到公元99999年的1000000光年内人类所能观察到的所有天文现象。它可不是一般的天文教学软件，只有一点文字，图片或动画而以，而是实时模拟软件。你可以把观察点设在自己所在地，看看今晚的星空，保证和你看到的实际星空一样(由于环境污染，真实星空估计你是看不到的)。你也可以把时间设到1万年前，看看那时的北斗七星是个什么排列，甚至可以站在冥王星上看日出，坐...
opengl 多窗口渲染 mac_CR渲染器/ZB教程/ACDSee
weixin_39690105的博客
12-22 546
|Corona Renderer 5|链接：https://pan.baidu.com/s/1upgG4F_DO8ylfQttRsdCYQ提取码：s7an说明：离线安装不需要互联网，AiO安装。包括：1. corona-5-3dsmax-hotfix2.exe2.修补程序3. MaterialLibrary(用于corona 5)4. NvidiaAiDenoiser新增的THX 新...
Android平台OpenGLES3将GL-TEXTURE-2D纹理id渲染到ImageReader提供的Surface上
最新发布
06-28
Android平台 将 GL_TEXTURE_2D纹理 渲染到 Surface 上 案例实现文章介绍： https://xiaxl.blog.csdn.net/article/details/131682521 技术实现流程大致如下： 1、OpenGLES3中加载GL_TEXTURE_2D纹理，生成纹理ID； 2...
OpenGL实现离屏渲染(Offscreen Render),
12-30
离屏渲染（Offscreen Rendering）是OpenGL中的一个重要技术，它允许我们在屏幕之外的纹理或帧缓冲区进行渲染操作，然后将结果用于后续的图形处理或者保存为图像文件。这个初级的OpenGL程序Demo就是围绕离屏渲染展开...
OpenGL ES渲染管线概述（一）
08-27
渲染管线可以分为多个阶段，每个阶段都执行特定的任务，包括读取顶点数据、顶点着色器、组装图元、光栅化图元、片元着色器、写入帧缓冲区、显示到屏幕上。 1. 读取顶点数据 读取顶点数据是渲染管线的第一阶段，这...
在Win32程序中应用OpenGL进行多窗口显示
09-16
运行时点击渲染，弹出对话框后在四个text控件中分别显示四幅OpenGL渲染得到的图像。用到了多线程
OpenGL下多视窗口的实现
11-19
这是一篇如何使用OpenGL实现多视窗口的文章，内容十分简单易懂，看了很容易明白。
游戏开发完整学习路线（各个版本都有）！就是一门实时渲染的艺术！
HUYA69的博客
09-25 808
在软件开发中，游戏开发这个方向看起来目标很明确，但其实是个领域很广的方向，入门的时候如果得不到指点一二，很容易误入歧途，相反，如果走这条路之前能得到前人的一些指路，是可以事半功倍的。 一、平台与编程语言选择 首先，游戏开发的平台就有很多类型： 个人主机平台：Windows、Linux、Mac OC； 移动平台：iOS、Android、Windows Phone、BlackBerryOS、Symbian； 专业主机平台：Xbox、PlayStation、Will等。...
OpenGL渲染流程
weixin_34341117的博客
12-23 923
一.什么是openGL OpenGL被定义为“图形硬件的一种软件接口”。从本质上说，它是一个3D图形和模型库，具有高度的可移植性，具有非常快的速度。 二.管线 管线这个术语描述了opengl渲染的整个过程。openGL采用cs模型：c是cpu，s是GPU，c给s的输入是vertex信息和Texture信息，s的输出是显示器上显示的图像。下面这2个图比较清楚的讲解了opengl的渲染管线。 ...
OPenGL--几何着色器的应用（多视口输出）
先锋小牛
05-08 1879
简述在OpenGL中，可以将一个物体的渲染结果输出到不同的帧缓冲区域，实现多个的视口效果，着色器中提供了一个内置的输出变量gl_ViewportIndex来重定向输出，它的值也可以作为片元着色器的输入使用。多视口在三维建模软件中比较常见，如3DMAX。在OpenGL应用程序中可以通过glViewportIndexedf()或glViewportIndexedfv()函数来设置，可以指定剪切坐标窗口...
OpenGL ES 多线程和多屏渲染
10-12 4084
原文：https://www.imgtec.com/blog/understanding-opengl-es-multi-thread-multi-window-rendering/ 转载：https://blog.csdn.net/hanbingfengying/article/details/38782043 “内容归纳” 应用程序和驱动程序之间的传输完成之前，阻塞型操作有： 1、上传数据的图...
OpenGL：同时创建并渲染多个数据
weixin_38401090的博客
04-08 1566
使用数组储存多个顶点数据 同时渲染多个对象 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <iostream> using namespace std; const unsigned int screen_width = 800; const unsigned int screen_heigh...
opengl实现鼠标控制和左右分屏观看全景图
ssuper_bin的专栏
02-27 5960
opengl实现鼠标控制视角和左右分屏观看全景图首先贴出效果图再过几天说明代码实现的过程： 先给出参考的页面： http://learnopengl-cn.readthedocs.org/zh/latest/04%20Advanced%20OpenGL/06%20Cubemaps/ 参考资料内容给的很完善，首先按照他所给的内容配置好需要的additional library。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值