OpenGL学习之路(3.0)：OpenGL 深度测试

2019-03-04  本文已影响0人  velue

[TOC]

学习目标

一、在渲染过程中可能产生的问题

在绘制3D场景的时候,我们需要决定哪些部分是对观察者可见的,或者哪些部分是对观察者不可⻅的.对于不可见的部分,应该及早丢弃.例例如在⼀个不透明的墙壁后,就不应该渲染.这种情况叫做”隐藏⾯消除”(Hidden surface elimination).
比如以下的图形：

image.png

1.1、解决方案：油画法

1.2、解决方案：油画弊端

1.3、解决方案：正背面剔除（Face Culling）

1.5、解决方案：分析顶点顺序

1.6、解决方案：分析立方体中的正背面

1.7、解决方案：正背面剔除的常用函数

    void glEnable(GL_CULL_FACE);    

    void glDisable(GL_CULL_FACE);

    //mode参数为: GL_FRONT,GL_BACK,GL_FRONT_AND_BACK ,默认GL_BACK（背面剔除）
     void glCullFace(GLenum mode);


    /**
    mode参数为: GL_CW,GL_CCW,默认值:GL_CCW
    GL_CW 顺时针为正面，GL_CCW 逆时针为正面
    */
    void glFrontFace(GLenum mode);


    glCullFace(GL_BACK);
    glFrontFace(GL_CW);



    glCullFace(GL_FRONT);

源码实例一：

//工具类
#include "GLTools.h"
//矩阵堆栈
#include "GLMatrixStack.h"
//投影矩阵
#include "GLFrame.h"
//矩阵
#include "GLFrustum.h"
//几何变换管道
#include "GLGeometryTransform.h"

#include <math.h>
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

// 观察者照相机
GLFrame             viewFrame;
//使用GLFrustum类来设置透视投影
GLFrustum           viewFrustum;
//容器帮助类
GLTriangleBatch     torusBatch;
//模型视图矩阵
GLMatrixStack       modelViewMatix;
//投影视图矩阵
GLMatrixStack       projectionMatrix;
//几何变换管道
GLGeometryTransform transformPipeline;
//着色器
GLShaderManager     shaderManager;

 // 标记背面剔除、深度测试
 int iCull = 0;
 int iDepth = 0;

// 这个函数不需要初始化渲染
// context. 图像上下文
void SetupRc() {
    
    //设置背景颜色
    glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
    
    //初始化着色器管理器
    shaderManager.InitializeStockShaders();
    
    //将照相机向后移动7个单元，这是肉眼到物体的距离
    viewFrame.MoveForward(7.0f);
    
    //创建一个甜甜圈
    // void gltMakeTorus(GLTriangleBatch& torusBatch, GLfloat majorRadius, GLfloat minorRadius, GLint numMajor, GLint numMinor);
    /**
     参数一：容器帮助类
     参数二：外边缘半径（主半径）
     参数三：内边缘半径（从半径）
     参数四五：主半径和从半径的细分单元（三角形）数量
     */
    gltMakeTorus(torusBatch, 1.0f, 0.3f, 52, 26);
    
    //设置点的大小
    glPointSize(4.0f);
    
}
// 召唤场景
void RenderScene(void) {
    
    //清除窗口和深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //根据设置iClull标记来判断是否开启背面剔除
    if (iCull) {
        
        //开启背面剔除
        glEnable(GL_CULL_FACE);
        //指定逆向针顺序三角形为正面/指定顺时针下三角形为正面
        glFrontFace(GL_CCW);
        //切除那个面
        glCullFace(GL_BACK);
    }
    
    /**
     模型视图矩阵：图形发生变化：平移/旋转/缩放 放射变换，模型视图矩阵就是为了记录这些矩阵值
     投影矩阵：投影方式正投影/透视，通过投影矩阵来记录这些矩阵值
     */
    //把摄像机矩阵压入模型矩阵中-压栈方式
    modelViewMatix.PushMatrix(viewFrame);
    
    GLfloat vRed[] = {1.0f, 0.0f, 0.0f, 1.0f};
    
    //使用平面着色器
    //参数1：平面着色器
    //参数2：模型视图投影矩阵
    //有几种方式：transformPipeline.GetModelViewMatrix()：模型视图矩阵,GetNormalMatrix()默认视图矩阵，GetProjectionMatrix()投影视图矩阵，GetModelViewProjectionMatrix() 模型视图投影矩阵
    //参数3：颜色
    shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vRed);
    
    
    //使用默认光源着色器
    //通过光源、阴影效果跟提现立体效果
    //参数1：GLT_SHADER_DEFAULT_LIGHT 默认光源着色器 - 着色器类型
    //参数2：模型视图矩阵：
    //参数3：投影矩阵
    //参数4：基本颜色值
   // shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, transformPipeline.GetModelViewMatrix(), transformPipeline.GetProjectionMatrix(), vRed);
    
    //绘制
    torusBatch.Draw();
    
    //出栈
    modelViewMatix.PopMatrix();
    
    //
    glutSwapBuffers();
}

