//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void VertexColoring::onKeyPressEvent(KeyEvent* keyEvent)
{
Key key = keyEvent->key();
char character = keyEvent->character();
if (key == Key_S || key == Key_F)
{
m_useShaders = (key == Key_S) ? true : false;
Collection<Part> partCollection;
m_renderSequence->firstRendering()->scene()->model(0)->allParts(&partCollection);
for (size_t i = 0; i < partCollection.size(); i++)
{
ref<Part> part = partCollection[i];
part->setEffect(m_useShaders ? m_shaderEffect.p() : m_fixedFuncEffect.p());
}
}
if (key == Key_L)
{
bool lightingOn = (character == 'l') ? true : false;
RenderStateLighting_FF* rsLighting = dynamic_cast<RenderStateLighting_FF*>(m_fixedFuncEffect->renderStateOfType(RenderState::LIGHTING_FF));
rsLighting->enable(lightingOn);
}
if (key == Key_C)
{
bool colorMaterialOn = (character == 'c') ? true : false;
RenderStateMaterial_FF* rsMaterial = dynamic_cast<RenderStateMaterial_FF*>(m_fixedFuncEffect->renderStateOfType(RenderState::MATERIAL_FF));
rsMaterial->enableColorMaterial(colorMaterialOn);
}
keyEvent->setRequestedAction(REDRAW);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software)
{
CVF_CALLSITE_OPENGL(oglContext);
Camera projCam;
projCam.setViewport(position.x(), position.y(), size.x(), size.y());
projCam.setProjectionAsPixelExact2D();
projCam.setViewMatrix(Mat4d::IDENTITY);
// Turn off depth test
RenderStateDepth depth(false, RenderStateDepth::LESS, false);
depth.applyOpenGL(oglContext);
float vertexArray[12];
float textureCoords[] = {0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f};
projCam.viewport()->applyOpenGL(oglContext, Viewport::DO_NOT_CLEAR);
if (software)
{
// Create a POW2 texture for software rendering if needed
if (m_image.notNull() && m_pow2Image.isNull() && (!Math::isPow2(m_image->width()) || !Math::isPow2(m_image->height())))
{
m_pow2Image = new TextureImage;
m_pow2Image->allocate(Math::roundUpPow2(m_image->width()), Math::roundUpPow2(m_image->height()));
m_pow2Image->fill(Color4ub(Color3::BLACK));
for (uint y = 0; y < m_image->height(); ++y)
{
for (uint x = 0; x < m_image->width(); ++x)
{
m_pow2Image->setPixel(x, y, m_image->pixel(x, y));
}
}
}
if (ShaderProgram::supportedOpenGL(oglContext))
{
ShaderProgram::useNoProgram(oglContext);
}
#ifndef CVF_OPENGL_ES
RenderStateMaterial_FF mat;
mat.enableColorMaterial(true);
mat.applyOpenGL(oglContext);
RenderStateLighting_FF light(false);
light.applyOpenGL(oglContext);
if (m_textureBindings.isNull())
{
// Use fixed function texture setup
ref<Texture2D_FF> texture = new Texture2D_FF(m_pow2Image.notNull() ? m_pow2Image.p() : m_image.p());
texture->setWrapMode(Texture2D_FF::CLAMP);
texture->setMinFilter(Texture2D_FF::NEAREST);
texture->setMagFilter(Texture2D_FF::NEAREST);
texture->setupTexture(oglContext);
texture->setupTextureParams(oglContext);
ref<RenderStateTextureMapping_FF> textureMapping = new RenderStateTextureMapping_FF(texture.p());
textureMapping->setTextureFunction(m_blendMode == TEXTURE_ALPHA ? RenderStateTextureMapping_FF::MODULATE : RenderStateTextureMapping_FF::DECAL);
m_textureBindings = textureMapping;
}
#endif
// Adjust texture coordinates
if (m_pow2Image.notNull())
{
float xMax = static_cast<float>(m_image->width())/static_cast<float>(m_pow2Image->width());
float yMax = static_cast<float>(m_image->height())/static_cast<float>(m_pow2Image->height());
textureCoords[2] = xMax;
textureCoords[4] = xMax;
textureCoords[5] = yMax;
textureCoords[7] = yMax;
}
projCam.applyOpenGL();
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
if (m_shaderProgram.isNull())
{
ShaderProgramGenerator gen("OverlayImage_Shader", ShaderSourceProvider::instance());
gen.addVertexCode(ShaderSourceRepository::vs_MinimalTexture);
if (m_blendMode == GLOBAL_ALPHA)
{
gen.addFragmentCode(ShaderSourceRepository::src_TextureGlobalAlpha);
}
else
{
gen.addFragmentCode(ShaderSourceRepository::src_Texture);
}
gen.addFragmentCode(ShaderSourceRepository::fs_Unlit);
m_shaderProgram = gen.generate();
m_shaderProgram->linkProgram(oglContext);
}
if (m_shaderProgram->useProgram(oglContext))
{
MatrixState projMatrixState(projCam);
m_shaderProgram->clearUniformApplyTracking();
m_shaderProgram->applyFixedUniforms(oglContext, projMatrixState);
}
if (m_texture->textureOglId() == 0)
{
m_texture->setupTexture(oglContext);
}
if (m_textureBindings.isNull())
{
cvf::RenderStateTextureBindings* textureBindings = new cvf::RenderStateTextureBindings;
textureBindings->addBinding(m_texture.p(), m_sampler.p(), "u_texture2D");
m_textureBindings = textureBindings;
}
}
float offset = 0.0f;
Vec3f min(offset, offset, 0.0f);
Vec3f max(static_cast<float>(size.x()) + offset, static_cast<float>(size.y()) + offset, 0.0f);
// Setup the vertex array
float* v1 = &vertexArray[0];
float* v2 = &vertexArray[3];
float* v3 = &vertexArray[6];
float* v4 = &vertexArray[9];
v1[0] = min.x(); v1[1] = min.y(); v1[2] = 0.0f;
v2[0] = max.x(); v2[1] = min.y(); v2[2] = 0.0f;
v3[0] = max.x(); v3[1] = max.y(); v3[2] = 0.0f;
v4[0] = min.x(); v4[1] = max.y(); v4[2] = 0.0f;
if (m_blendMode != NO_BLENDING)
{
RenderStateBlending blend;
blend.configureTransparencyBlending();
blend.applyOpenGL(oglContext);
}
m_textureBindings->applyOpenGL(oglContext);
if (software)
{
#ifndef CVF_OPENGL_ES
glColor4f(1.0f, 1.0f, 1.0f, m_blendMode == GLOBAL_ALPHA ? m_alpha : 1.0f);
glBegin(GL_TRIANGLE_FAN);
glTexCoord2f(textureCoords[0], textureCoords[1]);
glVertex3fv(v1);
glTexCoord2f(textureCoords[2], textureCoords[3]);
glVertex3fv(v2);
glTexCoord2f(textureCoords[4], textureCoords[5]);
glVertex3fv(v3);
glTexCoord2f(textureCoords[6], textureCoords[7]);
glVertex3fv(v4);
glEnd();
#endif
}
else
{
if (m_blendMode == GLOBAL_ALPHA)
{
UniformFloat alphaUniform("u_alpha", m_alpha);
m_shaderProgram->applyUniform(oglContext, alphaUniform);
}
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
if (m_blendMode != NO_BLENDING)
{
RenderStateBlending blend;
blend.applyOpenGL(oglContext);
}
RenderStateDepth resetDepth;
resetDepth.applyOpenGL(oglContext);
if (software)
{
#ifndef CVF_OPENGL_ES
RenderStateTextureMapping_FF resetTextureMapping;
resetTextureMapping.applyOpenGL(oglContext);
#endif
}
if (!software)
{
glDisableVertexAttribArray(ShaderProgram::VERTEX);
glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OverlayTextBox::renderBackgroundAndBorder(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software)
{
CVF_CALLSITE_OPENGL(oglContext);
// Prepare 2D pixel exact projection to draw texts
Camera projCam;
projCam.setViewport(position.x(), position.y(), size.x(), size.y());
projCam.setProjectionAsPixelExact2D();
projCam.setViewMatrix(Mat4d::IDENTITY);
// Turn off depth test
RenderStateDepth depth(false, RenderStateDepth::LESS, false);
depth.applyOpenGL(oglContext);
ref<ShaderProgram> backgroundShader;
float vertexArray[12];
projCam.viewport()->applyOpenGL(oglContext, Viewport::DO_NOT_CLEAR);
if (software)
{
if (ShaderProgram::supportedOpenGL(oglContext))
{
ShaderProgram::useNoProgram(oglContext);
}
#ifndef CVF_OPENGL_ES
RenderStateMaterial_FF mat;
mat.enableColorMaterial(true);
mat.applyOpenGL(oglContext);
RenderStateLighting_FF light(false);
light.applyOpenGL(oglContext);
#endif
projCam.applyOpenGL();
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
backgroundShader = oglContext->resourceManager()->getLinkedUnlitColorShaderProgram(oglContext);
if (backgroundShader->useProgram(oglContext))
{
MatrixState projMatrixState(projCam);
backgroundShader->clearUniformApplyTracking();
backgroundShader->applyFixedUniforms(oglContext, projMatrixState);
}
}
Vec3f min(1.0f, 1.0f, 0.0f);
Vec3f max(static_cast<float>(size.x() - 1), static_cast<float>(size.y() - 1), 0.0f);
// Setup the vertex array
float* v1 = &vertexArray[0];
float* v2 = &vertexArray[3];
float* v3 = &vertexArray[6];
float* v4 = &vertexArray[9];
v1[0] = min.x();
v1[1] = min.y();
v1[2] = 0.0f;
v2[0] = max.x();
v2[1] = min.y();
v2[2] = 0.0f;
v3[0] = max.x();
v3[1] = max.y();
v3[2] = 0.0f;
v4[0] = min.x();
v4[1] = max.y();
v4[2] = 0.0f;
if (m_drawBackground)
{
if (software)
{
#ifndef CVF_OPENGL_ES
glColor4fv(m_backgroundColor.ptr());
glBegin(GL_TRIANGLE_FAN);
glVertex3fv(v1);
glVertex3fv(v2);
glVertex3fv(v3);
glVertex3fv(v4);
glEnd();
#endif
}
else
{
// Draw background
UniformFloat backgroundColor("u_color", Color4f(m_backgroundColor));
backgroundShader->applyUniform(oglContext, backgroundColor);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
}
if (m_drawBorder)
{
if (software)
{
#ifndef CVF_OPENGL_ES
glColor3fv(m_borderColor.ptr());
glBegin(GL_LINE_LOOP);
glVertex3fv(v1);
glVertex3fv(v2);
glVertex3fv(v3);
glVertex3fv(v4);
glEnd();
#endif
}
else
{
UniformFloat borderColor("u_color", Color4f(m_borderColor));
backgroundShader->applyUniform(oglContext, borderColor);
RenderStateLine line(static_cast<float>(3));
line.applyOpenGL(oglContext);
// Draw border
glDrawArrays(GL_LINE_LOOP, 0, 4);
RenderStateLine resetLine;
resetLine.applyOpenGL(oglContext);
}
}
}
