void OpenGLRenderer::setUniform(Renderer::ShaderProgram* p,
const std::string& name, const glm::vec2& m) {
useProgram(p);
glUniform2fv(currentProgram->getUniformLocation(name.c_str()), 1,
glm::value_ptr(m));
}
void Renderer::setTextureUnits() {
useProgram("textured");
glUniform1i(uniformHandle("color_texture"), 0);
useProgram("circles_screen_textured");
glUniform1i(uniformHandle("color_texture"), 0);
useProgram("textured_with_shadows");
glUniform1i(uniformHandle("color_texture"), 0);
glUniform1i(uniformHandle("shadow_texture"), 1);
useProgram("shadows");
glUniform1i(uniformHandle("occluder_texture"), 0);
useProgram("particle_draw");
glUniform1i(uniformHandle("color_texture"), 0);
}
//! SceneRenderer:: Draws scene
void GLSLSceneRenderer::render()
{
// Clear framebuffer
glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
//glDepthMask(GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Setup viewport
glViewport(0, 0, Application::get().getWindow().getWidth(), Application::get().getWindow().getHeight());
// Get and update camera if window has been resized
scene->getCamera().setAspectRatio(Application::get().getWindow().getWidth() / (float) Application::get().getWindow().getHeight());
useProgram("BlinnPhongShader.shader");
// Setup lights
for(auto it : light_map) {
Light * light = it.first;
String light_tag = String("light_source[") + it.second + String("].");
/* Get params ref */
Light::LightSourceParameters & param = light->getParametersRef();
/* Set up shader parameters */
Mat4 model_view = light->getMover().getScene().getCamera().getTransform() * light->getMover().getCachedTransformRef();
Mat4 normal_matrix = model_view.inverse().transpose();
Vec4 position = model_view * param.position;
Vec3 spotDirection = normal_matrix * param.spotDirection;
Vec3 half_vector = light->getMover().getScene().getCamera().getMover().getDerivedPosition() - param.position;
getProgram().setParamVec4(light_tag + "ambient", param.ambient);
getProgram().setParamVec4(light_tag + "diffuse", param.diffuse);
getProgram().setParamVec4(light_tag + "specular", param.specular);
getProgram().setParamVec4(light_tag + "position", position);
getProgram().setParamVec3(light_tag + "half_vector", half_vector);
getProgram().setParamVec3(light_tag + "spot_direction", spotDirection);
getProgram().setParamFloat(light_tag + "spot_exponent", param.spotExponent);
getProgram().setParamFloat(light_tag + "spot_cutoff", param.spotCutoff);
getProgram().setParamFloat(light_tag + "spot_cos_cutoff", param.spotCosCutoff);
getProgram().setParamVec3(light_tag + "attenuation", param.attenuation);
}
// Setup scene parameters
Vec4 ambient_color(0.1, 0.1, 0.1, 1.0);
getProgram().setParamVec4("scene_ambient_color", ambient_color);
getProgram().setParamInt("num_of_enabled_lights", (int)light_map.size());
getProgram().setParamBool("need_local_viewer", 1);
// Draw scene
for (Drawable * drawable : drawable_list) {
drawable->_drawOccurrences(*this);
}
}
void ImageSprite::draw(SPRenderer renderer)
{
auto context = renderer->getContext();
context->useProgram(_program);
// setUniform must after useProgram
_program->setUniform(_program->getUniform("view"), Director::getInstance().getView());
_program->setUniform(_program->getUniform("proj"), Director::getInstance().getProj());
_program->setUniform(_program->getUniform("model"), getModel());
context->bindTexture(_texture, 0);
context->drawArrays(*_vao, cppgl::Primitive::Triangles, 0, 6);
}
void StateManagerGL::deleteProgram(GLuint program)
{
if (program != 0)
{
if (mProgram == program)
{
useProgram(0);
}
mFunctions->deleteProgram(program);
}
}
void Shader::setUniform<float>(const std::string& name, const float& data) {
int prev_bound_program;
glGetIntegerv(GL_CURRENT_PROGRAM, &prev_bound_program);
if(name_to_location.count(name) == 0) {
throw Exceptions::InvalidUniformNameException(name);
}
if(prev_bound_program != program_object)
useProgram();
glUniform1f(name_to_location[name], data);
if(prev_bound_program != program_object)
glUseProgram(prev_bound_program);
}
void Shader::setUniform<glm::vec2>(const std::string& name, const glm::vec2& data) {
int prev_bound_program;
glGetIntegerv(GL_CURRENT_PROGRAM, &prev_bound_program);
if(name_to_location.count(name) == 0) {
throw Exceptions::InvalidUniformNameException(name);
}
if(prev_bound_program != program_object)
useProgram();
glUniform2fv(name_to_location[name], 1, glm::value_ptr(data));
if(prev_bound_program != program_object)
glUseProgram(prev_bound_program);
}
COGLES2Renderer2d::COGLES2Renderer2d( irr::video::COGLES2Driver *driver, irr::io::IFileSystem *fs )
: COGLES2SLMaterialRenderer( driver, fs, 0, 0, sBuiltInShaderUniformNames, UNIFORM_COUNT )
{
#ifdef _DEBUG
setDebugName( "COGLES2Renderer2d" );
#endif
s32 dummy = -1;
if (!initFromFiles( dummy, vertexShaderFile, fragmentShaderFile, false))
return;
useProgram();
int texUnit = 0;
setUniform( TEXTURE_UNIT, &texUnit );
}
//! Constructor
COGLES2ParallaxMapRenderer::COGLES2ParallaxMapRenderer( video::COGLES2Driver* driver,
io::IFileSystem* fs, s32& outMaterialTypeNr, IMaterialRenderer* baseMaterial )
: COGLES2SLMaterialRenderer( driver, fs, 0, baseMaterial, sBuiltInShaderUniformNames, UNIFORM_COUNT ), CompiledShaders( true )
{
#ifdef _DEBUG
setDebugName( "COGLES2ParallaxMapRenderer" );
#endif
// set this as callback. We could have done this in
// the initialization list, but some compilers don't like it.
CallBack = this;
// basically, this simply compiles the hard coded shaders if the
// hardware is able to do them, otherwise it maps to the base material
// check if already compiled normal map shaders are there.
video::IMaterialRenderer* renderer = driver->getMaterialRenderer( EMT_PARALLAX_MAP_SOLID );
if ( renderer )
{
// use the already compiled shaders
video::COGLES2ParallaxMapRenderer* pmr = reinterpret_cast<video::COGLES2ParallaxMapRenderer*>( renderer );
CompiledShaders = false;
Program = pmr->Program;
UniformInfo = pmr->UniformInfo;
AttributeInfo = pmr->AttributeInfo;
outMaterialTypeNr = driver->addMaterialRenderer( this );
}
else
{
// compile shaders on our own
if (initFromFiles( outMaterialTypeNr, VertexShaderFile, FragmentShaderFile))
{
useProgram();
int dummy = 0;
setUniform( TEXTURE_UNIT0, &dummy );
dummy = 1;
setUniform( TEXTURE_UNIT1, &dummy );
}
}
// fallback if compilation has failed
if ( -1 == outMaterialTypeNr )
outMaterialTypeNr = driver->addMaterialRenderer( this );
}
void GLDrawUI::Common::setUp(SetUpPhase phase) {
switch (phase) {
case SetUpPhase::CompileLinkProgram:
compileLinkProgram();
/* FALL THROUGH */
case SetUpPhase::UseProgram:
useProgram();
/* FALL THROUGH */
case SetUpPhase::UpdateMVPMatrix:
updateMVPMatrix();
/* FALL THROUGH */
default:
break;
}
}
bool ShaderManager::loadUseProgram(const LoadUseProgramDescription &desc, vx::StackAllocator* scratchAllocator, std::string* error)
{
// check for not used shader stage
if (strcmp(desc.id, "''") == 0)
{
return true;
}
auto fileHandle = FileHandle(desc.id);
if (!loadProgram(fileHandle, desc.type, *desc.programDir, *desc.includeDir, scratchAllocator, error))
return false;
if (!useProgram(*desc.pipe, fileHandle))
return false;
return true;
}
void Renderer::init(int width, int height) {
width_ = width;
height_ = height;
aspect_ = static_cast<float>(width)/height;
// OpenGL settings.
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClearDepth(1.0f);
glDepthFunc(GL_LESS);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
loadShaders();
setupScreenQuad();
setupFBOs();
useProgram("shadows");
glUniform1f(uniformHandle("density"), 2.0f);
glUniform1f(uniformHandle("decay_rate"), 0.98f);
glUniform1f(uniformHandle("constant_factor"), 0.85f);
glUniform1f(uniformHandle("scale_factor"), 1.0f/160.0f);
}
void VertexArrayObject::bind() const {
useProgram();
switch (vaoSupported_) {
case VaoSupported::CHECK_SUPPORTED:
if (mw::Window::getOpenGlMajorVersion() >= 3) {
vaoSupported_ = VaoSupported::SUPPORTED;
// Fall trough to next case.
} else {
vaoSupported_ = VaoSupported::NOT_SUPPORTED;
bindBuffer();
setVertexAttribPointer();
break;
}
case VaoSupported::SUPPORTED:
if (*vao_ == 0) { // Create the vertex array only the first time.
glGenVertexArrays(1, &*vao_);
glBindVertexArray(*vao_);
checkGlError();
// Remove the block to unneeded calls to buffer changes.
VertexBufferObject::setIgnoreCurrentBind(true);
bindBuffer();
// Restore the block.
VertexBufferObject::setIgnoreCurrentBind(false);
currentVertexArrayObject = *vao_;
setVertexAttribPointer();
} else {
glBindVertexArray(*vao_);
checkGlError();
}
break;
case VaoSupported::NOT_SUPPORTED:
bindBuffer();
setVertexAttribPointer();
break;
}
}
void SGLShaderProgram::setUniformMat4f(const char* name, glm::mat4& value)
{
useProgram();
glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, &value[0][0]);
}
void OpenGLRenderer::setUniform(Renderer::ShaderProgram* p,
const std::string& name, float f) {
useProgram(p);
glUniform1fv(currentProgram->getUniformLocation(name.c_str()), 1, &f);
}
gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data)
{
const gl::State &state = *data.state;
const gl::Caps &caps = *data.caps;
const gl::Program *program = state.getProgram();
const ProgramGL *programGL = GetImplAs<ProgramGL>(program);
useProgram(programGL->getProgramID());
// TODO: Only apply textures referenced by the program.
for (auto textureTypeIter = mTextures.begin(); textureTypeIter != mTextures.end(); textureTypeIter++)
{
GLenum textureType = textureTypeIter->first;
// Determine if this texture type can exist in the source context
bool validTextureType = (textureType == GL_TEXTURE_2D || textureType == GL_TEXTURE_CUBE_MAP ||
(textureType == GL_TEXTURE_2D_ARRAY && data.clientVersion >= 3) ||
(textureType == GL_TEXTURE_3D && data.clientVersion >= 3));
const std::vector<GLuint> &textureVector = textureTypeIter->second;
for (size_t textureUnitIndex = 0; textureUnitIndex < textureVector.size(); textureUnitIndex++)
{
const gl::Texture *texture = nullptr;
bool validTextureUnit = textureUnitIndex < caps.maxCombinedTextureImageUnits;
if (validTextureType && validTextureUnit)
{
texture = state.getSamplerTexture(textureUnitIndex, textureType);
}
if (texture != nullptr)
{
const TextureGL *textureGL = GetImplAs<TextureGL>(texture);
textureGL->syncSamplerState(texture->getSamplerState());
if (mTextures[textureType][textureUnitIndex] != textureGL->getTextureID())
{
activeTexture(textureUnitIndex);
bindTexture(textureType, textureGL->getTextureID());
}
// TODO: apply sampler object if one is bound
}
else
{
if (mTextures[textureType][textureUnitIndex] != 0)
{
activeTexture(textureUnitIndex);
bindTexture(textureType, 0);
}
}
}
}
const gl::Framebuffer *framebuffer = state.getDrawFramebuffer();
const FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer);
bindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferGL->getFramebufferID());
setScissor(state.getScissor());
setViewport(state.getViewport());
const gl::BlendState &blendState = state.getBlendState();
setColorMask(blendState.colorMaskRed, blendState.colorMaskGreen, blendState.colorMaskBlue, blendState.colorMaskAlpha);
const gl::DepthStencilState &depthStencilState = state.getDepthStencilState();
setDepthMask(depthStencilState.depthMask);
setStencilMask(depthStencilState.stencilMask);
return gl::Error(GL_NO_ERROR);
}
void OpenGLRenderer::setUniformTexture(Renderer::ShaderProgram* p,
const std::string& name, GLint tex) {
useProgram(p);
glUniform1i(currentProgram->getUniformLocation(name), tex);
}
void Renderer::draw() {
// 2D rendering modelview
glm::mat3 view(1.0f);
view = translate2D(view, glm::vec2(-1.0f, -1.0f));
view = scale2D(view, glm::vec2(2.0f/aspect_, 2.0f));
view = translate2D(view, glm::vec2(-left_of_window_, 0.0f));
root_node_.setRelativeTransform(view);
vector<SceneNode *> draw2D;
root_node_.getSortedVisibleDescendants(&draw2D);
// Draw occluders to texture.
//glBindFramebuffer(GL_FRAMEBUFFER, 0);
//glViewport(0,0,width_, height_);
glBindFramebuffer(GL_FRAMEBUFFER, occluder_frame_buffer_);
glViewport(0,0,width_/2, height_/2);
glDepthMask(GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDepthMask(GL_FALSE);
for (vector<SceneNode *>::iterator it = draw2D.begin(); it != draw2D.end(); ++it) {
if ((*it)->isOccluder()) (*it)->drawOccluder();
}
//return;
//glBindFramebuffer(GL_FRAMEBUFFER, 0);
//glViewport(0,0,width_, height_);
glBindFramebuffer(GL_FRAMEBUFFER, shadow_frame_buffer_);
glDepthMask(GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDepthMask(GL_FALSE);
useProgram("shadows");
glm::vec3 transformed_light_position = view * glm::vec3(light_position_, 1.0f);
glUniform2fv(uniformHandle("light_position"), 1, glm::value_ptr(transformed_light_position));
glBindTexture(GL_TEXTURE_2D, shadow_texture_);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, occluder_texture_);
glBindVertexArray(quad_array_object_);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//return;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0,0,width_, height_);
glDepthMask(GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDepthMask(GL_FALSE);
glEnable(GL_MULTISAMPLE);
glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, shadow_texture_);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
for (vector<SceneNode *>::iterator it = draw2D.begin(); it != draw2D.end(); ++it) {
if ((*it)->isVisible()) (*it)->draw();
}
if (do_stencil_) {
glEnable(GL_STENCIL_TEST);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glStencilFunc(GL_ALWAYS, 0, 0xFF);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
for (vector<SceneNode *>::iterator it = draw2D.begin(); it != draw2D.end(); ++it) {
if ((*it)->is3DStencil()) (*it)->draw();
}
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glStencilFunc(GL_NOTEQUAL, 0, 0xFF);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
glEnable(GL_BLEND);
for (vector<Drawable *>::iterator it = draw3D_.begin(); it != draw3D_.end(); ++it) {
(*it)->draw();
}
glDisable(GL_BLEND);
if (do_stencil_) {
glDisable(GL_STENCIL_TEST);
}
}
gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data)
{
const gl::State &state = *data.state;
// If the context has changed, pause the previous context's transform feedback and queries
if (data.context != mPrevDrawContext)
{
if (mPrevDrawTransformFeedback != nullptr)
{
mPrevDrawTransformFeedback->syncPausedState(true);
}
for (QueryGL *prevQuery : mPrevDrawQueries)
{
prevQuery->pause();
}
}
mPrevDrawTransformFeedback = nullptr;
mPrevDrawQueries.clear();
mPrevDrawContext = data.context;
// Sync the current program state
const gl::Program *program = state.getProgram();
const ProgramGL *programGL = GetImplAs<ProgramGL>(program);
useProgram(programGL->getProgramID());
for (size_t uniformBlockIndex = 0; uniformBlockIndex < program->getActiveUniformBlockCount();
uniformBlockIndex++)
{
GLuint binding = program->getUniformBlockBinding(static_cast<GLuint>(uniformBlockIndex));
const OffsetBindingPointer<gl::Buffer> &uniformBuffer =
data.state->getIndexedUniformBuffer(binding);
if (uniformBuffer.get() != nullptr)
{
BufferGL *bufferGL = GetImplAs<BufferGL>(uniformBuffer.get());
if (uniformBuffer.getSize() == 0)
{
bindBufferBase(GL_UNIFORM_BUFFER, binding, bufferGL->getBufferID());
}
else
{
bindBufferRange(GL_UNIFORM_BUFFER, binding, bufferGL->getBufferID(),
uniformBuffer.getOffset(), uniformBuffer.getSize());
}
}
}
const std::vector<SamplerBindingGL> &appliedSamplerUniforms = programGL->getAppliedSamplerUniforms();
for (const SamplerBindingGL &samplerUniform : appliedSamplerUniforms)
{
GLenum textureType = samplerUniform.textureType;
for (GLuint textureUnitIndex : samplerUniform.boundTextureUnits)
{
const gl::Texture *texture = state.getSamplerTexture(textureUnitIndex, textureType);
if (texture != nullptr)
{
const TextureGL *textureGL = GetImplAs<TextureGL>(texture);
if (mTextures[textureType][textureUnitIndex] != textureGL->getTextureID())
{
activeTexture(textureUnitIndex);
bindTexture(textureType, textureGL->getTextureID());
}
textureGL->syncState(textureUnitIndex, texture->getTextureState());
}
else
{
if (mTextures[textureType][textureUnitIndex] != 0)
{
activeTexture(textureUnitIndex);
bindTexture(textureType, 0);
}
}
const gl::Sampler *sampler = state.getSampler(textureUnitIndex);
if (sampler != nullptr)
{
const SamplerGL *samplerGL = GetImplAs<SamplerGL>(sampler);
samplerGL->syncState(sampler->getSamplerState());
bindSampler(textureUnitIndex, samplerGL->getSamplerID());
}
else
{
bindSampler(textureUnitIndex, 0);
}
}
}
const gl::Framebuffer *framebuffer = state.getDrawFramebuffer();
const FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer);
bindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferGL->getFramebufferID());
framebufferGL->syncDrawState();
// Seamless cubemaps are required for ES3 and higher contexts.
setTextureCubemapSeamlessEnabled(data.clientVersion >= 3);
// Set the current transform feedback state
gl::TransformFeedback *transformFeedback = state.getCurrentTransformFeedback();
if (transformFeedback)
{
TransformFeedbackGL *transformFeedbackGL =
GetImplAs<TransformFeedbackGL>(transformFeedback);
bindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbackGL->getTransformFeedbackID());
transformFeedbackGL->syncActiveState(transformFeedback->isActive(),
transformFeedback->getPrimitiveMode());
transformFeedbackGL->syncPausedState(transformFeedback->isPaused());
mPrevDrawTransformFeedback = transformFeedbackGL;
}
else
{
bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
mPrevDrawTransformFeedback = nullptr;
}
// Set the current query state
for (GLenum queryType : QueryTypes)
{
gl::Query *query = state.getActiveQuery(queryType);
if (query != nullptr)
{
QueryGL *queryGL = GetImplAs<QueryGL>(query);
queryGL->resume();
mPrevDrawQueries.insert(queryGL);
}
}
return gl::Error(GL_NO_ERROR);
}
void SGLShaderProgram::setUniform1i(const char* name, int value)
{
useProgram();
glUniform1i(getUniformLocation(name), value);
}
void SGLShaderProgram::setUniform4f(const char* name, glm::vec4& value)
{
useProgram();
glUniform4f(getUniformLocation(name), value[0], value[1], value[2], value[3]);
}