//右键菜单栏选项
void ProcessMunu(int value) {
    
    switch (value) {
        case 1:
            //是否开启正/背面剔除
            iCull = !iCull;
            break;
            
        default:
            break;
    }
    
    glutPostRedisplay();
}



void SpecailKeys(int key, int x, int y) {
    
    if (key == GLUT_KEY_UP) {
        viewFrame.RotateWorld(m3dDegToRad(-5.0), 1.0, 0.0, 0.0);
    }
    
    if (key == GLUT_KEY_DOWN) {
        viewFrame.RotateWorld(m3dDegToRad(5.0), 1.0, 0.0, 0.0);
    }
    
    if (key == GLUT_KEY_LEFT) {
        viewFrame.RotateWorld(m3dDegToRad(-5.0), 0.0, 1.0, 0.0);
    }
    
    if (key == GLUT_KEY_RIGHT) {
        viewFrame.RotateWorld(m3dDegToRad(5.0), 0.0, 1.0, 0.0);
    }
    
    //重新刷新window
    glutPostRedisplay();
    
}

void ChangeSize(int w, int h) {
    
 //防止h为0
    if (h == 0) {
        h = 1;
    }
    
    //设置窗口尺寸
    glViewport(0, 0, w, h);
    
    //创建透视投影，并将它载入到投影矩阵堆栈中
    /*SetPerspective
     参数：
     1.垂直方向上的视场角度
     2.窗口的宽度与高度的纵横比
     3.近裁剪面距离
     4.远裁剪面距离
     */
    //设置透视模式，初始化其透视矩阵
    viewFrustum.SetPerspective(35.0f, float(w)/float(h), 1.0f, 100.f);
    
    // 把透视矩阵加载到透视矩阵队阵中
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    
    //初始化渲染管线
    transformPipeline.SetMatrixStacks(modelViewMatix, projectionMatrix);
    
}

int main(int argc, char* argv[])
{
    //设置工作路径
    gltSetWorkingDirectory(argv[0]);
    //初始化
    glutInit(&argc, argv);
    //初始化渲染模型
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
    //设置窗口大小
    glutInitWindowSize(800, 600);
    //设置窗口标题
    glutCreateWindow("Geometry Test Program");
    //注册回调函数（渲染、尺寸）
    glutReshapeFunc(ChangeSize);
    //特殊键位函数（上下左右）
    glutSpecialFunc(SpecailKeys);
    // 显示函数
    glutDisplayFunc(RenderScene);
    
    //创建右键菜单
    glutCreateMenu(ProcessMunu);
    
    glutAddMenuEntry("Toggle cull backFace", 1);
    glutAddMenuEntry("Toggle depth test", 2);
    glutAddMenuEntry("Set Line Mode", 3);
    glutAddMenuEntry("Set Line Mode", 4);
    glutAddMenuEntry("Set Point mode", 5);
    
    //设置右键
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    
    GLenum err = glewInit();
    if (GLEW_OK != err) {
        fprintf(stderr, "GLEW Error: %s\n", glewGetString(err));
        return 1;
    }
    
    SetupRc();
    
    glutMainLoop();
    return 0;
    
}

