OpenGL天空盒skybox

最新推荐文章于 2023-11-29 15:31:59 发布
最新推荐文章于 2023-11-29 15:31:59 发布
阅读量2.2k 收藏 18
点赞数 2
分类专栏： 计算机图形学 文章标签： opengl 图形学 c++ xcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56632617/article/details/121390713
版权

目录

痛彻的感悟

天空盒可能的难题

天空盒代码

痛彻的感悟

今天考完试才发现自己和别人的差距还挺大的，四五六班下午的考试题目，我很快做了出来，但是自己的班级的考试题目，我竟然一道都没有成功！！！所以我决定把我之前准备的代码公布一下，也希望对一些人有所帮助吧。

天空盒可能的难题

  • SOIL2的配置
  • glm的配置
  • mac的xcode里面还有res资源库的配置
  • 主要参考网站：立方体贴图，往下翻有源码
  • 前面的理论部分参考我的好友博客：码辣香锅

天空盒代码

项目目录概览：(天空盒六张图片可以在上述 立方体贴图 链接下载到)

或者在我的Github上找到GitHub - NaughtyRacoon/GLskybox

 

main.cpp


//main.cpp

#include <iostream>
#include <vector>
using namespace std;
//GLEW
#define GLEW_STATIC
#include <GL/glew.h>

//GLFW
#include <GLFW/glfw3.h>

//GLM
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtx/rotate_vector.hpp>//利用旋转所需头文件

#include "SOIL2/SOIL2.h"
#include "SOIL2/stb_image.h"

#include "camera.h"
#include "Shader.h"
#include "light.h"


const GLint WIDTH = 800, HEIGHT = 600;
void KeyCallback(GLFWwindow *window , int key ,int scancode, int action,int mode);//退出函数
void ScrollCallback(GLFWwindow *window,double xOffset,double yOffset);//滚轮移动
void MouseCallback(GLFWwindow *window,double xPos,double yPos);//鼠标移动

void DoMovement();//获得当前这帧下按键处理,每次poll event之后才会有键盘操作

GLuint loadTexture(GLchar* path);
GLuint loadCubemap(vector<const GLchar*> faces);

bool keys[1024];//临时变量存储所有键盘操作
Camera camera(glm::vec3(0.0f,0.0f,2.0f));//实例化，往后看

GLfloat deltaTime = 0.0f;
GLfloat lastTime = 0.0f;
GLfloat lastX = WIDTH/2.0f;
GLfloat lastY = HEIGHT/2.0f;
bool firstMouse = true;
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_OPENGL_FORWARD_COMPAT, GL_TRUE); // must for Mac
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);//不让窗口变动大小

//大写开头是变量
GLFWwindow *window = glfwCreateWindow(WIDTH, HEIGHT, "Learn OpenGL", nullptr, nullptr);//创建窗口



if (nullptr == window)
{
std::cout<<"Failed to create GLFW window"<<std::endl;
    glfwTerminate();
return -1;
}


    // next two lines are for mac retina display
    int screenWidth, screenHeight;
    glfwGetFramebufferSize( window, &screenWidth, &screenHeight);
    glfwMakeContextCurrent( window );
    glfwSetKeyCallback(window, KeyCallback);
    glfwSetCursorPosCallback(window, MouseCallback);
    glfwSetScrollCallback(window, ScrollCallback);
    glewExperimental = GL_TRUE;
    

if (GLEW_OK != glewInit() )
{
std::cout << "Failed to initialise GLEW" << std::endl;
return -1;
}
    
    
    glEnable(GL_DEPTH_TEST);//深度测试开启
    glDepthFunc(GL_LESS);//小于就改变
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glViewport( 0, 0, screenWidth, screenHeight );


    Shader ourShader = Shader("res/shaders/core.vs","res/shaders/core.fs");
    Shader lightShader = Shader("res/shaders/light.vs","res/shaders/light.fs");
    Shader skyboxShader = Shader("res/shaders/skybox.vs","res/shaders/skybox.fs");

    
   // Light lightModel = Light();


