OpenGL基础31：混合

最新推荐文章于 2023-12-08 15:23:54 发布

Jaihk662

最新推荐文章于 2023-12-08 15:23:54 发布

阅读量1.1k

点赞数 1

分类专栏： # openGL 文章标签： openGL

本文链接：https://blog.csdn.net/jaihk662/article/details/107252321

版权

openGL 专栏收录该内容

57 篇文章 106 订阅

订阅专栏

在很多游戏场景中，地面往往都不是完全干净和平坦的，如果是草坪，那么肯定会有一些长得比较高的杂草，而对于沙地，往往总会有一些奇形怪状的石头等，一般来讲确实可以用模型，但是贴图也是一个不错的选择

一、Alpha值

考虑给地面铺上“石头”：

注意如果想加载这种纹理，最好保证空白的部分是透明的而并非为白底！

前面讨论过颜色的属性：RGB，其实颜色还有一个属性A代表为透明度

也就是说：RGBA才是一个表示颜色的“完全体”，如果想渲染一些半透明的材质，就必须要考虑到透明度这一属性，就如上面的石头贴图：空白部分的透明度为0，而每块石头的底下都有一小块阴影，它们的颜色为灰色，透明度都在0.2~0.5范围内

二、片段丢弃

用之前的知识，新建一个简单的“石头”的着色器：

StoneVShader 和 StoneFShader

#version 330 core
layout (location = 0) in vec3 position;
layout (location = 1) in vec2 texture;
out vec2 texIn;
uniform mat4 model;             //模型矩阵
uniform mat4 view;              //观察矩阵
uniform mat4 projection;        //投影矩阵
void main()
{
    gl_Position = projection * view * model * vec4(position, 1.0);
    texIn = texture;
}



#version 330 core
out vec4 color;
in vec2 texIn;
uniform sampler2D texOut;
void main()
{
    vec4 texColor = texture(texOut, texIn);
    color = texColor;
}

然后设定几个石头的位置和顶点，新建VAOVBO，按照以前的知识渲染就好了：

