lenn/LearnOpenGL
1
0
Fork 0
mirror of https://github.com/JoeyDeVries/LearnOpenGL.git synced 2026-01-02 04:37:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

create seperate shader

Browse Source
This commit is contained in:
Jonas_sorgenfrei@yahoo.de
2022-04-04 14:34:41 +02:00
parent 8fe4397758
commit 36e0cc9ec3
4 changed files with 154 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
includes/learnopengl/shader_c.h Normal file
View File

@@ -0,0 +1,151 @@
#ifndef COMPUTE_SHADER_H
#define COMPUTE_SHADER_H
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
class ComputeShader
{
public:
unsigned int ID;
// constructor generates the shader on the fly
// ------------------------------------------------------------------------
ComputeShader(const char* computePath)
{
// 1. retrieve the vertex/fragment source code from filePath
std::string computeCode;
std::ifstream cShaderFile;
// ensure ifstream objects can throw exceptions:
cShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
// open files
cShaderFile.open(computePath);
std::stringstream cShaderStream;
// read file's buffer contents into streams
cShaderStream << cShaderFile.rdbuf();
// close file handlers
cShaderFile.close();
// convert stream into string
computeCode = cShaderStream.str();
}
catch (std::ifstream::failure& e)
{
std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ: " << e.what() << std::endl;
}
const char* cShaderCode = computeCode.c_str();
// 2. compile shaders
unsigned int compute;
// compute shader
compute = glCreateShader(GL_COMPUTE_SHADER);
glShaderSource(compute, 1, &cShaderCode, NULL);
glCompileShader(compute);
checkCompileErrors(compute, "COMPUTE");
// shader Program
ID = glCreateProgram();
glAttachShader(ID, compute);
glLinkProgram(ID);
checkCompileErrors(ID, "PROGRAM");
// delete the shaders as they're linked into our program now and no longer necessery
glDeleteShader(compute);
}
// activate the shader
// ------------------------------------------------------------------------
void use()
{
glUseProgram(ID);
}
// utility uniform functions
// ------------------------------------------------------------------------
void setBool(const std::string &name, bool value) const
{
glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
}
// ------------------------------------------------------------------------
void setInt(const std::string &name, int value) const
{
glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
}
// ------------------------------------------------------------------------
void setFloat(const std::string &name, float value) const
{
glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
}
// ------------------------------------------------------------------------
void setVec2(const std::string &name, const glm::vec2 &value) const
{
glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
}
void setVec2(const std::string &name, float x, float y) const
{
glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
}
// ------------------------------------------------------------------------
void setVec3(const std::string &name, const glm::vec3 &value) const
{
glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
}
void setVec3(const std::string &name, float x, float y, float z) const
{
glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
}
// ------------------------------------------------------------------------
void setVec4(const std::string &name, const glm::vec4 &value) const
{
glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
}
void setVec4(const std::string &name, float x, float y, float z, float w)
{
glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
}
// ------------------------------------------------------------------------
void setMat2(const std::string &name, const glm::mat2 &mat) const
{
glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
}
// ------------------------------------------------------------------------
void setMat3(const std::string &name, const glm::mat3 &mat) const
{
glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
}
// ------------------------------------------------------------------------
void setMat4(const std::string &name, const glm::mat4 &mat) const
{
glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
}
private:
// utility function for checking shader compilation/linking errors.
// ------------------------------------------------------------------------
void checkCompileErrors(GLuint shader, std::string type)
{
GLint success;
GLchar infoLog[1024];
if(type != "PROGRAM")
{
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if(!success)
{
glGetShaderInfoLog(shader, 1024, NULL, infoLog);
std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
}
}
else
{
glGetProgramiv(shader, GL_LINK_STATUS, &success);
if(!success)
{
glGetProgramInfoLog(shader, 1024, NULL, infoLog);
std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
}
}
}
};
#endif

5
includes/learnopengl/shader_m.h
View File

@@ -13,9 +13,6 @@ class Shader
{
public:
unsigned int ID;
Shader() {
ID = -1;
}
// constructor generates the shader on the fly
// ------------------------------------------------------------------------
@@ -139,7 +136,7 @@ public:
glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
}
protected:
private:
// utility function for checking shader compilation/linking errors.
// ------------------------------------------------------------------------
void checkCompileErrors(GLuint shader, std::string type)

49
src/8.guest/2022/5.computeshader_helloworld/computeShader.h
View File

@@ -1,49 +0,0 @@
#include <learnopengl/shader_m.h>
class ComputeShader : public Shader
{
public:
ComputeShader(const char* computePath)
{
// 1. retrieve the vertex/fragment source code from filePath
std::string computeCode;
std::ifstream cShaderFile;
// ensure ifstream objects can throw exceptions:
cShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
// open files
cShaderFile.open(computePath);
std::stringstream cShaderStream;
// read file's buffer contents into streams
cShaderStream << cShaderFile.rdbuf();
// close file handlers
cShaderFile.close();
// convert stream into string
computeCode = cShaderStream.str();
}
catch (std::ifstream::failure& e)
{
std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ: " << e.what() << std::endl;
}
const char* cShaderCode = computeCode.c_str();
// 2. compile shaders
unsigned int compute;
// compute shader
compute = glCreateShader(GL_COMPUTE_SHADER);
glShaderSource(compute, 1, &cShaderCode, NULL);
glCompileShader(compute);
checkCompileErrors(compute, "COMPUTE");
// shader Program
ID = glCreateProgram();
glAttachShader(ID, compute);
glLinkProgram(ID);
checkCompileErrors(ID, "PROGRAM");
// delete the shaders as they're linked into our program now and no longer necessery
glDeleteShader(compute);
}
};

4
src/8.guest/2022/5.computeshader_helloworld/computer_shader_hello_world.cpp
View File

@@ -5,13 +5,13 @@
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <learnopengl/shader_m.h>
#include <learnopengl/shader_c.h>
#include <learnopengl/camera.h>
#include <iostream>
#include "computeShader.h"
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void renderQuad();