void
OGLShaderObject::_initActiveSubroutine() noexcept
{
#if !defined(EGLAPI)
GLint numSubroutines = 0;
GLint maxSubroutines = 0;
glGetProgramStageiv(_program, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &numSubroutines);
glGetProgramStageiv(_program, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_MAX_LENGTH, &maxSubroutines);
if (numSubroutines)
{
auto nameSubroutines = make_scope<GLchar[]>(maxSubroutines + 1);
nameSubroutines[maxSubroutines + 1] = 0;
for (GLint i = 0; i < maxSubroutines; ++i)
{
GLenum type = GL_VERTEX_SHADER;
glGetActiveSubroutineName(_program, type, i, maxSubroutines, 0, nameSubroutines.get());
GLint location = glGetSubroutineIndex(_program, type, nameSubroutines.get());
auto subroutines = std::make_shared<ShaderSubroutine>();
subroutines->setName(nameSubroutines.get());
subroutines->setLocation(location);
_activeSubroutines.push_back(subroutines);
}
}
#endif
}
uint32_t cShaderObject::GetSubroutineInstance(eShaderType type, cStringRef name)
{
uint32_t ret
= glGetSubroutineIndex(mShaderProgram, GLShaderType(type), name.data());
AKJ_ASSERT_AND_THROW(ret != GL_INVALID_INDEX);
return ret;
}
/*************************************************************//**
*
* @brief サブルーチンのインデックスを取得する
* @param シェーダーの種類
* @param サブルーチン名
* @return サブルーチンのインデックス
*
****************************************************************/
C_BaseShader::SubroutineIndex C_BaseShader::GetSubroutineIndex(C_BaseShader::ShaderType type,
const std::string& rName)
{
assert(programObjectHandle_ != 0);
return glGetSubroutineIndex(programObjectHandle_, type, rName.c_str());
}
void subroutines_app::load_shaders()
{
GLuint shaders[2];
shaders[0] = sb6::shader::load("media/shaders/subroutines/subroutines.vs.glsl", GL_VERTEX_SHADER);
shaders[1] = sb6::shader::load("media/shaders/subroutines/subroutines.fs.glsl", GL_FRAGMENT_SHADER);
if (render_program)
glDeleteProgram(render_program);
render_program = sb6::program::link_from_shaders(shaders, 2, true);
subroutines[0] = glGetSubroutineIndex(render_program, GL_FRAGMENT_SHADER, "myFunction1");
subroutines[1] = glGetSubroutineIndex(render_program, GL_FRAGMENT_SHADER, "myFunction2");
uniforms.subroutine1 = glGetSubroutineUniformLocation(render_program, GL_FRAGMENT_SHADER, "mySubroutineUniform");
}
bool initProgram()
{
bool Validated = true;
compiler Compiler;
if(Validated)
{
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERTEX_SHADER_SOURCE);
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAGMENT_SHADER_SOURCE);
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glLinkProgram(ProgramName);
}
if(Validated)
{
Validated = Validated && Compiler.check();
Validated = Validated && Compiler.check_program(ProgramName);
}
if(Validated)
{
GLint ProgramVertSubroutine(0);
GLint ProgramFragSubroutine(0);
glGetProgramStageiv(ProgramName, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &ProgramVertSubroutine);
glGetProgramStageiv(ProgramName, GL_FRAGMENT_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &ProgramFragSubroutine);
UniformMVP = glGetUniformLocation(ProgramName, "MVP");
UniformDXT1 = glGetUniformLocation(ProgramName, "DiffuseDXT1");
UniformRGB8 = glGetUniformLocation(ProgramName, "DiffuseRGB8");
UniformDisplacement = glGetUniformLocation(ProgramName, "Displacement");
UniformDiffuse = glGetSubroutineUniformLocation(ProgramName, GL_FRAGMENT_SHADER, "Diffuse");
IndexDXT1 = glGetSubroutineIndex(ProgramName, GL_FRAGMENT_SHADER, "diffuseLQ");
IndexRGB8 = glGetSubroutineIndex(ProgramName, GL_FRAGMENT_SHADER, "diffuseHQ");
}
return Validated;
}
int Graphic::Renderer::InitUniforms()
{
const ShaderProgram* const shaderProg = GetShaderProgramWithType(ShaderProgram::Type::Main);
assert(shaderProg);
modelViewProjMatLoc = glGetUniformLocation(shaderProg->id, "modelViewProjMat");
modelViewMatLoc = glGetUniformLocation(shaderProg->id, "modelViewMat");
normalMatLoc = glGetUniformLocation(shaderProg->id, "normalMat");
// DEBUG delete if work
shadeModelSubroutine[0] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "PhongLight");
shadeModelSubroutine[1] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "LighSourceLight");
//shadeModelSubroutine[2] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "SkyBoxLight");
modelSubroutine = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "PhongLight");
lightSubroutine = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "LighSourceLight");
normalTextureSubroutines[0] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "TransformToObjectLocal");
normalTextureSubroutines[1] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "GetNormalFromTexture");
noNormalTextureSubroutines[0] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "NotTransformToObjectLocal");
noNormalTextureSubroutines[1] = glGetSubroutineIndex(shaderProg->id, GL_FRAGMENT_SHADER, "GetOriginalNormal");
drawObjectSubroutines[0] = glGetSubroutineIndex(shaderProg->id, GL_VERTEX_SHADER, "DrawModel");
drawObjectSubroutines[1] = glGetSubroutineIndex(shaderProg->id, GL_VERTEX_SHADER, "DrawSkyBox");
#ifdef _DEBUG
if ( GL_INVALID_INDEX == modelSubroutine
|| GL_INVALID_INDEX == lightSubroutine
|| GL_INVALID_INDEX == normalTextureSubroutines[0]
|| GL_INVALID_INDEX == normalTextureSubroutines[1]
|| GL_INVALID_INDEX == noNormalTextureSubroutines[0]
|| GL_INVALID_INDEX == noNormalTextureSubroutines[1])
std::cout << "Failed to get graphic subroutine index. \n ";
if (-1 == modelViewProjMatLoc
|| -1 == normalMatLoc
|| -1 == modelViewMatLoc)
{
std::cout << "Failed to get trans matrices loc";
return -1;
}
#endif // _DEBUG
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLuint programHandle = prog.getHandle();
GLuint adsIndex = glGetSubroutineIndex( programHandle, GL_VERTEX_SHADER, "phongModel" );
GLuint diffuseIndex = glGetSubroutineIndex(programHandle, GL_VERTEX_SHADER, "diffuseOnly");
glUniformSubroutinesuiv( GL_VERTEX_SHADER, 1, &adsIndex);
model = mat4(1.0f);
model *= glm::translate(vec3(-3.0f,-1.5f,0.0f));
model *= glm::rotate(-90.0f, vec3(1.0f,0.0f,0.0f));
setMatrices();
teapot->render();
glUniformSubroutinesuiv( GL_VERTEX_SHADER, 1, &diffuseIndex);
model = mat4(1.0f);
model *= glm::translate(vec3(3.0f,-1.5f, 0.0f));
model *= glm::rotate(-90.0f, vec3(1.0f,0.0f,0.0f));
setMatrices();
teapot->render();
}
GLuint
Program::getSubroutineIndex(GLenum shader, const char* name) const
//[]----------------------------------------------------[]
//| Get subroutine index |
//[]----------------------------------------------------[]
{
checkInUse();
GLuint index = glGetSubroutineIndex(handle, shader, name);
if (index == GL_INVALID_INDEX)
error(SUBROUTINE_NOT_FOUND, getName(), name);
return index;
}
void Plane::init_shader()
{
m_PlaneShader.init();
m_PlaneShader.attach(GL_VERTEX_SHADER, "light.vert");
m_PlaneShader.attach(GL_FRAGMENT_SHADER, "light.frag");
m_PlaneShader.link();
m_PlaneShader.info();
uniform_loc.lightSub[0] = -1; uniform_loc.lightSub[1] = -1;
program = m_PlaneShader.getProgram();
uniform_loc.woodTex = glGetUniformLocation(program, "u_WoodTex");
uniform_loc.lightSub[0] = glGetSubroutineIndex(program, GL_FRAGMENT_SHADER, "Phong");
uniform_loc.lightSub[1] = glGetSubroutineIndex(program, GL_FRAGMENT_SHADER, "BlinnPhong");
uniform_loc.lightModelSub = glGetSubroutineUniformLocation(program, GL_FRAGMENT_SHADER, "lightModelUniform");
uniform_loc.model = glGetUniformLocation(program, "u_Model");
uniform_loc.view = glGetUniformLocation(program, "u_View");
uniform_loc.proj = glGetUniformLocation(program, "u_Proj");
uniform_loc.gamma = glGetUniformLocation(program, "u_Gamma");
uniform_loc.lightPos = glGetUniformLocation(program, "u_LightPos");
uniform_loc.lightColor = glGetUniformLocation(program, "u_LightColor");
uniform_loc.viewPos = glGetUniformLocation(program, "u_ViewPos");
}
bool initProgram()
{
bool Validated = true;
// Create program
if(Validated)
{
GLuint VertexShaderName = glf::createShader(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERTEX_SHADER_SOURCE);
GLuint FragmentShaderName = glf::createShader(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAGMENT_SHADER_SOURCE);
Validated = Validated && glf::checkShader(VertexShaderName, VERTEX_SHADER_SOURCE);
Validated = Validated && glf::checkShader(FragmentShaderName, FRAGMENT_SHADER_SOURCE);
ProgramName = glCreateProgram();
glAttachShader(ProgramName, VertexShaderName);
glAttachShader(ProgramName, FragmentShaderName);
glDeleteShader(VertexShaderName);
glDeleteShader(FragmentShaderName);
glLinkProgram(ProgramName);
Validated = Validated && glf::checkProgram(ProgramName);
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName, "MVP");
UniformDXT1 = glGetUniformLocation(ProgramName, "DiffuseDXT1");
UniformRGB8 = glGetUniformLocation(ProgramName, "DiffuseRGB8");
UniformDisplacement = glGetUniformLocation(ProgramName, "Displacement");
UniformDiffuse = glGetSubroutineUniformLocation(ProgramName, GL_FRAGMENT_SHADER, "Diffuse");
IndexDXT1 = glGetSubroutineIndex(ProgramName, GL_FRAGMENT_SHADER, "diffuseLQ");
IndexRGB8 = glGetSubroutineIndex(ProgramName, GL_FRAGMENT_SHADER, "diffuseHQ");
}
return Validated && glf::checkError("initProgram");
}
void PrepareShader()
{
// const char* vert_shader_name = "res_learn_opengl/shaders/Phong_Phong_vert.glsl";
// const char* frag_shader_name = "res_learn_opengl/shaders/Phong_Phong_frag.glsl";
const char* vert_shader_name = "res_learn_opengl/shaders/gl_test_vert.glsl";
const char* frag_shader_name = "res_learn_opengl/shaders/gl_test_frag.glsl";
// create shader object
vert_shader = muggle::CreateShaderObj(
renderer, vert_shader_name, "main",
muggle::ShaderStageType::VS, muggle::ShaderType::GLSL
);
frag_shader = muggle::CreateShaderObj(
renderer, frag_shader_name, "main",
muggle::ShaderStageType::PS, muggle::ShaderType::GLSL
);
// initialize shader program
shader_program.Initialize();
shader_program.Attach(vert_shader);
shader_program.Attach(frag_shader);
// link shader program
shader_program.Link();
// get subroutine index
shade_model[GTSM_Ambient] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "AmbientColor");
shade_model[GTSM_Diffuse] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "DiffuseColor");
shade_model[GTSM_PhongSpec] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "PhongSpecularColor");
shade_model[GTSM_BlinnSPec] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "BlinnPhongSpecularColor");
shade_model[GTSM_Phong] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "PhongModel");
shade_model[GTSM_Blinn] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "BlinnPhongModel");
shade_model[GTSM_Normal] = glGetSubroutineIndex(shader_program.getHandle(), GL_FRAGMENT_SHADER, "NormalColor");
for (int i = 0; i < GTSM_Max; ++i)
{
if (GL_INVALID_INDEX == shade_model[i])
{
MASSERT(0);
}
}
shade_model_index = shade_model[GTSM_Normal];
}
void
UniformGroup::apply_subroutines(ProgramPtr prog, GLenum shadertype,
const std::unordered_map<std::string, std::string>& subroutines)
{
assert_gl("apply_subroutines:enter");
GLint num_uniform_locations;
glGetProgramStageiv(prog->get_id(), shadertype, GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, &num_uniform_locations);
std::vector<GLuint> subroutine_mappings;
for(int i = 0; i < num_uniform_locations; ++i)
{
char name[256];
GLsizei length;
glGetActiveSubroutineUniformName(prog->get_id(), shadertype, i, sizeof(name), &length, name);
const auto& it = subroutines.find(name);
if (it == subroutines.end())
{
log_error("unmapped subroutine: %s", name);
}
else
{
GLuint loc = glGetSubroutineIndex(prog->get_id(), shadertype, it->second.c_str());
if (loc == GL_INVALID_INDEX)
{
log_error("unknown subroutine: %s", it->second);
}
else
{
subroutine_mappings.emplace_back(loc);
}
}
}
glUniformSubroutinesuiv(shadertype, subroutine_mappings.size(), subroutine_mappings.data());
assert_gl("apply_subroutines:exit");
}
void Shader::addAllSubroutines()
{
GLenum interfaces[] = { GL_VERTEX_SUBROUTINE, GL_FRAGMENT_SUBROUTINE };
GLenum shader_stages[] = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER };
GLint interfaces_count = sizeof(interfaces) / sizeof(interfaces[0]);
for(GLint i = 0; i < interfaces_count; ++i)
{
/* Get all active subroutines */
GLenum program_interface = interfaces[i];
GLint num_subroutines = 0;
glGetProgramInterfaceiv(m_program_id, program_interface, GL_ACTIVE_RESOURCES, &num_subroutines);
const GLenum properties[] = { GL_NAME_LENGTH };
const GLint properties_size = sizeof(properties) / sizeof(properties[0]);
GLint count_subroutine_locations = 0;
glGetProgramStageiv(m_program_id, shader_stages[i], GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, &count_subroutine_locations);
m_active_subroutine_uniform_locations[shader_stages[i]] = count_subroutine_locations;
for (GLint j = 0; j < num_subroutines; ++j)
{
GLint values[properties_size];
GLint length = 0;
glGetProgramResourceiv(m_program_id, program_interface, j, properties_size, properties, properties_size, &length, values);
std::vector<char> name_data(values[0]);
glGetProgramResourceName(m_program_id, program_interface, j, name_data.size(), nullptr, &name_data[0]);
std::string subroutine_name(name_data.begin(), name_data.end() - 1);
GLuint subroutine_index = glGetSubroutineIndex(m_program_id, shader_stages[i], subroutine_name.c_str());
m_subroutine_indices[subroutine_name] = subroutine_index;
}
}
}
void ShaderEffect::SetSubroutineUniforms(uint_t shaderType, SubroutineLink* link, int numLinks)
{
int maxUniforms;
glGetProgramStageiv(mProgram, shaderType, GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, &maxUniforms);
ASSERT(maxUniforms < MAX_SHADER_SUBROUTINES);
for(int uniform = 0; uniform < maxUniforms; ++uniform)
{
if(uniform < numLinks)
{
SubroutineLink* ci = &link[uniform];
const int uniformIndex = glGetSubroutineUniformLocation(mProgram, shaderType, ci->UniformName);
const int functionIndex = glGetSubroutineIndex(mProgram, shaderType, ci->FunctionName);
mSubroutineMap[uniformIndex] = functionIndex;
}
}
glUniformSubroutinesuiv(shaderType, maxUniforms, mSubroutineMap);
}
static bool
consistency_check(GLuint prog, GLenum programInterface, const char *name,
GLint index)
{
bool subroutine = false;
const GLchar *names[] = { name };
GLuint old_idx = 0xdeadcafe;
GLenum shader;
/* Validate result against old API. */
switch (programInterface) {
case GL_UNIFORM:
glGetUniformIndices(prog, 1, names, &old_idx);
piglit_check_gl_error(GL_NO_ERROR);
break;
case GL_UNIFORM_BLOCK:
old_idx = glGetUniformBlockIndex(prog, name);
piglit_check_gl_error(GL_NO_ERROR);
break;
case GL_VERTEX_SUBROUTINE:
shader = GL_VERTEX_SHADER;
subroutine = true;
break;
case GL_TESS_CONTROL_SUBROUTINE:
shader = GL_TESS_CONTROL_SHADER;
subroutine = true;
break;
case GL_TESS_EVALUATION_SUBROUTINE:
shader = GL_TESS_EVALUATION_SHADER;
subroutine = true;
break;
case GL_GEOMETRY_SUBROUTINE:
shader = GL_GEOMETRY_SHADER;
subroutine = true;
break;
case GL_FRAGMENT_SUBROUTINE:
shader = GL_FRAGMENT_SHADER;
subroutine = true;
break;
case GL_COMPUTE_SUBROUTINE:
shader = GL_COMPUTE_SHADER;
subroutine = true;
break;
default:
/* There are no old APIs for this program interface */
return true;
}
if (subroutine) {
old_idx = glGetSubroutineIndex(prog, shader, name);
piglit_check_gl_error(GL_NO_ERROR);
}
if (index != old_idx) {
printf("Index inconsistent with the old API: %i vs %i\n", index,
old_idx);
return false;
} else
return true;
}
GLUSboolean init(GLUSvoid)
{
// Points of a triangle in normalized device coordinates.
GLfloat points[] = { -0.25f, 0.0f, 0.0f, 1.0f, 0.25f, 0.0f, 0.0f, 1.0f, 0.0f, 0.25f, 0.0f, 1.0f };
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
// Load the source of the vertex and fragment shader.
glusFileLoadText("../Example39/shader/offset.vert.glsl", &vertexSource);
glusFileLoadText("../Example39/shader/red_green_blue.frag.glsl", &fragmentSource);
// Build the programs.
glusProgramBuildSeparableFromSource(&g_vertexProgram, GL_VERTEX_SHADER, (const GLchar**) &vertexSource.text);
glusProgramBuildSeparableFromSource(&g_fragmentProgram, GL_FRAGMENT_SHADER, (const GLchar**) &fragmentSource.text);
// Destroy the text resources.
glusFileDestroyText(&vertexSource);
glusFileDestroyText(&fragmentSource);
// Build the program pipeline.
glusProgramPipelineBuild(&g_programPipeline, g_vertexProgram.program, 0, 0, 0, g_fragmentProgram.program);
//
// Get the subroutine indices from the vertex shader.
g_getOffsetRedSubIndex = glGetSubroutineIndex(g_vertexProgram.program, GL_VERTEX_SHADER, "redOffset");
g_getOffsetGreenSubIndex = glGetSubroutineIndex(g_vertexProgram.program, GL_VERTEX_SHADER, "greenOffset");
g_getOffsetBlueSubIndex = glGetSubroutineIndex(g_vertexProgram.program, GL_VERTEX_SHADER, "blueOffset");
// Get the subroutine indices from the fragment shader.
g_getColorRedSubIndex = glGetSubroutineIndex(g_fragmentProgram.program, GL_FRAGMENT_SHADER, "redColor");
g_getColorGreenSubIndex = glGetSubroutineIndex(g_fragmentProgram.program, GL_FRAGMENT_SHADER, "greenColor");
g_getColorBlueSubIndex = glGetSubroutineIndex(g_fragmentProgram.program, GL_FRAGMENT_SHADER, "blueColor");
// Retrieve the vertex location in the vertex program.
g_vertexLocation = glGetAttribLocation(g_vertexProgram.program, "a_vertex");
//
// Create and bind the VBO for the vertices.
glGenBuffers(1, &g_verticesVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
// Transfer the vertices from CPU to GPU.
glBufferData(GL_ARRAY_BUFFER, 3 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//
// Bind the program pipeline.
glBindProgramPipeline(g_programPipeline.pipeline);
// Create the VAO for the program pipeline.
glGenVertexArrays(1, &g_vao);
glBindVertexArray(g_vao);
// Bind the only used VBO in this example.
glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO);
glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexLocation);
//
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
return GLUS_TRUE;
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
makeCurrent();
qglClearColor(QColor::fromCmykF(0.79, 0.79, 0.79, 0.0).dark());
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
glEnable(GL_DEPTH_TEST);
qDebug() << "Loading quad (vertex shader)";
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/plane.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (fragment shader)";
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/plane.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (tessellation control shader)";
QOpenGLShader *tcshader = new QOpenGLShader(QOpenGLShader::TessellationControl, this);
tcshader->compileSourceFile(":/resources/plane.tcs.vert");
if (!tcshader->log().isEmpty()) qDebug() << tcshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (tessellation evaluation shader)";
QOpenGLShader *teshader = new QOpenGLShader(QOpenGLShader::TessellationEvaluation, this);
teshader->compileSourceFile(":/resources/plane.tes.vert");
if (!teshader->log().isEmpty()) qDebug() << teshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (geometry shader)";
QOpenGLShader *gshader = new QOpenGLShader(QOpenGLShader::Geometry, this);
QFile gFile(":/resources/plane.geom");
gFile.open(QFile::ReadOnly);
qDebug() << gFile.isOpen() << " File";
QTextStream in(&gFile);
QString preambule = "#version 400 core\n"
"layout(triangle_strip, max_vertices = 3) out;\n" ;
QString shaderCode = in.readAll();
gshader->compileSourceCode(preambule+shaderCode);
//gshader->compileSourceFile(in.readAll());
if (!gshader->log().isEmpty()) qDebug() << gshader->log();
else qDebug() << "done";
program = new QOpenGLShaderProgram(this);
program->addShader(vshader);
program->addShader(fshader);
program->addShader(tcshader);
program->addShader(teshader);
program->addShader(gshader);
program->bindAttributeLocation("FragColor",0);
program->bindAttributeLocation("FragNormal",1);
program->bindAttributeLocation("FragGlowColor",2);
program->bindAttributeLocation("FragPosition",3);
GLCHK(program->link());
GLCHK(program->bind());
program->setUniformValue("texDiffuse" , 0);
program->setUniformValue("texNormal" , 1);
program->setUniformValue("texSpecular" , 2);
program->setUniformValue("texHeight" , 3);
program->setUniformValue("texSSAO" , 4);
program->setUniformValue("texRoughness", 5);
program->setUniformValue("texMetallic", 6);
program->setUniformValue("texMaterial", 7);
program->setUniformValue("texDiffuseEnvMap", 8);
program->setUniformValue("texEnvMap" , 9);
// lines shader
qDebug() << "Compiling lines program...";
preambule = QString("#version 400 core\n")+
"layout(line_strip, max_vertices = 3) out;\n" ;
gshader->compileSourceCode(preambule+shaderCode);
line_program = new QOpenGLShaderProgram(this);
line_program->addShader(vshader);
line_program->addShader(fshader);
line_program->addShader(tcshader);
line_program->addShader(teshader);
line_program->addShader(gshader);
line_program->bindAttributeLocation("FragColor",0);
line_program->bindAttributeLocation("FragNormal",1);
line_program->bindAttributeLocation("FragGlowColor",2);
line_program->bindAttributeLocation("FragPosition",3);
GLCHK(line_program->link());
GLCHK(line_program->bind());
line_program->setUniformValue("texDiffuse" , 0);
line_program->setUniformValue("texNormal" , 1);
line_program->setUniformValue("texSpecular" , 2);
line_program->setUniformValue("texHeight" , 3);
line_program->setUniformValue("texSSAO" , 4);
line_program->setUniformValue("texRoughness", 5);
line_program->setUniformValue("texMetallic", 6);
line_program->setUniformValue("texMaterial", 7);
line_program->setUniformValue("texDiffuseEnvMap", 8);
line_program->setUniformValue("texEnvMap" , 9);
delete vshader;
delete fshader;
delete tcshader;
delete teshader;
delete gshader;
// loading sky box shader
qDebug() << "Loading skybox shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/skybox.vert.glsl");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading skybox shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/skybox.frag.glsl");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
skybox_program = new QOpenGLShaderProgram(this);
skybox_program->addShader(vshader);
skybox_program->addShader(fshader);
skybox_program->bindAttributeLocation("FragColor",0);
skybox_program->bindAttributeLocation("FragNormal",1);
skybox_program->bindAttributeLocation("FragGlowColor",2);
skybox_program->bindAttributeLocation("FragPosition",3);
GLCHK(skybox_program->link());
GLCHK(skybox_program->bind());
skybox_program->setUniformValue("texEnv" , 0);
// loading enviromental shader
qDebug() << "Loading enviromental shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/env.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading enviromental shader (geometry shader)";
gshader = new QOpenGLShader(QOpenGLShader::Geometry, this);
gshader->compileSourceFile(":/resources/env.geom");
if (!gshader->log().isEmpty()) qDebug() << gshader->log();
else qDebug() << "done";
qDebug() << "Loading enviromental shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/env.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
env_program = new QOpenGLShaderProgram(this);
env_program->addShader(vshader);
env_program->addShader(gshader);
env_program->addShader(fshader);
GLCHK(env_program->link());
GLCHK(env_program->bind());
env_program->setUniformValue("texEnv" , 0);
delete vshader;
delete fshader;
delete gshader;
// -------------------------------------------------
// Loading post processing filters
// -------------------------------------------------
qDebug() << "Loading post-processing shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/filters_3d.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading post-processing shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/filters_3d.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
filters_program = new QOpenGLShaderProgram(this);
filters_program->addShader(vshader);
filters_program->addShader(fshader);
filters_program->bindAttributeLocation("positionIn", 0);
GLCHK( filters_program->link() );
GLCHK( filters_program->bind() );
GLCHK( filters_program->setUniformValue("layerA" , 0) );
GLCHK( filters_program->setUniformValue("layerB" , 1) );
GLCHK( filters_program->setUniformValue("layerC" , 2) );
GLCHK( filters_program->setUniformValue("layerD" , 3) );
GLCHK( filters_program->setUniformValue("layerE" , 4) );
GLCHK( filters_program->setUniformValue("layerF" , 5) );
GLCHK( filters_program->setUniformValue("layerG" , 6) );
GLCHK( subroutines["mode_normal_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_normal_filter") );
GLCHK( subroutines["mode_gauss_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_gauss_filter") );
GLCHK( subroutines["mode_bloom_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_bloom_filter") );
GLCHK( subroutines["mode_dof_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_dof_filter") );
GLCHK( filters_program->release());
delete vshader;
delete fshader;
camera.position.setZ( -0 );
camera.toggleFreeCamera(false);
newCamera.toggleFreeCamera(false);
lightDirection.position.setZ(0);
lightDirection.toggleFreeCamera(false);
lightDirection.radius = 1;
mesh = new Mesh("Core/3D/","Cube.obj");
skybox_mesh = new Mesh("Core/3D/","sky_cube.obj");
env_mesh = new Mesh("Core/3D/","sky_cube_env.obj");
quad_mesh = new Mesh("Core/3D/","quad.obj");
m_prefiltered_env_map = new GLTextureCube(512);
resizeFBOs();
emit readyGL();
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL40_nglGetSubroutineIndex(JNIEnv *__env, jclass clazz, jint program, jint shadertype, jlong nameAddress, jlong __functionAddress) {
const GLchar *name = (const GLchar *)(intptr_t)nameAddress;
glGetSubroutineIndexPROC glGetSubroutineIndex = (glGetSubroutineIndexPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
return (jint)glGetSubroutineIndex(program, shadertype, name);
}
void NGLScene::initializeGL()
{
// we must call this first before any other GL commands to load and link the
// gl commands from the lib, if this is not done program will crash
ngl::NGLInit::instance();
glEnable(GL_MULTISAMPLE);
glClearColor(0.4f, 0.4f, 0.4f, 1.0f); // Grey Background
// enable depth testing for drawing
glEnable(GL_DEPTH_TEST);
// enable multisampling for smoother drawing
glEnable(GL_MULTISAMPLE);
// This is a static camera so it only needs to be set once
// First create Values for the camera position
ngl::Vec3 from(2,2,2);
ngl::Vec3 to(0,0,0);
ngl::Vec3 up(0,1,0);
// now load to our new camera
m_view=ngl::lookAt(from,to,up);
// set the shape using FOV 45 Aspect Ratio based on Width and Height
// The final two are near and far clipping planes of 0.5 and 10
m_project=ngl::perspective(45.0f,720.0f/576.0f,0.05f,350.0f);
// now to load the shader and set the values
// grab an instance of shader manager
ngl::ShaderLib *shader=ngl::ShaderLib::instance();
// we are creating a shader called Phong
shader->createShaderProgram("Phong");
// now we are going to create empty shaders for Frag and Vert
shader->attachShader("PhongVertex",ngl::ShaderType::VERTEX);
shader->attachShader("PhongFragment",ngl::ShaderType::FRAGMENT);
// attach the source
shader->loadShaderSource("PhongVertex","shaders/PhongVert.glsl");
shader->loadShaderSource("PhongFragment","shaders/PhongFrag.glsl");
// compile the shaders
shader->compileShader("PhongVertex");
shader->compileShader("PhongFragment");
// add them to the program
shader->attachShaderToProgram("Phong","PhongVertex");
shader->attachShaderToProgram("Phong","PhongFragment");
// now we have associated this data we can link the shader
shader->linkProgramObject("Phong");
// and make it active ready to load values
(*shader)["Phong"]->use();
ngl::Vec4 lightPos(-2.0f,5.0f,2.0f,0.0f);
shader->setUniform("light.position",lightPos);
shader->setUniform("light.ambient",0.0f,0.0f,0.0f,1.0f);
shader->setUniform("light.diffuse",1.0f,1.0f,1.0f,1.0f);
shader->setUniform("light.specular",0.8f,0.8f,0.8f,1.0f);
// gold like phong material
shader->setUniform("material.ambient",0.274725f,0.1995f,0.0745f,0.0f);
shader->setUniform("material.diffuse",0.75164f,0.60648f,0.22648f,0.0f);
shader->setUniform("material.specular",0.628281f,0.555802f,0.3666065f,0.0f);
shader->setUniform("material.shininess",51.2f);
shader->setUniform("viewerPos",from);
// now load our texture shader
shader->createShaderProgram("TextureShader");
shader->attachShader("TextureVertex",ngl::ShaderType::VERTEX);
shader->attachShader("TextureFragment",ngl::ShaderType::FRAGMENT);
shader->loadShaderSource("TextureVertex","shaders/TextureVertex.glsl");
shader->loadShaderSource("TextureFragment","shaders/TextureFragment.glsl");
shader->compileShader("TextureVertex");
shader->compileShader("TextureFragment");
shader->attachShaderToProgram("TextureShader","TextureVertex");
shader->attachShaderToProgram("TextureShader","TextureFragment");
// link the shader no attributes are bound
shader->linkProgramObject("TextureShader");
(*shader)["TextureShader"]->use();
shader->setUniform("numSamples",m_numSamples);
GLuint id=shader->getProgramID("TextureShader");
m_subroutines[0] = glGetSubroutineIndex(id, GL_FRAGMENT_SHADER, "getMultiSampleTexture");
m_subroutines[1] = glGetSubroutineIndex(id, GL_FRAGMENT_SHADER, "getMultiSampleTexture2");
// now create our texture object
createTextureObject();
// now the fbo
createFramebufferObject();
// now create the primitives to draw
ngl::VAOPrimitives *prim=ngl::VAOPrimitives::instance();
prim->createTrianglePlane("plane",2,2,20,20,ngl::Vec3(0,1,0));
prim->createSphere("sphere",0.4f,80);
startTimer(1);
GLint maxAttach = 0;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxAttach);
glGetIntegerv(GL_MAX_SAMPLES,&maxAttach);
ngl::msg->addMessage(fmt::format("Max Samples {0}",maxAttach));
}
GLuint ShaderProgram::GetSubroutineIndex(const GLenum type, const std::string& name) const
{
return glGetSubroutineIndex(_programHandle, type, name.c_str());
}
void loadAssets()
{
loadParticles();
loadPlane();
pstack.push(glm::perspective(45.0f,
(GLfloat)window.GetWidth()/window.GetHeight(), 0.1f, 175.0f));
mstack.push(glm::lookAt(vec3(0, 2.7, 7), vec3(0, 2.4, 6), vec3(0, 1, 0)));
// Load terrain shader
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-vert.glsl",
GLSLShader::VERTEX)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-frag.glsl",
GLSLShader::FRAGMENT)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-tc.glsl",
GLSLShader::TESS_CONTROL)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "terrain-te.glsl",
GLSLShader::TESS_EVALUATION)) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
if (!g_program.link()) {
fprintf(stderr, "%s\n", g_program.log().c_str());
exit(1);
}
// Load plane shader
if (!d_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "default-vert.glsl",
GLSLShader::VERTEX)) {
fprintf(stderr, "%s\n", d_program.log().c_str());
exit(1);
}
if (!d_program.compileShaderFromFile(
ROOT_PATH_RELATIVE SHADER_DIR "default-frag.glsl",
GLSLShader::FRAGMENT)) {
fprintf(stderr, "%s\n", d_program.log().c_str());
exit(1);
}
const char *outputNames[] = { "Position" };
glTransformFeedbackVaryings(d_program.getHandle(), 1, outputNames, GL_SEPARATE_ATTRIBS);
if (!d_program.link()) {
fprintf(stderr, "%s\n", d_program.log().c_str());
exit(1);
}
g_program.use();
g_program.setUniform("Viewport", viewport);
g_program.setUniform("MinTessLevel", 1.0f);
g_program.setUniform("MaxTessLevel", max_tess);
//g_program.setUniform("MaxTessLevel", 20.0f);
g_program.setUniform("NearClip", 0.1f);
g_program.setUniform("FarClip", 175.0f);
g_program.setUniform("NearFog", 10.0f);
g_program.setUniform("FarFog", 125.0f);
g_program.setUniform("Light0.position", vec3(L0POSITION));
g_program.setUniform("Light0.La", vec3(L0AMBIENT));
g_program.setUniform("Light0.Ld", vec3(L0DIFFUSE));
GLuint terrainmap = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "heightmap-vlarge.png",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint watermap = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "watermap.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex1 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "grass.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex2 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "stonesnow.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex3 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "water.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint ttex4 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "foam.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint nmap1 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "normalmap-vlarge.png",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint nmap2 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "watermap_NRM.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
GLuint omap1 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "occmap-vlarge.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
omap2 = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "watermap_OCC.jpg",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
plane = SOIL_load_OGL_texture (
ROOT_PATH_RELATIVE TEXTURE_DIR "F16_diffusemap2.tga",
SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L );
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, terrainmap);
g_program.setUniform("TerrainMap", 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, watermap);
g_program.setUniform("WaterMap", 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, ttex1);
g_program.setUniform("TTex1", 2);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, ttex2);
g_program.setUniform("TTex2", 3);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, ttex3);
g_program.setUniform("TTex3", 4);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_2D, ttex4);
g_program.setUniform("TTex4", 5);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_2D, nmap1);
g_program.setUniform("NMap1", 6);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D, nmap2);
g_program.setUniform("NMap2", 7);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE8);
glBindTexture(GL_TEXTURE_2D, omap1);
g_program.setUniform("OMap1", 8);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, omap2);
g_program.setUniform("OMap2", 9);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
d_program.use();
plv = glGetSubroutineIndex(d_program.getHandle(), GL_VERTEX_SHADER, "RenderPlane");
plf = glGetSubroutineIndex(d_program.getHandle(), GL_FRAGMENT_SHADER, "RenderPlane");
pav = glGetSubroutineIndex(d_program.getHandle(), GL_VERTEX_SHADER, "RenderParticles");
paf = glGetSubroutineIndex(d_program.getHandle(), GL_FRAGMENT_SHADER, "RenderParticles");
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, plane);
d_program.setUniform("PlaneTex", 9);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
d_program.setUniform("Light0.position", vec3(L0POSITION));
d_program.setUniform("Light0.La", vec3(L0AMBIENT));
d_program.setUniform("Light0.Ld", vec3(L0DIFFUSE));
loadLand(156, 100);
}
