mirror/projectm
3
0
Fork 0
mirror of https://github.com/projectM-visualizer/projectm.git synced 2026-03-07 16:05:26 +00:00
Code Issues Projects Releases Wiki Activity

Merging GLES3 changes in

Browse Source
This commit is contained in:
Mischa Spiegelmock
2018-06-10 16:59:12 +03:00
parent 4b2ba9513b 1cacdd6799
commit c2c00a1e1a
29 changed files with 1209 additions and 768 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
src/libprojectM/Renderer/ShaderEngine.cpp
View File

@ -10,9 +10,98 @@
#include "BeatDetect.hpp"
#include "HLSLTranslator.hpp"
#define GLSL_VERSION "410"
std::string v2f_c4f_vert(
"#version "
GLSL_VERSION
"\n"
""
"layout(location = 0) in vec2 vertex_position;\n"
"layout(location = 1) in vec4 vertex_color;\n"
""
"uniform mat4 vertex_transformation;\n"
"uniform float vertex_point_size;\n"
""
"out vec4 fragment_color;\n"
""
"void main(){\n"
" gl_Position = vertex_transformation * vec4(vertex_position, 0.0, 1.0);\n"
" gl_PointSize = vertex_point_size;\n"
" fragment_color = vertex_color;\n"
"}\n");
std::string v2f_c4f_frag(
"#version "
GLSL_VERSION
"\n"
"precision mediump float;\n"
""
"in vec4 fragment_color;\n"
"out vec4 color;\n"
""
"void main(){\n"
" color = fragment_color;\n"
"}\n");
std::string v2f_c4f_t2f_vert(
"#version "
GLSL_VERSION
"\n"
"layout(location = 0) in vec2 vertex_position;\n"
"layout(location = 1) in vec4 vertex_color;\n"
"layout(location = 2) in vec2 vertex_texture;\n"
""
"uniform mat4 vertex_transformation;\n"
""
"out vec4 fragment_color;\n"
"out vec2 fragment_texture;\n"
""
"void main(){\n"
" gl_Position = vertex_transformation * vec4(vertex_position, 0.0, 1.0);\n"
" fragment_color = vertex_color;\n"
" fragment_texture = vertex_texture;\n"
"}\n");
std::string v2f_c4f_t2f_frag(
"#version "
GLSL_VERSION
"\n"
"precision mediump float;\n"
""
"in vec4 fragment_color;\n"
"in vec2 fragment_texture;\n"
""
"uniform sampler2D texture_sampler;\n"
""
"out vec4 color;\n"
""
"void main(){\n"
" color = fragment_color * texture(texture_sampler, fragment_texture.st);\n"
"}\n");
GLint ShaderEngine::UNIFORM_V2F_C4F_VERTEX_TRANFORMATION = 0;
GLint ShaderEngine::UNIFORM_V2F_C4F_VERTEX_POINT_SIZE = 0;
GLint ShaderEngine::UNIFORM_V2F_C4F_T2F_VERTEX_TRANFORMATION = 0;
GLint ShaderEngine::UNIFORM_V2F_C4F_T2F_FRAG_TEXTURE_SAMPLER = 0;
ShaderEngine::ShaderEngine()
{
InitShaderProgram();
GLuint m_temp_vao;
glGenVertexArrays(1, &m_temp_vao);
glBindVertexArray(m_temp_vao);
programID_v2f_c4f = CompileShaderProgram(v2f_c4f_vert, v2f_c4f_frag);
programID_v2f_c4f_t2f = CompileShaderProgram(v2f_c4f_t2f_vert, v2f_c4f_t2f_frag);
UNIFORM_V2F_C4F_VERTEX_TRANFORMATION = glGetUniformLocation(programID_v2f_c4f, "vertex_transformation");
UNIFORM_V2F_C4F_VERTEX_POINT_SIZE = glGetUniformLocation(programID_v2f_c4f, "vertex_point_size");
UNIFORM_V2F_C4F_T2F_VERTEX_TRANFORMATION = glGetUniformLocation(programID_v2f_c4f_t2f, "vertex_transformation");
UNIFORM_V2F_C4F_T2F_FRAG_TEXTURE_SAMPLER = glGetUniformLocation(programID_v2f_c4f_t2f, "texture_sampler");
}
ShaderEngine::~ShaderEngine()
@ -267,7 +356,7 @@ bool ShaderEngine::LoadHLSLProgram(GLenum shaderType, Shader &pmShader, std::str
}
// std::cout << "Got program: " << program << std::endl;
// now we need to prepend the HLSL template to the program
// transpile from HLSL (aka preset shader aka directX shader) to GLSL (aka OpenGL shader lang)
@ -277,10 +366,10 @@ bool ShaderEngine::LoadHLSLProgram(GLenum shaderType, Shader &pmShader, std::str
std::cerr << "Failed to parse shader from " << shaderFilename << std::endl;
return false;
}
// https://www.khronos.org/opengl/wiki/Shader_Compilation#Shader_object_compilation
GLuint shader = glCreateShader(shaderType);
// replace shader_body in preset with parameters and main():
// const char *main = "void main(in sampler2D myTexture)\n";
// program.replace(int(found), 11, main);
@ -289,10 +378,10 @@ bool ShaderEngine::LoadHLSLProgram(GLenum shaderType, Shader &pmShader, std::str
std::cout << "Got program: " << glslSource.get()->c_str() << std::endl;
const char *shaderSourceCStr = glslSource.get()->c_str();
glShaderSource(shader, 1, &shaderSourceCStr, NULL);
// compile shader
glCompileShader(shader);
// check result
GLint isCompiled = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
@ -300,17 +389,17 @@ bool ShaderEngine::LoadHLSLProgram(GLenum shaderType, Shader &pmShader, std::str
{
GLint maxLength = 1024;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
GLchar infoLog[512];
glGetShaderInfoLog(shader, 512, nullptr, infoLog);
std::cerr << (std::string("Failed to compile shader: ") + infoLog) << std::endl;
glDeleteShader(shader); // Don't leak the shader.
return false;
}
programs[&pmShader] = shader;
return true;
@ -324,7 +413,7 @@ GLuint ShaderEngine::makeShader(GLenum type, const char *filename)
std::stringstream source;
source << shader_file.rdbuf();
shader_file.close();
const char *sourceCStr = source.str().c_str();
GLint length = (int) source.str().length();
@ -446,10 +535,10 @@ void ShaderEngine::SetupUserTexture(GLuint program, const UserTexture* texture)
}
glUniform1i(param, 0);
glActiveTexture(GL_TEXTURE0 + 0);
glBindTexture(GL_TEXTURE_2D, texture->texID);
if (texture->texsizeDefined)
{
std::string texsizeName = "texsize_" + texture->name;
@ -658,3 +747,81 @@ void ShaderEngine::reset()
rand_preset[2] = (rand() % 100) * .01;
rand_preset[3] = (rand() % 100) * .01;
}
GLuint ShaderEngine::CompileShaderProgram(const std::string & VertexShaderCode, const std::string & FragmentShaderCode){
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
GLint Result = GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
glCompileShader(VertexShaderID);
// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
fprintf(stderr, "Error compiling base vertex shader: %s\n", &VertexShaderErrorMessage[0]);
}
// Compile Fragment Shader
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
glCompileShader(FragmentShaderID);
// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
fprintf(stderr, "Error compiling base fragment shader: %s\n", &FragmentShaderErrorMessage[0]);
}
// Link the program
GLuint programID = glCreateProgram();
glAttachShader(programID, VertexShaderID);
glAttachShader(programID, FragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &Result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(programID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
fprintf(stderr, "%s\n", &ProgramErrorMessage[0]);
}
glValidateProgram(programID);
// Check the program
glGetProgramiv(programID, GL_VALIDATE_STATUS, &Result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(programID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
fprintf(stderr, "%s\n", &ProgramErrorMessage[0]);
}
glDetachShader(programID, VertexShaderID);
glDetachShader(programID, FragmentShaderID);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return programID;
}