GLfloat cubeVertices[]=
    {
        //position                 //法向量nomal
       -0.5f,-0.5f,-0.5f,       0.0f,0.0f,-1.0f,
        0.5f,-0.5f,-0.5f,       0.0f,0.0f,-1.0f,
        0.5f, 0.5f,-0.5f,       0.0f,0.0f,-1.0f,
        0.5f, 0.5f,-0.5f,       0.0f,0.0f,-1.0f,
       -0.5f, 0.5f,-0.5f,       0.0f,0.0f,-1.0f,
       -0.5f,-0.5f,-0.5f,       0.0f,0.0f,-1.0f,

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

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

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

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

        -0.5f,0.5f,-0.5f,       0.0f,1.0f,0.0f,
         0.5f,0.5f,-0.5f,       0.0f,1.0f,0.0f,
         0.5f,0.5f, 0.5f,       0.0f,1.0f,0.0f,
         0.5f,0.5f, 0.5f,       0.0f,1.0f,0.0f,
        -0.5f,0.5f, 0.5f,       0.0f,1.0f,0.0f,
        -0.5f,0.5f,-0.5f,       0.0f,1.0f,0.0f,
    };
    GLfloat skyboxVertices[] = {
           // Positions
           -1.0f,  1.0f, -1.0f,
           -1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f,  1.0f, -1.0f,
           -1.0f,  1.0f, -1.0f,
     
           -1.0f, -1.0f,  1.0f,
           -1.0f, -1.0f, -1.0f,
           -1.0f,  1.0f, -1.0f,
           -1.0f,  1.0f, -1.0f,
           -1.0f,  1.0f,  1.0f,
           -1.0f, -1.0f,  1.0f,
     
            1.0f, -1.0f, -1.0f,
            1.0f, -1.0f,  1.0f,
            1.0f,  1.0f,  1.0f,
            1.0f,  1.0f,  1.0f,
            1.0f,  1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
      
           -1.0f, -1.0f,  1.0f,
           -1.0f,  1.0f,  1.0f,
            1.0f,  1.0f,  1.0f,
            1.0f,  1.0f,  1.0f,
            1.0f, -1.0f,  1.0f,
           -1.0f, -1.0f,  1.0f,
     
           -1.0f,  1.0f, -1.0f,
            1.0f,  1.0f, -1.0f,
            1.0f,  1.0f,  1.0f,
            1.0f,  1.0f,  1.0f,
           -1.0f,  1.0f,  1.0f,
           -1.0f,  1.0f, -1.0f,
     
           -1.0f, -1.0f, -1.0f,
           -1.0f, -1.0f,  1.0f,
            1.0f, -1.0f, -1.0f,
            1.0f, -1.0f, -1.0f,
           -1.0f, -1.0f,  1.0f,
            1.0f, -1.0f,  1.0f
       };
    GLfloat vertices[]=
        {
            //position           //color
           -0.5f,-0.5f,-0.5f,     1.0f,0.0f,0.0f,
            0.5f,-0.5f,-0.5f,     1.0f,0.0f,0.0f,
            0.5f, 0.5f,-0.5f,     1.0f,0.0f,0.0f,
            0.5f, 0.5f,-0.5f,     1.0f,0.0f,0.0f,
           -0.5f, 0.5f,-0.5f,     1.0f,0.0f,0.0f,
           -0.5f,-0.5f,-0.5f,     1.0f,0.0f,0.0f,
            
            -0.5f,-0.5f,0.5f,     0.0f,1.0f,0.0f,
             0.5f,-0.5f,0.5f,     0.0f,1.0f,0.0f,
             0.5f, 0.5f,0.5f,     0.0f,1.0f,0.0f,
             0.5f, 0.5f,0.5f,     0.0f,1.0f,0.0f,
            -0.5f, 0.5f,0.5f,     0.0f,1.0f,0.0f,
            -0.5f,-0.5f,0.5f,     0.0f,1.0f,0.0f,
            
            -0.5f, 0.5f, 0.5f,    0.0f,0.0f,1.0f,
            -0.5f, 0.5f,-0.5f,    0.0f,0.0f,1.0f,
            -0.5f,-0.5f,-0.5f,    0.0f,0.0f,1.0f,
            -0.5f,-0.5f,-0.5f,    0.0f,0.0f,1.0f,
            -0.5f,-0.5f, 0.5f,    0.0f,0.0f,1.0f,
            -0.5f, 0.5f, 0.5f,    0.0f,0.0f,1.0f,
            
            0.5f, 0.5f, 0.5f,     1.0f,1.0f,0.0f,
            0.5f, 0.5f,-0.5f,     1.0f,1.0f,0.0f,
            0.5f,-0.5f,-0.5f,     1.0f,1.0f,0.0f,
            0.5f,-0.5f,-0.5f,     1.0f,1.0f,0.0f,
            0.5f,-0.5f, 0.5f,     1.0f,1.0f,0.0f,
            0.5f, 0.5f, 0.5f,     1.0f,1.0f,0.0f,
            
            -0.5f,-0.5f,-0.5f,    1.0f,0.0f,1.0f,
             0.5f,-0.5f,-0.5f,    1.0f,0.0f,1.0f,
             0.5f,-0.5f, 0.5f,    1.0f,0.0f,1.0f,
             0.5f,-0.5f, 0.5f,    1.0f,0.0f,1.0f,
            -0.5f,-0.5f, 0.5f,    1.0f,0.0f,1.0f,
            -0.5f,-0.5f,-0.5f,    1.0f,0.0f,1.0f,
            
            -0.5f,0.5f,-0.5f,  0.0f,1.0f,1.0f,
             0.5f,0.5f,-0.5f,  0.0f,1.0f,1.0f,
             0.5f,0.5f, 0.5f,  0.0f,1.0f,1.0f,
             0.5f,0.5f, 0.5f,  0.0f,1.0f,1.0f,
            -0.5f,0.5f, 0.5f,  0.0f,1.0f,1.0f,
            -0.5f,0.5f,-0.5f,  0.0f,1.0f,1.0f
        };
    
    GLuint VAO,VBO;
    glGenVertexArrays(1,&VAO);
    glGenBuffers(1,&VBO);
    
    //绑定 VAO 和 VBO
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER,VBO);//告诉显卡需要预留空间
    
    //传输数据
    glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW);//static多次读不改数据，dynamic多次读并且修改
    
    //设置VAO
    //location=0的变量，每次读三个浮点数，赋值到position，每隔三个浮点数取一个当作位置信息
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,6*sizeof(GLfloat),(GLvoid *)0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,6*sizeof(GLfloat),(GLvoid *)(3*sizeof(GLfloat)));
    glEnableVertexAttribArray(1);

    //下面是解绑操作
    glBindBuffer(GL_ARRAY_BUFFER,0);        //VBO解绑
    glBindVertexArray(0);                   //VAO解绑

    
    
    // Setup cube VAO
        GLuint cubeVAO, cubeVBO;
        glGenVertexArrays(1, &cubeVAO);
        glGenBuffers(1, &cubeVBO);
        glBindVertexArray(cubeVAO);
        glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
        glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW);
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
        glBindVertexArray(0);
    
    
    // Setup skybox VAO
       GLuint skyboxVAO, skyboxVBO;
       glGenVertexArrays(1, &skyboxVAO);
       glGenBuffers(1, &skyboxVBO);
       glBindVertexArray(skyboxVAO);
       glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
       glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
       glEnableVertexAttribArray(0);
       glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
       glBindVertexArray(0);
    
    
    
    vector<const GLchar*> faces;
       faces.push_back("res/images/right.jpg");
       faces.push_back("res/images/left.jpg");
       faces.push_back("res/images/top.jpg");
       faces.push_back("res/images/bottom.jpg");
       faces.push_back("res/images/back.jpg");
       faces.push_back("res/images/front.jpg");
       GLuint skyboxTexture = loadCubemap(faces);
   
    
    
