device_t device_create(struct gs_init_data *info)
{
struct gs_device *device = bzalloc(sizeof(struct gs_device));
device->plat = gl_platform_create(device, info);
if (!device->plat)
goto fail;
if (!gl_init_extensions(device))
goto fail;
gl_enable(GL_CULL_FACE);
glGenProgramPipelines(1, &device->pipeline);
if (!gl_success("glGenProgramPipelines"))
goto fail;
glBindProgramPipeline(device->pipeline);
if (!gl_success("glBindProgramPipeline"))
goto fail;
device_leavecontext(device);
device->cur_swap = gl_platform_getswap(device->plat);
return device;
fail:
blog(LOG_ERROR, "device_create (GL) failed");
bfree(device);
return NULL;
}
device_t device_create(struct gs_init_data *info)
{
struct gs_device *device = bmalloc(sizeof(struct gs_device));
memset(device, 0, sizeof(struct gs_device));
device->plat = gl_platform_create(device, info);
if (!device->plat)
goto fail;
glGenProgramPipelines(1, &device->pipeline);
if (!gl_success("glGenProgramPipelines"))
goto fail;
glBindProgramPipeline(device->pipeline);
if (!gl_success("glBindProgramPipeline"))
goto fail;
#ifdef _DEBUG
glEnable(GL_DEBUG_OUTPUT);
if (glGetError() == GL_INVALID_ENUM)
blog(LOG_DEBUG, "OpenGL debug information not available");
#endif
gl_enable(GL_CULL_FACE);
device_leavecontext(device);
device->cur_swap = gl_platform_getswap(device->plat);
return device;
fail:
blog(LOG_ERROR, "device_create (GL) failed");
bfree(device);
return NULL;
}
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 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);
if(Validated)
{
GLuint VertShaderName = amd::createShader(GL_VERTEX_SHADER, VERT_SHADER_SOURCE);
GLuint FragShaderName = amd::createShader(GL_FRAGMENT_SHADER, FRAG_SHADER_SOURCE);
ProgramName[program::VERTEX_SHADER] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERTEX_SHADER], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERTEX_SHADER], VertShaderName);
glLinkProgram(ProgramName[program::VERTEX_SHADER]);
glDeleteShader(VertShaderName);
Validated = Validated && amd::checkProgram(ProgramName[program::VERTEX_SHADER]);
ProgramName[program::FRAGMENT_SHADER] = glCreateProgram();
glProgramParameteri(ProgramName[program::FRAGMENT_SHADER], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FRAGMENT_SHADER], FragShaderName);
glLinkProgram(ProgramName[program::FRAGMENT_SHADER]);
glDeleteShader(FragShaderName);
Validated = Validated && amd::checkProgram(ProgramName[program::FRAGMENT_SHADER]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERTEX_SHADER]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAGMENT_SHADER]);
}
return Validated;
}
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 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(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);
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");
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(pipeline::MAX, PipelineName);
glBindProgramPipeline(PipelineName[pipeline::READ]);
if(Validated)
{
std::string VertexSourceContent = glf::loadFile(glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_READ);
char const * VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
}
if(Validated)
{
std::string FragmentSourceContent = glf::loadFile(glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_READ);
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[pipeline::READ], GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName[pipeline::READ], GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
Validated = Validated && glf::checkError("initProgram - stage");
}
glBindProgramPipeline(PipelineName[pipeline::SAVE]);
if(Validated)
{
std::string VertexSourceContent = glf::loadFile(glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_SAVE);
char const * VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
}
if(Validated)
{
std::string FragmentSourceContent = glf::loadFile(glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_SAVE);
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[pipeline::SAVE], GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName[pipeline::SAVE], GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
Validated = Validated && glf::checkError("initProgram - stage");
}
return Validated;
}
GSShaderOGL::GSShaderOGL(bool debug) :
m_pipeline(0),
m_debug_shader(debug)
{
m_single_prog.clear();
if (GLLoader::found_GL_ARB_separate_shader_objects) {
glGenProgramPipelines(1, &m_pipeline);
glBindProgramPipeline(m_pipeline);
}
}
bool GraphicsPipeline::generate(bool separable)
{
mProgId = glCreateProgram();
glGenProgramPipelines(1, &mPipeId);
if (separable) {
glProgramParameteri(mProgId, GL_PROGRAM_SEPARABLE, GL_TRUE);
}
return true;
}
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;
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);
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);
if(Validated)
{
std::string VertexSourceContent = this->loadFile(getDataDirectory() + VERT_SHADER_SOURCE_READ);
char const* VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT_READ] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
}
if(Validated)
{
std::string FragmentSourceContent = this->loadFile(getDataDirectory() + FRAG_SHADER_SOURCE_READ);
char const* FragmentSourcePointer = FragmentSourceContent.c_str();
ProgramName[program::FRAG_READ] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
}
if(Validated)
{
std::string VertexSourceContent = this->loadFile(getDataDirectory() + VERT_SHADER_SOURCE_SAVE);
char const* VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT_SAVE] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
}
if(Validated)
{
std::string FragmentSourceContent = this->loadFile(getDataDirectory() + FRAG_SHADER_SOURCE_SAVE);
char const* FragmentSourcePointer = FragmentSourceContent.c_str();
ProgramName[program::FRAG_SAVE] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
}
if(Validated)
{
compiler Compiler;
Validated = Validated && Compiler.check_program(ProgramName[program::VERT_READ]);
Validated = Validated && Compiler.check_program(ProgramName[program::FRAG_READ]);
Validated = Validated && Compiler.check_program(ProgramName[program::VERT_SAVE]);
Validated = Validated && Compiler.check_program(ProgramName[program::FRAG_SAVE]);
}
if(Validated)
{
glGenProgramPipelines(pipeline::MAX, &PipelineName[0]);
glUseProgramStages(PipelineName[pipeline::READ], GL_VERTEX_SHADER_BIT, ProgramName[program::VERT_READ]);
glUseProgramStages(PipelineName[pipeline::READ], GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG_READ]);
glUseProgramStages(PipelineName[pipeline::SAVE], GL_VERTEX_SHADER_BIT, ProgramName[program::VERT_SAVE]);
glUseProgramStages(PipelineName[pipeline::SAVE], GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG_SAVE]);
}
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 TerrainTessellation::initRendering(void) {
if (!requireExtension("GL_ARB_tessellation_shader")) return;
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("TerrainTessellation");
loadShaders();
CHECK_GL_ERROR();
//
// Create a single default program pipeline to handle binding and unbinding
// separate shader objects
//
glGenProgramPipelines( 1, &mTerrainPipeline);
glBindProgramPipeline( mTerrainPipeline);
CHECK_GL_ERROR();
//create ubo and initialize it with the structure data
glGenBuffers( 1, &mUBO);
glBindBuffer( GL_UNIFORM_BUFFER, mUBO);
glBufferData( GL_UNIFORM_BUFFER, sizeof(TessellationParams), &mParams, GL_STREAM_DRAW);
CHECK_GL_ERROR();
//create simple single-vertex VBO
float vtx_data[] = { 0.0f, 0.0f, 0.0f, 1.0f};
glGenBuffers( 1, &mVBO);
glBindBuffer( GL_ARRAY_BUFFER, mVBO);
glBufferData( GL_ARRAY_BUFFER, sizeof(vtx_data), vtx_data, GL_STATIC_DRAW);
CHECK_GL_ERROR();
srand(0);
int noiseSize = 256;
int noiseSize3D = 64;
mRandTex = createNoiseTexture2D(noiseSize, noiseSize, GL_R8);
CHECK_GL_ERROR();
mRandTex3D = createNoiseTexture4f3D(noiseSize3D, noiseSize3D, noiseSize3D, GL_RGBA8);
CHECK_GL_ERROR();
mParams.invNoiseSize = 1.0f / noiseSize;
mParams.invNoise3DSize = 1.0f / noiseSize3D;
glGenQueries(1, &mGPUQuery);
CHECK_GL_ERROR();
//initTerrainFbo();
//updateQuality();
//CHECK_GL_ERROR();
}
void ShaderPipeline::loadShaders(GLuint& m_programPipeline, GLuint& m_updateProg, const char* m_shaderPrefix, const char* shaderFile)
{
if (m_updateProg) {
glDeleteProgram(m_updateProg);
m_updateProg = 0;
}
glGenProgramPipelines(1, &m_programPipeline);
std::string src = loadShaderSourceWithUniformTag("shaders/uniforms.h", shaderFile);
m_updateProg = createShaderPipelineProgram(GL_COMPUTE_SHADER, src.c_str(), m_shaderPrefix, m_programPipeline);
}
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 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)
{
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");
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
// Create program
if(Validated)
{
GLuint ShaderName[] = {
glf::createShader(GL_VERTEX_SHADER, SAMPLE_VERT_SHADER),
glf::createShader(GL_TESS_CONTROL_SHADER, SAMPLE_CONT_SHADER),
glf::createShader(GL_TESS_EVALUATION_SHADER, SAMPLE_EVAL_SHADER),
glf::createShader(GL_GEOMETRY_SHADER, SAMPLE_GEOM_SHADER),
glf::createShader(GL_FRAGMENT_SHADER, SAMPLE_FRAG_SHADER)};
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]);
glDeleteShader(ShaderName[i]);
glLinkProgram(ProgramName[i]);
}
for(std::size_t i = 0; i < program::MAX; ++i)
Validated = Validated && glf::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 && glf::checkError("initProgram");
}
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);
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);
// 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");
}
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 graphics::line_batcher::initShaders()
{
char const * VS_SOURCE = "data/shaders/line.vert";
char const * FS_SOURCE = "data/shaders/line.frag";
m_Prog = glCreateProgram();
compiler compiler_instance;
auto pipe_mask = build(m_Prog, compiler_instance, VS_SOURCE, FS_SOURCE);
if (pipe_mask != 0 && compiler_instance.checkProgram(m_Prog))
{
glGenProgramPipelines(1, &m_Pipe);
glUseProgramStages(m_Pipe, pipe_mask, m_Prog);
return true;
}
return false;
}
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");
}
