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); } } }