//draw loop 绘制循环
while (!glfwWindowShouldClose (window))
{

    GLfloat currentTime = glfwGetTime();
    deltaTime = currentTime - lastTime;
    lastTime = currentTime;
    
    glViewport(0, 0, screenWidth, screenHeight);
    glfwPollEvents();
    DoMovement();

    
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
      
    // Draw scene as normal
    ourShader.use();
    glm::mat4 model;
    glm::mat4 view = camera.GetViewMatrix();
    glm::mat4 projection = glm::perspective(camera.GetZoom(), (float)screenWidth/(float)screenHeight, 0.1f, 100.0f);
    glUniformMatrix4fv(glGetUniformLocation(ourShader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
    glUniformMatrix4fv(glGetUniformLocation(ourShader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
    glUniformMatrix4fv(glGetUniformLocation(ourShader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
    glUniform3f(glGetUniformLocation(ourShader.Program, "cameraPos"), camera.GetPosition().x, camera.GetPosition().y, camera.GetPosition().z);
    
   
    
    
    // Cubes
    glBindVertexArray(cubeVAO);
    glBindTexture(GL_TEXTURE_CUBE_MAP, skyboxTexture);
    glDrawArrays(GL_TRIANGLES, 0, 36);
    glBindVertexArray(0);
    
    // Draw skybox as last
    glDepthFunc(GL_LEQUAL);
    skyboxShader.use();
    view = glm::mat4(glm::mat3(camera.GetViewMatrix()));
    glUniformMatrix4fv(glGetUniformLocation(skyboxShader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
    glUniformMatrix4fv(glGetUniformLocation(skyboxShader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
    
    // skybox cube
    glBindVertexArray(skyboxVAO);
    glDrawArrays(GL_TRIANGLES, 0, 36);
    glBindVertexArray(0);
    glfwSwapBuffers (window);

}

glfwTerminate();
glDeleteVertexArrays(1,&skyboxVAO);
glDeleteBuffers(1,&skyboxVBO);
    glDeleteVertexArrays(1,&VAO);
    glDeleteBuffers(1,&VBO);

return 0;

}

void KeyCallback(GLFWwindow *window,int key,int scancode,int action,int mode)
{
    if(key == GLFW_KEY_ESCAPE && action == GLFW_PRESS){
        glfwSetWindowShouldClose(window, GL_TRUE);
    }
    if(key>=0 && key<1024){
        if(action==GLFW_PRESS){
            keys[key]=true;
        }else if(action==GLFW_RELEASE)
        {
            keys[key]=false;
        }
    }
}

void DoMovement()
{
    if(keys[GLFW_KEY_W] ){
        camera.ProcessKeyboard(FORWARD, deltaTime);
    }
    if(keys[GLFW_KEY_S] ){
        camera.ProcessKeyboard(BACKWORD, deltaTime);
    }
    if(keys[GLFW_KEY_A] ){
        camera.ProcessKeyboard(LEFT, deltaTime);
    }
    if(keys[GLFW_KEY_D] ){
        camera.ProcessKeyboard(RIGHT, deltaTime);
    }
}

void MouseCallback(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;
    
    camera.ProcessMouseMovement(xOffset, yOffset);
    
    
}



void ScrollCallback(GLFWwindow *window,double xOffset,double yOffset)
{

    camera.ProcessMouseScroll(yOffset);
    
}



GLuint loadCubemap(vector<const GLchar*> faces)
{
    GLuint textureID;
    glGenTextures(1, &textureID);
    glActiveTexture(GL_TEXTURE0);

    int width,height;
    unsigned char* image;

    glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
    for(GLuint i = 0; i < faces.size(); i++)
    {
        image = SOIL_load_image(faces[i], &width, &height, 0, SOIL_LOAD_RGB);
        glTexImage2D(
            GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
            GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image
        );
    }
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

    return textureID;
}
GLuint loadTexture(GLchar* path)
{
    //Generate texture ID and load texture data
    GLuint textureID;
    glGenTextures(1, &textureID);
    int width,height;
    unsigned char* image = SOIL_load_image(path, &width, &height, 0, SOIL_LOAD_RGB);
    // Assign texture to ID
    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    glGenerateMipmap(GL_TEXTURE_2D);

    // Parameters
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 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;
}

light.h


#ifndef Light_h
#define Light_h

#include <GL/glew.h>

GLfloat vertices_light[] =
{
    
    //position
   -0.5f,-0.5f,-0.5f,
    0.5f,-0.5f,-0.5f,
    0.5f, 0.5f,-0.5f,
    0.5f, 0.5f,-0.5f,
   -0.5f, 0.5f,-0.5f,
   -0.5f,-0.5f,-0.5f,
    
    -0.5f,-0.5f,0.5f,
    0.5f,-0.5f,0.5f,
    0.5f,0.5f,0.5f,
    0.5f,0.5f,0.5f,
    -0.5f,0.5f,0.5f,
    -0.5f,-0.5f,0.5f,
    
    -0.5f,0.5f,0.5f,
    -0.5f,0.5f,-0.5f,
    -0.5f,-0.5f,-0.5f
    -0.5f,-0.5f,-0.5f
    -0.5f,-0.5f,0.5f,
    -0.5f,0.5f,0.5f,
    
    0.5f,0.5f,0.5f,
    0.5f,0.5f,-0.5f,
    0.5f,-0.5f,-0.5f,
    0.5f,-0.5f,-0.5f,
    0.5f,-0.5f,0.5f,
    0.5f,0.5f,0.5f,
    
    -0.5f,-0.5f,-0.5f,
    0.5f,-0.5f,-0.5f,
    0.5f,-0.5f,0.5f,
    0.5f,-0.5f,0.5f,
    -0.5f,-0.5f,0.5f,
    -0.5f,-0.5f,-0.5f
    
    -0.5f,0.5f,-0.5f,
    0.5f,0.5f,-0.5f,
    0.5f,0.5f,0.5f,
    0.5f,0.5f,0.5f,
    -0.5f,0.5f,0.5f,
    -0.5f,0.5f,-0.5f
};
class Light
{
public:
    Light()
    {
        this->update();
    }
    void Draw(Shader &shader)
    {
        glBindVertexArray(this->VAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        glBindVertexArray(0);
    }
private:
    GLuint VAO,VBO;
    void update()
    {
        glGenVertexArrays(1,&this->VAO);
        glGenBuffers(1,&this->VBO);
        //connect the VAO and VBO
        glBindVertexArray(VAO);
        glBindBuffer(GL_ARRAY_BUFFER,this->VBO);
        glBufferData(GL_ARRAY_BUFFER,sizeof(vertices_light),vertices_light,GL_STATIC_DRAW);

        glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(GLfloat),(GLvoid *)0);
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER,0);
        glBindVertexArray(0);
    }
};

#endif

mesh.h

#pragma once

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
#include <vector>
using namespace std;

#include <GL/glew.h> 
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>


struct Vertex {
    glm::vec3 Position;
    glm::vec3 Normal;
    glm::vec2 TexCoords;
};

struct Texture {
    GLuint id;
    string type;
    aiString path;
};

class Mesh {
public:

    vector<Vertex> vertices;
    vector<GLuint> indices;
    vector<Texture> textures;

    Mesh(vector<Vertex> vertices, vector<GLuint> indices, vector<Texture> textures)
    {
        this->vertices = vertices;
        this->indices = indices;
        this->textures = textures;

        // Now that we have all the required data, set the vertex buffers and its attribute pointers.
        this->setupMesh();
    }

    // Render the mesh
    void Draw(Shader shader)
    {
        // Bind appropriate textures
        GLuint diffuseNr = 1;
        GLuint specularNr = 1;
        for(GLuint i = 0; i < this->textures.size(); i++)
        {
            glActiveTexture(GL_TEXTURE0 + i); // Active proper texture unit before binding
            // Retrieve texture number (the N in diffuse_textureN)
            stringstream ss;
            string number;
            string name = this->textures[i].type;
            if(name == "texture_diffuse")
                ss << diffuseNr++; // Transfer GLuint to stream
            else if(name == "texture_specular")
                ss << specularNr++; // Transfer GLuint to stream
            number = ss.str();
            // Now set the sampler to the correct texture unit
            glUniform1i(glGetUniformLocation(shader.Program, (name + number).c_str()), i);
            // And finally bind the texture
            glBindTexture(GL_TEXTURE_2D, this->textures[i].id);
        }
        
        // Also set each mesh's shininess property to a default value (if you want you could extend this to another mesh property and possibly change this value)
        glUniform1f(glGetUniformLocation(shader.Program, "material.shininess"), 16.0f);

        // Draw mesh
        glBindVertexArray(this->VAO);
        glDrawElements(GL_TRIANGLES, this->indices.size(), GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);

        // Always good practice to set everything back to defaults once configured.
        for (GLuint i = 0; i < this->textures.size(); i++)
        {
            glActiveTexture(GL_TEXTURE0 + i);
            glBindTexture(GL_TEXTURE_2D, 0);
        }
    }

private:
    /*  Render data  */
    GLuint VAO, VBO, EBO;

    /*  Functions    */
    // Initializes all the buffer objects/arrays
    void setupMesh()
    {
        // Create buffers/arrays
        glGenVertexArrays(1, &this->VAO);
        glGenBuffers(1, &this->VBO);
        glGenBuffers(1, &this->EBO);

        glBindVertexArray(this->VAO);
        // Load data into vertex buffers
        glBindBuffer(GL_ARRAY_BUFFER, this->VBO);
        // A great thing about structs is that their memory layout is sequential for all its items.
        // The effect is that we can simply pass a pointer to the struct and it translates perfectly to a glm::vec3/2 array which
        // again translates to 3/2 floats which translates to a byte array.
        glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(Vertex), &this->vertices[0], GL_STATIC_DRAW);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->EBO);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->indices.size() * sizeof(GLuint), &this->indices[0], GL_STATIC_DRAW);

        // Set the vertex attribute pointers
        // Vertex Positions
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
        // Vertex Normals
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, Normal));
        // Vertex Texture Coords
        glEnableVertexAttribArray(2);
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, TexCoords));

        glBindVertexArray(0);
    }
};

model.h

#pragma once
// Std. Includes
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
// GL Includes
#include <GL/glew.h> // Contains all the necessery OpenGL includes
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "SOIL2/SOIL2.h"
#include "SOIL2/stb_image.h"
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

#include "mesh.h"

GLint TextureFromFile(const char* path, string directory);

class Model
{
public:
    /*  Functions   */
    // Constructor, expects a filepath to a 3D model.
    Model(GLchar* path)
    {
        this->loadModel(path);
    }

    // Draws the model, and thus all its meshes
    void Draw(Shader shader)
    {
        for(GLuint i = 0; i < this->meshes.size(); i++)
            this->meshes[i].Draw(shader);
    }
    
private:
    /*  Model Data  */
    vector<Mesh> meshes;
    string directory;
    vector<Texture> textures_loaded;    // Stores all the textures loaded so far, optimization to make sure textures aren't loaded more than once.

    /*  Functions   */
    // Loads a model with supported ASSIMP extensions from file and stores the resulting meshes in the meshes vector.
    void loadModel(string path)
    {
        // Read file via ASSIMP
        Assimp::Importer importer;
        const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
        // Check for errors
        if(!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
        {
            cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << endl;
            return;
        }
        // Retrieve the directory path of the filepath
        this->directory = path.substr(0, path.find_last_of('/'));

        // Process ASSIMP's root node recursively
        this->processNode(scene->mRootNode, scene);
    }

    // Processes a node in a recursive fashion. Processes each individual mesh located at the node and repeats this process on its children nodes (if any).
    void processNode(aiNode* node, const aiScene* scene)
    {
        // Process each mesh located at the current node
        for(GLuint i = 0; i < node->mNumMeshes; i++)
        {
            // The node object only contains indices to index the actual objects in the scene.
            // The scene contains all the data, node is just to keep stuff organized (like relations between nodes).
            aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
            this->meshes.push_back(this->processMesh(mesh, scene));
        }
        // After we've processed all of the meshes (if any) we then recursively process each of the children nodes
        for(GLuint i = 0; i < node->mNumChildren; i++)
        {
            this->processNode(node->mChildren[i], scene);
        }

    }

    Mesh processMesh(aiMesh* mesh, const aiScene* scene)
    {
        // Data to fill
        vector<Vertex> vertices;
        vector<GLuint> indices;
        vector<Texture> textures;

        // Walk through each of the mesh's vertices
        for(GLuint i = 0; i < mesh->mNumVertices; i++)
        {
            Vertex vertex;
            glm::vec3 vector; // We declare a placeholder vector since assimp uses its own vector class that doesn't directly convert to glm's vec3 class so we transfer the data to this placeholder glm::vec3 first.
            // Positions
            vector.x = mesh->mVertices[i].x;
            vector.y = mesh->mVertices[i].y;
            vector.z = mesh->mVertices[i].z;
            vertex.Position = vector;
            // Normals
            vector.x = mesh->mNormals[i].x;
            vector.y = mesh->mNormals[i].y;
            vector.z = mesh->mNormals[i].z;
            vertex.Normal = vector;
            // Texture Coordinates
            if(mesh->mTextureCoords[0]) // Does the mesh contain texture coordinates?
            {
                glm::vec2 vec;
                // A vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't
                // use models where a vertex can have multiple texture coordinates so we always take the first set (0).
                vec.x = mesh->mTextureCoords[0][i].x;
                vec.y = mesh->mTextureCoords[0][i].y;
                vertex.TexCoords = vec;
            }
            else
                vertex.TexCoords = glm::vec2(0.0f, 0.0f);
            vertices.push_back(vertex);
        }
        // Now wak through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices.
        for(GLuint i = 0; i < mesh->mNumFaces; i++)
        {
            aiFace face = mesh->mFaces[i];
            // Retrieve all indices of the face and store them in the indices vector
            for(GLuint j = 0; j < face.mNumIndices; j++)
                indices.push_back(face.mIndices[j]);
        }
        // Process materials
        if(mesh->mMaterialIndex >= 0)
        {
            aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
            // We assume a convention for sampler names in the shaders. Each diffuse texture should be named
            // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER.
            // Same applies to other texture as the following list summarizes:
            // Diffuse: texture_diffuseN
            // Specular: texture_specularN
            // Normal: texture_normalN

            // 1. Diffuse maps
            vector<Texture> diffuseMaps = this->loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
            textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
            // 2. Specular maps
            vector<Texture> specularMaps = this->loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
            textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
        }
        
        // Return a mesh object created from the extracted mesh data
        return Mesh(vertices, indices, textures);
    }

    // Checks all material textures of a given type and loads the textures if they're not loaded yet.
    // The required info is returned as a Texture struct.
    vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, string typeName)
    {
        vector<Texture> textures;
        for(GLuint i = 0; i < mat->GetTextureCount(type); i++)
        {
            aiString str;
            mat->GetTexture(type, i, &str);
            // Check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
            GLboolean skip = false;
            for(GLuint j = 0; j < textures_loaded.size(); j++)
            {
                if(std::strcmp(textures_loaded[j].path.C_Str(), str.C_Str()) == 0)
                {
                    textures.push_back(textures_loaded[j]);
                    skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization)
                    break;
                }
            }
            if(!skip)
            {   // If texture hasn't been loaded already, load it
                Texture texture;
                texture.id = TextureFromFile(str.C_Str(), this->directory);
                texture.type = typeName;
                texture.path = str;
                textures.push_back(texture);
                this->textures_loaded.push_back(texture);  // Store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures.
            }
        }
        return textures;
    }
};




