OpenGL--混合

最新推荐文章于 2024-08-09 11:49:11 发布
最新推荐文章于 2024-08-09 11:49:11 发布
阅读量2k 收藏 1
点赞数
分类专栏： OpenGL 文章标签： opengl 混合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010223072/article/details/44981677
版权
  • 理论基础
    混合：主要就是用来做一些如透明的特效，其实就是源颜色与目标颜色进行混合计算得到一个新颜色的过程。混合发生在图元光栅化之后，片段写入帧缓冲之前，片段与对应位置的帧缓冲区像素进行互操作形成新的像素颜色的过程及时混合。需要通过glEnable(GL_BLEND)来激活混合功能，否则的话片段直接覆盖对应像素。颜色的alpha分量值此时就会发挥作用。
    默认混合计算得到的新颜色是：
    这里写图片描述

注释：
1，先写入帧缓冲的是目标颜色，后将要写入的是源颜色,与它们的深度值大小无关。
2，openGL渲染时，将颜色值放在颜色缓冲区中，将深度值放在深度缓冲区中，如果深度测试关闭时，新的颜色值就会简单的覆盖颜色缓冲区中原来的值，而如果深度测试开启时，只有新的颜色深度值大于原来的值时才被覆盖。所以一般情况下颜色值要么完全覆盖要么完全丢弃。而如果同时又开启了混合，那么片段值就不能随便丢弃或覆盖了，这时主要就是要注意绘制的顺序，而如果这个绘制顺序很难确定，可以用glDepthMask(GL_FALSE)设置深度缓冲区为只读状态，这样来限制受深度测试的影响。
3，绘制顺序：对于半透明的，要先画远，再画近。对于不透明的，因为有深度测试，顺序不影响最终效果。但要优化性能的话，一般是先画近，再画远(直接丢弃而不需要覆盖)。苹果手机的显卡，对于不透明的，关闭混合之后，可以不论远近，性能一样。

  • 实例代码
    1，背景颜色与几何物体颜色做基本混合
#include "GLTools.h"
#include "GLShaderManager.h"

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

void init(void)
{
    glClearColor(1.0, 1.0, 0.0, 0.0);

    glBlendFunc(GL_ONE, GL_ONE);//设置源因子与目标因子取值
    glEnable(GL_BLEND);//开启混合
}

void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);

    //这个方形与背景混合
    glColor3f(0.0, 0.0, 1.0);
    glRectf(-0.5,-0.5,0.5,0.5);

    glFlush();
}

void reshape(int w, int h)
{
    GLdouble aspect = (GLdouble) w / h;

    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (aspect < 1.0) {
        aspect = 1.0 / aspect;
        glOrtho(-aspect, aspect, -1.0, 1.0, -1.0, 1.0);
    } else
        glOrtho(-1.0, 1.0, -aspect, aspect, -1.0, 1.0);
    glMatrixMode(GL_MODELVIEW);
}

void keyboard(unsigned char key, int x, int y)
{
    //设置混合的计算方式
    switch (key) {
        case 'a': case 'A':
            //源颜色+目标颜色(默认形式)
            glBlendEquation(GL_FUNC_ADD);
            break;

        case 's': case 'S':
            //源颜色-目标颜色
            glBlendEquation(GL_FUNC_SUBTRACT);
            break;

        case 'r': case 'R':
            //目标颜色-源颜色
            glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
            break;

        case 'm': case 'M':
            //分别取目标颜色和源颜色rgba中较小的值
            glBlendEquation(GL_MIN);
            break;

        case 'x': case 'X':
             //分别取目标颜色和源颜色rgba中较大的值
            glBlendEquation(GL_MAX);
            break;

        case 27:
            exit(0);
    }

    glutPostRedisplay();
}


int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(512,512);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[0]);
    init();
    glewInit();
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;

}

这里写图片描述

2，利用混合做遮挡透明

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

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


static int leftFirst = GL_TRUE;

static void init(void)
{
    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glShadeModel (GL_FLAT);
    glClearColor (0.0, 0.0, 0.0, 0.0);
}

static void drawLeftTriangle(void)
{
    glBegin (GL_TRIANGLES);
    glColor4f(1.0, 1.0, 0.0, 0.75);
    glVertex3f(0.1, 0.9, 0.0);
    glVertex3f(0.1, 0.1, 0.0);
    glVertex3f(0.7, 0.5, 0.0);
    glEnd();
}

static void drawRightTriangle(void)
{
    glBegin (GL_TRIANGLES);
    glColor4f(0.0, 1.0, 1.0, 0.75);
    glVertex3f(0.9, 0.9, 0.0);
    glVertex3f(0.3, 0.5, 0.0);
    glVertex3f(0.9, 0.1, 0.0);
    glEnd();
}

void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);

    if (leftFirst) {
        drawLeftTriangle();//目标颜色
        drawRightTriangle();//源颜色
    }
    else {
        drawRightTriangle();
        drawLeftTriangle();
    }

    glFlush();
}

