void CubeObj::drawgl(GLWidget &gl, QMatrix4x4 & cameramat ) {
QMatrix4x4 mobj = cameramat;
mobj *= getMatrix();
mobj.scale(scale);
static QColor color ( 1.0f, 0, 0.5f, 1 );
QGLShaderProgram * sp = gl.program;
if ( pro.actualobject == this ) {
sp = gl.program2;
}
for ( int i=0; i <6; i++) {
sp->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
sp->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
sp->setAttributeArray (PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());
sp->setAttributeArray (PROGRAM_TEXCOORD_ATTRIBUTE, texCoords.constData());
sp->bind();
sp->setUniformValue("matrix", mobj);
sp->setUniformValue("color", QVector4D (1,0,0,0.2f));
gl.glBindTexture(GL_TEXTURE_2D, this->textureIDs[i] );
gl.glDrawArrays(GL_QUADS, i*4, 4 );
}
if ( pro.getManger().edges ) {
gl.glDisable(GL_CULL_FACE);
sp = gl.solidcolorp;
sp->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
sp->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
sp->setAttributeArray (PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());
sp->setAttributeArray (PROGRAM_TEXCOORD_ATTRIBUTE, texCoords.constData());
sp->bind();
sp->setUniformValue("matrix", mobj);
sp->setUniformValue("color", QVector4D (0,1,0,0.8f));
if ( pro.actualobject == this ) {
sp->setUniformValue("color", QVector4D (1,0.8f,1,0.8f));
}
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
gl.glLineWidth(2);
gl.glDrawArrays(GL_QUADS, 0, 24 );
gl.glEnable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
}
// --------------------------------------------------------
void TouchWidgetRenderer::drawHollowCircle( GLResourceContainer * container, const QPointF & pos, qreal radius, qreal alpha, const QColor & color, qreal thickness, qreal blur_multiplier ) const
{
QSizeF size(2*radius, 2*radius);
QGLShaderProgram * shader = container->shaderProgram("circle");
shader->bind();
shader->setUniformValue("thickness", 1.0f/(GLfloat)size.width()*(float)thickness);
shader->setUniformValue("blur", (float) thickness*(float)blur_multiplier);
//shader->setUniformValue("blur", (float) radius);
shader->setUniformValue("alpha", (float) (this->alpha()*alpha));
shader->setUniformValue("color", color);
drawQuad(pos, size, 0, 1.0f /* ignored by shader anyway */);
shader->release();
}
void NightModeGraphicsEffect::draw(QPainter* painter)
{
int pixelRatio = painter->device()->devicePixelRatio();
QSize size(painter->device()->width() * pixelRatio, painter->device()->height() * pixelRatio);
if (fbo && fbo->size() != size)
{
delete fbo;
fbo = NULL;
}
if (!fbo)
{
QGLFramebufferObjectFormat format;
format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
format.setInternalTextureFormat(GL_RGBA);
fbo = new NightModeGraphicsEffectFbo(size, format, pixelRatio);
}
QPainter fboPainter(fbo);
drawSource(&fboPainter);
painter->save();
painter->beginNativePainting();
program->bind();
const GLfloat pos[] = {-1, -1, +1, -1, -1, +1, +1, +1};
const GLfloat texCoord[] = {0, 0, 1, 0, 0, 1, 1, 1};
program->setUniformValue(vars.source, 0);
program->setAttributeArray(vars.pos, pos, 2);
program->setAttributeArray(vars.texCoord, texCoord, 2);
program->enableAttributeArray(vars.pos);
program->enableAttributeArray(vars.texCoord);
glBindTexture(GL_TEXTURE_2D, fbo->texture());
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
program->release();
painter->endNativePainting();
painter->restore();
}
static void blitTexture(QGLContext *ctx, GLuint texture, const QSize &viewport, const QSize &texSize, const QRect &targetRect, const QRect &sourceRect)
{
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glViewport(0, 0, viewport.width(), viewport.height());
QGLShaderProgram *blitProgram =
QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
blitProgram->bind();
blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
// The shader manager's blit program does not multiply the
// vertices by the pmv matrix, so we need to do the effect
// of the orthographic projection here ourselves.
QRectF r;
qreal w = viewport.width();
qreal h = viewport.height();
r.setLeft((targetRect.left() / w) * 2.0f - 1.0f);
if (targetRect.right() == (viewport.width() - 1))
r.setRight(1.0f);
else
r.setRight((targetRect.right() / w) * 2.0f - 1.0f);
r.setBottom((targetRect.top() / h) * 2.0f - 1.0f);
if (targetRect.bottom() == (viewport.height() - 1))
r.setTop(1.0f);
else
r.setTop((targetRect.bottom() / w) * 2.0f - 1.0f);
drawTexture(r, texture, texSize, sourceRect);
}
void BinghamRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, PropertyGroup& props )
{
if ( renderMode != 1 ) // we are drawing opaque objects
{
// obviously not opaque
return;
}
setRenderParams( props );
if ( m_orient == 0 )
{
return;
}
m_pMatrix = p_matrix;
m_mvMatrix = mv_matrix;
initGeometry( props );
QGLShaderProgram* program = GLFunctions::getShader( "qball" );
program->bind();
program->setUniformValue( "u_alpha", 1.0f );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
program->setUniformValue( "mv_matrixInvert", mv_matrix.inverted() );
program->setUniformValue( "u_hideNegativeLobes", m_minMaxScaling );
program->setUniformValue( "u_scaling", m_scaling );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboIds[ 0 ] );
glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 1 ] );
setShaderVars( props );
glDrawElements( GL_TRIANGLES, m_tris1, GL_UNSIGNED_INT, 0 );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
/*!
Draw the particle, if effect was given in the constructor, we set the
diffuse value for the shader in order to color the particle as same
as the ball that hit the particle.
*/
void ExplosionParticle::draw(QGLPainter *painter)
{
if (userEffect()) {
QGLShaderProgram *program =
static_cast<QGLShaderProgramEffect*>(userEffect())->program();
if (m_DiffuseLoc == -1) {
m_DiffuseLoc = program->uniformLocation("diffuse");
}
program->setUniformValue(m_DiffuseLoc, material()->diffuseColor());
QGLSceneNode::draw(painter);
program->setUniformValue(m_DiffuseLoc,
QVector4D(1.0f, 1.0f, 1.0f, 1.0f));
}
else {
QGLSceneNode::draw(painter);
}
}
// --------------------------------------------------------
void TouchWidgetRenderer::drawMagnifyingGlass(
GLResourceContainer * container,
const MagnifyingGlass * mg,
float alpha ) const
{
// draw contents to fbo
QGLFramebufferObject * fbo = container->framebufferObject("mg_fbo");
drawSceneToFbo(fbo, mg->srcCenter(), mg->srcSize(), mg->angle());
//qDebug() << "drawing mg " << mg << mg->dstCenter() << mg->dstSize();
// draw magnifying glass including contents
QGLShaderProgram * shader = container->shaderProgram("mglass");
shader->bind();
shader->setUniformValue("mglass_tex", 0);
shader->setUniformValue("content_tex", 1);
shader->setUniformValue("alpha", this->alpha()*alpha);
glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, container->texture("mglass"));
glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, fbo->texture());
drawQuad(mg->dstCenter(), mg->dstSize(), -mg->angle(), this->alpha()*alpha);
shader->release();
}
void FiberRenderer::setShaderVars( PropertyGroup* props )
{
QGLShaderProgram* program = GLFunctions::getShader( "fiber" );
program->bind();
long int offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 10, (const void *) offset );
offset += sizeof(float) * 3;
int normalLocation = program->attributeLocation( "a_normal" );
program->enableAttributeArray( normalLocation );
glVertexAttribPointer( normalLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 10, (const void *) offset );
offset += sizeof(float) * 3;
int colorLocation = program->attributeLocation( "a_color" );
program->enableAttributeArray( colorLocation );
glVertexAttribPointer( colorLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 10, (const void *) offset );
offset += sizeof(float) * 3;
int extraLocation = program->attributeLocation( "a_extra" );
program->enableAttributeArray( extraLocation );
glVertexAttribPointer( extraLocation, 1, GL_FLOAT, GL_FALSE, sizeof(float) * 10, (const void *) offset );
program->setUniformValue( "u_colorMode", props->get( Fn::Property::COLORMODE ).toInt() );
program->setUniformValue( "u_colormap", props->get( Fn::Property::COLORMAP ).toInt() );
program->setUniformValue( "u_color", 1.0, 0.0, 0.0, 1.0 );
program->setUniformValue( "u_selectedMin", props->get( Fn::Property::SELECTED_MIN ).toFloat() );
program->setUniformValue( "u_selectedMax", props->get( Fn::Property::SELECTED_MAX ).toFloat() );
program->setUniformValue( "u_lowerThreshold", props->get( Fn::Property::LOWER_THRESHOLD ).toFloat() );
program->setUniformValue( "u_upperThreshold", props->get( Fn::Property::UPPER_THRESHOLD ).toFloat() );
program->setUniformValue( "u_dx", props->get( Fn::Property::DX ).toFloat() );
program->setUniformValue( "u_dy", props->get( Fn::Property::DY ).toFloat() );
program->setUniformValue( "u_dz", props->get( Fn::Property::DZ ).toFloat() );
program->setUniformValue( "u_x", props->get( Fn::Property::NX ).toFloat() / 10.f );
program->setUniformValue( "u_y", props->get( Fn::Property::NY ).toFloat() / 10.f );
program->setUniformValue( "u_z", props->get( Fn::Property::NZ ).toFloat() / 10.f );
}
void Annotation::draw(QGLShaderProgram& annotationShaderProg,
const TransformState& transState) const
{
glBindVertexArray(m_vao);
GLint texture0 = glGetUniformLocation(annotationShaderProg.programId(),
"texture0");
m_texture->bind(texture0);
annotationShaderProg.setUniformValue("annotationSize",
m_texture->width(),
m_texture->height());
transState.translate(m_position)
.setUniforms(annotationShaderProg.programId());
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindTexture(GL_TEXTURE_2D, 0);
glBindVertexArray(0);
}
void FiberRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, PropertyGroup* props )
{
float alpha = props->get( Fn::Property::ALPHA ).toFloat();
if ( renderMode != 1 ) // we are not picking
{
if ( renderMode == 4 || renderMode == 5 ) // we are drawing opaque objects
{
if ( alpha < 1.0 )
{
// obviously not opaque
return;
}
}
else // we are drawing tranparent objects
{
if ( !(alpha < 1.0 ) )
{
// not transparent
return;
}
}
}
QGLShaderProgram* program = GLFunctions::getShader( "fiber" );
program->bind();
GLFunctions::setupTextures();
GLFunctions::setTextureUniforms( GLFunctions::getShader( "fiber" ) );
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
program->setUniformValue( "mv_matrixInvert", mv_matrix.inverted() );
initGeometry();
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboIds[ 0 ] );
glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 1 ] );
setShaderVars( props );
program->setUniformValue( "u_alpha", alpha );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
glLineWidth( props->get( Fn::Property::FIBER_THICKNESS ).toFloat() );
QVector<bool>*selected = m_selector->getSelection();
if ( props->get( Fn::Property::COLORMODE ).toInt() != 2 )
{
for ( int i = 0; i < m_data.size(); ++i )
{
if ( selected->at( i ) )
{
glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
}
}
}
else
{
for ( int i = 0; i < m_data.size(); ++i )
{
if ( selected->at( i ) )
{
program->setUniformValue( "u_color", m_colorField[i].redF(),
m_colorField[i].greenF(),
m_colorField[i].blueF(), 1.0 );
glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
}
}
}
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
void TextRenderer::renderOverlay( QString text, int x, int y, int width, int height, int renderMode )
{
glActiveTexture( GL_TEXTURE13 );
glBindTexture( GL_TEXTURE_2D, m_fontTextureGLuint[0] );
glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 0 ] );
QGLShaderProgram* program = GLFunctions::getShader( "text" );
program->bind();
// Offset for position
intptr_t offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (const void *) offset );
program->setUniformValue( "u_x", (float)x );
program->setUniformValue( "u_y", (float)y );
program->setUniformValue( "u_z", -0.6f );
program->setUniformValue( "u_width", (float)width );
program->setUniformValue( "u_height", (float)height );
program->setUniformValue( "u_scaleX", 1.0f );
program->setUniformValue( "u_scaleY", 1.0f );
program->setUniformValue( "u_sizeX", m_textSizeX / (float)width );
program->setUniformValue( "u_sizeY", m_textSizeY / (float)height );
program->setUniformValue( "u_textColor", m_textColor.redF(), m_textColor.greenF(), m_textColor.blueF() );
program->setUniformValue( "u_alpha", 1.0f );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "fontTex", 13 );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
program->setUniformValue( "u_overlay", 1 );
for ( int i = 0; i < text.size(); ++i )
{
QChar c = text.at( i );
program->setUniformValue( "u_char", (float)m_characterPositions[ c ] );
program->setUniformValue( "u_pos", (float)i );
glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
void TextRenderer::renderLabel( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, QString text, float x, float y, float z, float alpha, int width, int height, int renderMode )
{
switch ( renderMode )
{
case 0:
break;
case 1:
{
if ( alpha < 1.0 ) // obviously not opaque
{
return;
}
break;
}
default:
{
if ( alpha == 1.0 ) // not transparent
{
return;
}
break;
}
}
glActiveTexture( GL_TEXTURE13 );
glBindTexture( GL_TEXTURE_2D, m_fontTextureGLuint[0] );
glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 0 ] );
QGLShaderProgram* program = GLFunctions::getShader( "text" );
program->bind();
// Offset for position
intptr_t offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (const void *) offset );
program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
program->setUniformValue( "u_x", x );
program->setUniformValue( "u_y", y );
program->setUniformValue( "u_z", z );
program->setUniformValue( "u_width", (float)width );
program->setUniformValue( "u_height", (float)height );
program->setUniformValue( "u_scaleX", 1.0f );
program->setUniformValue( "u_scaleY", 1.0f );
program->setUniformValue( "u_sizeX", m_textSizeX / (float)width );
program->setUniformValue( "u_sizeY", m_textSizeY / (float)height );
program->setUniformValue( "u_textColor", m_textColor.redF(), m_textColor.greenF(), m_textColor.blueF() );
program->setUniformValue( "u_alpha", 1.0f );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "fontTex", 13 );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
program->setUniformValue( "u_overlay", 0 );
for ( int i = 0; i < text.size(); ++i )
{
QChar c = text.at( i );
program->setUniformValue( "u_char", (float)m_characterPositions[ c ] );
program->setUniformValue( "u_pos", (float)i );
glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
void DatasetIsoline::draw( QMatrix4x4 pMatrix, QMatrix4x4 mvMatrix, int width, int height, int renderMode, QString target )
{
bool renderAnySlice = m_properties["maingl"].get( Fn::Property::D_RENDER_AXIAL ).toBool() ||
m_properties["maingl"].get( Fn::Property::D_RENDER_CORONAL ).toBool() ||
m_properties["maingl"].get( Fn::Property::D_RENDER_SAGITTAL ).toBool();
if ( !properties( target ).get( Fn::Property::D_ACTIVE ).toBool() || ! renderAnySlice )
{
return;
}
if ( m_dirty )
{
initGeometry();
}
float alpha = 1.0; //GLFunctions::sliceAlpha[target];
switch ( renderMode )
{
case 0:
break;
case 1:
{
if ( alpha < 1.0 ) // obviously not opaque
{
return;
}
break;
}
default:
{
if ( alpha == 1.0 ) // not transparent
{
return;
}
break;
}
}
QGLShaderProgram* program = GLFunctions::getShader( "stipple" );
if ( ( m_vertCountAxial + m_vertCountCoronal + m_vertCountSagittal ) > 0 )
{
program->bind();
intptr_t offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, vbo0 );
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
GLFunctions::f->glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (const void *) offset );
offset += sizeof(float) * 3;
int offsetLocation = program->attributeLocation( "a_vec" );
program->enableAttributeArray( offsetLocation );
GLFunctions::f->glVertexAttribPointer( offsetLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (const void *) offset );
offset += sizeof(float) * 3;
int dirLocation = program->attributeLocation( "a_dir2" );
program->enableAttributeArray( dirLocation );
GLFunctions::f->glVertexAttribPointer( dirLocation, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (const void *) offset );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, 0 );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, vbo1 );
int colorLocation = program->attributeLocation( "a_color" );
program->enableAttributeArray( colorLocation );
GLFunctions::f->glVertexAttribPointer( colorLocation, 4, GL_FLOAT, GL_FALSE, 0, 0 );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, 0 );
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", pMatrix * mvMatrix );
program->setUniformValue( "u_scaling", 1.0f );
program->setUniformValue( "u_alpha", 1.0f );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
program->setUniformValue( "u_aVec", 1., 0., 0. );
program->setUniformValue( "u_bVec", 0., 1., 0. );
program->setUniformValue( "u_orient", 0 );
program->setUniformValue( "u_glyphThickness", m_properties["maingl"].get( Fn::Property::D_LINE_WIDTH ).toFloat() );
program->setUniformValue( "u_glyphSize", m_properties["maingl"].get( Fn::Property::D_STIPPLE_GLYPH_SIZE ).toFloat() );
program->setUniformValue( "u_constantThickness", true );
if ( m_properties["maingl"].get( Fn::Property::D_RENDER_AXIAL ).toBool() && m_vertCountAxial > 0 )
{
glDrawArrays( GL_TRIANGLES, 0, m_vertCountAxial );
GLFunctions::getAndPrintGLError( "render stipples: opengl error" );
}
if ( m_properties["maingl"].get( Fn::Property::D_RENDER_CORONAL ).toBool() && m_vertCountCoronal > 0 )
{
program->setUniformValue( "u_aVec", 1., 0., 0. );
program->setUniformValue( "u_bVec", 0., 0., 1. );
program->setUniformValue( "u_orient", 1 );
glDrawArrays( GL_TRIANGLES, m_vertCountAxial, m_vertCountCoronal );
GLFunctions::getAndPrintGLError( "render stipples: opengl error" );
}
if ( m_properties["maingl"].get( Fn::Property::D_RENDER_SAGITTAL ).toBool() && m_vertCountSagittal > 0 )
{
program->setUniformValue( "u_aVec", 0., 1., 0. );
program->setUniformValue( "u_bVec", 0., 0., 1. );
program->setUniformValue( "u_orient", 2 );
glDrawArrays( GL_TRIANGLES, m_vertCountAxial + m_vertCountCoronal, m_vertCountSagittal );
GLFunctions::getAndPrintGLError( "render stipples: opengl error" );
}
}
if ( ( m_stripeVertCountAxial + m_stripeVertCountCoronal + m_stripeVertCountSagittal ) > 0 )
{
program->bind();
intptr_t offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, vbo2 );
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
GLFunctions::f->glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (const void *) offset );
offset += sizeof(float) * 3;
int offsetLocation = program->attributeLocation( "a_vec" );
program->enableAttributeArray( offsetLocation );
GLFunctions::f->glVertexAttribPointer( offsetLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (const void *) offset );
offset += sizeof(float) * 3;
int dirLocation = program->attributeLocation( "a_dir2" );
program->enableAttributeArray( dirLocation );
GLFunctions::f->glVertexAttribPointer( dirLocation, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (const void *) offset );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, 0 );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, vbo3 );
int colorLocation = program->attributeLocation( "a_color" );
program->enableAttributeArray( colorLocation );
GLFunctions::f->glVertexAttribPointer( colorLocation, 4, GL_FLOAT, GL_FALSE, 0, 0 );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, 0 );
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", pMatrix * mvMatrix );
program->setUniformValue( "u_scaling", 1.0f );
program->setUniformValue( "u_alpha", 1.0f );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
program->setUniformValue( "u_aVec", 1., 0., 0. );
program->setUniformValue( "u_bVec", 0., 1., 0. );
program->setUniformValue( "u_orient", 0 );
program->setUniformValue( "u_glyphThickness", m_properties["maingl"].get( Fn::Property::D_ISOLINE_STRIPES_WIDTH ).toFloat() );
program->setUniformValue( "u_glyphSize", m_properties["maingl"].get( Fn::Property::D_STIPPLE_GLYPH_SIZE ).toFloat() );
program->setUniformValue( "u_constantThickness", true );
if ( m_properties["maingl"].get( Fn::Property::D_RENDER_AXIAL ).toBool() && m_stripeVertCountAxial > 0 )
{
glDrawArrays( GL_TRIANGLES, 0, m_stripeVertCountAxial );
GLFunctions::getAndPrintGLError( "render stipples: opengl error" );
}
if ( m_properties["maingl"].get( Fn::Property::D_RENDER_CORONAL ).toBool() && m_stripeVertCountCoronal > 0 )
{
program->setUniformValue( "u_aVec", 1., 0., 0. );
program->setUniformValue( "u_bVec", 0., 0., 1. );
program->setUniformValue( "u_orient", 1 );
glDrawArrays( GL_TRIANGLES, m_stripeVertCountAxial, m_stripeVertCountCoronal );
GLFunctions::getAndPrintGLError( "render stipples: opengl error" );
}
if ( m_properties["maingl"].get( Fn::Property::D_RENDER_SAGITTAL ).toBool() && m_stripeVertCountSagittal > 0 )
{
program->setUniformValue( "u_aVec", 0., 1., 0. );
program->setUniformValue( "u_bVec", 0., 0., 1. );
program->setUniformValue( "u_orient", 2 );
glDrawArrays( GL_TRIANGLES, m_stripeVertCountAxial + m_stripeVertCountCoronal, m_stripeVertCountSagittal );
GLFunctions::getAndPrintGLError( "render stipples: opengl error" );
}
}
}
void FiberRenderer::setShaderVars( PropertyGroup& props )
{
QGLShaderProgram* program = GLFunctions::getShader( "fiber" );
program->bind();
intptr_t offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
int numFloats = 6;
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * numFloats, (const void *) offset );
offset += sizeof(float) * 3;
int normalLocation = program->attributeLocation( "a_normal" );
program->enableAttributeArray( normalLocation );
glVertexAttribPointer( normalLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * numFloats, (const void *) offset );
offset += sizeof(float) * 3;
program->setUniformValue( "u_colorMode", props.get( Fn::Property::D_COLORMODE ).toInt() );
program->setUniformValue( "u_mriSource", props.get( Fn::Property::D_STIPPLE_PROB_MASK ).toInt() );
program->setUniformValue( "u_colormap", props.get( Fn::Property::D_COLORMAP ).toInt() );
program->setUniformValue( "u_color", 1.0, 0.0, 0.0, 1.0 );
if ( props.get( Fn::Property::D_COLORMODE ).toInt() == 3 )
{
float texMin = props.get( Fn::Property::D_MIN ).toFloat();
float texMax = props.get( Fn::Property::D_MAX ).toFloat();
program->setUniformValue( "u_lowerThreshold", ( props.get( Fn::Property::D_LOWER_THRESHOLD ).toFloat() - texMin ) / ( texMax - texMin ) );
program->setUniformValue( "u_upperThreshold", ( props.get( Fn::Property::D_UPPER_THRESHOLD ).toFloat() - texMin ) / ( texMax - texMin ) );
program->setUniformValue( "u_selectedMin", ( props.get( Fn::Property::D_SELECTED_MIN ).toFloat() - texMin ) / ( texMax - texMin ) );
program->setUniformValue( "u_selectedMax", ( props.get( Fn::Property::D_SELECTED_MAX ).toFloat() - texMin ) / ( texMax - texMin ) );
}
else
{
program->setUniformValue( "u_selectedMin", props.get( Fn::Property::D_SELECTED_MIN ).toFloat() );
program->setUniformValue( "u_selectedMax", props.get( Fn::Property::D_SELECTED_MAX ).toFloat() );
program->setUniformValue( "u_lowerThreshold", props.get( Fn::Property::D_LOWER_THRESHOLD ).toFloat() );
program->setUniformValue( "u_upperThreshold", props.get( Fn::Property::D_UPPER_THRESHOLD ).toFloat() );
}
program->setUniformValue( "u_cutdx", props.get( Fn::Property::D_DX ).toFloat() );
program->setUniformValue( "u_cutdy", props.get( Fn::Property::D_DY ).toFloat() );
program->setUniformValue( "u_cutdz", props.get( Fn::Property::D_DZ ).toFloat() );
program->setUniformValue( "u_cutx", props.get( Fn::Property::D_NX ).toFloat() / 10.f );
program->setUniformValue( "u_cuty", props.get( Fn::Property::D_NY ).toFloat() / 10.f );
program->setUniformValue( "u_cutz", props.get( Fn::Property::D_NZ ).toFloat() / 10.f );
}
void DatasetPlane::draw( QMatrix4x4 pMatrix, QMatrix4x4 mvMatrix, int width, int height, int renderMode, QString target )
{
if ( !properties( target ).get( Fn::Property::D_ACTIVE ).toBool() )
{
return;
}
QVector3D h0 = m_properties["maingl"].get( Fn::Property::D_HANDLE_0 ).value<QVector3D>();
QVector3D h1 = m_properties["maingl"].get( Fn::Property::D_HANDLE_1 ).value<QVector3D>();
QVector3D h2 = m_properties["maingl"].get( Fn::Property::D_HANDLE_2 ).value<QVector3D>();
if ( m_properties["maingl"].get( Fn::Property::D_SHOW_PLANE_HANDLES ).toBool() )
{
QColor color = m_properties["maingl"].get( Fn::Property::D_HANDLE_COLOR ).value<QColor>();
color.setAlpha( 254 );
GLFunctions::renderSphere( pMatrix, mvMatrix, h0.x(), h0.y(), h0.z(), 5, 5, 5,
color, m_handle0, width, height, renderMode );
GLFunctions::renderSphere( pMatrix, mvMatrix, h1.x(), h1.y(), h1.z(), 5, 5, 5,
color, m_handle1, width, height, renderMode );
GLFunctions::renderSphere( pMatrix, mvMatrix, h2.x(), h2.y(), h2.z(), 5, 5, 5,
color, m_handle2, width, height, renderMode );
}
if ( dirty )
{
initGeometry();
}
float alpha = GLFunctions::sliceAlpha[target];
switch ( renderMode )
{
case 0:
break;
case 1:
{
if ( alpha < 1.0 ) // obviously not opaque
{
return;
}
break;
}
default:
{
if ( alpha == 1.0 ) // not transparent
{
return;
}
break;
}
}
if ( !GLFunctions::setupTextures() )
{
return;
}
QGLShaderProgram* program = GLFunctions::getShader( "slice" );
program->bind();
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, vbo0 );
intptr_t offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
GLFunctions::f->glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (const void *) offset );
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", pMatrix * mvMatrix );
program->setUniformValue( "u_alpha", alpha );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
GLFunctions::setTextureUniforms( program, target );
// Draw cube geometry using indices from VBO 0
glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
GLFunctions::f->glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
void SliceRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, QString target )
{
float alpha = GLFunctions::sliceAlpha[target];
switch ( renderMode )
{
case 0:
break;
case 1:
{
if ( alpha < 1.0 ) // obviously not opaque
{
return;
}
break;
}
default:
{
if ( alpha == 1.0 ) // not transparent
{
return;
}
break;
}
}
if ( !GLFunctions::setupTextures() )
{
return;
}
QGLShaderProgram* program = GLFunctions::getShader( "slice" );
program->bind();
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
program->setUniformValue( "u_alpha", alpha );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
float pAlpha = 1.0;
float green = 0.0f;
float red = 0.0f;
initGeometry();
if ( Models::getGlobal( Fn::Property::G_SHOW_AXIAL ).toBool() )
{
float blue = (float)(( 1 ) & 0xFF) / 255.f;
GLFunctions::getShader( "slice" )->setUniformValue( "u_pickColor", red, green , blue, pAlpha );
drawAxial( target );
}
if ( Models::getGlobal( Fn::Property::G_SHOW_CORONAL ).toBool() )
{
float blue = (float)(( 2 ) & 0xFF) / 255.f;
GLFunctions::getShader( "slice" )->setUniformValue( "u_pickColor", red, green , blue, pAlpha );
drawCoronal( target );
}
if ( Models::getGlobal( Fn::Property::G_SHOW_SAGITTAL ).toBool() )
{
float blue = (float)(( 3 ) & 0xFF) / 255.f;
GLFunctions::getShader( "slice" )->setUniformValue( "u_pickColor", red, green , blue, pAlpha );
drawSagittal( target );
}
}
void FiberRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, PropertyGroup& props )
{
float alpha = props.get( Fn::Property::D_ALPHA ).toFloat();
if ( renderMode == 0 ) // picking
{
return;
}
else if ( renderMode == 1 ) // we are drawing opaque objects
{
if ( alpha < 1.0 )
{
// obviously not opaque
return;
}
}
else // we are drawing tranparent objects
{
if ( !(alpha < 1.0 ) )
{
// not transparent
return;
}
}
if ( m_updateExtraData )
{
updateExtraData( m_selectedExtraData );
}
QGLShaderProgram* program = GLFunctions::getShader( "fiber" );
program->bind();
GLFunctions::setupTextures();
GLFunctions::setTextureUniforms( GLFunctions::getShader( "fiber" ), "maingl" );
// Set modelview-projection matrix
program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
program->setUniformValue( "mv_matrixInvert", mv_matrix.inverted() );
program->setUniformValue( "mv_matrixTI", mv_matrix.transposed().inverted() );
program->setUniformValue( "userTransformMatrix", props.get( Fn::Property::D_TRANSFORM ).value<QMatrix4x4>() );
initGeometry();
glBindBuffer( GL_ARRAY_BUFFER, vbo );
setShaderVars( props );
glBindBuffer( GL_ARRAY_BUFFER, dataVbo );
int extraLocation = program->attributeLocation( "a_extra" );
program->enableAttributeArray( extraLocation );
glVertexAttribPointer( extraLocation, 1, GL_FLOAT, GL_FALSE, sizeof(float), 0 );
glBindBuffer( GL_ARRAY_BUFFER, indexVbo );
int indexLocation = program->attributeLocation( "a_indexes" );
program->enableAttributeArray( indexLocation );
glVertexAttribPointer( indexLocation, 1, GL_FLOAT, GL_FALSE, sizeof(float), 0 );
program->setUniformValue( "u_alpha", alpha );
program->setUniformValue( "u_renderMode", renderMode );
program->setUniformValue( "u_canvasSize", width, height );
program->setUniformValue( "D0", 9 );
program->setUniformValue( "D1", 10 );
program->setUniformValue( "D2", 11 );
program->setUniformValue( "P0", 12 );
program->setUniformValue( "C5", 13 );
program->setUniformValue( "u_fibGrowth", props.get( Fn::Property::D_FIBER_GROW_LENGTH).toFloat() );
program->setUniformValue( "u_lighting", props.get( Fn::Property::D_LIGHT_SWITCH ).toBool() );
program->setUniformValue( "u_lightAmbient", props.get( Fn::Property::D_LIGHT_AMBIENT ).toFloat() );
program->setUniformValue( "u_lightDiffuse", props.get( Fn::Property::D_LIGHT_DIFFUSE ).toFloat() );
program->setUniformValue( "u_materialAmbient", props.get( Fn::Property::D_MATERIAL_AMBIENT ).toFloat() );
program->setUniformValue( "u_materialDiffuse", props.get( Fn::Property::D_MATERIAL_DIFFUSE ).toFloat() );
program->setUniformValue( "u_materialSpecular", props.get( Fn::Property::D_MATERIAL_SPECULAR ).toFloat() );
program->setUniformValue( "u_materialShininess", props.get( Fn::Property::D_MATERIAL_SHININESS ).toFloat() );
glLineWidth( props.get( Fn::Property::D_FIBER_THICKNESS ).toFloat() );
std::vector<bool>*selected = m_selector->getSelection();
int percent = props.get( Fn::Property::D_FIBER_THIN_OUT ).toFloat() * 10;
for ( unsigned int i = 0; i < m_fibs->size(); ++i )
{
if ( ( i % 1000 ) > percent )
{
continue;
}
if ( selected->at( i ) )
{
QColor c = m_fibs->at( i ).customColor();
program->setUniformValue( "u_color", c.redF(), c.greenF(), c.blueF(), 1.0 );
c = m_fibs->at( i ).globalColor();
program->setUniformValue( "u_globalColor", c.redF(), c.greenF(), c.blueF(), 1.0 );
glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
}
else
{
if ( Models::getGlobal( Fn::Property::G_UNSELECTED_FIBERS_GREY ).toBool() )
{
program->setUniformValue( "u_color", .4f, .4f, .4f, 1.0 );
program->setUniformValue( "u_globalColor", .4f, .4f, .4f, 1.0 );
glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
}
}
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
void GLWidget::drawPoint(const Vector& pos, float r, float g, float b)
{
static bool created = false;
static QGLShaderProgram program;
static GLuint VAO;
if (!created)
{
created = true;
// 1. Create shaders
QGLShader vs(QGLShader::Vertex);
vs.compileSourceCode("#version 330 core \n in vec3 vertex; in vec3 color; uniform mat4 modelViewProjectionMatrix; out vec4 frontColor; void main() { frontColor = vec4(color,1); gl_Position = modelViewProjectionMatrix * vec4(vertex, 1.0); }");
QGLShader fs(QGLShader::Fragment);
fs.compileSourceCode("#version 330 core \n in vec4 frontColor; out vec4 FragColor; void main() {FragColor = frontColor;}");
program.addShader(&vs);
program.addShader(&fs);
program.link();
// Get location of VS attributes
GLuint vertexLoc = program.attributeLocation("vertex");
GLuint colorLoc = program.attributeLocation("color");
// 2. Create VBO Buffers
// Create & bind empty VAO
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
// Create VBO with (x,y,z) coordinates
float coords[] = { 0, 0, 0};
GLuint VBO_coords;
glGenBuffers(1, &VBO_coords);
glBindBuffer(GL_ARRAY_BUFFER, VBO_coords);
glBufferData(GL_ARRAY_BUFFER, sizeof(coords), coords, GL_STATIC_DRAW);
glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(vertexLoc);
// Create VBO with (r,g,b) color
float colors[] = {r, g, b};
GLuint VBO_colors;
glGenBuffers(1, &VBO_colors);
glBindBuffer(GL_ARRAY_BUFFER, VBO_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
glVertexAttribPointer(colorLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(colorLoc);
glBindVertexArray(0);
}
program.bind();
// 1. Define uniforms
QMatrix4x4 T;
T.translate(pos);
QMatrix4x4 MVP = camera()->projectionMatrix() * camera()->modelviewMatrix()*T;
program.setUniformValue("modelViewProjectionMatrix", MVP);
// 2. Draw
glPointSize(8);
glBindVertexArray (VAO);
glDrawArrays(GL_POINTS, 0, 1);
glBindVertexArray(0);
program.release();
}
void GLWidget::drawAxes()
{
float L = 1;
static bool created = false;
static QGLShaderProgram program;
static GLuint VAO_axes;
if (!created)
{
created = true;
// 1. Create shaders
// VS
QGLShader vs(QGLShader::Vertex);
vs.compileSourceCode("#version 330 core \n in vec3 vertex; in vec3 color; uniform mat4 modelViewProjectionMatrix; out vec4 frontColor; void main() { frontColor = vec4(color,1); gl_Position = modelViewProjectionMatrix * vec4(vertex, 1.0); }");
// FS
QGLShader fs(QGLShader::Fragment);
fs.compileSourceCode("#version 330 core \n in vec4 frontColor; out vec4 FragColor; void main() {FragColor = frontColor;}");
// Program
program.addShader(&vs);
program.addShader(&fs);
program.link();
// Get location of VS attributes
GLuint vertexLoc = program.attributeLocation("vertex");
GLuint colorLoc = program.attributeLocation("color");
// 2. Create VBO Buffers
// Create & bind empty VAO
glGenVertexArrays(1, &VAO_axes);
glBindVertexArray(VAO_axes);
// Create VBO with (x,y,z) coordinates
float coords[] = { 0, 0, 0,
L, 0, 0,
0, 0, 0,
0, L, 0,
0, 0, 0,
0, 0, L};
GLuint VBO_coords;
glGenBuffers(1, &VBO_coords);
glBindBuffer(GL_ARRAY_BUFFER, VBO_coords);
glBufferData(GL_ARRAY_BUFFER, sizeof(coords), coords, GL_STATIC_DRAW);
glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(vertexLoc);
// Create VBO with (r,g,b) color
float colors[] = {1, 0, 0, 1, 0, 0,
0, 1, 0, 0, 1, 0,
0, 0, 1, 0, 0, 1};
GLuint VBO_colors;
glGenBuffers(1, &VBO_colors);
glBindBuffer(GL_ARRAY_BUFFER, VBO_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
glVertexAttribPointer(colorLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(colorLoc);
glBindVertexArray(0);
}
program.bind();
// 1. Define uniforms
float r = max(MIN_AXES_LENGTH, scene()->boundingBox().radius());
QMatrix4x4 scale;
scale.scale(r,r,r);
QMatrix4x4 MVP = camera()->projectionMatrix() * camera()->modelviewMatrix()*scale;
program.setUniformValue("modelViewProjectionMatrix", MVP);
// 2. Draw
glBindVertexArray (VAO_axes);
glDrawArrays(GL_LINES, 0, 6);
glBindVertexArray(0);
program.release();
// 5. CleanUp
/*
glDeleteVertexArrays(1, &VAO_axes);
glDeleteBuffers(1, &VBO_coords);
glDeleteBuffers(1, &VBO_colors);
*/
/*
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
glColor3f(1,0,0); glVertex3f(0,0,0); glVertex3f(L,0,0); // X
glColor3f(0,1,0); glVertex3f(0,0,0); glVertex3f(0,L,0); // Y
glColor3f(0,0,1); glVertex3f(0,0,0); glVertex3f(0,0,L); // Z
glEnd();
glEnable(GL_LIGHTING);
*/
}
void GLWidget::paintGL()
{
GLenum errCode;
// First pass for shadowmapping
QGLShaderProgram * p;
Camera * cam;
Light * light;
if (this->debugMode != 3) {
for (int i = 0; i < this->_lights.size(); i++) {
light = this->_lights.at(i);
if (!light->initializedFBO) {
light->initializeShadowFBO(QSize(this->_screenWidth, this->_screenHeight));
return;
}
if (this->debugMode != 4) {
light->bindFBO();
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glCullFace(GL_FRONT);
if (this->debugMode == 4) {
p = this->_program;
p = this->_shadowProgram;
} else {
glViewport(0,0, this->_screenWidth/2, this->_screenHeight/2);
p = this->_shadowProgram;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cam = this->_lights.at(i)->camera;
p->bind();
// wont be used in shadow program
p->setUniformValue("debug_mode", 4);
cam->injectToShader(p);
for (int i = 0; i < this->_objects.size(); i++) {
this->_objects.at(i)->injectToShader(p);
}
if (this->debugMode == 4) {
p->release();
return;
}
light->releaseFBO();
p->release();
}
}
if (this->showDebug) {
// DEBUG only. this piece of code draw the depth buffer onscreen
glBindFramebuffer(GL_FRAMEBUFFER,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
this->_shadowProgram->release();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-this->_screenWidth/2, this->_screenWidth/2, -this->_screenHeight/2, this->_screenHeight/2, 1, 60);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(1,1,1,1);
this->_lights.at(0)->bindDebugShadowMap();
glEnable(GL_TEXTURE_2D);
glTranslated(0,0,-1);
glBegin(GL_QUADS);
glTexCoord2d(0,0);glVertex3f(0,0,0);
glTexCoord2d(1,0);glVertex3f(_screenWidth/2,0,0);
glTexCoord2d(1,1);glVertex3f(_screenWidth/2,_screenHeight/2,0);
glTexCoord2d(0,1);glVertex3f(0,_screenHeight/2,0);
glEnd();
glDisable(GL_TEXTURE_2D);
//glutSwapBuffers();
return;
}
// Second pass
p = this->_program;
cam = this->camera;
glViewport(0,0, this->_screenWidth, this->_screenHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if ((errCode = glGetError()) != GL_NO_ERROR) {
qDebug() << "GLWidget::draw after clear: " << errCode;
}
p->bind();
cam->injectToShader(p);
if ((errCode = glGetError()) != GL_NO_ERROR) {
qDebug() << "GLWidget::draw after cam: " << errCode;
}
p->setUniformValue("debug_mode", this->debugMode);
for (int i = 0; i < this->_lights.size(); i++) {
this->_lights.at(i)->injectToShader(p, i);
}
for (int i = 0; i < this->_objects.size(); i++) {
this->_objects.at(i)->injectToShader(p);
}
this->_program->release();
if ((errCode = glGetError()) != GL_NO_ERROR) {
qDebug() << "GLWidget after 2nd pas: " << errCode;
}
}
void View::renderScene()
{
QGLShaderProgram *shader = m_shaderPrograms["snow"];
// Render the wireframes if enabled
if( m_isWireframe ) {
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
for(vector<SceneObject *>::iterator it = m_objects.begin(); it != m_objects.end(); it++) {
(*it)->render(m_useVbo);
}
}
// Render the solid scene
if( m_isSolid ) {
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
// Enable cube maps and draw the skybox
if( m_showSkybox )
{
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_cubeMap);
GLuint sky = ResourceLoader::loadSkybox();
glCallList(sky);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
glDisable(GL_TEXTURE_CUBE_MAP);
glEnable(GL_LIGHTING);
}
for(vector<SceneObject *>::iterator it = m_objects.begin(); it != m_objects.end(); it++) {
SceneObject *obj = *it;
if(m_useShader){
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
shader->bind();
shader->setUniformValue("snowTexture", 1);
shader->setUniformValue("snowDisplacement", 2);
shader->setUniformValue("localTexture", 3);
shader->setUniformValue("snowSurfaceTexture", 4);
shader->setUniformValue("useDisplacement", m_useDisplacement);
Vector4 color = obj->getColor();
shader->setUniformValue("color",color.x, color.y, color.z, color.w);
Vector3 scale = obj->getOriginalScale();
shader->setUniformValue("scale",scale.x, scale.y, scale.z);
shader->setUniformValue("tesselationParam", obj->getShape()->getParamOne());
// Set the blur data
int radius = 6;
int dim = radius * 2 + 1;
GLfloat kernel[dim * dim];
GLfloat offsets[dim * dim * 2];
GLfloat ambientAry[4] = {0.7, 0.7, 0.7, 1.0};
GLfloat diffuseAry[4] = {color.x, color.y, color.z, color.w};
GLfloat specularAry[4] = {0.9, 0.9, 0.9, 0.0};
GLfloat m = 0.55;
GLfloat r0 = 0.7;
ShaderAssistant::createBlurKernel(radius, width(), height(), &kernel[0], &offsets[0]);
shader->setUniformValue("arraySize", dim * dim);
shader->setUniformValueArray("offsets", offsets, 2 * dim * dim, 2);
shader->setUniformValueArray("ambient", ambientAry, 1, 4);
shader->setUniformValueArray("diffuse", diffuseAry, 1, 4);
shader->setUniformValueArray("specular", specularAry, 1, 4);
shader->setUniformValue("m", m);
shader->setUniformValue("r0", r0);
// Displacement
ResourceLoader::reloadHeightMapTexture(obj->getDisplacementMap(),obj->getDisplacementMapId());
glActiveTexture(GL_TEXTURE2);
//glUniform1i(glGetUniformLocation(shader->programId(), "snowDisplacement"), 0);
glBindTexture(GL_TEXTURE_2D,obj->getDisplacementMapId());
// Bump
glActiveTexture(GL_TEXTURE1);
//QImage img = QGLWidget::convertToGLFormat((* obj->getBumpMap()).mirrored(false,true));
if(!m_usePbo){
ResourceLoader::reloadHeightMapTexture(obj->getBumpMap(),obj->getBumpMapId());
glBindTexture(GL_TEXTURE_2D,obj->getBumpMapId());
}else{
m_pboIndexA = (m_pboIndexA + 1) % 2;
m_pboIndexB = (m_pboIndexA + 1) % 2;
glBindTexture(GL_TEXTURE_2D,obj->getBumpMapId());
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, obj->getPboBuffers()[m_pboIndexA]);
//PBO -> Texture
int width = obj->getBumpMap()->width();
int height = obj->getBumpMap()->height();
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, height, width, GL_BGRA, GL_UNSIGNED_BYTE, 0);
int imgSize = width * height* sizeof(BGRA);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, obj->getPboBuffers()[m_pboIndexB]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, imgSize, 0, GL_STREAM_DRAW_ARB);
GLubyte* ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB);
if(ptr){
unsigned char *pixel = (unsigned char *)ptr;
/*for (int i = 0; i < img.height(); i++) {
memcpy(pixel, img.scanLine(i), img.bytesPerLine());
pixel += img.bytesPerLine();
}*/
memcpy(pixel, obj->getBumpMap()->bits(), obj->getBumpMap()->byteCount());
glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
}
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
}
if( obj->getColorTexture() != 0 ) {
shader->setUniformValue("useLocalTexture", true);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, obj->getColorTexture());
} else {
shader->setUniformValue("useLocalTexture", false);
}
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, m_snowTextureId);
glActiveTexture(GL_TEXTURE0);
}
(*it)->render(m_useVbo);
if( m_useShader )
{
shader->release();
glBindTexture(GL_TEXTURE_2D,0);
glDisable(GL_BLEND);
}
}
}
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
}
void QGLTextureGlyphCache::resizeTextureData(int width, int height)
{
if (ctx == 0) {
qWarning("QGLTextureGlyphCache::resizeTextureData: Called with no context");
return;
}
QGLGlyphTexture *glyphTexture = m_textureResource.value(ctx);
int oldWidth = glyphTexture->m_width;
int oldHeight = glyphTexture->m_height;
// Make the lower glyph texture size 16 x 16.
if (width < 16)
width = 16;
if (height < 16)
height = 16;
GLuint oldTexture = glyphTexture->m_texture;
createTextureData(width, height);
if (ctx->d_ptr->workaround_brokenFBOReadBack) {
QImageTextureGlyphCache::resizeTextureData(width, height);
Q_ASSERT(image().depth() == 8);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
glDeleteTextures(1, &oldTexture);
return;
}
// ### the QTextureGlyphCache API needs to be reworked to allow
// ### resizeTextureData to fail
glBindFramebuffer(GL_FRAMEBUFFER_EXT, glyphTexture->m_fbo);
GLuint tmp_texture;
glGenTextures(1, &tmp_texture);
glBindTexture(GL_TEXTURE_2D, tmp_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
m_filterMode = Nearest;
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, tmp_texture, 0);
glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
glBindTexture(GL_TEXTURE_2D, oldTexture);
if (pex != 0)
pex->transferMode(BrushDrawingMode);
glDisable(GL_STENCIL_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glViewport(0, 0, oldWidth, oldHeight);
QGLShaderProgram *blitProgram = 0;
if (pex == 0) {
if (m_blitProgram == 0) {
m_blitProgram = new QGLShaderProgram(ctx);
{
QString source;
source.append(QLatin1String(qglslMainWithTexCoordsVertexShader));
source.append(QLatin1String(qglslUntransformedPositionVertexShader));
QGLShader *vertexShader = new QGLShader(QGLShader::Vertex, m_blitProgram);
vertexShader->compileSourceCode(source);
m_blitProgram->addShader(vertexShader);
}
{
QString source;
source.append(QLatin1String(qglslMainFragmentShader));
source.append(QLatin1String(qglslImageSrcFragmentShader));
QGLShader *fragmentShader = new QGLShader(QGLShader::Fragment, m_blitProgram);
fragmentShader->compileSourceCode(source);
m_blitProgram->addShader(fragmentShader);
}
m_blitProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
m_blitProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
m_blitProgram->link();
}
glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_vertexCoordinateArray);
glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_textureCoordinateArray);
m_blitProgram->bind();
m_blitProgram->enableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
m_blitProgram->enableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
m_blitProgram->disableAttributeArray(int(QT_OPACITY_ATTR));
blitProgram = m_blitProgram;
} else {
pex->setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, m_vertexCoordinateArray);
pex->setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, m_textureCoordinateArray);
pex->shaderManager->useBlitProgram();
blitProgram = pex->shaderManager->blitProgram();
}
blitProgram->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindTexture(GL_TEXTURE_2D, glyphTexture->m_texture);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, 0);
glDeleteTextures(1, &tmp_texture);
glDeleteTextures(1, &oldTexture);
glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
if (pex != 0) {
glViewport(0, 0, pex->width, pex->height);
pex->updateClipScissorTest();
}
}
void PerspectiveView::glPass(GLResourceContext &ctx)
{
glEnable(GL_DEPTH_TEST);
QMatrix4x4 cameraProjM = _camera->getProjMatrix(width(), height());
QMatrix4x4 cameraViewM = _camera->getViewMatrix(width(), height());
QMatrix4x4 cameraProjViewM = cameraProjM * cameraViewM;
QMatrix4x4 objToWorld;
Scene* scene = Scene::activeScene();
// render each mesh
QHashIterator<QString,Mesh*> meshes = scene->meshes();
while (meshes.hasNext()) {
meshes.next();
Mesh* mesh = meshes.value();
// make sure a texture exists for this mesh
if (!hasMeshTexture(mesh)) {
std::cout << "creating mesh texture" << std::endl;
QOpenGLFramebufferObject* transferFbo = ctx.transferFbo();
transferFbo->bind();
GLuint textureId;
glGenTextures(1, &textureId);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glClearColor(.5,.5,.5,1);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,1,0,1,-1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, 256, 256);
glColor3f(.8,.8,.8);
glBegin(GL_QUADS);
{
glVertex2f(.25,.25);
glVertex2f(.75,.25);
glVertex2f(.75,.75);
glVertex2f(.25,.75);
}
glEnd();
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 256, 256, 0);
transferFbo->release();
//glActiveTexture(GL_TEXTURE0);
//QImage img("/tmp/lena.jpg");
//QImage image = QGLWidget::convertToGLFormat(img);
//glTexSubImage2D(GL_TEXTURE_2D, 0, 0,0 , image.width(), image.height(), GL_RGB, GL_UNSIGNED_BYTE, image.bits() );
glViewport(0, 0, width(), height());
setMeshTexture(mesh, textureId);
}
QOpenGLFramebufferObject* paintFbo = ctx.paintFbo();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, meshTexture(mesh));
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, paintFbo->texture());
glActiveTexture(GL_TEXTURE0);
QGLShaderProgram* meshShader = ctx.meshShader();
meshShader->bind();
meshShader->setUniformValue("objToWorld", objToWorld);
meshShader->setUniformValue("cameraPV", cameraProjViewM);
meshShader->setUniformValue("paintFboWidth", PAINT_FBO_WIDTH);
meshShader->setUniformValue("brushColor", _brushColor.redF(), _brushColor.greenF(), _brushColor.blueF(), 1);
meshShader->setUniformValue("meshTexture", 0);
meshShader->setUniformValue("paintTexture", 1);
renderMesh(mesh);
meshShader->release();
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrixf(cameraProjM.data());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf(cameraViewM.data());
glBegin(GL_LINES);
for (int i = -10; i <= 10; i++) {
glVertex3f(-10, 0, i);
glVertex3f(10, 0, i);
}
glEnd();
glDisable(GL_DEPTH_TEST);
drawPaintStrokes(ctx);
if (_bakePaintLayer) {
bakePaintLayer(ctx);
}
}