GLint TextureFromFile(const char* path, string directory)
{
     //Generate texture ID and load texture data
    string filename = string(path);
    filename = directory + '/' + filename;
    GLuint textureID;
    glGenTextures(1, &textureID);
    int width,height;
    unsigned char* image = SOIL_load_image(filename.c_str(), &width, &height, 0, SOIL_LOAD_RGB);
    // Assign texture to ID
    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    glGenerateMipmap(GL_TEXTURE_2D);

    // Parameters
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 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;
}

camera.h


#ifndef camera_h
#define camera_h

#include <vector>
#define GLEW_STATIC
#include <GL/glew.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
enum Camera_Movement//解决朝向问题
{
    FORWARD,
    BACKWORD,
    LEFT,
    RIGHT
};
const GLfloat YAW         = -90.0f;   //从外往里视角,水平角
const GLfloat PITCH       = 0.0f;     //俯仰角
const GLfloat ZOOM        = 45.0f;    //视域，控制缩放
const GLfloat SPEED       = 6.0f;     //设置初始速度
const GLfloat SENSITIVITY = 0.25f;    //灵敏度

class Camera
{
public:
    //camera位置信息
    Camera(glm::vec3 position = glm::vec3(0.0f,0.0f,0.0f),glm::vec3 up = glm::vec3(0.0f,1.0f,0.0f),GLfloat yaw=YAW,GLfloat pitch = PITCH):front(glm::vec3(0.0f,0.0f,-1.0f)),zoom(ZOOM),movementSpeed(SPEED),mouseSensitivity(SENSITIVITY)
    {
        this->position = position;
        this->worldUP = up;
        this->yaw = yaw;
        this->pitch = pitch;
        this->updateCameraVectors();
        
    }
    glm::mat4 GetViewMatrix()//获得私有变量的值
    {
        return glm::lookAt(this->position,this->position + this->front,this->up);
    }
    GLfloat GetZoom()  //获得私有变量的值
    {
        return this->zoom;
    }
    glm::vec3 GetPosition()
    {
        return  this->position;
    }
    void ProcessKeyboard(Camera_Movement direction,GLfloat deltaTime)
    {
        GLfloat velocity = this->movementSpeed * deltaTime;
        if (direction == FORWARD){
            this->position+=this->front*velocity;
        }
        if (direction == BACKWORD){
            this->position-=this->front*velocity;
        }
        if (direction == LEFT){
            this->position-=this->right*velocity;
        }
        if (direction == RIGHT){
            this->position+=this->right*velocity;
        }
    }
    
    
    void ProcessMouseScroll(GLfloat yOffset)
    {
        if ( this->zoom >= 1.0f && this->zoom <= 45.0f )
        {
            this->zoom += yOffset;
        }
        if ( this->zoom <= 1.0f )
        {
            this->zoom = 1.0f;
        }
        if ( this->zoom >= 45.0f )
        {
            this->zoom = 45.0f;
        }
    }
    