void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h)
        gluOrtho2D (0.0, 1.0, 0.0, 1.0*(GLfloat)h/(GLfloat)w);
    else
        gluOrtho2D (0.0, 1.0*(GLfloat)w/(GLfloat)h, 0.0, 1.0);
}

void keyboard(unsigned char key, int x, int y)
{
    switch (key) {
        case 't':
        case 'T':
            leftFirst = !leftFirst;
            glutPostRedisplay();
            break;
        case 27:  /*  Escape key  */
            exit(0);
            break;
        default:
            break;
    }
}


int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize (200, 200);
    glutCreateWindow (argv[0]);
    init();
    glutReshapeFunc (reshape);
    glutKeyboardFunc (keyboard);
    glutDisplayFunc (display);
    glutMainLoop();
    return 0;
}

这里写图片描述

3，使用深度缓冲区进行三维混合(主要是使用glDepthMask来控制不让深度测试丢弃遮挡部分颜色值，然后就可以和基本操作一样进行混合)

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

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


#define MAXZ 8.0
#define MINZ -8.0
#define ZINC 0.4

static float solidZ = MAXZ;
static float transparentZ = MINZ;
static GLuint sphereList, cubeList;

static void init(void)
{
    GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 0.15 };
    GLfloat mat_shininess[] = { 100.0 };
    GLfloat position[] = { 0.5, 0.5, 1.0, 0.0 };

    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glLightfv(GL_LIGHT0, GL_POSITION, position);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);

    //使用显示列表绘制球体
    sphereList = glGenLists(1);
    glNewList(sphereList, GL_COMPILE);
    glutSolidSphere (0.4, 16, 16);
    glEndList();

    //使用显示列表绘制立方体
    cubeList = glGenLists(1);
    glNewList(cubeList, GL_COMPILE);
    glutSolidCube (0.6);
    glEndList();
}


void display(void)
{
    GLfloat mat_solid[] = { 0.75, 0.75, 0.0, 1.0 };
    GLfloat mat_zero[] = { 0.0, 0.0, 0.0, 1.0 };
    GLfloat mat_transparent[] = { 0.0, 0.8, 0.8, 0.6 };
    GLfloat mat_emission[] = { 0.0, 0.3, 0.3, 0.6 };

    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glPushMatrix ();
    glTranslatef (-0.15, -0.15, solidZ);
    glMaterialfv(GL_FRONT, GL_EMISSION, mat_zero);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_solid);
    glCallList (sphereList);
    glPopMatrix ();

    glPushMatrix ();
    glTranslatef (0.15, 0.15, transparentZ);
    glRotatef (15.0, 1.0, 1.0, 0.0);
    glRotatef (30.0, 0.0, 1.0, 0.0);
    glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_transparent);
    glEnable (GL_BLEND);
    glDepthMask (GL_FALSE);//设置深度缓冲区只读(目的是不让它丢弃遮挡部分)
    glBlendFunc (GL_SRC_ALPHA, GL_ONE);
    glCallList (cubeList);
    glDepthMask (GL_TRUE);//恢复深度缓冲区读写
    glDisable (GL_BLEND);
    glPopMatrix ();

    glutSwapBuffers();
}

