// XXX Need a way to deal with blits with Camera/Lighting. void DisplayDeviceOpenGL::doBlitTexture(const TexturePtr& tex, int dstx, int dsty, int dstw, int dsth, float rotation, int srcx, int srcy, int srcw, int srch) { ASSERT_LOG(false, "DisplayDevice::doBlitTexture deprecated"); ASSERT_LOG(!tex, "Texture passed in was not of expected type."); const float tx1 = float(srcx) / tex->width(); const float ty1 = float(srcy) / tex->height(); const float tx2 = srcw == 0 ? 1.0f : float(srcx + srcw) / tex->width(); const float ty2 = srch == 0 ? 1.0f : float(srcy + srch) / tex->height(); const float uv_coords[] = { tx1, ty1, tx2, ty1, tx1, ty2, tx2, ty2, }; const float vx1 = float(dstx); const float vy1 = float(dsty); const float vx2 = float(dstx + dstw); const float vy2 = float(dsty + dsth); const float vtx_coords[] = { vx1, vy1, vx2, vy1, vx1, vy2, vx2, vy2, }; // Apply blend mode from texture if there is any. BlendEquationScopeOGL be_scope(*tex); BlendModeScopeOGL bm_scope(*tex); glm::mat4 model = glm::translate(glm::mat4(1.0f), glm::vec3((vx1+vx2)/2.0f,(vy1+vy2)/2.0f,0.0f)) * glm::rotate(glm::mat4(1.0f), rotation, glm::vec3(0.0f,0.0f,1.0f)) * glm::translate(glm::mat4(1.0f), glm::vec3(-(vx1+vy1)/2.0f,-(vy1+vy1)/2.0f,0.0f)); glm::mat4 mvp = glm::ortho(0.0f, 800.0f, 600.0f, 0.0f) * model; auto shader = OpenGL::ShaderProgram::defaultSystemShader(); shader->makeActive(); getDefaultShader()->setUniformsForTexture(tex); shader->setUniformValue(shader->getMvpUniform(), glm::value_ptr(mvp)); shader->setUniformValue(shader->getColorUniform(), glm::value_ptr(glm::vec4(1.0f,1.0f,1.0f,1.0f))); // XXX the following line are only temporary, obviously. //shader->setUniformValue(shader->getUniform("discard"), 0); glEnableVertexAttribArray(shader->getVertexAttribute()); glVertexAttribPointer(shader->getVertexAttribute(), 2, GL_FLOAT, GL_FALSE, 0, vtx_coords); glEnableVertexAttribArray(shader->getTexcoordAttribute()); glVertexAttribPointer(shader->getTexcoordAttribute(), 2, GL_FLOAT, GL_FALSE, 0, uv_coords); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDisableVertexAttribArray(shader->getTexcoordAttribute()); glDisableVertexAttribArray(shader->getVertexAttribute()); }
/** * Set the color for ambient and diffuse lighting (or no lighting). * Alternatively use a color array and color attribute. */ void GLESRenderer::setAmbientAndDiffuseColor(const GLColorRGBA newVal) { ambientAndDiffuseColor = newVal; if(bound && location_uAmbientAndDiffuseColor != -1) setUniformValue(location_uAmbientAndDiffuseColor, ambientAndDiffuseColor.red(), ambientAndDiffuseColor.green(), ambientAndDiffuseColor.blue(), ambientAndDiffuseColor.alpha()); }
/** * Set the color for specular lighting. */ void GLESRenderer::setSpecularColor(const GLColorRGBA newVal) { specularColor = newVal; if(bound && (location_uSpecularColor != -1)) setUniformValue(location_uSpecularColor, specularColor.red(), specularColor.green(), specularColor.blue(), specularColor.alpha()); }
void setWorldMatrix(GLfloat m[4][4]) { static bool init = true; if (init || memcmp(m, worldMatrix, sizeof(worldMatrix))) { setUniformValue("matWorld", m); memcpy(worldMatrix, m, sizeof(worldMatrix)); init = false; } }
void Z3DShaderProgram::bindTexture(const QString &name, GLenum target, GLuint textureId) { m_textureUnitManager.nextAvailableUnit(); m_textureUnitManager.activateCurrentUnit(); glBindTexture(target, textureId); setUniformValue(name, m_textureUnitManager.getCurrentUnitNumber()); glActiveTexture(GL_TEXTURE0); CHECK_GL_ERROR; }
void PainterShaderProgram::setTextureMatrix(const Matrix3& textureMatrix) { if(textureMatrix == m_textureMatrix) return; bind(); setUniformValue(TEXTURE_MATRIX_UNIFORM, textureMatrix); m_textureMatrix = textureMatrix; }
void PainterShaderProgram::setProjectionMatrix(const Matrix3& projectionMatrix) { if(projectionMatrix == m_projectionMatrix) return; bind(); setUniformValue(PROJECTION_MATRIX_UNIFORM, projectionMatrix); m_projectionMatrix = projectionMatrix; }
void PainterShaderProgram::setTransformMatrix(const Matrix3& transformMatrix) { if(transformMatrix == m_transformMatrix) return; bind(); setUniformValue(TRANSFORM_MATRIX_UNIFORM, transformMatrix); m_transformMatrix = transformMatrix; }
void PainterShaderProgram::setResolution(const Size& resolution) { if(m_resolution == resolution) return; bind(); setUniformValue(RESOLUTION_UNIFORM, (float)resolution.width(), (float)resolution.height()); m_resolution = resolution; }
void PainterShaderProgram::setOpacity(float opacity) { if(m_opacity == opacity) return; bind(); setUniformValue(OPACITY_UNIFORM, opacity); m_opacity = opacity; }
/** * Set modelview matrix. Updates mvpMatrix and normalMatrix too. * Call setPMatrix first. */ void GLESRenderer::setMvMatrix(const QMatrix4x4 newVal) { mvMatrix = newVal; normalMatrix = mvMatrix.normalMatrix(); //invert and transpose mvMatrix invertedMvpMatrixValid = false; //delay matrix inversion until it is really neccessary if(bound && (location_uNormalMatrix != -1)) setUniformValue(location_uNormalMatrix, normalMatrix); mvpMatrix = pMatrix * mvMatrix; if(bound && (location_uMvpMatrix != -1)) setUniformValue(location_uMvpMatrix, mvpMatrix); #ifdef DEBUG_GLESRENDERER ShaderDebugger::debugMatrix4x4(mvMatrix, "GLESRenderer uses modelview matrix:"); ShaderDebugger::debugMatrix3x3(normalMatrix, "GLESRenderer uses normal matrix:"); ShaderDebugger::debugMatrix4x4(mvpMatrix, "GLESRenderer uses MVP matrix:"); #endif }
void PainterShaderProgram::setColor(const Color& color) { if(color == m_color) return; bind(); setUniformValue(COLOR_UNIFORM, color); m_color = color; }
/** * Set light direction. */ void GLESRenderer::setLightDirection(const QVector3D & newVal) { lightDirection = newVal; #ifdef DEBUG_GLESRENDERER ShaderDebugger::debugVector3D(lightDirection, "GLESRenderer uses lightDirection in object space:"); #endif QMatrix4x4 nMatrix = QMatrix4x4(normalMatrix); lightDirection = (nMatrix * lightDirection);//transform to eye space halfPlaneVector = (lightDirection + QVector3D(0.0,0.0,1.0)).normalized();//eye direction is 0,0,1 in eye space #ifdef DEBUG_GLESRENDERER ShaderDebugger::debugVector3D(lightDirection, "GLESRenderer uses lightDirection in eye space:"); ShaderDebugger::debugVector3D(lightDirection, "GLESRenderer uses halfplane vector in eye space:"); #endif if(bound && (location_uLightDirection != -1)) setUniformValue(location_uLightDirection, lightDirection); if(location_uHalfPlaneVector != -1) setUniformValue(location_uHalfPlaneVector, halfPlaneVector); }
void PainterShaderProgram::updateTime() { float time = g_clock.seconds() - m_startTime; if(m_time == time) return; bind(); setUniformValue(TIME_UNIFORM, time); m_time = time; }
void Z3DShaderProgram::bindTexture(const QString &name, const Z3DTexture *texture) { if (texture) { m_textureUnitManager.nextAvailableUnit(); m_textureUnitManager.activateCurrentUnit(); texture->bind(); setUniformValue(name, m_textureUnitManager.getCurrentUnitNumber()); glActiveTexture(GL_TEXTURE0); CHECK_GL_ERROR; } }
void ScalarDisplay::Bind (GLfloat minValue, GLfloat maxValue, StatisticsType::Enum displayType, AverageCountType::Enum countType, GLfloat globalCount) { ShaderProgram::Bind (); setUniformValue (m_displayTypeLocation, displayType); setUniformValue (m_countTypeLocation, countType); setUniformValue (m_globalCountLocation, globalCount); setUniformValue (m_minValueLocation, minValue); setUniformValue (m_maxValueLocation, maxValue); setUniformValue (m_colorBarTexUnitLocation, GetColorMapTexUnit ()); setUniformValue (m_scalarAverageTexUnitLocation, GetScalarAverageTexUnit ()); }
/** * Set size of points drawn with GL_POINTS. */ void GLESRenderer::setPointSize(int newVal) { pointSize = newVal; if(bound && (location_uPointSize != -1)) setUniformValue(location_uPointSize, pointSize); }
/** * Set the texture flag. */ void GLESRenderer::setTextureEnabled(bool newVal) { textureEnabled = newVal; if(bound && (location_uTextureEnabled != -1)) setUniformValue(location_uTextureEnabled, textureEnabled); }
void setValue(const std::vector<T> &data, GLsizei count = 1) { setUniformValue(id, data, count); }
/** * Enable / disable lighting. */ void GLESRenderer::setLightingEnabled(bool newVal) { lightingEnabled = newVal; if(bound && (location_uLightingEnabled != -1)) setUniformValue(location_uLightingEnabled, lightingEnabled); }
/** * Enable / disable color array. */ void GLESRenderer::setColorArrayEnabled(bool newVal) { colorArrayEnabled = newVal; if(bound && (location_uColorArrayEnabled != -1)) setUniformValue(location_uColorArrayEnabled, colorArrayEnabled); }
void setValue(const BaseMatrix<mattype, i, j> &data, GLsizei count = 1, GLboolean transpose = GL_FALSE) { setUniformValue(id, data, count, transpose); }
/** * Set the shininess for specular lighting. */ void GLESRenderer::setShininess(float newVal) { shininess = newVal; if(bound && (location_uShininess != -1)) setUniformValue(location_uShininess, shininess); }
void setValue(const T& data) { setUniformValue(id, data); }
/** * Bind program and transfer attribute and uniform data to the shaders. * Calls initialize, if not already initialized. */ bool GLESRenderer::bind() { bool ok = true; if(!initialized) ok = initialize(); if(!ok) return false; renderProgram->bind(); //Activate uniforms //flags if(location_uColorArrayEnabled != -1) setUniformValue(location_uColorArrayEnabled, colorArrayEnabled); if(location_uLightingEnabled != -1) setUniformValue(location_uLightingEnabled, lightingEnabled); if(location_uTextureEnabled != -1) setUniformValue(location_uTextureEnabled, textureEnabled); //matrices if( location_uNormalMatrix != -1) setUniformValue(location_uNormalMatrix, normalMatrix); if(location_uMvpMatrix != -1) setUniformValue(location_uMvpMatrix, mvpMatrix); //lighting if(location_uAmbientAndDiffuseColor != -1) setUniformValue(location_uAmbientAndDiffuseColor, ambientAndDiffuseColor.red(), ambientAndDiffuseColor.green(), ambientAndDiffuseColor.blue(), ambientAndDiffuseColor.alpha()); if(location_uAmbientLightBrightness != -1) setUniformValue(location_uAmbientLightBrightness, ambientLightBrightness); if(location_uLightDirection != -1) setUniformValue(location_uLightDirection, lightDirection); if(location_uSpecularColor != -1) setUniformValue(location_uSpecularColor, specularColor.red(), specularColor.green(), specularColor.blue(), specularColor.alpha()); if(location_uShininess != -1) setUniformValue(location_uShininess, shininess); if(location_uHalfPlaneVector != -1) setUniformValue(location_uHalfPlaneVector, halfPlaneVector); //texture if(location_uTextureSampler != -1) setUniformValue(location_uTextureSampler, 0); //set sampler to use texture unit 0 //point size if(location_uPointSize != -1) setUniformValue(location_uPointSize, pointSize); bound = true; return bound; }
void setBlurStep(GLfloat b) { if (b != blurstep) { setUniformValue("blurstep", b); blurstep = b; } }
void setOpacity(GLfloat o) { if (o != opacity) { setUniformValue("opacity", o); opacity = o; } }
void setTexture(GLuint t) { if (t != texture) { setUniformValue("texture", t); texture = t; } }
/** * Set the dimming factor for ambient light. * Defaults to 0.2. */ void GLESRenderer::setAmbientLightBrightness(float newVal) { ambientLightBrightness = newVal; if(bound && location_uAmbientLightBrightness != -1) setUniformValue(location_uAmbientLightBrightness, ambientLightBrightness); }
void DisplayDeviceOpenGL::render(const Renderable* r) const { if(!r->isEnabled()) { // Renderable item not enabled then early return. return; } StencilScopePtr stencil_scope; if(r->hasClipSettings()) { ModelManager2D mm(r->getPosition().x, r->getPosition().y); auto clip_shape = r->getStencilMask(); bool cam_set = false; if(clip_shape->getCamera() == nullptr && r->getCamera() != nullptr) { cam_set = true; clip_shape->setCamera(r->getCamera()); } stencil_scope.reset(new StencilScopeOGL(r->getStencilSettings())); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthMask(GL_FALSE); glClear(GL_STENCIL_BUFFER_BIT); render(clip_shape.get()); stencil_scope->applyNewSettings(keep_stencil_settings); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_TRUE); if(cam_set) { clip_shape->setCamera(nullptr); } } auto shader = r->getShader(); shader->makeActive(); BlendEquationScopeOGL be_scope(*r); BlendModeScopeOGL bm_scope(*r); // apply lighting/depth check/depth write here. bool use_lighting = r->isLightingStateSet() ? r->useLighting() : false; // Set the depth enable. if(r->isDepthEnableStateSet()) { if(get_current_depth_enable() != r->isDepthEnabled()) { if(r->isDepthEnabled()) { glEnable(GL_DEPTH_TEST); } else { glDisable(GL_DEPTH_TEST); } get_current_depth_enable() = r->isDepthEnabled(); } } else { // We assume that depth is disabled if not specified. if(get_current_depth_enable() == true) { glDisable(GL_DEPTH_TEST); get_current_depth_enable() = false; } } glm::mat4 pmat(1.0f); glm::mat4 vmat(1.0f); if(r->getCamera()) { // set camera here. pmat = r->getCamera()->getProjectionMat(); vmat = r->getCamera()->getViewMat(); } else if(get_default_camera() != nullptr) { pmat = get_default_camera()->getProjectionMat(); vmat = get_default_camera()->getViewMat(); } if(use_lighting) { for(auto lp : r->getLights()) { /// xxx need to set lights here. } } if(r->getRenderTarget()) { r->getRenderTarget()->apply(); } if(shader->getPUniform() != ShaderProgram::INVALID_UNIFORM) { shader->setUniformValue(shader->getPUniform(), glm::value_ptr(pmat)); } if(shader->getMvUniform() != ShaderProgram::INVALID_UNIFORM) { glm::mat4 mvmat = vmat; if(is_global_model_matrix_valid() && !r->ignoreGlobalModelMatrix()) { mvmat *= get_global_model_matrix() * r->getModelMatrix(); } else { mvmat *= r->getModelMatrix(); } shader->setUniformValue(shader->getMvUniform(), glm::value_ptr(mvmat)); } if(shader->getMvpUniform() != ShaderProgram::INVALID_UNIFORM) { glm::mat4 pvmat(1.0f); if(is_global_model_matrix_valid() && !r->ignoreGlobalModelMatrix()) { pvmat = pmat * vmat * get_global_model_matrix() * r->getModelMatrix(); } else { pvmat = pmat * vmat * r->getModelMatrix(); } shader->setUniformValue(shader->getMvpUniform(), glm::value_ptr(pvmat)); } if(shader->getColorUniform() != ShaderProgram::INVALID_UNIFORM) { if(r->isColorSet()) { shader->setUniformValue(shader->getColorUniform(), r->getColor().asFloatVector()); } else { shader->setUniformValue(shader->getColorUniform(), ColorScope::getCurrentColor().asFloatVector()); } } shader->setUniformsForTexture(r->getTexture()); // XXX we should make this either or with setting the mvp/color uniforms above. auto uniform_draw_fn = shader->getUniformDrawFunction(); if(uniform_draw_fn) { uniform_draw_fn(shader); } // Loop through uniform render variables and set them. /*for(auto& urv : r->UniformRenderVariables()) { for(auto& rvd : urv->VariableDescritionList()) { auto rvdd = std::dynamic_pointer_cast<RenderVariableDeviceData>(rvd->GetDisplayData()); ASSERT_LOG(rvdd != nullptr, "Unable to cast DeviceData to RenderVariableDeviceData."); shader->SetUniformValue(rvdd->GetActiveMapIterator(), urv->Value()); } }*/ // Need to figure the interaction with shaders. /// XXX Need to create a mapping between attributes and the index value below. for(auto as : r->getAttributeSet()) { //ASSERT_LOG(as->getCount() > 0, "No (or negative) number of vertices in attribute set. " << as->getCount()); if((!as->isMultiDrawEnabled() && as->getCount() <= 0) || (as->isMultiDrawEnabled() && as->getMultiDrawCount() <= 0)) { //LOG_WARN("No (or negative) number of vertices in attribute set. " << as->getCount()); continue; } GLenum draw_mode = convert_drawing_mode(as->getDrawMode()); // apply blend, if any, from attribute set. BlendEquationScopeOGL be_scope(*as); BlendModeScopeOGL bm_scope(*as); if(shader->getColorUniform() != ShaderProgram::INVALID_UNIFORM && as->isColorSet()) { shader->setUniformValue(shader->getColorUniform(), as->getColor().asFloatVector()); } for(auto& attr : as->getAttributes()) { if(attr->isEnabled()) { shader->applyAttribute(attr); } } if(as->isInstanced()) { if(as->isIndexed()) { as->bindIndex(); // XXX as->GetIndexArray() should be as->GetIndexArray()+as->GetOffset() glDrawElementsInstanced(draw_mode, static_cast<GLsizei>(as->getCount()), convert_index_type(as->getIndexType()), as->getIndexArray(), as->getInstanceCount()); as->unbindIndex(); } else { glDrawArraysInstanced(draw_mode, static_cast<GLint>(as->getOffset()), static_cast<GLsizei>(as->getCount()), as->getInstanceCount()); } } else { if(as->isIndexed()) { as->bindIndex(); // XXX as->GetIndexArray() should be as->GetIndexArray()+as->GetOffset() glDrawElements(draw_mode, static_cast<GLsizei>(as->getCount()), convert_index_type(as->getIndexType()), as->getIndexArray()); as->unbindIndex(); } else { if(as->isMultiDrawEnabled()) { glMultiDrawArrays(draw_mode, as->getMultiOffsetArray().data(), as->getMultiCountArray().data(), as->getMultiDrawCount()); } else { glDrawArrays(draw_mode, static_cast<GLint>(as->getOffset()), static_cast<GLsizei>(as->getCount())); } } } shader->cleanUpAfterDraw(); glBindBuffer(GL_ARRAY_BUFFER, 0); } if(r->getRenderTarget()) { r->getRenderTarget()->unapply(); } }