    void ProcessMouseMovement(GLfloat xOffset,GLfloat yOffset)
    {
        //灵敏度调节
        xOffset *= this->mouseSensitivity;
        yOffset *= this->mouseSensitivity;
        
        this->yaw += xOffset;
        this->pitch += yOffset;
        this->updateCameraVectors();//变化完更新相机指针
        
        
    }
private:
    GLfloat yaw;
    GLfloat pitch;
    GLfloat zoom;
    GLfloat movementSpeed;
    GLfloat mouseSensitivity;
    
    glm::vec3 position;
    glm::vec3 front;
    glm::vec3 right;
    glm::vec3 up;
    glm::vec3 worldUP;
    void updateCameraVectors()
    {
        glm::vec3 front;
        front.x=cos(glm::radians(this->pitch)) * cos(glm::radians(this->yaw));
        front.y=sin(glm::radians(this->pitch));
        front.z=cos(glm::radians(this->pitch)) * sin(glm::radians(this->yaw));
        this->front = glm::normalize(front);
        
        this->right=glm::normalize(glm::cross(this->front,this->worldUP));
        
        this->up = glm::normalize(glm::cross(this->right,this->front));
    }
};

#endif /* camera_h */

Shader.h


#pragma once

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

class Shader
{
    GLuint vertex,fragment;
public:
    GLuint Program;
    Shader(const GLchar *vertexPath,const GLchar *fragmentPath)
    {
        std::string vertexCode;
        std::string fragmentCode;
        std::ifstream vShaderFile;
        std::ifstream fShaderFile;
        vShaderFile.exceptions(std::ifstream::badbit);
        fShaderFile.exceptions(std::ifstream::badbit);
        
        try {
            vShaderFile.open(vertexPath);
            fShaderFile.open(fragmentPath);
            std::stringstream vShaderStream,fShaderStream;
            vShaderStream<<vShaderFile.rdbuf();
            fShaderStream<<fShaderFile.rdbuf();
            vShaderFile.close();
            fShaderFile.close();
            vertexCode = vShaderStream.str();
            fragmentCode = fShaderStream.str();
            
        } catch (std::ifstream::failure e) {
            std::cout<<"ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ"<<std::endl;
        }
        
        const GLchar *vShaderCode = vertexCode.c_str();
        const GLchar *fShaderCode = fragmentCode.c_str();
        GLint success;
        GLchar infoLog[512];
        vertex = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertex,1,&vShaderCode,NULL);
        glCompileShader(vertex);
        glGetShaderiv(vertex,GL_COMPILE_STATUS,&success);
        if (!success) {
            glGetShaderInfoLog(vertex,512,NULL,infoLog);
            std::cout<<"ERROR::SHADER::VERTEX::COMPILATION_FAILED\n"<<
            infoLog<<std::endl;
        }
        
