OpenGL的裁剪和混合

最新推荐文章于 2024-07-16 12:57:18 发布

龙行天下01

最新推荐文章于 2024-07-16 12:57:18 发布

阅读量548

点赞数

分类专栏： opengl 文章标签： linux 运维服务器

原文链接：https://www.jianshu.com/p/4626024fc363

版权

opengl 专栏收录该内容

192 篇文章 38 订阅

订阅专栏

窗⼝，视⼝，裁剪区域

窗⼝: 就是显示界⾯
视⼝: 就是窗⼝中⽤来显示图形的⼀块矩形区域，它可以和窗⼝等⼤，也可以⽐窗⼝⼤或者⼩。只有绘制在视⼝区域中的图形才能被显示，如果图形有⼀部分超出了视⼝区域，那么那⼀部分是看不到的。通过glViewport()函数设置。
裁剪区域（平⾏投影）：就是视⼝矩形区域的最⼩最⼤x坐标（left,right)和最⼩最⼤y坐标(bottom,top)，⽽不是窗⼝的最⼩最⼤x坐标和y坐标。通过glOrtho()函数设置，这个函数还需指定最近最远z坐标，形成⼀个⽴体的裁剪区域。

裁剪

在OpenGL 中提⾼渲染的⼀种⽅式。只刷新屏幕上发⽣变化的部分。OpenGL 允许将要进⾏渲染的窗⼝中指定⼀个裁剪框。
基本原理：⽤于渲染时限制绘制区域，通过此技术可以再屏幕（帧缓冲）指定⼀个矩形区域。启⽤剪裁测试之后，不在此矩形区域内的⽚元被丢弃，只有在此矩形区域内的⽚元才有可能进⼊帧缓冲。因此实际达到的效果就是在屏幕上开辟了⼀个⼩窗⼝，可以再其中进⾏指定内容的绘制。

//1.开启裁剪测试
glEnable(GL_SCISSOR_TEST);

//2.关闭裁剪测试
glDisable(GL_SCISSOR_TEST);

//3.指定裁剪窗⼝
 void glScissor(Glint x,Glint y,GLSize width,GLSize height);
 x,y:指定裁剪框左下⻆位置；
 width , height:指定裁剪尺⼨

新建“OpenGL 裁剪”示例程序，代码如下：

//在Mac 系统下，`#include<glut/glut.h>` 在Windows 和 Linux上，我们使⽤freeglut的静态库版本并且需要添加⼀个宏
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif



//ChangeSize 函数:⾃定义函数.通过glutReshaperFunc(函数名)注册为重塑函数.当屏幕⼤⼩发⽣变化/或者第⼀次创建窗⼝时,会调⽤该函数调整窗⼝⼤⼩/视⼝⼤⼩.
void ChangeSize(int w ,int h)
{
    //设置视口窗口尺寸
    glViewport(0, 0, w, h);
}


//RenderScene 函数:⾃定义函数.通过glutDisplayFunc(函数名)注册为显示渲染函数.当屏幕发⽣变化/或者开发者主动渲染会调⽤此函数,⽤来实现数据->渲染过程
void RenderScene(void)
{
    //设置清屏颜⾊为蓝⾊
    glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
    //清理缓存区(颜⾊,深度,模板缓存区等)
    glClear(GL_COLOR_BUFFER_BIT);
    
    //1.现在剪成⼩红⾊分区
    //(1)设置裁剪区颜⾊为红⾊
    glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
    //(2)设置裁剪尺⼨
    glScissor(400, 400, 800, 400);
    //(3)开启裁剪测试
    glEnable(GL_SCISSOR_TEST);
    //(4)开启清屏，执⾏裁剪
    glClear(GL_COLOR_BUFFER_BIT);
    
    // 2.裁剪⼀个绿⾊的⼩矩形
    //(1).设置清屏颜⾊为绿⾊
    glClearColor(0.0f, 1.0f, 0.0f, 0.0f);
    //(2).设置裁剪尺⼨
    glScissor(600, 500, 400, 200);
    //(3).开始清屏执⾏裁剪
    glClear(GL_COLOR_BUFFER_BIT);
    
    //关闭裁剪测试
    glDisable(GL_SCISSOR_TEST);
    
    //交换缓存区
    glutSwapBuffers();
}