1.8、了解深度

1.9、解决⽅法: Z-buffer⽅法(深度缓冲区Depth-buffer)

二、使用深度测试


        glClearColor(0.0f,0.0f,0.0f,1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

2.1、指定深度测试判断式

        //指定深度测试判断模式
        void glDepthFunc(GLEnum mode);

    void glDepthMask(GLBool value);
    value : GL_TURE 开启深度缓冲区写入; //GL_FALSE 关闭深度缓冲区写⼊



//右键菜单栏选项
void ProcessMunu(int value) {
    
    switch (value) {
        case 1:
            //是否开启正/背面剔除
            iCull = !iCull;
            break;
        case 2:
            // 是否开启深度测试
            iDepth = !iDepth;
            break;
            
        case 3:
            // 填充方式-三角形
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            break;
            
        case 4:
            //填充方式-线
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
            break;
            
        case 5:
            //填充方式-点
            glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
            break;
    }
    
    //无论上面选择了哪一个选项，都修改了显示效果，所以需要重新渲染
    glutPostRedisplay();
}

// 召唤场景
void RenderScene(void) {
    
    //清除窗口和深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //根据设置iClull标记来判断是否开启背面剔除
    if (iCull) {
        
        //开启背面剔除
        glEnable(GL_CULL_FACE);
        //指定逆向针顺序三角形为正面/指定顺时针下三角形为正面
        glFrontFace(GL_CCW);
        //切除那个面
        glCullFace(GL_BACK);
        
    }else {
        
        glDisable(GL_CULL_FACE);
    }
    
    //根据设置iDepth标记来判断是否开启深度测试
    if (iDepth) {
        glEnable(GL_DEPTH_TEST);
    }else {
        glDisable(GL_DEPTH_TEST);
    }
    
    /**
     模型视图矩阵：图形发生变化：平移/旋转/缩放 放射变换，模型视图矩阵就是为了记录这些矩阵值
     投影矩阵：投影方式正投影/透视，通过投影矩阵来记录这些矩阵值
     */
    //把摄像机矩阵压入模型矩阵中-压栈方式
    modelViewMatix.PushMatrix(viewFrame);
    
    GLfloat vRed[] = {1.0f, 0.0f, 0.0f, 1.0f};
    
    //使用平面着色器
    //参数1：平面着色器
    //参数2：模型视图投影矩阵
    //有几种方式：transformPipeline.GetModelViewMatrix()：模型视图矩阵,GetNormalMatrix()默认视图矩阵，GetProjectionMatrix()投影视图矩阵，GetModelViewProjectionMatrix() 模型视图投影矩阵
    //参数3：颜色
    //    shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vRed);
    
    
    //使用默认光源着色器
    //通过光源、阴影效果跟提现立体效果
    //参数1：GLT_SHADER_DEFAULT_LIGHT 默认光源着色器 - 着色器类型
    //参数2：模型视图矩阵：
    //参数3：投影矩阵
    //参数4：基本颜色值
    shaderManager.UseStockShader(GLT_SHADER_DEFAULT_LIGHT, transformPipeline.GetModelViewMatrix(), transformPipeline.GetProjectionMatrix(), vRed);
    
    //绘制
    torusBatch.Draw();
    
    //出栈
    modelViewMatix.PopMatrix();
    
    //
    glutSwapBuffers();
}

三、ZFighting问题的原因

3.1、ZFighting闪烁问题问题解决

    //启⽤Polygon Offset⽅式: glEnable(GL_POLYGON_OFFSET_FILL)
    //参数列表: GL_POLYGON_OFFSET_POINT GL_POLYGON_OFFSET_LINE 

    GL_POLYGON_OFFSET_FILL

    //对应光栅化模式: GL_POINT 对应光栅化模式: GL_LINE
    //对应光栅化模式: GL_FILL



    glDisable(GL_POLYGON_OFFSET_FILL)

3.2、ZFighting闪烁问题预防

四、裁剪

在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:指定裁剪尺⼨

4.1、理解窗口，视口，裁剪区域

image.png
image.png

代码实例



//demo OpenGL 裁剪
#include "GLTools.h"
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

//召唤场景
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(100, 100, 600, 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(200, 200, 400, 200);
    //(3).开始清屏执行裁剪
    glClear(GL_COLOR_BUFFER_BIT);
    
    //关闭裁剪测试
    glDisable(GL_SCISSOR_TEST);
    
    //强制执行缓存区
    glutSwapBuffers();
}

void ChangeSize(int w, int h)
{
    //保证高度不能为0
    if(h == 0)
        h = 1;
    
    // 将视口设置为窗口尺寸
    glViewport(0, 0, w, h);
}

//程序入口
int main(int argc, char* argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(800,600);
    glutCreateWindow("OpenGL Scissor");
    glutReshapeFunc(ChangeSize);
    glutDisplayFunc(RenderScene);
    glutMainLoop();
    
    return 0;
}

五、混合

我们把OpenGL 渲染时会把颜⾊值存在颜色缓存区中，每个⽚片段的深度值也是放在深度缓冲区。当深度 缓冲区被关闭时，新的颜色将简单的覆盖原来颜色缓存区存在的颜⾊值，当深度缓冲区再次打开时，新的颜⾊片段只是当它们⽐原来的值更接近邻近的裁剪平⾯才会替换原来的颜⾊片段。


    glEnable(GL_BlEND);

5.3 课堂案例

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

    
    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)