        fragment = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragment,1,&fShaderCode,NULL);
        glCompileShader(fragment);
        
        glGetShaderiv(fragment,GL_COMPILE_STATUS,&success);
        if (!success) {
            glGetShaderInfoLog(fragment,512,NULL,infoLog);
            std::cout<<"ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n"<<
            infoLog<<std::endl;
        }
        this->Program= glCreateProgram();
        glAttachShader(this->Program,vertex);
        glAttachShader(this->Program,fragment);
        glLinkProgram(this->Program);
        
        glGetProgramiv(this->Program,GL_LINK_STATUS,&success);
        if (!success) {
            glGetProgramInfoLog(this->Program,512,NULL,infoLog);
            std::cout<<"ERROR::SHADER::PROGRAM::LINKING_FAILED\n"<<infoLog<<std::endl;
        }
    }
    
    ~Shader()
    {
        glDetachShader(this->Program,vertex);
        glDetachShader(this->Program,fragment);
        glDeleteShader(vertex);
        glDeleteShader(fragment);
        glDeleteProgram(this->Program);
    }
    
    void use()
    {
        glUseProgram(this->Program);
    }
};

core.vs

#version 330 core
layout(location = 0) in vec3 position;
//layout(location = 1) in vec3 ourColor;
layout(location = 1) in vec3 normal;

