bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, VERT_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, FRAG_SHADER_SOURCE);
ProgramName[program::VERTEX] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERTEX], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERTEX], VertShaderName);
glLinkProgram(ProgramName[program::VERTEX]);
glDeleteShader(VertShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::VERTEX]);
ProgramName[program::FRAGMENT] = glCreateProgram();
glProgramParameteri(ProgramName[program::FRAGMENT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FRAGMENT], FragShaderName);
glLinkProgram(ProgramName[program::FRAGMENT]);
glDeleteShader(FragShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAGMENT]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERTEX]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAGMENT]);
}
return Validated;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 420 --profile core");
Validated = Validated && Compiler.check();
ProgramName[program::VERTEX] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERTEX], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERTEX], VertShaderName);
glLinkProgram(ProgramName[program::VERTEX]);
Validated = Validated && Compiler.checkProgram(ProgramName[program::VERTEX]);
ProgramName[program::FRAGMENT] = glCreateProgram();
glProgramParameteri(ProgramName[program::FRAGMENT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FRAGMENT], FragShaderName);
glLinkProgram(ProgramName[program::FRAGMENT]);
Validated = Validated && Compiler.checkProgram(ProgramName[program::FRAGMENT]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERTEX]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAGMENT]);
}
return Validated;
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLuint prog;
int i, j;
piglit_require_extension("GL_ARB_geometry_shader4");
/* NV_geometry_shader4 relaxes some restrictions on valid program
* parameters.
*/
piglit_require_not_extension("GL_NV_geometry_shader4");
/* Create shader. */
prog = create_shader(vs_text, gs_text, fs_text);
glProgramParameteri(prog, GL_GEOMETRY_VERTICES_OUT_ARB, 3);
for (i = 0; i < ARRAY_SIZE(primitives_in); i++) {
const struct primitive_geom_info geom = primitives_in[i];
if (geom.error != GL_NO_ERROR)
continue;
glProgramParameteri(prog, GL_GEOMETRY_INPUT_TYPE_ARB,
geom.type);
glLinkProgram(prog);
if (!piglit_link_check_status(prog) ||
!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "vertex_count"), 1);
for (j = 0; j < ARRAY_SIZE(primitives_draw); j++) {
const struct primitive_draw_info draw =
primitives_draw[j];
GLenum e;
printf("Testing drawing type %s, geometry input "
"type %s.\n",
piglit_get_prim_name(draw.type),
piglit_get_prim_name(geom.type));
if (draw.base_type == geom.type)
e = GL_NO_ERROR;
else
e = GL_INVALID_OPERATION;
glDrawArrays(draw.type, 0, 0);
pass = piglit_check_gl_error(e) && pass;
}
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(pipeline::MAX, &PipelineName[0]);
if(Validated)
{
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER,
glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_TEXTURE,
"--version 440 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER,
glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_TEXTURE,
"--version 440 --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]);
glDeleteShader(VertShaderName);
glDeleteShader(FragShaderName);
Validated = Validated && glf::checkProgram(ProgramName[pipeline::TEXTURE]);
}
if(Validated)
glUseProgramStages(PipelineName[pipeline::TEXTURE], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[pipeline::TEXTURE]);
if(Validated)
{
glf::compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER,
glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_SPLASH,
"--version 440 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER,
glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_SPLASH,
"--version 440 --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]);
glDeleteShader(VertShaderName);
glDeleteShader(FragShaderName);
Validated = Validated && glf::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);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, SAMPLE_VERT_SHADER);
GLuint ContShaderName = glf::createShader(GL_TESS_CONTROL_SHADER, SAMPLE_CONT_SHADER);
GLuint EvalShaderName = glf::createShader(GL_TESS_EVALUATION_SHADER, SAMPLE_EVAL_SHADER);
GLuint GeomShaderName = glf::createShader(GL_GEOMETRY_SHADER, SAMPLE_GEOM_SHADER);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, 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]);
glDeleteShader(VertShaderName);
glDeleteShader(ContShaderName);
glDeleteShader(EvalShaderName);
glDeleteShader(GeomShaderName);
glDeleteShader(FragShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
Validated = Validated && glf::checkProgram(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 && glf::checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
if(Validated)
{
GLuint VertShader = glf::createShader(GL_VERTEX_SHADER, SHADER_VERT_SOURCE);
ProgramName[program::VERTEX] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERTEX], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERTEX], VertShader);
glDeleteShader(VertShader);
glLinkProgram(ProgramName[program::VERTEX]);
Validated = Validated && glf::checkProgram(ProgramName[program::VERTEX]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERTEX]);
Validated = Validated && glf::checkError("initProgram - stage");
}
if(Validated)
{
GLuint FragShader = glf::createShader(GL_FRAGMENT_SHADER, SHADER_FRAG_SOURCE);
ProgramName[program::FRAGMENT] = glCreateProgram();
glProgramParameteri(ProgramName[program::FRAGMENT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FRAGMENT], FragShader);
glDeleteShader(FragShader);
glLinkProgram(ProgramName[program::FRAGMENT]);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAGMENT]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAGMENT]);
Validated = Validated && glf::checkError("initProgram - stage");
}
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERTEX], "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAGMENT], "Diffuse");
}
return glf::checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
compiler Compiler;
glGenProgramPipelines(GLsizei(PIPELINE_MAX), PipelineName);
if(Validated)
{
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE1, "--version 430 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE1, "--version 430 --profile core");
Validated = Validated && Compiler.check();
ProgramName[LAYERING] = glCreateProgram();
glProgramParameteri(ProgramName[LAYERING], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[LAYERING], VertShaderName);
glAttachShader(ProgramName[LAYERING], FragShaderName);
glLinkProgram(ProgramName[LAYERING]);
Validated = Validated && Compiler.check_program(ProgramName[LAYERING]);
}
if(Validated)
glUseProgramStages(PipelineName[LAYERING], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[LAYERING]);
if(Validated)
{
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE2, "--version 430 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE2, "--version 430 --profile core");
Validated = Validated && Compiler.check();
ProgramName[VIEWPORT] = glCreateProgram();
glProgramParameteri(ProgramName[VIEWPORT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[VIEWPORT], VertShaderName);
glAttachShader(ProgramName[VIEWPORT], FragShaderName);
glLinkProgram(ProgramName[VIEWPORT]);
Validated = Validated && Compiler.check_program(ProgramName[VIEWPORT]);
}
if(Validated)
glUseProgramStages(PipelineName[VIEWPORT], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[VIEWPORT]);
if(Validated)
{
for(std::size_t i = 0; i < PIPELINE_MAX; ++i)
UniformMVP[i] = glGetUniformLocation(ProgramName[i], "MVP");
}
return Validated;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
glObjectLabel(GL_PROGRAM_PIPELINE, PipelineName, -1, "Pipeline Program object");
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[program::VERTEX] = glCreateProgram();
glObjectLabel(GL_PROGRAM, PipelineName, -1, "Vertex Program object");
glProgramParameteri(ProgramName[program::VERTEX], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERTEX], VertShaderName);
glLinkProgram(ProgramName[program::VERTEX]);
glDeleteShader(VertShaderName);
ProgramName[program::FRAGMENT] = glCreateProgram();
glObjectLabel(GL_PROGRAM, PipelineName, -1, "Fragment Program object");
glProgramParameteri(ProgramName[program::FRAGMENT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FRAGMENT], FragShaderName);
glLinkProgram(ProgramName[program::FRAGMENT]);
glDeleteShader(FragShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::VERTEX]);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAGMENT]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERTEX]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAGMENT]);
}
return Validated;
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
// Create program
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE);
GLuint GeomShaderName = glf::createShader(GL_GEOMETRY_SHADER, glf::DATA_DIRECTORY + GEOM_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE);
ProgramName[program::VERT] = glCreateProgram();
ProgramName[program::FRAG] = glCreateProgram();
glAttachShader(ProgramName[program::VERT], VertShaderName);
glAttachShader(ProgramName[program::VERT], GeomShaderName);
glAttachShader(ProgramName[program::FRAG], FragShaderName);
glDeleteShader(VertShaderName);
glDeleteShader(GeomShaderName);
glDeleteShader(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 && glf::checkProgram(ProgramName[program::VERT]);
Validated = Validated && glf::checkProgram(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 && glf::checkError("initProgram");
}
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(program::MAX, PipelineName);
for(int i = 0; i < program::MAX; ++i)
{
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[i],
"--version 420 --profile core");
Validated = Validated && Compiler.check();
ProgramName[i] = glCreateProgram();
glProgramParameteri(ProgramName[i], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[i], VertShaderName);
glAttachShader(ProgramName[i], FragShaderName);
glLinkProgram(ProgramName[i]);
Validated = Validated && glf::checkProgram(ProgramName[i]);
if(Validated)
glUseProgramStages(PipelineName[i], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[i]);
}
return Validated;
}
void GLSLProgramPipeline::compileIndividualProgram(GLSLGpuProgram *program)
{
GLint linkStatus = 0;
// Compile and attach program
if(program && !program->isLinked())
{
try
{
program->getGLSLProgram()->compile(true);
}
catch (Exception& e)
{
LogManager::getSingleton().stream() << e.getDescription();
mTriedToLinkAndFailed = true;
return;
}
GLuint programHandle = program->getGLSLProgram()->getGLProgramHandle();
OGRE_CHECK_GL_ERROR(glProgramParameteri(programHandle, GL_PROGRAM_SEPARABLE, GL_TRUE));
program->getGLSLProgram()->attachToProgramObject(programHandle);
OGRE_CHECK_GL_ERROR(glLinkProgram(programHandle));
OGRE_CHECK_GL_ERROR(glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus));
program->setLinked(linkStatus);
mLinked = linkStatus;
mTriedToLinkAndFailed = !linkStatus;
logObjectInfo( getCombinedName() + String("GLSL program result : "), programHandle );
if(program->getType() == GPT_VERTEX_PROGRAM)
setSkeletalAnimationIncluded(program->isSkeletalAnimationIncluded());
}
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
// Create shaders
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE);
GLuint GeomShaderName = Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + GEOM_SHADER_SOURCE);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE);
Validated = Validated && Compiler.check();
if(Validated)
{
ProgramName = glCreateProgram();
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, GeomShaderName);
glAttachShader(ProgramName, FragShaderName);
glLinkProgram(ProgramName);
Validated = Validated && Compiler.checkProgram(ProgramName);
}
}
if(Validated)
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);
return Validated;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + 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;
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
// Create program
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;
}
AsProgramLink AsShaderProgram::BuildProgram()
{
//to start, create the program
mProgramID = glCreateProgram();
//attach all of the shaders
for (auto i : mVertex)
{
glAttachShader(mProgramID, i.GetShaderID());
}
for (auto i : mTessCtrl)
{
glAttachShader(mProgramID, i.GetShaderID());
}
for (auto i : mTessEval)
{
glAttachShader(mProgramID, i.GetShaderID());
}
for (auto i : mGeometry)
{
glAttachShader(mProgramID, i.GetShaderID());
}
for (auto i : mFragment)
{
glAttachShader(mProgramID, i.GetShaderID());
}
//if this is in PPO, then use ppo mode
if (mIsProgrammiblePipelineObject == GL_TRUE)
{
glProgramParameteri(mProgramID, GL_PROGRAM_SEPARABLE, GL_TRUE);
}
//now link the program
glLinkProgram(mProgramID);
glGetProgramiv(mProgramID, GL_LINK_STATUS, &mLinkLog.mSuccess);
if(mLinkLog.mSuccess == GL_FALSE)
{
GLint maxLength = 0;
glGetProgramiv(mProgramID, GL_INFO_LOG_LENGTH, &maxLength);
//The maxLength includes the NULL character
mLinkLog.mLogLength = maxLength;
glGetProgramInfoLog(mProgramID, maxLength, &maxLength, &mLinkLog.mBuildLog[0]);
//We don't need the shader anymore.
glDeleteProgram(mProgramID);
mLinkLog.mSuccess = GL_FALSE;
}
else
{
mLinkLog.mSuccess = GL_TRUE; //nothing went wrong
}
return mLinkLog;
}
bool initProgram()
{
bool Validated(true);
compiler Compiler;
if(Validated)
{
GLuint ComputeShaderName = Compiler.create(GL_COMPUTE_SHADER, getDataDirectory() + CS_SOURCE);
ProgramName = glCreateProgram();
glAttachShader(ProgramName, ComputeShaderName);
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glLinkProgram(ProgramName);
}
if(Validated)
{
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.check_program(ProgramName);
}
if(Validated)
{
glGenProgramPipelines(1, &PipelineName);
glUseProgramStages(PipelineName, GL_COMPUTE_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);
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;
}
GLuint ShaderManager::cookDough(gland::ShaderDough &dough, bool separable){
GLuint shaderProgram = glCreateProgram();
std::vector<GLuint> shaders = dough.getShaders();
for(GLuint i : shaders){
glAttachShader (shaderProgram, i);
}
if(separable){
glProgramParameteri(shaderProgram, GL_PROGRAM_SEPARABLE, GL_TRUE);
}
glLinkProgram (shaderProgram);
// check if link was successful
int params = -1;
glGetProgramiv (shaderProgram, GL_LINK_STATUS, ¶ms);
if (GL_TRUE != params) {
fprintf (
stderr,
"ERROR: could not link shader programme GL index %i\n",
shaderProgram
);
gllog::_print_programme_info_log (shaderProgram);
}
//Clean up
for(GLuint i : shaders){
glDeleteShader(i);
}
return shaderProgram;
}
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() + VERT_SHADER_SOURCE_AA);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_AA);
ProgramName[pipeline::MULTISAMPLE] = glCreateProgram();
glProgramParameteri(ProgramName[pipeline::MULTISAMPLE], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[pipeline::MULTISAMPLE], VertShaderName);
glAttachShader(ProgramName[pipeline::MULTISAMPLE], FragShaderName);
glLinkProgram(ProgramName[pipeline::MULTISAMPLE]);
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.checkProgram(ProgramName[pipeline::MULTISAMPLE]);
}
if(Validated)
{
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_SPLASH);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_SPLASH);
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.check();
Validated = Validated && Compiler.checkProgram(ProgramName[pipeline::SPLASH]);
}
if(Validated)
{
glGenProgramPipelines(pipeline::MAX, &PipelineName[0]);
glUseProgramStages(PipelineName[pipeline::MULTISAMPLE], GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName[pipeline::MULTISAMPLE]);
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);
// 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");
}
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");
}
/*
* Category: Shaders
*
* Core in:
* OpenGL : 4.1
* OpenGLES : 3.0
*/
void rglProgramParameteri( GLuint program,
GLenum pname,
GLint value)
{
#if !defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES) && (defined(HAVE_OPENGLES3) || defined(HAVE_OPENGLES_3_1))
glProgramParameteri(program, pname, value);
#else
printf("WARNING! Not implemented.\n");
#endif
}
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;
}
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");
}
bool GraphicsPipeline::generate(bool separable)
{
mProgId = glCreateProgram();
glGenProgramPipelines(1, &mPipeId);
if (separable) {
glProgramParameteri(mProgId, GL_PROGRAM_SEPARABLE, GL_TRUE);
}
return true;
}
/**
* \brief Setup output primitive type for the geometry shader
*
* \param prog a GLSL program
* \param prim desired output primitive type
* \returns SCE_ERROR on error, SCE_OK otherwise
*/
int SCE_RSetProgramOutputPrimitive (SCE_RProgram *prog,
SCE_EPrimitiveType prim)
{
SCEenum p = sce_rprimtypes[prim];
glProgramParameteri (prog->id, GL_GEOMETRY_OUTPUT_TYPE_EXT, p);
if (prog->linked) {
/* automatic relink if the shader was already linked */
prog->linked = SCE_FALSE;
return SCE_RBuildProgram (prog);
}
return SCE_OK;
}
static void CopyShaderState_Geometry(GLuint newProgID, GLuint oldProgID)
{
#if defined(GL_ARB_geometry_shader4) && defined(GL_ARB_get_program_binary)
if (!GLEW_ARB_geometry_shader4)
return;
// "GL_INVALID_OPERATION is generated if pname is GL_GEOMETRY_VERTICES_OUT,
// GL_GEOMETRY_INPUT_TYPE, or GL_GEOMETRY_OUTPUT_TYPE, and program does not
// contain a geometry shader."
if (!CopyShaderState_ContainsGeometryShader(oldProgID))
return;
GLint verticesOut = 0, inputType = 0, outputType = 0;
glGetProgramiv(oldProgID, GL_GEOMETRY_INPUT_TYPE, &inputType);
glGetProgramiv(oldProgID, GL_GEOMETRY_OUTPUT_TYPE, &outputType);
glGetProgramiv(oldProgID, GL_GEOMETRY_VERTICES_OUT, &verticesOut);
if (inputType != 0) glProgramParameteri(newProgID, GL_GEOMETRY_INPUT_TYPE, inputType);
if (outputType != 0) glProgramParameteri(newProgID, GL_GEOMETRY_OUTPUT_TYPE, outputType);
if (verticesOut != 0) glProgramParameteri(newProgID, GL_GEOMETRY_VERTICES_OUT, verticesOut);
#endif
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
// Create program
if(Validated)
{
compiler Compiler;
GLuint ShaderName[] = {
Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER, "--version 410 --profile core"),
Compiler.create(GL_TESS_CONTROL_SHADER, getDataDirectory() + SAMPLE_CONT_SHADER, "--version 410 --profile core"),
Compiler.create(GL_TESS_EVALUATION_SHADER, getDataDirectory() + SAMPLE_EVAL_SHADER, "--version 410 --profile core"),
Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER, "--version 410 --profile core"),
Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER, "--version 410 --profile core")} ;
Validated = Validated && Compiler.check();
for(std::size_t i = 0; i < program::MAX; ++i)
{
ProgramName[i] = glCreateProgram();
glProgramParameteri(ProgramName[i], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[i], ShaderName[i]);
glLinkProgram(ProgramName[i]);
}
for(std::size_t i = 0; i < program::MAX; ++i)
Validated = Validated && Compiler.checkProgram(ProgramName[i]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_TESS_CONTROL_SHADER_BIT, ProgramName[program::CONT]);
glUseProgramStages(PipelineName, GL_TESS_EVALUATION_SHADER_BIT, ProgramName[program::EVAL]);
glUseProgramStages(PipelineName, GL_GEOMETRY_SHADER_BIT, ProgramName[program::GEOM]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
}
return Validated && this->checkError("initProgram");
}