//main 函数: 程序⼊⼝.OpenGL 是⾯向过程编程.所以你会发现利⽤OpenGL处理图形/图像都是链式形式.以及基于OpenGL封装的图像处理框架也是链式编程
int main(int argc, char* argv[])
{
    glutInit(&argc, argv);
    //申请一个颜色缓存区、双缓存区
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    //设置窗口的尺寸
    glutInitWindowSize(800, 800);
    //设置窗口的名称
    glutCreateWindow("OpenGL 裁剪");
    //注册回调函数（改变尺寸）
    glutReshapeFunc(ChangeSize);
    //注册显示函数
    glutDisplayFunc(RenderScene);
    
   
    //runloop运行循环
    glutMainLoop();
    
    return 0;
}

运行效果如下：

OpenGL 裁剪.png

混合

OpenGL 渲染时会把颜⾊值存在颜⾊缓存区中，每个⽚段的深度值也是放在深度缓冲区。当深度缓冲区被关闭时，新的颜⾊将简单的覆盖原来颜⾊缓存区存在的颜⾊值，当深度缓冲区再次打开时，新的颜⾊⽚段只有当它们⽐原来的值更接近邻近的裁剪平⾯才会替换原来的颜⾊⽚段。如果打开了OpenGL的混合功能，那么下层的颜色值就不会被清除。

glEnable(GL_BlEND);

打开混合功能的情况下，新的颜色会与已存在的颜色值在颜色缓冲区中进行组合。这些颜色的组合方式不同会导致很多不同的特殊效果。

组合颜色

⽬标颜⾊：已经存储在颜⾊缓存区的颜⾊值
源颜⾊：作为当前渲染命令结果进⼊颜⾊缓存区的颜⾊值

当混合功能被启动时，源颜⾊和⽬标颜⾊的组合⽅式是混合⽅程式控制的。在默认情况
下，混合⽅程式如下所示：
Cf = (Cs * S) + (Cd * D)

Cf ：最终计算参数的颜⾊
Cs ：源颜⾊
Cd ：⽬标颜⾊
S：源混合因⼦
D：⽬标混合因⼦

设置混合因⼦

设置混合因⼦，需要⽤到glBlendFun函数

glBlendFunc(GLenum S,GLenum D);
S:源混合因⼦
D：⽬标混合因⼦

混合因子.png

表中R、G、B、A 分别代表红、绿、蓝、alpha
表中下标S、D，分别代表源、⽬标
表中C 代表常量颜⾊（默认⿊⾊）

下⾯通过⼀个常⻅的混合函数组合来说明问题：

glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

如果颜⾊缓存区已经有⼀种颜⾊红⾊（1.0f,0.0f,0.0f,0.0f），这个⽬标颜⾊Cd，如果在这上⾯⽤⼀种alpha为0.6的蓝⾊（0.0f,0.0f,1.0f,0.6f）

Cd (⽬标颜⾊) = （1.0f,0.0f,0.0f,0.0f）
Cs (源颜⾊) = （0.0f,0.0f,1.0f,0.6f）
S = 源alpha值 = 0.6f
D = 1 - 源alpha值= 1-0.6f = 0.4f

⽅程式Cf = (Cs * S) + (Cd * D)
等价于 = （Blue * 0.6f） + (Red * 0.4f)

最终颜⾊是以原先的红⾊（⽬标颜⾊）与后来的蓝⾊（源颜⾊）进⾏组合。源颜⾊的alpha值越⾼，添加的蓝⾊颜⾊成分越⾼，⽬标颜⾊所保留的成分就会越少。混合函数经常⽤于实现在其他⼀些不透明的物体前⾯绘制⼀个透明物体的效果。

改变混合⽅程式

默认混合⽅程式：Cf = (Cs * S) + (Cd * D)
实际上远不⽌这⼀种混合⽅程式，我们可以从5个不同的⽅程式中进⾏选择

选择混合⽅程式的函数：

glbBlendEquation(GLenum mode);

混合方程式.png

除了能使⽤glBlendFunc 来设置混合因⼦，还可以有更灵活的选择。