//out vec3 vertexColor;
out vec3 Normal;
out vec3 FragPos;
uniform mat4 transform;//顶点位置修改
uniform mat4 view;
uniform mat4 projection;

void main()
{
    gl_Position = projection * view * transform * vec4(position,1.0f);
    FragPos =vec3 (transform * vec4(position,1.0f));
//    vertexColor = ourColor;
    Normal = mat3(transpose(inverse(transform)))*normal;

}

core.fs

#version 330 core
out vec4 color;
//in vec3 vertexColor;
in vec3 Normal;
in vec3 FragPos;

//uniform运行过程中从CPU传给我们的
uniform float time;
uniform vec3 LightPos;
uniform vec3 ViewPos;

struct Material
{
    float diffuse;
    float specular;
    
};
uniform Material material;

void main()
{
//color = vec4(vertexColor,1.0f);
    vec3 lightDirection = normalize(LightPos-FragPos);//光源方向
    vec3 viewDirection = normalize(ViewPos-FragPos);//视野方向
    vec3 norm = normalize(Normal);
    
    //ambient环境部分
//    vec3 ambient = 0.5 * vertexColor;
    
    //diffuse
    float diff = material.diffuse * max(dot(norm,lightDirection),0.0f);
    //vec3 diffuse = diff * vertexColor;
    
    //specular
    vec3 halfAngle = normalize(viewDirection + lightDirection);
    float spec = material.specular * pow(max (dot(norm,halfAngle),0.0f),64.0f);
    //vec3 specular = spec * vertexColor;
    
    color = vec4(1.0f,0.0f,0.0f,1.0f);
    
  
}

light.vs

#version 330 core
layout(location = 0) in vec3 position;
uniform mat4 transform;//顶点位置修改
uniform mat4 view;
uniform mat4 projection;
void main()
{
    gl_Position = projection * view * transform * vec4(position,1.0f);
}

light.fs

#version 330 core
out vec4 color;
void main()
{
color = vec4(1.0f,1.0f,1.0f,1.0f);
  
}

skybox.vs

#version 330 core
layout (location = 0) in vec3 position;
out vec3 TexCoords;

uniform mat4 projection;
uniform mat4 view;

void main()
{
    gl_Position =   projection * view * vec4(position, 1.0);
    TexCoords = position;
}

skybox.fs

#version 330 core
in vec3 TexCoords;
out vec4 color;

uniform samplerCube skybox;

void main()
{
    color = texture(skybox, TexCoords);
}