void reshape(int w, int h)
{
    glViewport(0, 0, (GLint) w, (GLint) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h)
        glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
                 1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
    else
        glOrtho (-1.5*(GLfloat)w/(GLfloat)h,
                 1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void animate(void)
{
    if (solidZ <= MINZ || transparentZ >= MAXZ)
        glutIdleFunc(NULL);
    else {
        solidZ -= ZINC;
        transparentZ += ZINC;
        glutPostRedisplay();
    }
}

void keyboard(unsigned char key, int x, int y)
{
    switch (key) {
        case 'a':
        case 'A':
            solidZ = MAXZ;
            transparentZ = MINZ;
            glutIdleFunc(animate);
            break;
        case 'r':
        case 'R':
            solidZ = MAXZ;
            transparentZ = MINZ;
            glutPostRedisplay();
            break;
        case 27:
            exit(0);
    }
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow(argv[0]);
    init();
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

这里写图片描述

超級码力
关注
专栏目录
opengl--混合和雾化
蓝蓝的天
10-31 352
混合 使能混合 glEnable(GL_BLEND); 混合函数 一般步骤 使能深度测试 禁用混合 绘制远物体 深度测试设为只读 混合设置 绘制近物体 深度测试设为读写 示例 void draw_blend() { set_defaultviewprojection();//默认渲染器需要 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);...
OpenGL-SDK库
10-20
- **状态机模型**：OpenGL是一个状态机，通过设置各种状态（如深度测试、混合模式等）来控制渲染行为。 - **纹理映射（Texture Mapping）**：将2D图像贴附到3D物体表面，增加视觉真实感。 - **缓冲区对象（Buffer ...
OpenGL的Alpha混合（演示程序）
12-14
此资源是演示程序，可以免费下载。 ---------------------------------------- 有很久都没有使用OpenGL了。一直都只是看书，一旦实践起来就会发现比想象起来困难得多。不过我还是实现了OpenGL下面一个小小的效果：Alpha混合。 以前在DirectX上做过，所以赶紧回去看了看自己以前写的文章。果然像一些高手说得一样，Direct3D和OpenGL其实是相通的。像Direct3D中要实现此功能要这么写： m_pDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE ); m_pDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); m_pDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); 在OpenGL中则是这么写： glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
OpenGL: 混合
Augusdi的专栏
04-15 7011
OpenGL 红宝书 混合6.1 混合6.1.1 源因子和目标因子假定源和目标混合因子分别为(Sr, Sg, Sb, Sa)和(Dr,Dg,Db,Da), 混合后的RGB值如下:(RsSr + RdDr, GsSg + GdDg, BsSb + BdDb, AsSa + AdDa)最后,将该四元组的各个分量截取到[0,1].将源片元和目标象素合并起来的默认方式是,将它们的值相加. 选择源混合因子和
LearnOpenGL——混合、面剔除
最新发布
weixin_70073176的博客
08-09 668
实际的环绕顺序是。
OpenGL-混合
weixin_45054115的博客
09-03 805
OpenGL 混合
OpenGL学习笔记一之高级OpenGL篇三 混合
飞飞飞的博客
05-06 617
转载自https://learnopengl-cn.github.io/04%20Advanced%20OpenGL/03%20Blending/ OpenGL中，混合(Blending)通常是实现物体透明度(Transparency)的一种技术。透明就是说一个物体（或者其中的一部分）不是纯色(Solid Color)的，它的颜色是物体本身的颜色和它背后其它物体的颜色的不同强度结合。一个有色玻...
OpenGL 混合
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
06-19 1024
混合(Blending)通常是实现物体透明度的一种技术。透明就是说一个物体（或者其中的一部分）不是纯色(Solid Color)的，它的颜色是物体本身的颜色和它背后其它物体的颜色的不同强度结合。
OpenGL快速查找手册-OpenGL-ES-2_0-Reference-card
04-10
9. **状态机模型（State Machine）**：OpenGL ES 2.0中有大量的状态变量，如颜色混合、深度测试等，可以通过函数调用来设置。 10. **着色器变量（Shader Variables）**：包括uniforms（全局变量，可由CPU设置，着色...
android-openGL-canvas-master.zip
08-21
理解并正确管理这些状态（如深度测试、混合模式、纹理单元等）对于优化性能和避免渲染错误至关重要。 5. **Canvas 绘图**：开发者可能在 OpenGL 渲染完成后，利用 Canvas 在上面绘制2D元素。这可能涉及到对 Canvas ...
opengl-1.1.rar_opengl 1.1
09-20
9. **渲染管线**：OpenGL的核心是其渲染管线，它将图形数据从模型空间经过变换、裁剪、投影，再到屏幕空间，最后进行颜色混合和深度测试，生成最终图像。 10. **错误检查和调试**：OpenGL提供了一些函数，如`...
QtOpenGL二维和三维混合的例子（源代码）
01-12
Qt自有一个混图的引擎，这个引擎的核心就是QPainter，我们知道QPainter在渲染二维图形和文字有很大的优势，而OpenGL是当前流行的三维渲染器，怎样才能将两者结合起来，制作更为丰富的应用程序？《C++GUI Programming with Qt 4, secondedition》这本书给了我们一个小的例子，不过我们还要深入地以这个例子为基础进行挖掘，配合Qt的文档，我们才能真正地了解Qt对OpenGL的封装。
opengl之混合
wqdqwass的博客
08-30 239
混合的理论 openglCN官网之混合 不考虑深度和模板的情况下 代码内容修改 glsl:由于启用了混合，我们就不需要丢弃片段了，所以我们把片段着色器还原(这里我们用的是透明值) FragColor=vec4(result,texColor.a); 主函数修改 首先生成模型model都是一样的，所以都提出来；然后旋转效果去掉 for (_modelsIter = _models.begin(); _modelsIter != _models.end(); _modelsIte
opengl混合
copymaster
01-04 171
OpenGL中，混合(Blending)通常是实现物体透明度(Transparency)的一种技术。透明就是说一个物体（或者其中的一部分）不是纯色(Solid Color)的，它的颜色是物体本身的颜色和它背后其它物体的颜色的不同强度结合。一个有色玻璃窗是一个透明的物体，玻璃有它自己的颜色，但它最终的颜色还包含了玻璃之后所有物体的颜色。这也是混合这一名字的出处，我们混合(Blend)（不同物体的）多...
OpenGL混合
xuexi23456的博客
07-26 579
混合
opengl---7.混合
WADE
05-27 267
一、概念 “混合”是指两种颜色的叠加方式。在新图片将要渲染画到屏幕上的时候，将用在新图片中的红、绿、蓝和透明度信息，与屏幕上已经存在的图片颜色信息相融合。 说的具体一点，就是把某一像素位置上原来的颜色和将要画上去的颜色，通过某种方式混在一起，从而实现特殊的效果。 新图片颜色被称作“源颜色”，而屏幕上已存在的图片颜色则被称作“目标颜色”。 OpenGL会把源颜色和目标颜色各自取出，并乘以一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值