void glBlendFuncSeparate(GLenum strRGB,GLenum dstRGB ,GLenum strAlpha,GLenum dstAlpha);

strRGB: 源颜⾊的混合因⼦
dstRGB: ⽬标颜⾊的混合因⼦
strAlpha: 源颜⾊的Alpha因⼦
dstAlpha: ⽬标颜⾊的Alpha因⼦

glBlendFunc 指定源和⽬标 RGBA值的混合函数；但是glBlendFuncSeparate函数则允许为RGB 和Alpha 成分单独指定混合函数。
在混合因⼦表中，GL_CONSTANT_COLOR,GL_ONE_MINUS_CONSTANT_COLOR,GL_CONSTANT_ALPHA,GL
_ONE_MINUS_CONSTANT值允许混合⽅程式中引⼊⼀个常量混合颜⾊。
常量混合颜⾊，默认初始化为⿊⾊（0.0f,0.0f,0.0f,0.0f），可以修改这个常量混合颜⾊。

void glBlendColor(GLclampf red ,GLclampf green ,GLclampf blue ,GLclampf alpha );

新建“OpenGL 混合”示例程序，代码如下：

#include "GLTools.h"
#include "GLShaderManager.h"

//在Mac 系统下，`#include<glut/glut.h>` 在Windows 和 Linux上，我们使⽤freeglut的静态库版本并且需要添加⼀个宏
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

GLBatch squareBatch;
GLBatch greenBatch;
GLBatch redBatch;
GLBatch blueBatch;
GLBatch blackBatch;

GLShaderManager shaderManager;

GLfloat blockSize = 0.2f;
GLfloat vVerts[] = { -blockSize, -blockSize, 0.0f,
blockSize, -blockSize, 0.0f,
blockSize,  blockSize, 0.0f,
-blockSize,  blockSize, 0.0f};



//ChangeSize 函数:⾃定义函数.通过glutReshaperFunc(函数名)注册为重塑函数.当屏幕⼤⼩发⽣变化/或者第⼀次创建窗⼝时,会调⽤该函数调整窗⼝⼤⼩/视⼝⼤⼩.
void ChangeSize(int w ,int h)
{
    //设置视口窗口尺寸
    glViewport(0, 0, w, h);
}


void SetupRC()
{
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f );
    shaderManager.InitializeStockShaders();
    
    //绘制1个移动矩形
    squareBatch.Begin(GL_TRIANGLE_FAN, 4);
    squareBatch.CopyVertexData3f(vVerts);
    squareBatch.End();
    
    //绘制4个固定矩形
    GLfloat vBlock[] = { 0.25f, 0.25f, 0.0f,
        0.75f, 0.25f, 0.0f,
        0.75f, 0.75f, 0.0f,
        0.25f, 0.75f, 0.0f};
    
    greenBatch.Begin(GL_TRIANGLE_FAN, 4);
    greenBatch.CopyVertexData3f(vBlock);
    greenBatch.End();
    
    
    GLfloat vBlock2[] = { -0.75f, 0.25f, 0.0f,
        -0.25f, 0.25f, 0.0f,
        -0.25f, 0.75f, 0.0f,
        -0.75f, 0.75f, 0.0f};
    
    redBatch.Begin(GL_TRIANGLE_FAN, 4);
    redBatch.CopyVertexData3f(vBlock2);
    redBatch.End();
    
    
    GLfloat vBlock3[] = { -0.75f, -0.75f, 0.0f,
        -0.25f, -0.75f, 0.0f,
        -0.25f, -0.25f, 0.0f,
        -0.75f, -0.25f, 0.0f};
    
    blueBatch.Begin(GL_TRIANGLE_FAN, 4);
    blueBatch.CopyVertexData3f(vBlock3);
    blueBatch.End();
    
    
    GLfloat vBlock4[] = { 0.25f, -0.75f, 0.0f,
        0.75f, -0.75f, 0.0f,
        0.75f, -0.25f, 0.0f,
        0.25f, -0.25f, 0.0f};
    
    blackBatch.Begin(GL_TRIANGLE_FAN, 4);
    blackBatch.CopyVertexData3f(vBlock4);
    blackBatch.End();
}

