void device_load_vertexshader(device_t device, shader_t vertshader)
{
GLuint program = 0;
vertbuffer_t cur_vb = device->cur_vertex_buffer;
if (device->cur_vertex_shader == vertshader)
return;
if (vertshader && vertshader->type != SHADER_VERTEX) {
blog(LOG_ERROR, "Specified shader is not a vertex shader");
goto fail;
}
/* unload and reload the vertex buffer to sync the buffers up with
* the specific shader */
if (cur_vb && !vertexbuffer_load(device, NULL))
goto fail;
device->cur_vertex_shader = vertshader;
if (vertshader)
program = vertshader->program;
glUseProgramStages(device->pipeline, GL_VERTEX_SHADER_BIT, program);
if (!gl_success("glUseProgramStages"))
goto fail;
if (cur_vb && !vertexbuffer_load(device, cur_vb))
goto fail;
return;
fail:
blog(LOG_ERROR, "device_load_vertexshader (GL) failed");
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
if(Validated)
{
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE,
"--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE,
"--version 420 --profile core");
Validated = Validated && Compiler.check();
ProgramName = glCreateProgram();
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glLinkProgram(ProgramName);
Validated = Validated && glf::checkProgram(ProgramName);
}
if(Validated)
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);
return Validated;
}
bool initProgram()
{
bool Validated(true);
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 440 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 440 --profile core");
Validated = Validated && Compiler.check();
ProgramName = glCreateProgram();
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glLinkProgram(ProgramName);
Validated = Validated && Compiler.checkProgram(ProgramName);
}
if(Validated)
{
glGenProgramPipelines(1, &PipelineName);
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);
}
return Validated && this->checkError("initProgram");
}
GLint ComputeWaterSimulation::createShaderPipelineProgram(GLuint target, const char* src, GLuint &pipeline, GLuint &program)
{
GLint status;
glGenProgramPipelines(1, &pipeline);
program = glCreateShaderProgramv(target, 1, (const GLchar **)&src);
glBindProgramPipeline(pipeline);
glUseProgramStages(pipeline, GL_COMPUTE_SHADER_BIT, program);
glValidateProgramPipeline(pipeline);
glGetProgramPipelineiv(pipeline, GL_VALIDATE_STATUS, &status);
if (status != GL_TRUE)
{
GLint logLength;
glGetProgramPipelineiv(pipeline, GL_INFO_LOG_LENGTH, &logLength);
char *log = new char [logLength];
glGetProgramPipelineInfoLog(pipeline, logLength, 0, log);
LOGI("Shader pipeline not valid:\n%s\n", log);
delete [] log;
}
glBindProgramPipeline(0);
return status;
}
bool testDrawIndexing::initProgram()
{
bool Validated(true);
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE[this->Indexing], "--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE[this->Indexing], "--version 420 --profile core");
Validated = Validated && Compiler.check();
if(Validated)
{
this->ProgramName = glCreateProgram();
glProgramParameteri(this->ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(this->ProgramName, VertShaderName);
glAttachShader(this->ProgramName, FragShaderName);
glLinkProgram(this->ProgramName);
Validated = Validated && glf::checkProgram(this->ProgramName);
}
if(Validated)
{
if(this->Indexing == UNIFORM_INDEXING)
UniformDrawIndex = glGetUniformLocation(this->ProgramName, "DrawID");
}
glGenProgramPipelines(1, &this->PipelineName);
if(Validated)
glUseProgramStages(this->PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, this->ProgramName);
return Validated;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, VERT_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, FRAG_SHADER_SOURCE);
ProgramName = glCreateProgram();
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glDeleteShader(VertShaderName);
glDeleteShader(FragShaderName);
glLinkProgram(ProgramName);
Validated = glf::checkProgram(ProgramName);
}
if(Validated)
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);
glBindProgramPipeline(0);
return Validated;
}
void device_load_pixelshader(device_t device, shader_t pixelshader)
{
GLuint program = 0;
if (device->cur_pixel_shader == pixelshader)
return;
if (pixelshader && pixelshader->type != SHADER_PIXEL) {
blog(LOG_ERROR, "Specified shader is not a pixel shader");
goto fail;
}
device->cur_pixel_shader = pixelshader;
if (pixelshader)
program = pixelshader->program;
glUseProgramStages(device->pipeline, GL_FRAGMENT_SHADER_BIT, program);
if (!gl_success("glUseProgramStages"))
goto fail;
clear_textures(device);
if (pixelshader)
load_default_pixelshader_samplers(device, pixelshader);
return;
fail:
blog(LOG_ERROR, "device_load_pixelshader (GL) failed");
}
bool initProgram()
{
bool Validated = true;
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE);
ProgramName = glCreateProgram();
glProgramParameteri(this->ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(this->ProgramName, VertShaderName);
glAttachShader(this->ProgramName, FragShaderName);
glLinkProgram(this->ProgramName);
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.checkProgram(this->ProgramName);
}
if(Validated)
{
glGenProgramPipelines(1, &this->PipelineName);
glUseProgramStages(this->PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, this->ProgramName);
}
return Validated;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(pipeline::MAX, &PipelineName[0]);
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TEXTURE, "--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_TEXTURE, "--version 420 --profile core");
Validated = Validated && Compiler.check();
ProgramName[pipeline::TEXTURE] = glCreateProgram();
glProgramParameteri(ProgramName[pipeline::TEXTURE], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[pipeline::TEXTURE], VertShaderName);
glAttachShader(ProgramName[pipeline::TEXTURE], FragShaderName);
glLinkProgram(ProgramName[pipeline::TEXTURE]);
Validated = Validated && Compiler.checkProgram(ProgramName[pipeline::TEXTURE]);
}
if(Validated)
glUseProgramStages(PipelineName[pipeline::TEXTURE], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[pipeline::TEXTURE]);
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_SPLASH, "--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_SPLASH, "--version 420 --profile core");
Validated = Validated && Compiler.check();
ProgramName[pipeline::SPLASH] = glCreateProgram();
glProgramParameteri(ProgramName[pipeline::SPLASH], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[pipeline::SPLASH], VertShaderName);
glAttachShader(ProgramName[pipeline::SPLASH], FragShaderName);
glLinkProgram(ProgramName[pipeline::SPLASH]);
Validated = Validated && Compiler.checkProgram(ProgramName[pipeline::SPLASH]);
}
if(Validated)
glUseProgramStages(PipelineName[pipeline::SPLASH], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[pipeline::SPLASH]);
return Validated;
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER);
GLuint ContShaderName = Compiler.create(GL_TESS_CONTROL_SHADER, getDataDirectory() + SAMPLE_CONT_SHADER);
GLuint EvalShaderName = Compiler.create(GL_TESS_EVALUATION_SHADER, getDataDirectory() + SAMPLE_EVAL_SHADER);
GLuint GeomShaderName = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER);
ProgramName[program::VERT] = glCreateProgram();
ProgramName[program::FRAG] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glProgramParameteri(ProgramName[program::FRAG], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERT], VertShaderName);
glAttachShader(ProgramName[program::VERT], ContShaderName);
glAttachShader(ProgramName[program::VERT], EvalShaderName);
glAttachShader(ProgramName[program::VERT], GeomShaderName);
glLinkProgram(ProgramName[program::VERT]);
glAttachShader(ProgramName[program::FRAG], FragShaderName);
glLinkProgram(ProgramName[program::FRAG]);
Validated = Validated && Compiler.check_program(ProgramName[program::VERT]);
Validated = Validated && Compiler.check_program(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_TESS_CONTROL_SHADER_BIT | GL_TESS_EVALUATION_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
}
return Validated;
}
bool initProgram()
{
bool Validated(true);
compiler Compiler;
if(Validated)
{
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SHADER_VERT_SOURCE_UPDATE);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SHADER_FRAG_SOURCE_UPDATE);
ProgramName[program::UPDATE] = glCreateProgram();
glProgramParameteri(ProgramName[program::UPDATE], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::UPDATE], VertShaderName);
glAttachShader(ProgramName[program::UPDATE], FragShaderName);
glLinkProgram(ProgramName[program::UPDATE]);
}
if(Validated)
{
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SHADER_VERT_SOURCE_BLIT);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SHADER_FRAG_SOURCE_BLIT);
ProgramName[program::BLIT] = glCreateProgram();
glProgramParameteri(ProgramName[program::BLIT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::BLIT], VertShaderName);
glAttachShader(ProgramName[program::BLIT], FragShaderName);
glLinkProgram(ProgramName[program::BLIT]);
}
if(Validated)
{
Validated = Validated && Compiler.check_program(ProgramName[program::UPDATE]);
Validated = Validated && Compiler.check_program(ProgramName[program::BLIT]);
}
if(Validated)
{
glGenProgramPipelines(pipeline::MAX, &PipelineName[0]);
glUseProgramStages(PipelineName[pipeline::UPDATE], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::UPDATE]);
glUseProgramStages(PipelineName[pipeline::BLIT], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::BLIT]);
}
return Validated && this->checkError("initProgram - stage");
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
// Create program
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 410 --profile core");
GLuint GeomShaderName = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + GEOM_SHADER_SOURCE, "--version 410 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 410 --profile core");
Validated = Validated && Compiler.check();
ProgramName[program::VERT] = glCreateProgram();
ProgramName[program::FRAG] = glCreateProgram();
glAttachShader(ProgramName[program::VERT], VertShaderName);
glAttachShader(ProgramName[program::VERT], GeomShaderName);
glAttachShader(ProgramName[program::FRAG], FragShaderName);
glProgramParameteri(ProgramName[program::VERT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glProgramParameteri(ProgramName[program::FRAG], GL_PROGRAM_SEPARABLE, GL_TRUE);
glLinkProgram(ProgramName[program::VERT]);
glLinkProgram(ProgramName[program::FRAG]);
Validated = Validated && Compiler.check_program(ProgramName[program::VERT]);
Validated = Validated && Compiler.check_program(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAG], "Diffuse");
}
return Validated && this->checkError("initProgram");
}
void Triangle::init_shader()
{
glGenProgramPipelines(1, &m_pipe);
auto vertSource = byhj::textFileRead("triangle.vert");
const char *ver = vertSource.c_str();
m_vert = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &ver);
glUseProgramStages(m_pipe, GL_VERTEX_SHADER, m_vert);
mvp_loc = glGetUniformLocation(m_vert, "mvp");
auto fragContext = textFileRead("triangle.frag");
const char *frg = fragContext.c_str();
m_frag = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &frg);
glUseProgramStages(m_pipe, GL_FRAGMENT_SHADER_BIT, m_frag);
color_loc = glGetUniformLocation(m_frag, "color");
}
bool Pipeline :: setStage ( GLbitfield mask, Program * program )
{
if ( id == 0 || program == NULL || !program -> isOk () )
return false;
glUseProgramStages ( id, mask, program -> getProgram () );
return true;
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
if(Validated)
{
std::string VertexSourceContent = glf::loadFile(glf::DATA_DIRECTORY + VERT_SHADER_SOURCE);
char const * VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
Validated = Validated && glf::checkError("initProgram - stage");
}
if(Validated)
{
std::string FragmentSourceContent = glf::loadFile(glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE);
char const * FragmentSourcePointer = FragmentSourceContent.c_str();
ProgramName[program::FRAG] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
Validated = Validated && glf::checkError("initProgram - stage");
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAG], "Diffuse");
}
return Validated && glf::checkError("initProgram");
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(program::MAX, PipelineName);
if(Validated)
{
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VS_SOURCE, "--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FS_SOURCE, "--version 420 --profile core");
GLuint CompShaderName = Compiler.create(GL_COMPUTE_SHADER, glf::DATA_DIRECTORY + CS_SOURCE, "--version 420 --profile core");
Validated = Validated && Compiler.check();
if(Validated)
{
ProgramName[program::GRAPHICS] = glCreateProgram();
glProgramParameteri(ProgramName[program::GRAPHICS], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::GRAPHICS], VertShaderName);
glAttachShader(ProgramName[program::GRAPHICS], FragShaderName);
glLinkProgram(ProgramName[program::GRAPHICS]);
}
if(Validated)
{
ProgramName[program::COMPUTE] = glCreateProgram();
glProgramParameteri(ProgramName[program::COMPUTE], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::COMPUTE], CompShaderName);
glLinkProgram(ProgramName[program::COMPUTE]);
}
Validated = Validated && glf::checkProgram(ProgramName[program::GRAPHICS]);
Validated = Validated && glf::checkProgram(ProgramName[program::COMPUTE]);
}
if(Validated)
{
glUseProgramStages(PipelineName[program::GRAPHICS], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::GRAPHICS]);
glUseProgramStages(PipelineName[program::COMPUTE], GL_COMPUTE_SHADER_BIT, ProgramName[program::COMPUTE]);
}
return Validated;
}
void GSShaderOGL::GS(GLuint s)
{
if (GLState::gs != s)
{
GLState::gs = s;
GLState::dirty_prog = true;
if (GLLoader::found_GL_ARB_separate_shader_objects)
glUseProgramStages(m_pipeline, GL_GEOMETRY_SHADER_BIT, s);
}
}
bool initProgram()
{
bool Validated = true;
compiler Compiler;
GLuint VertTransformShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TRANSFORM, "--version 440 --profile core");
GLuint VertFeedbackShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_FEEDBACK, "--version 440 --profile core");
GLuint FragFeedbackShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_FEEDBACK, "--version 440 --profile core");
if(Validated)
{
ProgramName[program::TRANSFORM] = glCreateProgram();
glProgramParameteri(ProgramName[program::TRANSFORM], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::TRANSFORM], VertTransformShaderName);
glLinkProgram(ProgramName[program::TRANSFORM]);
}
if(Validated)
{
ProgramName[program::FEEDBACK] = glCreateProgram();
glProgramParameteri(ProgramName[program::FEEDBACK], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FEEDBACK], VertFeedbackShaderName);
glAttachShader(ProgramName[program::FEEDBACK], FragFeedbackShaderName);
glLinkProgram(ProgramName[program::FEEDBACK]);
}
if(Validated)
{
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.check_program(ProgramName[program::TRANSFORM]);
Validated = Validated && Compiler.check_program(ProgramName[program::FEEDBACK]);
}
if(Validated)
{
glGenProgramPipelines(program::MAX, &PipelineName[0]);
glUseProgramStages(PipelineName[program::TRANSFORM], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::TRANSFORM]);
glUseProgramStages(PipelineName[program::FEEDBACK], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::FEEDBACK]);
}
return Validated && this->checkError("initProgram");
}
void ZZshSetPixelShader(ZZshShaderLink prog) {
g_psprog = prog;
FRAGMENTSHADER* ps = (FRAGMENTSHADER*)g_psprog.link;
if (!ps) return;
if (ps->program != g_current_ps) {
glUseProgramStages(s_pipeline, GL_FRAGMENT_SHADER_BIT, ps->program);
g_current_ps = ps->program;
}
}
void ZZshSetVertexShader(ZZshShaderLink prog) {
g_vsprog = prog;
VERTEXSHADER* vs = (VERTEXSHADER*)g_vsprog.link;
if (!vs) return;
if (vs->program != g_current_vs) {
glUseProgramStages(s_pipeline, GL_VERTEX_SHADER_BIT, vs->program);
g_current_vs = vs->program;
}
}
bool initProgram()
{
bool Validated = true;
if(Validated)
{
std::string VertexSourceContent = this->loadFile(getDataDirectory() + VERT_SHADER_SOURCE);
char const * VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
}
if(Validated)
{
std::string FragmentSourceContent = this->loadFile(getDataDirectory() + FRAG_SHADER_SOURCE);
char const * FragmentSourcePointer = FragmentSourceContent.c_str();
ProgramName[program::FRAG] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
}
if(Validated)
{
compiler Compiler;
Validated = Validated && Compiler.checkProgram(ProgramName[program::VERT]);
Validated = Validated && Compiler.checkProgram(ProgramName[program::FRAG]);
}
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAG], "Diffuse");
}
if(Validated)
{
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
return Validated && this->checkError("initProgram");
}
static void
build_and_validate_pipe(GLuint pipe, bool expected, const char *test_name,
GLbitfield bit_a, GLuint prog_a,
GLbitfield bit_b, GLuint prog_b,
GLbitfield bit_c, GLuint prog_c,
GLbitfield bit_d, GLuint prog_d,
GLbitfield bit_e, GLuint prog_e)
{
if (!piglit_automatic)
printf("%s\n", test_name);
if (bit_a != GL_ALL_SHADER_BITS)
glUseProgramStages(pipe, GL_ALL_SHADER_BITS, 0);
if (bit_a != 0)
glUseProgramStages(pipe, bit_a, prog_a);
if (bit_b != 0)
glUseProgramStages(pipe, bit_b, prog_b);
if (bit_c != 0)
glUseProgramStages(pipe, bit_c, prog_c);
if (bit_d != 0)
glUseProgramStages(pipe, bit_d, prog_d);
if (bit_e != 0)
glUseProgramStages(pipe, bit_e, prog_e);
validate_pipe(pipe, expected, test_name);
if (!piglit_automatic)
printf("\n");
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(program::MAX, &PipelineName[0]);
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 420 --profile core");
GLuint FragShaderNameNorm = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE[program::NORM], "--version 420 --profile core");
GLuint FragShaderNameUint = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE[program::UINT], "--version 420 --profile core");
Validated = Validated && Compiler.check();
if(Validated)
{
ProgramName[program::NORM] = glCreateProgram();
glProgramParameteri(ProgramName[program::NORM], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::NORM], VertShaderName);
glAttachShader(ProgramName[program::NORM], FragShaderNameNorm);
glLinkProgram(ProgramName[program::NORM]);
Validated = Validated && Compiler.check_program(ProgramName[program::NORM]);
}
if(Validated)
{
ProgramName[program::UINT] = glCreateProgram();
glProgramParameteri(ProgramName[program::UINT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::UINT], VertShaderName);
glAttachShader(ProgramName[program::UINT], FragShaderNameUint);
glLinkProgram(ProgramName[program::UINT]);
Validated = Validated && Compiler.check_program(ProgramName[program::UINT]);
}
if(Validated)
{
glUseProgramStages(PipelineName[program::NORM], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::NORM]);
glUseProgramStages(PipelineName[program::UINT], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[program::UINT]);
}
return Validated;
}
bool GlslProgram::link(bool pipeline)
{
cleanup();
if(pipeline)
{
glGenProgramPipelines(1, &m_pipeline_id);
}
else
{
m_id = glCreateProgram();
}
for(GlslShaderUptr &vv : m_shaders)
{
if(!vv->compile(pipeline))
{
return false;
}
if(pipeline)
{
glUseProgramStages(m_pipeline_id, vv->getStage(), vv->getPipelineId());
}
else
{
glAttachShader(m_id, vv->getId());
}
}
if(pipeline)
{
std::string log = get_pipeline_info_log(m_pipeline_id);
if(!log.empty())
{
std::cout << log;
return false;
}
}
else
{
glLinkProgram(m_id);
if(!get_program_link_status(m_id))
{
std::cout << get_program_info_log(m_id);
return false;
}
}
return true;
}
void piglit_init(int argc, char **argv)
{
GLuint vs_prog, fs_prog;
piglit_require_extension("GL_ARB_separate_shader_objects");
vs_prog = glCreateShaderProgramv(GL_VERTEX_SHADER, 1,
(const GLchar *const*) &vs_code);
piglit_link_check_status(vs_prog);
fs_prog = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1,
(const GLchar *const *) &fs_code);
piglit_link_check_status(fs_prog);
glGenProgramPipelines(1, &pipeline);
glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, vs_prog);
glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, fs_prog);
piglit_program_pipeline_check_status(pipeline);
if (!piglit_check_gl_error(0))
piglit_report_result(PIGLIT_FAIL);
}
GLUSvoid GLUSAPIENTRY glusProgramPipelineDestroy(GLUSprogrampipeline* programPipeline)
{
if (!programPipeline)
{
return;
}
if (programPipeline->pipeline)
{
glUseProgramStages(programPipeline->pipeline, GLUS_COMPUTE_SHADER_BIT, 0);
glUseProgramStages(programPipeline->pipeline, GLUS_VERTEX_SHADER_BIT, 0);
glUseProgramStages(programPipeline->pipeline, GLUS_FRAGMENT_SHADER_BIT, 0);
glDeleteProgramPipelines(1, &programPipeline->pipeline);
programPipeline->pipeline = 0;
}
programPipeline->computeProgram = 0;
programPipeline->fragmentProgram = 0;
programPipeline->vertexProgram = 0;
}
void AsProgramPipelineObject::AddProgram(AsShaderProgram pProgram)
{
//first check if it is a ppo enabled shader
if (!pProgram.IsProgrammiblePipelineObject())
return;
mPrograms.push_back(pProgram);
//now add it to the openGL context
glUseProgramStages(mPipelineID, pProgram.GetShaderTypes(),
pProgram.GetProgramID());
}
GLUSAPI GLUSboolean GLUSAPIENTRY glusProgramPipelineBuild(GLUSprogrampipeline* programPipeline, GLUSuint vertexProgram, GLUSuint fragmentProgram)
{
if (!programPipeline)
{
return GLUS_FALSE;
}
programPipeline->computeProgram = 0;
programPipeline->vertexProgram = vertexProgram;
programPipeline->fragmentProgram = fragmentProgram;
glGenProgramPipelines(1, &programPipeline->pipeline);
if (vertexProgram)
{
glUseProgramStages(programPipeline->pipeline, GLUS_VERTEX_SHADER_BIT, vertexProgram);
}
if (fragmentProgram)
{
glUseProgramStages(programPipeline->pipeline, GLUS_FRAGMENT_SHADER_BIT, fragmentProgram);
}
return GLUS_TRUE;
}
bool initSeparateProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
if(Validated)
{
std::string VertexSourceContent = glf::loadFile(VERTEX_SHADER_SOURCE);
char const * VertexSourcePointer = VertexSourceContent.c_str();
SeparateProgramName[program::VERTEX] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
Validated = glf::checkProgram(SeparateProgramName[program::VERTEX]);
}
if(Validated)
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, SeparateProgramName[program::VERTEX]);
if(Validated)
{
std::string FragmentSourceContent = glf::loadFile(FRAGMENT_SHADER_SOURCE);
char const * FragmentSourcePointer = FragmentSourceContent.c_str();
SeparateProgramName[program::FRAGMENT] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
Validated = glf::checkProgram(SeparateProgramName[program::FRAGMENT]);
}
if(Validated)
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, SeparateProgramName[program::FRAGMENT]);
// Get variables locations
if(Validated)
{
SeparateUniformMVP = glGetUniformLocation(SeparateProgramName[program::VERTEX], "MVP");
SeparateUniformDiffuse = glGetUniformLocation(SeparateProgramName[program::FRAGMENT], "Diffuse");
}
return Validated && glf::checkError("initProgram");
}
void GSShaderOGL::PS(GLuint s)
{
#ifdef _DEBUG
if (true)
#else
if (GLState::ps != s)
#endif
{
// In debug always sets the program. It allow to replace the program in apitrace easily.
GLState::ps = s;
GLState::dirty_prog = true;
if (GLLoader::found_GL_ARB_separate_shader_objects) {
glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, s);
}
}
}
