//-----------------------------------------------------------------------
void GLSLProgram::attachChildShader(const String& name)
{
// is the name valid and already loaded?
// check with the high level program manager to see if it was loaded
HighLevelGpuProgramPtr hlProgram = HighLevelGpuProgramManager::getSingleton().getByName(name);
if (!hlProgram.isNull())
{
if (hlProgram->getSyntaxCode() == "glsl")
{
// make sure attached program source gets loaded and compiled
// don't need a low level implementation for attached shader objects
// loadHighLevelImpl will only load the source and compile once
// so don't worry about calling it several times
GLSLProgram* childShader = static_cast<GLSLProgram*>(hlProgram.getPointer());
// load the source and attach the child shader only if supported
if (isSupported())
{
childShader->loadHighLevelImpl();
// add to the container
mAttachedGLSLPrograms.push_back( childShader );
mAttachedShaderNames += name + " ";
}
}
}
}
//-----------------------------------------------------------------------
void GLSLProgram::attachToProgramObject( const GLhandleARB programObject )
{
glAttachObjectARB( programObject, mGLHandle );
checkForGLSLError( "GLSLLinkProgram::GLSLLinkProgram",
"Error attaching " + mName + " shader object to GLSL Program Object", programObject );
// attach child objects
GLSLProgramContainerIterator childprogramcurrent = mAttachedGLSLPrograms.begin();
GLSLProgramContainerIterator childprogramend = mAttachedGLSLPrograms.end();
while (childprogramcurrent != childprogramend)
{
GLSLProgram* childShader = *childprogramcurrent;
// bug in ATI GLSL linker : modules without main function must be recompiled each time
// they are linked to a different program object
// don't check for compile errors since there won't be any
// *** minor inconvenience until ATI fixes there driver
childShader->compile(false);
childShader->attachToProgramObject( programObject );
++childprogramcurrent;
}
}
//-----------------------------------------------------------------------
void GLSLProgram::buildConstantDefinitions() const
{
// We need an accurate list of all the uniforms in the shader, but we
// can't get at them until we link all the shaders into a program object.
// Therefore instead, parse the source code manually and extract the uniforms
createParameterMappingStructures(true);
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
GLSLProgramPipelineManager::getSingleton().extractConstantDefs(mSource, *mConstantDefs.get(), mName);
}
else
{
GLSLLinkProgramManager::getSingleton().extractConstantDefs(mSource, *mConstantDefs.get(), mName);
}
// Also parse any attached sources
for (GLSLProgramContainer::const_iterator i = mAttachedGLSLPrograms.begin();
i != mAttachedGLSLPrograms.end(); ++i)
{
GLSLProgram* childShader = *i;
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
GLSLProgramPipelineManager::getSingleton().extractConstantDefs(childShader->getSource(),
*mConstantDefs.get(), childShader->getName());
}
else
{
GLSLLinkProgramManager::getSingleton().extractConstantDefs(childShader->getSource(),
*mConstantDefs.get(), childShader->getName());
}
}
}
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName, std::string vertString, std::string fragString)
{
GLSLProgram* prog = GetShader(vertName, fragName,vertString, fragString);
assert(prog != NULL);
prog->use();
return prog;
}
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName)
{
GLSLProgram* prog = GetShader(vertName, fragName);
assert(prog != NULL);
prog->use();
return prog;
}
///////////////////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering context.
// This is the first opportunity to do any OpenGL related tasks.
void SetupRC()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
prog.compileShaderFromFile("subroutine.vert", GLSLShader::VERTEX);
prog.compileShaderFromFile("subroutine.frag", GLSLShader::FRAGMENT);
prog.link();
prog.use();
glEnable(GL_DEPTH_TEST);
plane = new VBOPlane(50.0f, 50.0f, 1, 1);
teapot = new VBOTeapot(14, mat4(1.0f));
view = glm::lookAt(vec3(0.0f,0.0f,10.0f), vec3(0.0f,0.0f,0.0f), vec3(0.0f,1.0f,0.0f));
prog.setUniform("Light.Position", vec4(0.0f,0.0f,0.0f,1.0f));
prog.setUniform("Light.La", 0.4f, 0.4f, 0.4f);
prog.setUniform("Light.Ld", 1.0f, 1.0f, 1.0f);
prog.setUniform("Light.Ls", 1.0f, 1.0f, 1.0f);
prog.setUniform("Material.Kd", 0.9f, 0.5f, 0.3f);
prog.setUniform("Material.Ka", 0.9f, 0.5f, 0.3f);
prog.setUniform("Material.Ks", 0.8f, 0.8f, 0.8f);
prog.setUniform("Material.Shininess", 100.0f);
}
void HelloGLSL::customInit()
{
try
{
glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "HelloGLSL.vert");
glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "HelloGLSL.frag");
}
catch (GLSLProgramException& e)
{
printf("%s\n", e.what());
system("pause");
exit(EXIT_FAILURE);
}
glslProgram.link();
glGenBuffers(1, &positionBufferObject);
glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLint positionLoc = glslProgram.getAttributeLocation("position");
glEnableVertexAttribArray(positionLoc);
glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, 0);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void Model::drawModel(GLSLProgram &shader) const {
for (size_t i=0; i<materials_.size(); ++i) {
if (materials_[i].map_Kd != "") {
glUniform1f(shader("useTextureMap"), 1.0); //use texture
GLint whichID[1];
glActiveTexture(GL_TEXTURE0);
glGetIntegerv(GL_TEXTURE_BINDING_2D, whichID);
if (whichID[0] != textures_[i]) {
glBindTexture(GL_TEXTURE_2D, textures_[i]);
}
}
else {
glUniform1f(shader("useTextureMap"), 0.0);
glUniform3fv(shader("materialKd"), 1 , glm::value_ptr(materials_[i].Kd));
if (shader.isActive(shader("materialKs")))
glUniform3fv(shader("materialKs"), 1 , glm::value_ptr(materials_[i].Ks));
if (shader.isActive(shader("materialKa")))
glUniform3fv(shader("materialKa"), 1 , glm::value_ptr(materials_[i].Ka));
if (shader.isActive(shader("materialNs")))
glUniform1f(shader("materialNs"), materials_[i].Ns);
}
if (materials_.size() == 1)
glDrawElements(GL_TRIANGLES, indices_.size(), GL_UNSIGNED_SHORT, 0);
else
glDrawElements(GL_TRIANGLES, materials_[i].count, GL_UNSIGNED_SHORT,
(const GLvoid*)(&indices_[materials_[i].offset]));
}
}
void OgroInvasion::customInit()
{
filename = g_programName + "/" + "Lenna.png";
try
{
glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "shader.vert");
glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "shader.frag");
}
catch (GLSLProgramException& e)
{
printf("%s\n", e.what());
system("pause");
exit(EXIT_FAILURE);
}
glslProgram.link();
GLint vertexAttribLoc = glslProgram.getAttributeLocation("vVertex");
//quad vertices and indices
glm::vec2 vertices[4];
GLushort indices[6];
vertices[0] = glm::vec2(0.0f, 0.0f);
vertices[1] = glm::vec2(1.0f, 0.0f);
vertices[2] = glm::vec2(1.0f, 1.0f);
vertices[3] = glm::vec2(0.0f, 1.0f);
GLushort* id = indices;
*id++ = 0;
*id++ = 1;
*id++ = 2;
*id++ = 0;
*id++ = 2;
*id++ = 3;
glGenVertexArrays(1, &vaoID);
glBindVertexArray(vaoID);
glGenBuffers(1, &vboVerticesID);
glGenBuffers(1, &vboIndicesID);
glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(vertexAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(vertexAttribLoc);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
mTexture = new Texture(filename);
mTexture->load();
mTexture->activateTexture(0); // GL_TEXTURE0
glslProgram.setUniform("textureMap", 0); // GL_TEXTURE0
}
void reloadShaders() {
GLSLProgram* hold = new GLSLProgram();
hold->compileShaders("C:/Users/josh/Desktop/Shader/Shaders/vertex.glsl", "C:/Users/josh/Desktop/Shader/Shaders/fragment.glsl");
hold->addAttribute("vertexPosition");
hold->linkShaders();
_Program = *hold;
}
//------------------------------------------------------------------------------
static void
drawStencils() {
g_samplesProgram.Use( );
const float scale = 0.02f;
glUniform1f(g_samplesProgram.GetUniformScale(), scale);
glUniformMatrix4fv(g_samplesProgram.GetUniformModelViewMatrix(),
1, GL_FALSE, g_transformData.ModelViewMatrix);
glUniformMatrix4fv(g_samplesProgram.GetUniformProjectionMatrix(),
1, GL_FALSE, g_transformData.ProjectionMatrix);
glBindVertexArray(g_stencilsVAO);
glBindBuffer(GL_ARRAY_BUFFER, g_stencilOutput->BindDstBuffer());
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*9, 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*9, (void*)(sizeof(GLfloat)*3));
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*9, (void*)(sizeof(GLfloat)*6));
glDrawArrays(GL_POINTS, 0, g_stencilOutput->GetNumStencils());
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glBindVertexArray(0);
glUseProgram(0);
}
void setMatrices()
{
mat4 mv = view * model;
prog.setUniform("ModelViewMatrix", mv);
prog.setUniform("NormalMatrix",
mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) ));
prog.setUniform("MVP", projection * mv);
}
void initializeShaders()
{
colorProgram.compileShaders("Shaders/color.vertex", "Shaders/color.fragment");
colorProgram.addAttribute("vertexPosition");
colorProgram.addAttribute("vertexColor");
colorProgram.addAttribute("vertexUV");
colorProgram.linkShaders();
}
void Shader::setGeometryShaderParameters(Ogre::RenderOperation::OperationType in,
Ogre::RenderOperation::OperationType out, int max)
{
GLSLProgram* t = static_cast<GLSLProgram*> (geometry.getPointer());
t->setInputOperationType(in);
t->setOutputOperationType(out);
t->setMaxOutputVertices(max);
}
void Renderer::init(GLSLProgram & shader)
{
setProjectionMatrix(30,1, 1, -100, projection);
shader.use();
shader.setUniformMatrix4fv("projectionMatrix", projection);
shader.unuse();
}
void SkyBox::Render()
{
glBindVertexArray(_vao);
GLSLProgram* p = _material->Program();
p->SetUniform("draw_sky_box", true);
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
p->SetUniform("draw_sky_box", false);
}
GLSLProgram* GLSLProgram::createFromStrings(const char *vertSrc, const char *fragSrc) {
GLSLProgram *prog = new GLSLProgram();
if (prog->setSourceFromStrings(vertSrc, fragSrc)) {
return prog;
} else {
delete prog;
return NULL;
}
}
void PlaneModelData::useMaterial(GLSLProgram const& prog) const
{
prog.setUniform("material.ambient", *reinterpret_cast<glm::vec3 const*>(material.ambient));
prog.setUniform("material.diffuse", *reinterpret_cast<glm::vec3 const*>(material.diffuse));
prog.setUniform("material.specular", *reinterpret_cast<glm::vec3 const*>(material.specular));
prog.setUniform("material.shininess", material.shininess);
glActiveTexture(GL_TEXTURE0 + 5);
glBindTexture(GL_TEXTURE_2D, (GLuint) material.texture1_map.user_ptr);
}
GLSLProgram* GLSLProgram::createFromFiles(const char *vertFilename, const char *fragFilename) {
GLSLProgram *prog = new GLSLProgram();
if (prog->setSourceFromFiles(vertFilename, fragFilename)) {
return prog;
} else {
delete prog;
return NULL;
}
}
void CascadedShadowMap::sendToShader(string sShader)
{
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader(sShader);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D,m_shadowMaps[0]->getTexture());
glslProgram->sendUniform("shadowMap[0]",4);
glActiveTexture(GL_TEXTURE5);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,m_shadowMaps[1]->getTexture());
glslProgram->sendUniform("shadowMap[1]",5);
glActiveTexture(GL_TEXTURE6);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,m_shadowMaps[2]->getTexture());
glslProgram->sendUniform("shadowMap[2]",6);
glActiveTexture(GL_TEXTURE7);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,m_shadowMaps[3]->getTexture());
glslProgram->sendUniform("shadowMap[3]",7);
glslProgram->sendUniform("slices[0]",m_nSlices[0]);
glslProgram->sendUniform("slices[1]",m_nSlices[1]);
glslProgram->sendUniform("slices[2]",m_nSlices[2]);
m_m4LightMatrix[0] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[0];
m_m4LightMatrix[1] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[1];
m_m4LightMatrix[2] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[2];
m_m4LightMatrix[3] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[3];
glslProgram->sendUniform("lightMatrix[0]", &m_m4LightMatrix[0][0][0]);
glslProgram->sendUniform("lightMatrix[1]", &m_m4LightMatrix[1][0][0]);
glslProgram->sendUniform("lightMatrix[2]", &m_m4LightMatrix[2][0][0]);
glslProgram->sendUniform("lightMatrix[3]", &m_m4LightMatrix[3][0][0]);
}
GLSLProgram* ShaderManager::Load(const char* vertName, const char*fragName)
{
GLSLProgram* prog = new GLSLProgram();
if (!prog->compileShaderFromFile(vertName, GLSLShader::VERTEX))
{
printf("Vertex shader failed to compile!\n%s", prog->log().c_str());
sLog(Level::Severe) << "Vertex shader <" << vertName << "> failed to compile." << prog->log();
assert(false && "Vertex shader failed to compile");
return NULL;
}
if (!prog->compileShaderFromFile(fragName, GLSLShader::FRAGMENT))
{
printf("Fragment shader failed to compile!\n%s", prog->log().c_str());
sLog(Level::Severe) << "Fragment shader <" << fragName << "> failed to compile." << prog->log();
assert(false && "Fragment shader failed to compile");
return NULL;
}
if (!prog->link())
{
printf("Shader program failed to link!\n%s", prog->log().c_str());
sLog(Level::Severe) << "Shader program failed to link." << prog->log();
assert(false && "Shader program failed to link.");
return NULL;
}
assert(prog != NULL);
return prog;
}
void CascadedShadowMap::buildShadowMaps(Camera *camera, View *view, DirectLight *light)
{
//Profiler::getInstance()->startProfile("Build Shadow Maps");
float nSlice[] = {0.0, m_nSlices[0], m_nSlices[1], m_nSlices[2], 1.0};
Frustum *frustum = new Frustum();
frustum->getFrustum(camera, view);
m_shadowMaps[3]->bind();
glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_CULL_FACE);
for (int i=0; i<4; i++)
{
Camera *lightCamera = createLightCamera(nSlice[i],nSlice[i+1],camera,view,light);
View *lightView = createLightView(nSlice[i],nSlice[i+1],camera,lightCamera,view,frustum);
Frustum *lightFrustum = new Frustum();
lightFrustum->getOrthoFrustum(lightCamera,lightView);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
m_shadowMaps[i]->bind();
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glPushAttrib( GL_VIEWPORT_BIT );
glViewport( 0, 0, m_nSize, m_nSize);
lightView->use3D(false);
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("DirectShadow");
glslProgram->use();
glm::mat4 cameraMat = glm::mat4(1.0f);
cameraMat = lightCamera->transformToMatrix(cameraMat);
m_m4LightMatrix[i] = MatrixManager::getInstance()->getMatrix4(PROJECTION) * cameraMat;
MatrixManager::getInstance()->putMatrix4(MODELVIEW, cameraMat);
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
SceneManager::getInstance()->draw("DirectShadow");
glslProgram->disable();
glPopAttrib();
m_shadowMaps[i]->unbind();
delete lightCamera;
delete lightView;
delete lightFrustum;
}
glEnable(GL_CULL_FACE);
//Profiler::getInstance()->endProfile();
}
void Actor::drawActor(string sShader)
{
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader(sShader);
glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]);
if (sShader == "Basic" || sShader == "GBuffer" || sShader == "BuildVoxels")
{
glslProgram->sendUniform("normalMatrix", &MatrixManager::getInstance()->getMatrix3(NORMAL)[0][0],false,3);
MaterialManager::getInstance()->getMaterial(*m_psMaterial)->sendToShader(sShader);
}
ModelManager::getInstance()->getModel(*m_psModel)->draw();
}
void HelloGLSL::onRender()
{
glslProgram.use();
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
glslProgram.unUse();
glBindVertexArray(0);
}
///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mat4 mv = view * model;
prog.setUniform("ModelViewMatrix", mv);
prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) ));
prog.setUniform("MVP", projection * mv);
current->render();
}
void OgroInvasion::onRender()
{
glslProgram.use();
glBindVertexArray(vaoID);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
glBindVertexArray(0);
glslProgram.unUse();
}
void glslProcess()
{
GLSLProgram glprog;
glprog.SetGstap(true);
glprog.SetVerbose(true);
if(!glprog.Create("D:\\v0.vert", "D:\\v0.frag")) {
return ;
}
glprog.Use();
}
void MainGraphicsWidget::voxelRender()
{
VoxelGrid::getInstance()->buildVoxels(m_lightBuffer->getLight());
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f));
MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f));
view->viewport();
view->use3D(true);
camera->transform();
GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Voxel");
glslProgram->use();
glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor");
glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex");
glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]);
glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]);
glm::mat4 cameraInverse = glm::mat4(1.0);
cameraInverse = camera->transformToMatrix(cameraInverse);
cameraInverse = glm::inverse(cameraInverse);
glslProgram->sendUniform("invCameraMatrix", &cameraInverse[0][0]);
glslProgram->sendUniform("worldSize", WORLD_SIZE);
//glslProgram->sendUniform("numVoxels", VOXEL_SIZE);
//glslProgram->sendUniform("mipLevel", VoxelGrid::getInstance()->getMipLevel());
int mipFactor = pow(2.0, VoxelGrid::getInstance()->getMipLevel());
glActiveTexture(GL_TEXTURE8);
glEnable(GL_TEXTURE_3D);
VoxelGrid::getInstance()->bind(VoxelGrid::getInstance()->getMipLevel());
glslProgram->sendUniform("voxelmap", 8);
//glEnable(GL_POINT_SMOOTH);
glPointSize(10.0f*mipFactor);
float voxelWidth = (float)WORLD_SIZE / (float)VOXEL_SIZE * mipFactor;
glBegin(GL_POINTS);
for (float x=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); x<(WORLD_SIZE/2.0); x+=voxelWidth)
{
for (float y=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); y<(WORLD_SIZE/2.0); y+=voxelWidth)
{
for (float z=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); z<(WORLD_SIZE/2.0); z+=voxelWidth)
{
glVertex3f(x,y,z);
}
}
}
glEnd();
glslProgram->disable();
}
void PlaneModelData::drawInstances(GLSLProgram const& prog) const
{
glBindVertexArray(modelVAO);
useMaterial(prog);
BOOST_FOREACH(DrawInstance const& inst, drawInst)
{
prog.setUniform("modelMatrix", inst.modelMatrix);
prog.setUniform("tint", inst.tint);
glDrawElements(GL_TRIANGLE_STRIP, NUM_INDICES, GL_UNSIGNED_BYTE, NULL);
}
//-----------------------------------------------------------------------
void GLSLProgram::detachFromProgramObject( const GLuint programObject )
{
OGRE_CHECK_GL_ERROR(glDetachShader(programObject, mGLShaderHandle));
logObjectInfo( "Error detaching " + mName + " shader object from GLSL Program Object", programObject );
// attach child objects
GLSLProgramContainerIterator childprogramcurrent = mAttachedGLSLPrograms.begin();
GLSLProgramContainerIterator childprogramend = mAttachedGLSLPrograms.end();
while (childprogramcurrent != childprogramend)
{
GLSLProgram* childShader = *childprogramcurrent;
childShader->detachFromProgramObject( programObject );
++childprogramcurrent;
}
}