//绑定VAOVBO的部分略，可以参考完整代码
shaderStone.Use();
glBindVertexArray(stoneVAO);
glBindTexture(GL_TEXTURE_2D, stone);
glUniformMatrix4fv(glGetUniformLocation(shaderStone.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(shaderStone.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
for (GLuint i = 0; i < vegetation.size(); i++)
{
    model = glm::mat4(1.0f);
    model = glm::translate(model, vegetation[i]);
    model = glm::rotate(model, glm::radians(90.0f), glm::vec3(-1.0f, 0.0f, 0.0f));
    glUniformMatrix4fv(glGetUniformLocation(shaderStone.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
    glDrawArrays(GL_TRIANGLES, 0, 6);
}

需要考虑的一点是，之前生成纹理是没有考虑透明度的，因此要小小的修改下纹理的设置：

其中一些设置都是往“合理”的方向考虑的，例如如果考虑了透明度，就不要采用重复纹理平铺的方式，而是采用边缘拉伸（想想看既然边缘是完全透明，这个时候边缘拉伸就不会有任何的问题）

GLuint loadTexture(const GLchar* path, GLboolean alpha)
{
    GLuint textureID;
    glGenTextures(1, &textureID);
    int width, height;
    unsigned char* image;
    if (alpha)
        image = SOIL_load_image(path, &width, &height, 0, SOIL_LOAD_RGBA);
    else
        image = SOIL_load_image(path, &width, &height, 0, SOIL_LOAD_RGB);
    cout << path << image << endl;
    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexImage2D(GL_TEXTURE_2D, 0, alpha ? GL_RGBA : GL_RGB, width, height, 0, alpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, image);
    glGenerateMipmap(GL_TEXTURE_2D);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, alpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, alpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);
    SOIL_free_image_data(image);
    return textureID;
}

搞定之后，应该可以得到以下的效果：

这明显是有问题的，需要把alpha为0的部分丢弃掉

可以在片段着色器中是用discard命令丢弃片段，它保证了片段不会被进一步处理，这样就不会进入颜色缓冲：

#version 330 core
out vec4 color;
in vec2 texIn;
uniform sampler2D texOut;
void main()
{
    vec4 texColor = texture(texOut, texIn);
    if(texColor.a < 0.1)            //如果当前片段alpha值<0.1则丢弃
        discard;
    color = texColor;
}

搞定了！效果如上：还是有问题。。石头的阴影被显示了完全真实的颜色（黑色），并没有考虑其透明度

事实上，对于阴影部分的颜色，应该是当前阴影色（黑色）与地板颜色混合而成的

当然可以用一些奇技淫巧：例如颜色过深继续忽略：

if(texColor.a < 0.1 || (texColor.r < 0.5 && texColor.g < 0.5 && texColor.b < 0.5))
    discard;

好了，完(qiang)美(xing)解决，直接去掉了阴影：

三、混合

在《OpenGL基础3：渲染管线》这一章的图片中，就有测试与混合这一阶段，测试（深度测试和模板测试）在前面已经理解过了，接下来就是混合了

也是为了解决上面的问题

如果一个透明度为0.4的物体薄片在最外层，那么当前片段的颜色就应由40%的物体自身的颜色和60%的后面的颜色组成，这就是混合

在openGL中，用公式描述就是：

$\bar{C}_{\text {result}}=\bar{C}_{\text {source}} * F_{\text {source}}+\bar{C}_{\text {destination}} * F_{\text {destination}}$

$\bar{C}_{\text {source}}$ ：源颜色向量，来自当前纹理的本来的颜色向量
$\bar{C}_{\text {destination}}$ ：目标颜色向量。这是储存在颜色缓冲中当前位置的颜色向量
$F_{\text {source}}$ ：源因子。设置了对源颜色的alpha值影响
$F_{\text {destination}}$ ：目标因子。设置了对目标颜色的alpha影响

一个很简单的例子：

对应的计算公式就为

$\bar{C}_{\text {result}}=\left(\begin{array}{c} 0.0 \\ 1.0 \\ 0.0 \\ 0.6 \end{array}\right) * 0.6+\left(\begin{array}{c} 1.0 \\ 0.0 \\ 0.0 \\ 1.0 \end{array}\right) *(1-0.6)$

片段着色器运行完成并且所有的测试都通过以后，混合方程才能自由执行片段的颜色输出，前面片段的颜色在当前片段之前储存，都位于颜色缓冲中，源和目标颜色会自动被OpenGL设置，而源和目标因子可以让我们自由设置

像大多数OpenGL的功能一样，可以开启GL_BLEND来启用混合(Blending)功能：

glEnable(GL_BLEND);

颜色因子设置函数：

glBlendFunc(F1, F2)：设置源因子的值和目标因子的值
glBlendFuncSeperate(F1forRGB, F2forRGB, F1forA, F2forA)：将RGB和alpha通道分开计算，设置对应源因子的值和目标因子的值

有以下几种参数：

在正常情况下都是将源颜色的alpha值给源因子，1−alpha给目标因子，也就是进行只需要添加2行代码就可以解决问题：

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

这样就也不再需要在片段着色器中丢弃片段了

搞定，OpenGL还给了我们更多的自由，甚至可以改变方程源和目标部分的操作符，默认是源和目标元素相加，如果我们愿意的话，我们还可以将它们相减

glBlendEquation(GLenum mode)允许我们设置这个操作，有3种可行的选项：

GL_FUNC_ADD：默认的，彼此元素相加： $\bar{C}_{\text {result}}=\operatorname{Src}+D s t$
GL_FUNC_SUBTRACT：彼此元素相减： $\bar{C}_{\text {result}}=\operatorname{Src}-D s t$
GL_FUNC_REVERSE_SUBTRACT：彼此元素相减，但顺序相反： $\bar{C}_{\text {result}}=D s t - \operatorname{Src}$

一般都是第一种（可以随便设置下看看效果）

四、扩展

阴影(Shadow)：

其实看下上面的图片会有种很怪的感觉，因为它还是有问题的，这个阴影很明显还是不应该显示，毕竟阴影的位置是由光照决定的，当然不可能画死在纹理里，然而之前在光照的那些章节中并没有讲解关于阴影的内容

其实阴影属于比较难的一部分了，不属于基础光照的范畴，如果有机会，后面专门开一篇讲

次序无关透明度(order independent transparency)和深度剥离算法(Depth Peeling)：

上面没有考虑到的一种情况是：有多个透明物体需要依次渲染

一个很暴力的方法就是对这些透明物体按照离摄像机的距离排序，然后严格按照此顺序渲染，换句话说，我们必须保证一些物体在另一个透明物体之前绘制好，不然就有可能出现不应该被丢弃的颜色片段由于没有通过深度测试的原因，提前被丢弃

然而，事实上远比这个复杂得多，先不说排序的复杂度，物体之间的关系可能非常的复杂，物体的数量大小和形状也都需要被考虑，因此半透明物体的绘制（简单点的有鱼缸、克莱因瓶、比色卡等）其实是有相当的难度的，对此两个很经典的技术就是次序无关透明度(order independent transparency)和深度剥离算法(Depth Peeling)，这个也是有机会后面再专门讲吧

总而言之，上面说的都不再属于openGL的基础内容了，但却是都要被考虑到的

完整代码：

#include<iostream>
#include<opengl/glew.h>
#define GLEW_STATIC
#include<GLFW/glfw3.h>
#include"Shader.h"
#include"Camera.h"
#include<glm/glm.hpp>
#include<glm/gtc/matrix_transform.hpp>
#include<glm/gtc/type_ptr.hpp>
#include"Mesh.h"
#include"Model.h"
#include<opengl/freeglut.h>
#include<SOIL.h>

bool keys[1024];
Camera camera;
GLfloat lastX, lastY;
bool firstMouse = true;
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
GLuint loadTexture(const GLchar* path, GLboolean alpha);
void cameraMove();
const GLuint WIDTH = 800, HEIGHT = 600;

int main()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
    glfwMakeContextCurrent(window);
    glfwSetKeyCallback(window, key_callback);
    glfwSetCursorPosCallback(window, mouse_callback);
    glfwSetScrollCallback(window, scroll_callback);

    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    glewExperimental = GL_TRUE;
    glewInit();

    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    glViewport(0, 0, width, height);

    Shader shaderObj("ObjVShader.vert", "ObjFShader.frag");
    Shader shaderLight("LightVShader.vert", "LightFShader.frag");
    Shader shaderStone("StoneVShader.vert", "StoneFShader.frag");

    GLfloat vertices[] = 
    {
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  0.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
         0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,

        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
        -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,

         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
         0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
         0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f
    };
    GLfloat stoneVertices[] = 
    {
        0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
        0.0f, -0.5f,  0.0f,  0.0f,  1.0f,
        1.0f, -0.5f,  0.0f,  1.0f,  1.0f,
        0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
        1.0f, -0.5f,  0.0f,  1.0f,  1.0f,
        1.0f,  0.5f,  0.0f,  1.0f,  0.0f
    };
    glm::vec3 positions[] = 
    {
        glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3(0.0f, 0.89f, 0.0f),
        glm::vec3(0.0f, 1.78f, 0.0f),
        glm::vec3(-2.0f, 0.0f, 0.0f),
        glm::vec3(-2.0f, 0.89f, 0.0f),
        glm::vec3(-3.0f, 0.0f, 0.0f),
        glm::vec3(-2.0f, 0.0f, 1.0f),
        glm::vec3(-1.0f, 0.0f, -4.0f),
    };
    glm::vec3 pointLightPositions[] = 
    {
       glm::vec3(-1.0f, 1.8f, -2.0f),
       glm::vec3(0.0f, 0.8f, 2.0f),
       glm::vec3(-5.0f, 0.8f, 1.0f),
    };
    vector<glm::vec3> vegetation;
    vegetation.push_back(glm::vec3(-1.5f, -0.01f, -0.48f));
    vegetation.push_back(glm::vec3(1.5f, -0.01f, 0.51f));
    vegetation.push_back(glm::vec3(0.0f, -0.01f, 0.7f));
    vegetation.push_back(glm::vec3(-0.3f, -0.01f, -2.3f));
    vegetation.push_back(glm::vec3(0.5f, -0.01f, -0.6f));
    GLuint VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);

    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);

    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
    glEnableVertexAttribArray(2);

    GLuint lightVAO;
    glGenVertexArrays(1, &lightVAO);
    glBindVertexArray(lightVAO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
    //VBO数据已经绑定且我们就用之前的顶点数据，所以无需再管理VBO
    glEnableVertexAttribArray(0);

    GLuint stoneVAO, stoneVBO;
    glGenVertexArrays(1, &stoneVAO);
    glGenBuffers(1, &stoneVBO);
    glBindVertexArray(stoneVAO);
    glBindBuffer(GL_ARRAY_BUFFER, stoneVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(stoneVertices), stoneVertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
    glEnableVertexAttribArray(1);
    GLuint stone = loadTexture("Texture/stone3.png", true);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_STENCIL_TEST);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);             //模板测试和深度测试都成功时，将对应像素的模板值设置为用glStencilFunc函数设置的ref值
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    Model wood("Object/wood/file.fbx", "Object/wood/file.fbx");
    Model ground("Object/ground/ground.fbx", "Object/ground");
    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glStencilMask(0xFF);                  //设置模板缓冲区可写入，如果设置为不可写入之后清空模板缓冲区，将会清空失败！毕竟不可写入了
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
        cameraMove();

        shaderLight.Use();
        glm::mat4 view = camera.GetViewMatrix();
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
        glm::mat4 model = glm::mat4(1.0f);
        GLint modelLoc = glGetUniformLocation(shaderLight.Program, "model");
        GLint viewLoc = glGetUniformLocation(shaderLight.Program, "view");
        GLint projLoc = glGetUniformLocation(shaderLight.Program, "projection");
        glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
        glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));

        glBindVertexArray(lightVAO);
        glStencilFunc(GL_ALWAYS, 0xFF, 0xFF);                   //无论模板测试如何，一定可以绘制;
        glUniform3f(glGetUniformLocation(shaderLight.Program, "lightColor"), 1.0f, 1.0f, 1.0f);
        for (int i = 0; i <= 2; i++)
        {
            model = glm::translate(glm::mat4(1.0f), pointLightPositions[i]);
            model = glm::scale(model, glm::vec3(0.2f));
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            glDrawArrays(GL_TRIANGLES, 0, 36);
        }
        glStencilFunc(GL_NOTEQUAL, 0xFF, 0xFF);                 //对应像素模板值若等于256，则对应像素不绘制
        glStencilMask(0x00);                                    //模板缓冲区不再可写
        glUniform3f(glGetUniformLocation(shaderLight.Program, "lightColor"), 1.0f, 1.0f, 0.0f);
        for (int i = 0; i <= 2; i++)
        {
            model = glm::translate(glm::mat4(1.0f), pointLightPositions[i]);
            model = glm::scale(model, glm::vec3(0.22f));
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            glDrawArrays(GL_TRIANGLES, 0, 36);
        }
        glStencilFunc(GL_ALWAYS, 0xFF, 0xFF);
        shaderObj.Use();
        glUniform3f(glGetUniformLocation(shaderObj.Program, "sunLight.direction"), -0.2f, -1.0f, -0.3f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "sunLight.diffuse"), 0.4f, 0.4f, 0.4f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "sunLight.specular"), 0.5f, 0.5f, 0.5f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[0].position"), pointLightPositions[0].x, pointLightPositions[0].y, pointLightPositions[0].z);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[0].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[0].k0"), 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[0].k1"), 0.09);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[0].k2"), 0.032);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[1].position"), pointLightPositions[1].x, pointLightPositions[1].y, pointLightPositions[1].z);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[1].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[1].k0"), 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[1].k1"), 0.09);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[1].k2"), 0.032);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[2].position"), pointLightPositions[2].x, pointLightPositions[2].y, pointLightPositions[2].z);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[2].diffuse"), 0.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "pointLights[2].specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[2].k0"), 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[2].k1"), 0.09);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "pointLights[2].k2"), 0.032);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "spotLight.position"), camera.Position.x, camera.Position.y, camera.Position.z);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "spotLight.direction"), camera.Front.x, camera.Front.y, camera.Front.z);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "spotLight.diffuse"), 1.0f, 1.0f, 1.0f);
        glUniform3f(glGetUniformLocation(shaderObj.Program, "spotLight.specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "spotLight.k0"), 1.0f);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "spotLight.k1"), 0.09);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "spotLight.k2"), 0.032);
        glUniform1f(glGetUniformLocation(shaderObj.Program, "spotLight.cutOff"), glm::cos(glm::radians(12.5f)));
        glUniform1f(glGetUniformLocation(shaderObj.Program, "spotLight.outCutOff"), glm::cos(glm::radians(16.0f)));
        glUniform3f(glGetUniformLocation(shaderObj.Program, "viewPos"), camera.Position.x, camera.Position.y, camera.Position.z);

        modelLoc = glGetUniformLocation(shaderObj.Program, "model");
        viewLoc = glGetUniformLocation(shaderObj.Program, "view");
        projLoc = glGetUniformLocation(shaderObj.Program, "projection");
        glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
        for (int i = 0; i <= 7; i++)
        {
            model = glm::translate(glm::mat4(1.0f), positions[i]);
            model = glm::scale(model, glm::vec3(0.01f));
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            wood.Draw(shaderObj);
        }
        for (int i = -2; i <= 1; i++)
        {
            for(int j = -2; j <= 1; j++)
            {
                model = glm::translate(glm::mat4(1.0f), glm::vec3(i * 3.52f, -0.05f, j * 3.72f));
                model = glm::scale(model, glm::vec3(0.1f));
                model = glm::rotate(model, glm::radians(90.0f), glm::vec3(-1.0f, 0.0f, 0.0f));
                glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
                ground.Draw(shaderObj);
            }
        }

        shaderStone.Use();
        glBindVertexArray(stoneVAO);
        glBindTexture(GL_TEXTURE_2D, stone);
        glUniformMatrix4fv(glGetUniformLocation(shaderStone.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(glGetUniformLocation(shaderStone.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
        for (GLuint i = 0; i < vegetation.size(); i++)
        {
            model = glm::mat4(1.0f);
            model = glm::translate(model, vegetation[i]);
            model = glm::rotate(model, glm::radians(90.0f), glm::vec3(-1.0f, 0.0f, 0.0f));
            glUniformMatrix4fv(glGetUniformLocation(shaderStone.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
            glDrawArrays(GL_TRIANGLES, 0, 6);
        }

        glBindVertexArray(0);
        glfwSwapBuffers(window);
    }
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glfwTerminate();
    return 0;
}

GLuint loadTexture(const GLchar* path, GLboolean alpha)
{
    GLuint textureID;
    glGenTextures(1, &textureID);
    int width, height;
    unsigned char* image;
    if (alpha)
        image = SOIL_load_image(path, &width, &height, 0, SOIL_LOAD_RGBA);
    else
        image = SOIL_load_image(path, &width, &height, 0, SOIL_LOAD_RGB);
    cout << path << image << endl;
    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexImage2D(GL_TEXTURE_2D, 0, alpha ? GL_RGBA : GL_RGB, width, height, 0, alpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, image);
    glGenerateMipmap(GL_TEXTURE_2D);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, alpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, alpha ? GL_CLAMP_TO_EDGE : GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);
    SOIL_free_image_data(image);
    return textureID;
}

GLfloat deltaTime = 0.0f;
GLfloat lastFrame = 0.0f;
void cameraMove()
{
    GLfloat currentFrame = glfwGetTime();
    deltaTime = currentFrame - lastFrame;
    lastFrame = currentFrame;

    GLfloat cameraSpeed = 1.0f * deltaTime;
    if (keys[GLFW_KEY_W])
        camera.ProcessKeyboard(Camera_Movement(FORWARD), deltaTime);
    if (keys[GLFW_KEY_S])
        camera.ProcessKeyboard(Camera_Movement(BACKWARD), deltaTime);
    if (keys[GLFW_KEY_A])
        camera.ProcessKeyboard(Camera_Movement(LEFT), deltaTime);
    if (keys[GLFW_KEY_D])
        camera.ProcessKeyboard(Camera_Movement(RIGHT), deltaTime);
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GL_TRUE);
    if (action == GLFW_PRESS)           //如果当前是按下操作
        keys[key] = true;
    else if (action == GLFW_RELEASE)            //松开键盘
        keys[key] = false;
}

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
    camera.ProcessMouseScroll(yoffset);
}

void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }
    GLfloat xoffset = xpos - lastX;
    GLfloat yoffset = lastY - ypos;
    lastX = xpos;
    lastY = ypos;
    
    GLfloat sensitivity = 0.05;
    xoffset *= sensitivity;
    yoffset *= sensitivity;
    
    camera.ProcessMouseMovement(xoffset, yoffset);
}

Jaihk662

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
OpenGL基础31：混合

在很多游戏场景中，地面往往都不是完全干净和平坦的，如果是草坪，那么肯定会有一些长得比较高的杂草，而对于沙地，往往总会有一些奇形怪状的石头等，一般来讲确实可以用模型，但是贴图也是一个不错的选择一、Alpha值考虑给地面铺上“石头”：注意如果想加载这种纹理，最好保证空白的部分是透明的而并非为白底！前面讨论过颜色的属性：RGB，其实颜色还有一个属性A代表为透明度也就是说：RGBA才是一个表示颜色的“完全体”，如果想渲染一些半透明的材质，就必须要考虑到透明度这一属性，就如上面的石头...
复制链接

扫一扫