一派倾城
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
076：vue+cesium 自定义天空盒（skybox）效果
大剑师兰特的GIS世界
06-07 657
本示例介绍如何在vue+cesium中 自定义天空盒效果。天空盒（Sky Box）是一种计算机图形学技术，用于在三维环境中模拟远处的天空和背景。它通常是一个纹理映射到立方体或球体上的图像，从任何角度看都能提供逼真的视觉效果。在场景周围设置一个天空盒来绘制星星，这个天空盒使用真赤道平均春分点（True Equator Mean Equinox，简称TEME）坐标轴定义。这仅在3D模式下受支持。在变换到2D或哥伦布视角时，天空盒会逐渐消失。
LearnOpenGL-高级OpenGL-6.天空盒
qq_34060370的博客
03-16 2576
立方体贴图就是一个包含了6个2D纹理的纹理，每个2D纹理都组成了立方体的一个面：一个有纹理的立方体。
OpenGL学习（十）天空盒
AKGWSB 's blog
01-03 7342
目录写在前面天空盒简介创建立方体贴图渲染一个立方体立方体贴图着色器开始绘制天空盒完整代码着色器c++ 写在前面 上一篇博客回顾：OpenGL学习（九）阴影映射（shadowMapping） 在昨天我们实现了非常简单的阴影映射特效，今天来更新立方体贴图的内容。这部分的内容相当简单，前提是要对 OpenGL 及其绘制过程有一个基本的理解。 相信我，仅 10 分钟足够你完成一个立方体贴图，并且用于天空盒的渲染。 天空盒简介 注意到我们之前的代码都是利用： glClearColor(1.0, 1.0, 1.0, 1
计算机图形学与opengl C++版 学习笔记 第9章 天空和背景
Doggerlas的博客
06-12 1569
计算机图形学与opengl C++版 学习笔记 第9章 天空和背景
【计算机图形学】多种光源+多种材质+天空盒 OpenGL设计实践
zhushatong的博客
11-29 1658
这是一个C++ OpenGL程序（含代码）。https://github.com/Zhu-Shatong/OpenGL-CG-TextureAndLights。 同济大学
【openGL2021版】天空盒
Lampard的博客
08-21 2518
【openGL2021版】天空盒 大家好，我是Lampard猿奋~ 欢迎来到船新的openGL基础系列的博客，今天主要实现的是天空盒 （1）什么是天空盒 上周我们已经实现了FPS式的摄像机控制，键盘的“WSAD”可以控制摄像头的前后左右移动，鼠标右键可以控制摄像头旋转 接下来就是要丰富一下蓝蓝的背景，给背景加上一个天空盒。那什么是天空盒呢？ 在实时渲染中，如果要绘制...
OPENGL天空盒Skybox
06-09
OpenGL实现的天空盒
OpenGL天空盒
04-23
使用立方体贴图技术，实现天空盒功能，提供了两套天空盒图片。本人博客：https://blog.csdn.net/lady_killer9/article/details/89468950
openGL天空盒实现
03-10
OpenGL天空盒是一种在3D场景中创建环境背景的特效技术，它通过绘制一个虚拟的立方体，将每个面贴上代表天空或环境的纹理，然后将这个立方体置于摄像机周围，使得无论摄像机如何移动，用户总是看到一个连续且无缝的...
天空盒skybox六张jpg图片格式
11-06
天空盒（Skybox）是一种在三维图形渲染中广泛使用的虚拟环境技术，主要用于创建游戏或模拟应用中的无限远背景。它利用六个相对的二维图像来构建一个立方体，每个面分别对应着观察者的上、下、前、后、左、右六个方向...
opengl与QT实现天空盒
11-26
OpenGL与QT结合实现天空盒是一种常见的3D场景渲染技术，用于在虚拟环境中模拟逼真的天空效果。这个项目基于QT 5.8.0版本，它是一个跨平台的应用程序开发框架，特别适合创建图形用户界面。而OpenGL则是一个强大的、与...
OpenGL--天空盒
热门推荐
疯狂的程序员
12-08 1万+
理论基础1，目前虚拟场景中天空建模常用的方法有天空顶(SkyDome:半球形)和天空盒(SkyBox:长方体)两种方法。其本质都是摄像机处在一个盒子中间，这个盒子通过纹理贴图形成的虚拟世界场景。其中天空盒绘制技术非常简单，因此被广泛应用。然而，有时也会存在一些问题，例如使用雾效时，如果雾被设置在观察者的旁边，天空盒将减淡甚至消失。另一个更坑爹的问题是雾会聚积在天空盒的顶点处，从而使天空盒的多边形暴露
opengl制作天空盒
grootLee
11-22 615
创建并编译shader（这里我将编译shader封装成了类，通用的用法）我们把下述全景图片进行切割后载入到程序中。或者微软应用商店搜索PanoSplit。
OpenGL 天空盒Skybox实现 天空盒显示不全（天空盒部分被截断）
qq_37421018的博客
08-04 2169
OpenGL 天空盒实现过程中踩坑
opengl天空盒_游戏引擎养成《十三》 天空盒
weixin_39593519的博客
11-23 165
# 四月的天空三月底新项目启动，估计整个Q2都会忙死。上篇搭了一个Input的架子，但是输入很别扭，另外场景上就一个模型显得空荡荡的，今天我们就把天空盒加上。参考 https://learnopengl.com/Advanced-OpenGL/Cubemaps 非常棒的Tutorial.中间场景的一章还没有时间补齐，不过我们先过天空盒吧，以OpenGL为例。# 原理 ## CubeMap 天...
OpenGL学习脚印：立方体纹理和天空包围盒(Cubemaps And Skybox)
王定桥的专栏
09-11 1万+
写在前面 之前学习了2D纹理映射，实际上还有其他类型的纹理有待我们进一步学习，本节将要学习的立方体纹理(cubemaps)，是一种将多个纹理图片复合到一个立方体表面的技术。在游戏中应用得较多的天空包围盒可以使用cubemap实现。本节示例程序均可以在我的github下载。 本节内容整理自: 1.Tutorial 25:SkyBox 2.www.learnopengl.
Qt::QOpenGLWidget 渲染天空壳
D_Guco的专栏
02-28 1089
Qt::QOpenGLWidget 渲染天空壳
OpenGL去除天空盒缝隙
m0_62798462的博客
10-24 82
天空盒去除缝隙
十六、立方体贴图（天空盒）
zw1996的博客
06-07 1081
opengles实现立体贴图
opengl 天空盒 python
最新发布
05-14
OpenGL是一种图形学应用程序编程接口（API），可以用来渲染2D和3D图形。天空盒（Skybox）是一种通过贴图的方式，在3D场景中实现类似于天空的效果的技术。在OpenGL中，我们可以使用纹理贴图技术来实现天空盒效果。Python是一种高级编程语言，可以用来编写OpenGL程序。 如果你想在Python中实现天空盒效果，可以使用PyOpenGL这个Python的OpenGL接口库。通过PyOpenGL，你可以在Python中使用OpenGL的各种功能，包括贴图、渲染等。具体实现天空盒的方法可以参考以下步骤： 1. 加载6张贴图，分别代表天空盒的六个面。 2. 创建一个立方体，将每个面上的贴图映射到对应的面上。 3. 将立方体放置在摄像机的位置，使得视角始终在立方体中心。 4. 在渲染场景时，先将摄像机移动到立方体中心，再将场景渲染出来。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值