//上下左右键位控制移动
void SpecialKeys(int key, int x, int y)
{
    GLfloat stepSize = 0.025f;
    
    GLfloat blockX = vVerts[0];
    GLfloat blockY = vVerts[7];
    
    if(key == GLUT_KEY_UP)
        blockY += stepSize;
    
    if(key == GLUT_KEY_DOWN)
        blockY -= stepSize;
    
    if(key == GLUT_KEY_LEFT)
        blockX -= stepSize;
    
    if(key == GLUT_KEY_RIGHT)
        blockX += stepSize;
    
    
    if(blockX < -1.0f) blockX = -1.0f;
    if(blockX > (1.0f - blockSize * 2)) blockX = 1.0f - blockSize * 2;;
    if(blockY < -1.0f + blockSize * 2)  blockY = -1.0f + blockSize * 2;
    if(blockY > 1.0f) blockY = 1.0f;
    
    
    vVerts[0] = blockX;
    vVerts[1] = blockY - blockSize*2;
    
    vVerts[3] = blockX + blockSize*2;
    vVerts[4] = blockY - blockSize*2;
    
    vVerts[6] = blockX + blockSize*2;
    vVerts[7] = blockY;
    
    vVerts[9] = blockX;
    vVerts[10] = blockY;
    
    squareBatch.CopyVertexData3f(vVerts);
    
    glutPostRedisplay();
}

//RenderScene 函数:⾃定义函数.通过glutDisplayFunc(函数名)注册为显示渲染函数.当屏幕发⽣变化/或者开发者主动渲染会调⽤此函数,⽤来实现数据->渲染过程
void RenderScene(void)
{
    //清理缓存区(颜⾊,深度,模板缓存区等)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    
    //定义颜色
    GLfloat vRed[] = { 1.0f, 0.0f, 0.0f, 1.0f };
    GLfloat vGreen[] = { 0.0f, 1.0f, 0.0f, 1.0f };
    GLfloat vBlue[] = { 0.0f, 0.0f, 1.0f, 1.0f };
    GLfloat vBlack[] = { 0.0f, 0.0f, 0.0f, 1.0f };
    GLfloat vSquare[] = { 1.0f, 0.0f, 0.0f, 0.5f };
    
    //召唤场景的时候，将4个固定矩形绘制好
    //使用 单位着色器
    //参数1：简单的使用默认笛卡尔坐标系（-1，1），所有片段都应用一种颜色。GLT_SHADER_IDENTITY
    //参数2：着色器颜色
    shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vGreen);
    greenBatch.Draw();
    
    shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vRed);
    redBatch.Draw();
    
    shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vBlue);
    blueBatch.Draw();
    

    shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vBlack);
    blackBatch.Draw();
    
       
    //组合核心代码
    //1.开启混合
    glEnable(GL_BLEND);
    //2.开启组合函数 计算混合颜色因子
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       
    //3.使用着色器管理器
    //*使用 单位着色器
    //参数1：简单的使用默认笛卡尔坐标系（-1，1），所有片段都应用一种颜色。GLT_SHADER_IDENTITY
    //参数2：着色器颜色
    shaderManager.UseStockShader(GLT_SHADER_IDENTITY, vSquare);
      
    //4.容器类开始绘制
    squareBatch.Draw();
    //5.关闭混合功能
    glDisable(GL_BLEND);
       
    //同步绘制命令
    glutSwapBuffers();
    
}


//main 函数: 程序⼊⼝.OpenGL 是⾯向过程编程.所以你会发现利⽤OpenGL处理图形/图像都是链式形式.以及基于OpenGL封装的图像处理框架也是链式编程
int main(int argc, char* argv[])
{
    glutInit(&argc, argv);
    //申请一个颜色缓存区、双缓存区、深度缓存区
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    //设置窗口的尺寸
    glutInitWindowSize(800, 800);
    //设置窗口的名称
    glutCreateWindow("OpenGL 混合");
    //注册回调函数（改变尺寸）
    glutReshapeFunc(ChangeSize);
    //注册显示函数
    glutDisplayFunc(RenderScene);
    
    glutSpecialFunc(SpecialKeys);
    
    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
        return 1;
    }
    
    SetupRC();
   
    //runloop运行循环
    glutMainLoop();
    
    return 0;
}

运行效果如下：