openGL缓存概念和缓存清除（01）

一、说明

   操作缓存就是操作屏幕；而因为渲染的多样性需求，缓存是多样的，对多样的缓存操作，就是渲染操作。本篇对基本的几个渲染缓存进行操作。

二、gl函数明细

2.1 示例代码

from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *


def drawFun():
    glClearColor(1.0,0.0,1.,0.0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glutWireTeapot(0.5)
    glFlush()


glutInit()
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(500, 500)
glutCreateWindow("First")
glutDisplayFunc(drawFun)
glutMainLoop()

2.3 buff清除glClear

• 函数原型:

  void glClear(GLbitfield mask);

• 参数说明：

   GLbitfield：可以使用 | 运算符组合不同的缓冲标志位，表明需要清除的缓冲，例如glClear（GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT）表示要清除颜色缓冲以及深度缓冲，可以使用以下标志位

GL_COLOR_BUFFER_BIT: 当前可写的颜色缓冲
GL_DEPTH_BUFFER_BIT: 深度缓冲
GL_ACCUM_BUFFER_BIT: 累积缓冲
GL_STENCIL_BUFFER_BIT: 模板缓冲

• 函数说明：

   glClear（）函数的作用是用当前缓冲区清除值，也就是glClearColor或者glClearDepth、glClearIndex、glClearStencil、glClearAccum等函数所指定的值来清除指定的缓冲区，也可以使用glDrawBuffer一次清除多个颜色缓存。

三、缓冲和渲染的关系

3.1 颜色buff的情节

** 例：用黄色背景清除屏幕**

glClearColor（1.0，1.0，0.0，0.0）;
glClear（GL_COLOR_BUFFER_BIT）;

• 第一条语句表示清除颜色设为黄色，第二条语句表示实际完成了把整个窗口清除为黄色的任务，glClear（）的唯一参数表示需要被清除的缓冲区。
• 像素检验、裁剪检验、抖动和缓存的写屏蔽都会影响glClear的操作，其中，裁剪范围限制了清除的区域，而glClear命令还会忽略alpha函数、融合函数、逻辑操作、模板、纹理映射和z缓存；

3.2 深度缓冲详解(DepthBuffer)

1. 深度缓冲概念
  深度缓冲区与帧缓冲区相对应，用于记录上面每个像素的深度值，通过深度缓冲区，我们可以进行深度测试，从而确定像素的遮挡关系，保证渲染正确。
2. 何为深度
  深度其实就是该象素点在3d世界中距离摄象机的距离（绘制坐标），深度缓存中存储着每个象素点（绘制在屏幕上的）的深度值！深度值（Z值）越大，则离摄像机越远。
3. 为什么需要深度？
  在不使用深度测试的时候，如果我们先绘制一个距离较近的物体，再绘制距离较远的物体，则距离远的物体因为后绘制，会把距离近的物体覆盖掉，这样的效果并不是我们所希望的。而有了深度缓冲以后，绘制物体的顺序就不那么重要了，都能按照远近（Z值）正常显示，这很关键。
4. 深度缓冲原理
  深度缓冲区原理就是把一个距离观察平面(近裁剪面)的深度值(或距离)与窗口中的每个像素相关联。
  首先，使用glClear(GL_DEPTH_BUFFER_BIT),把所有像素的深度值设置为最大值(一般是远裁剪面)。然后，在场景中以任意次序绘制所有物体。硬件或者软件所执行的图形计算把每一个绘制表面转换为窗口上一些像素的集合，此时并不考虑是否被其他物体遮挡。其次，OpenGL会计算这些表面和观察平面的距离。如果启用了深度缓冲区，在绘制每个像素之前，OpenGL会把它的深度值和已经存储在这个像素的深度值进行比较。新像素深度值<原先像素深度值，则新像素值会取代原先的；反之，新像素值被遮挡，他颜色值和深度将被丢弃。为了启动深度缓冲区，必须先启动它，即glEnable(GL_DEPTH_TEST)。每次绘制场景之前，需要先清除深度缓冲区，即glClear(GL_DEPTH_BUFFER_BIT)，然后以任意次序绘制场景中的物体。
5. 深度测试
在默认情况是将需要绘制的新像素的z值与深度缓冲区中对应位置的z值进行比较，如果比深度缓存中的值小，那么用新像素的颜色值更新帧缓存中对应像素的颜色值。
但是可以使用glDepthFunc(func)来对这种默认测试方式进行修改。其中参数func的值可以为GL_NEVER（没有处理）、GL_ALWAYS（处理所有）、GL_LESS（小于）、GL_LEQUAL（小于等于）、GL_EQUAL（等于）、GL_GEQUAL（大于等于）、GL_GREATER（大于）或GL_NOTEQUAL（不等于），其中默认值是GL_LESS。
一般来将，使用glDepthFunc(GL_LEQUAL);来表达一般物体之间的遮挡关系。
6. 所带来的弊端
启用了深度测试，那么这就不适用于同时绘制不透明物体。当需要绘制半透明物体时，需注意，在绘制半透明物体时前，还需要利用glDepthMask(GL_FALSE)将深度缓冲区设置为只读形式，否则可能出现画面错误。为什么呢，因为画透明物体时，将使用混色，这时就不能继续使用深度模式，而是利用混色函数来进行混合。这一来，就可以使用混合函数绘制半透明物体了。
7. 深入
像素的深度值是由视矩阵和投影矩阵决定的。在近裁平面上的像素深度值为0，在远裁平面上的像素的深度值为1。场景中的每个对象都需进行绘制，通常最靠近相机的像素会被保留，这些对象阻挡了在它们后面的对象的可见性。
深度缓冲通常还包含stencil bits – 所以深度缓冲又被叫做depth-stencil缓冲。深度缓冲总是32 bits，但可以用不同的方式组合，类似于纹理格式。常用的深度格式是Depth32，这种格式中32 bits都用来存储深度信息。另一个常用格式是DepthFormat.Depth24Stencil8，这种格式中24 bits用于深度计算而8 bits用于模版缓冲（stencil buffer）。
8. 补充内容
颜色缓冲区（COLOR_BUFFER）就是帧缓冲区（FRAME_BUFFER）,你需要渲染的场景最终每一个像素都要写入该缓冲区,然后由它在渲染到屏幕上显示.

3.3 Accumulation Buffer（累积缓存）

   累积缓存是为合成多幅图像而设计的，它不是简单的用引入象素片元来代替象素值，而是将片元进行缩放，然后加到已有的象素值上。为了经过一系列的混合操作后能够保持精度，累积缓存每个颜色分量的位数要比一般的可视化系统要多。
我们可以象其他缓存一样清空累积缓存，可以用glClearAccum()来设置红、绿和蓝色分量的清空值，按位顺序清空累积缓存或以GL_ACCUM_BUFFER_BIT调用glClear()命令。
你不能直接渲染进累积缓存，而是应该渲染到一个选定的缓存，然后用glAccum()来将在那缓存中的当前图像累积进累积缓存。glAccum()用当前选择的读取缓存来拷贝。你可以用glReadBuffer()来设置你想读取的缓存。
   glAccum()有2个参数：op和value。op值可为下面中的一个：
表1 glAccum()的op值

op值	动作
GL_ACCUM	从当前选定的缓存中读取象素（该缓存为了用glReadBuffer()进行读取而选定，用value乘上R、G、B、A值，然后将结果加到累积缓存中。
GL_LOAD	与GL_ACCUM操作类似，但它是用结果值替换掉累积缓存中的值，而不是与之相加。
GL_RETURN	从累积缓存中取值，以value乘以该值，然后将该结果放入为写操作而激活的颜色缓存中。
GL_ADD	将value值与累积缓存中的每个象素值的R、G、B、A分量相加
GL_MULT	将value值截取到[-1,1]之间，然后与累积缓存中的每象素的R、G、B、A分量相乘

   因为你必须在累积之前渲染到另一个缓存，所以累积图像典型的方法是，将图像渲染到后缓存若干次，累积每幅图像到累积缓存中，当所需的图像数目已累积后，将内容拷贝回后缓存中，然后交换前后缓存。这样，只有在最后，才显示累积的图像。
下面是累积n幅图像的一个示例程序：
   复制代码 1． 调用glDrawBuffer(GL_BACK)来只渲染到后缓存；
2． 调用glReadBuffer(GL_BACK)，这样累积缓存将从后缓存读取。
注意：前2步只有当应用程序已经改变了所选的写和读缓存时才需要。若可视化系统是双缓存，这些选择是默认的。
3． 调用glClear(bitfield)清空后缓存，然后渲染第1幅图像；
4． 调用glAccum(GL_LOAD,1.f/n);这允许你避免用分开的步骤来清空累积缓存；
5． 改变你的图像的参数，再重绘它；
6． 调用glAccum(GL_ACCUM,1.f/n)来将第2幅图像加到第1幅上；
7． 重复前面2个步骤≥n-2次……
8． 调用glAccum(GL_RETURN,1.f)来将完成的图像拷贝到后缓存中；
9． 调用glutSwapBuffers()（若使用GLUT）或SwapBuffers()（若使用Win32）来交换前后缓存。
   复制代码
   累积缓存提供了一种在保持好的颜色分辨率下实现在场景中“多重曝光（multiple exposures）”的方法。使用累积缓存可以产生许多图像效果来提高图像的真实性，其中包括：反走样、运动模糊、软阴影、深度域（景深）和卷积。要产生这些效果，必须将图像渲染多次，对场景位置（或所选的物体）进行微小的、渐增的改变，然后累积结果。

3.4 彻底搞懂模板测试(模板测试(Stencil Test)

   先给出learnopengl对于模板测试的解释：

   当片段着色器处理完一个片段之后，模板测试(Stencil Test)会开始执行，和深度测试一样，它也可能会丢弃片段。接下来，被保留的片段会进入深度测试，它可能会丢弃更多的片段。模板测试是根据又一个缓冲来进行的，它叫做模板缓冲(Stencil Buffer)，我们可以在渲染的时候更新它来获得一些很有意思的效果。

   从上面的信息我们可以了解到，模板测试是在深度测试之后的。

   模板缓冲的一个简单的例子：

   可以看出来在颜色缓冲之后，我们先设置模板缓冲的所有值为0，然后在将部分值修改为1，将模板缓冲值1的部分绘制出来，就可以的得到最后的效果。

   下面的内容我直接抄写gl的教程（本知识点翻译的比较难懂，我在抄取内容的时候加了自己的理解，用黑斜字体表示）。

   你可以启用GL_STENCIL_TEST来启用模板测试。在这一行代码之后，所有的渲染调用都会以某种方式影响着模板缓冲。

glEnable(GL_STENCIL_TEST);

   注意，和颜色和深度缓冲一样，你也需要在每次迭代之前清除模板缓冲。

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

   和深度测试的glDepthMask函数一样，模板缓冲也有一个类似的函数。glStencilMask允许我们设置一个位掩码(Bitmask)，它会与将要写入缓冲的模板值进行与(AND)运算。默认情况下设置的位掩码所有位都为1，不影响输出，但如果我们将它设置为0x00，写入缓冲的所有模板值最后都会变成0.这与深度测试中的glDepthMask(GL_FALSE)是等价的。

   glStencilMask(0xFF); // 每一位写入模板缓冲时都保持原样
glStencilMask(0x00); // 每一位在写入模板缓冲时都会变成0（禁用写入）
   大部分情况下你都只会使用0x00或者0xFF作为模板掩码(Stencil Mask)，但是知道有选项可以设置自定义的位掩码总是好的。

3.2 模板函数

   和深度测试一样，我们对模板缓冲应该通过还是失败，以及它应该如何影响模板缓冲，也是有一定控制的。一共有两个函数能够用来配置模板测试：glStencilFunc和glStencilOp。

glStencilFunc(GLenum func, GLint ref, GLuint mask)

   一共包含三个参数：

•    func：设置模板测试函数(Stencil Test Function)。这个测试函数将会应用到已储存的模板值上(其实就是模板缓冲的值，从这里开始翻译的就很奇怪了）和glStencilFunc函数的ref值上。可用的选项有：GL_NEVER、GL_LESS、GL_LEQUAL、GL_GREATER、GL_GEQUAL、GL_EQUAL、GL_NOTEQUAL和GL_ALWAYS。它们的语义和深度缓冲的函数类似。（解释一下就是比较res和模板缓冲的值）
•    ref：设置了模板测试的参考值(Reference Value)。模板缓冲的内容将会与这个值进行比较。
•    mask：设置一个掩码，它将会与参考值和储存的模板值在测试比较它们之前进行与(AND)运算。初始情况下所有位都为1。（翻译的有些奇怪？我的理解是将ref值和mask值做AND运算，结果为R，然后将模板缓冲中的中的值和mask做AND运算结果为S，之后在比较测试S和R，比较的方法是用前面设置的func函数）
     在一开始的那个简单的模板例子中，函数被设置为：

glStencilFunc(GL_EQUAL, 1, 0xFF)

   这会告诉OpenGL，只要一个片段的模板值等于(GL_EQUAL)参考值1，片段将会通过测试并被绘制，否则会被丢弃（补充，将ref（值为1）和0xFF做AND运算结果为1，假设模板缓冲的中值为1，和0xFF做AND运算结果为1，1 = 1所以通过模板测试），很多人对这个函数的作用的理解是马马虎虎，其实这个函数就是判断片段是否能通过模板测试并且绘制出来。

   但是glStencilFunc仅仅描述了OpenGL应该对模板缓冲内容做什么，而不是我们应该如何更新缓冲。这就需要glStencilOp这个函数了。

glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass)

   一共包含三个选项，我们能够设定每个选项应该采取的行为：

• sfail：模板测试失败时采取的行为。
• dpfail：模板测试通过，但深度测试失败时采取的行为。
• dppass：模板测试和深度测试都通过时采取的行为。
  每个选项都可以选用以下的其中一种行为：

   行为 描述
GL_KEEP 保持当前储存的模板值
GL_ZERO 将模板值设置为0
GL_REPLACE 将模板值设置为glStencilFunc函数设置的ref值
GL_INCR 如果模板值小于最大值则将模板值加1
GL_INCR_WRAP 与GL_INCR一样，但如果模板值超过了最大值则归零
GL_DECR 如果模板值大于最小值则将模板值减1
GL_DECR_WRAP 与GL_DECR一样，但如果模板值小于0则将其设置为最大值
GL_INVERT 按位翻转当前的模板缓冲值
默认情况下glStencilOp是设置为(GL_KEEP, GL_KEEP, GL_KEEP)的，所以不论任何测试的结果是如何，模板缓冲都会保留它的值。默认的行为不会更新模板缓冲，所以如果你想写入模板缓冲的话，你需要至少对其中一个选项设置不同的值。

   所以，通过使用glStencilFunc和glStencilOp，我们可以精确地指定更新模板缓冲的时机与行为了，我们也可以指定什么时候该让模板缓冲通过，即什么时候片段需要被丢弃。

物体轮廓

   仅仅看了前面的部分你还是不太可能能够完全理解模板测试的工作原理，所以我们将会展示一个使用模板测试就可以完成的有用特性，它叫做物体轮廓(Object Outlining)。

   在绘制（需要添加轮廓的）物体之前，将模板函数设置为GL_ALWAYS，每当物体的片段被渲染时，将模板缓冲更新为1。

渲染物体。

禁用模板写入以及深度测试。
将每个物体缩放一点点。
使用一个不同的片段着色器，输出一个单独的（边框）颜色。
再次绘制物体，但只在它们片段的模板值不等于1时才绘制。
再次启用模板写入和深度测试。
下面我就不再复制教程的内容，我给出我的理解，我写的注释很重要。

四、缓存的测试代码

 //启用深度测试
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glEnable(GL_STENCIL_TEST);
    //一开始模板缓冲的默认值是0，所以我们在不等于1的位置绘制物体。
    glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);//如果通过测试，就将模板缓冲中的值设置为指定的ref值。
                                              //如果禁用了模板更新，此语句作废。

    while (!glfwWindowShouldClose(window))
    {
        // per-frame time logic
        // --------------------
        float currentFrame = static_cast<float>(glfwGetTime());
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // input
        // -----
        processInput(window);

        // render
        // ------
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // don't forget to clear the stencil buffer!

        // set uniforms
        shaderSingleColor.use();
        glm::mat4 model = glm::mat4(1.0f);
        glm::mat4 view = camera.GetViewMatrix();
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        shaderSingleColor.setMat4("view", view);
        shaderSingleColor.setMat4("projection", projection);

        shader.use();
        shader.setMat4("view", view);
        shader.setMat4("projection", projection);

        //在绘制地板的时候，我们不更新模板缓冲，
        //所以glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);这段代码作废
        glStencilMask(0x00);
        // floor
        glBindVertexArray(planeVAO);
        glBindTexture(GL_TEXTURE_2D, floorTexture);
        shader.setMat4("model", glm::mat4(1.0f));
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);


       //现在我们要绘制箱子了，所以总是通过模板缓冲，在绘制箱子的地方，将模板缓冲的值设置为1
       //所以 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);这段代码生效，为什么模板缓冲的值为更新为1呢？
        glStencilFunc(GL_ALWAYS, 1, 0xFF);//因为这段代码设置了ref值为1，通过模板测试后就会更新模板值为1。
        glStencilMask(0xFF);
        // cubes
        glBindVertexArray(cubeVAO);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        shader.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        //现在绘制边框，在模板缓冲值不为1的地方绘制
        glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
        //当然我们不更新模板缓冲
        glStencilMask(0x00);
        //将深度测试禁用，是为了让边框不被地面所遮挡
        glDisable(GL_DEPTH_TEST);
        shaderSingleColor.use();
        float scale = 1.1f;
        // cubes
        glBindVertexArray(cubeVAO);
        glBindTexture(GL_TEXTURE_2D, cubeTexture);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
        model = glm::scale(model, glm::vec3(scale, scale, scale));
        shaderSingleColor.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        model = glm::mat4(1.0f);
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
        model = glm::scale(model, glm::vec3(scale, scale, scale));
        shaderSingleColor.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        glBindVertexArray(0);
        //这里是为了将模板缓冲清零，为下一次渲染做准备。
        glStencilMask(0xFF);
        glStencilFunc(GL_ALWAYS, 0, 0xFF);
        glEnable(GL_DEPTH_TEST);

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

   所以这里对模板缓冲有了一个直观的理解，可以类比PS里面的遮罩。