5.4、总结

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

5.5、案例


//颜色组合
#include "GLTools.h"
#include "GLShaderManager.h"

#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};


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();
}

//召唤场景
void RenderScene(void)
{
    
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    
    //定义4种颜色
    GLfloat vRed[]   = { 1.0f, 0.0f, 0.0f, 0.5f };
    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 };
    
    //召唤场景的时候，将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, vRed);
    //4.容器类开始绘制
    squareBatch.Draw();
    //5.关闭混合功能
    glDisable(GL_BLEND);
    
    
    //同步绘制命令
    glutSwapBuffers();
}


void ChangeSize(int w, int h)
{
    glViewport(0, 0, w, h);
}

int main(int argc, char* argv[])
{
    gltSetWorkingDirectory(argv[0]);
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("移动矩形，观察颜色");
    
    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
        return 1;
    }
    
    glutReshapeFunc(ChangeSize);
    glutDisplayFunc(RenderScene);
    glutSpecialFunc(SpecialKeys);
    
    SetupRC();
    
    glutMainLoop();
    return 0;
}

5.6、glBlendFuncSeparate 函数

除了能使⽤glBlendFunc 来设置混合因子，还可以有更灵活的选择。
void glBlendFuncSeparate(GLenum strRGB,GLenum dstRGB ,GLenum strAlpha,GLenum dstAlpha);
strRGB: 源颜色的混合因⼦ dstRGB: ⽬标颜色的混合因子 strAlpha: 源颜⾊的Alpha因子 dstAlpha: ⽬标颜⾊的Alpha因子

5.7 glBlendFuncSeparate 注意

5.8、常量混合颜色

常量混合颜色，默认初始化为⿊色(0.0f,0.0f,0.0f,0.0f)，但是还是可以修改这个常量混合颜色。
void glBlendColor(GLclampf red ,GLclampf green ,GLclampf blue ,GLclampf alpha);

上一篇下一篇

猜你喜欢

热点阅读