Opengl练习运行框架

最新推荐文章于 2020-04-14 20:31:16 发布

TriangleBOY

最新推荐文章于 2020-04-14 20:31:16 发布

阅读量137

点赞数

文章标签： shader opengl c++

本文链接：https://blog.csdn.net/qq_36867292/article/details/104347528

版权

本文主要介绍了使用OpenGL进行图像显示以及Shader的实现过程，包括如何设置OpenGL环境，加载和编译Shader，以及将Shader应用于图像显示。通过学习，读者可以掌握OpenGL的基础操作和Shader在图形渲染中的应用。

摘要由CSDN通过智能技术生成

一，图像显示部分

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <math.h>
#include "shader/Shader.h"
using namespace std;


// 按键检测
void processInput(GLFWwindow* window){
    if(glfwGetKey(window,GLFW_KEY_ESCAPE) == GLFW_PRESS){
        glfwSetWindowShouldClose(window,true);
    }
}


int main(int argc, char const *argv[])
{

    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3);
    glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);
    
     // 顶点
    float vertices[] = {
     0.5f,  0.5f, 0.0f, 1.0f,   0,  0,  // top right
     0.5f, -0.5f, 0.0f,  0, 1.0f,   0, // bottom right
    -0.5f, -0.5f, 0.0f,  0,  0,  1.0f,// bottom left
    -0.5f,  0.5f, 0.0f, 1.0f,1.0f,0 
    };  

    //顶点索引
    unsigned int indexs[] = {
        0,  1,  3,
        3,  2,  1
    };

    //定义windows
    GLFWwindow* window = glfwCreateWindow(800,800,"fuck you",NULL,NULL);
    if(window == NULL){
        cout << "failed to create window";
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    
    // 启动glad
    if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)){
        cout << "failed to initialize glad ";
         glfwTerminate();
        return -1;
    }
    //渲染窗口
    glViewport(0,0,800,800);

     //顶点数据管理
    unsigned int VAO;
    glGenVertexArrays(1,&VAO);
    //绑定VAO
    glBindVertexArray(VAO);

     //顶点数据缓冲区
    unsigned int VBO;
    glGenBuffers(1,&VBO);
    glBindBuffer(GL_ARRAY_BUFFER,VBO);
    glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW);

    //索引数据缓冲区
    unsigned int EBO;
    glGenBuffers(1,&EBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(indexs),indexs,GL_STATIC_DRAW);

    //shader program 生成
    unsigned int shaderProgram;
    Shader mShader ("../shaders/vertexShader.txt","../shaders/fragmentShader.txt");
    shaderProgram = mShader.program;
    
    //获取数据管理VAO中的顶点
    glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,6*sizeof(float),(void*) 0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,6*sizeof(float),(void*) (3*sizeof(float)) );
    glEnableVertexAttribArray(2);
   
   float currentTime = 0;
   float greenValue = 0;

    while (!glfwWindowShouldClose(window))
    {
        processInput(window);

        glClearColor(0,0,0,1);
        glClear(GL_COLOR_BUFFER_BIT);

        glUseProgram(shaderProgram);

        glBindVertexArray(VAO);
        // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);

        glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_INT,0);


        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 终止
    glfwTerminate();
    return -1;
    

    return 0;
}

二，shader的实现

#include <string>


class Shader
{
private:
    const char* vertexShaderSource; //顶点shader
    const char* fragmentShaderSource;//片段shader
    const char* endl = "\n";
    
    unsigned int vertexShader;
    unsigned int fragmentShader;

    char infoLog[512];

public:
    unsigned int program;
    const int VERTEX_SHADER_CODE = 1;
    const int FRAGMENT_SHADER_CODE = 2;
    //vertex shader 路径，fragment shader 路径
    Shader(std::string vertexPath,std::string fragmentPath);
protected:
    std::string readFile(std::string path);
    unsigned int generateShader(int codeName);
    void generateProgram();
};

#include "Shader.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <glad/glad.h>
#include <GLFW/glfw3.h>

Shader::Shader(std::string vertexPath,std::string fragmentPath)
{

    std::string vertexStr;
    std::string fragmentStr;

    //读取vertexshader
    vertexStr = readFile(vertexPath);
    this->vertexShaderSource = vertexStr.c_str();

    //读取fragmentshader
    fragmentStr = readFile(fragmentPath);
    this->fragmentShaderSource = fragmentStr.c_str();

    //产生shader
    this->vertexShader = generateShader(this->VERTEX_SHADER_CODE);
    this->fragmentShader = generateShader(this->FRAGMENT_SHADER_CODE);


    //link program
    generateProgram();

    //delete shader
    glDeleteShader(this->vertexShader);
    glDeleteShader(this->fragmentShader);

}

void Shader::generateProgram(){
    int success = 0;

    try
    {
        this->program = glCreateProgram();
        glAttachShader(this->program,this->vertexShader);
        glAttachShader(this->program,this->fragmentShader);
        glLinkProgram(this->program);

        glGetProgramiv(this->program,GL_LINK_STATUS,&success);

        if(!success){
            glGetProgramInfoLog(this->program,512,NULL,infoLog);

            throw "fail to link program!!!!";
        }

    }
    catch(const char*  e)
    {   
        std::cerr << endl << e << '\n';
        std::cerr << this->infoLog <<endl;
    }

}

unsigned int Shader::generateShader(int code){
    unsigned int shader;
    int success ;
    std::string msg;
    try
    {   
        if(code == this->VERTEX_SHADER_CODE){

            shader = glCreateShader(GL_VERTEX_SHADER);
            glShaderSource(shader,1,&vertexShaderSource,NULL);
            msg = "vertex shader";

        }else if(code == this->FRAGMENT_SHADER_CODE){

            shader = glCreateShader(GL_FRAGMENT_SHADER);
            glShaderSource(shader,1,&fragmentShaderSource,NULL);
            msg = "fragment shader";

        }
        
        glCompileShader(shader);

        glGetShaderiv(shader,GL_COMPILE_STATUS,&success);

        if(!success){
            glGetShaderInfoLog(shader,512,NULL,infoLog);
            throw "fail to complie shader :" ;
        }

    }
    catch(const char* e)
    {
        std::cerr << endl << e << msg <<'\n';
        std::cerr << this->infoLog << endl;
    }
    
    return shader;
}

std::string Shader::readFile(std::string path){

    std::ifstream shaderfile;
    std::stringstream shaderStr;
    std::string shaderSource = "";

    shaderfile.open(path);
    shaderfile.exceptions(std::fstream::badbit | std::fstream::failbit);

    try{
        if(!shaderfile.is_open()){
            throw "fail to open shader :" ;
        }
        shaderStr << shaderfile.rdbuf();
        shaderSource = shaderStr.str();
        shaderfile.close();
    }
    catch(std::ifstream::failure e)
    {
        std::cerr << "fail to read shader:" <<path<<endl;
        std::cerr << e.what() << '\n';
    }
    catch(const char* e){
        std::cerr <<endl << e << path <<endl;
    }
    return shaderSource;
}