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 SliceRenderer::setShaderVars( QString target )
{
QGLShaderProgram* program = GLFunctions::getShader( "slice" );
int vertexLocation = program->attributeLocation( "a_position" );
program->enableAttributeArray( vertexLocation );
glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0 );
GLFunctions::setTextureUniforms( program, target );
}
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 BinghamRenderer::setShaderVars( PropertyGroup& props )
{
QGLShaderProgram* program = GLFunctions::getShader( "qball" );
program->bind();
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, sizeof(float) * 7, (const void *) offset );
offset += sizeof(float) * 3;
int offsetLocation = program->attributeLocation( "a_offset" );
program->enableAttributeArray( offsetLocation );
glVertexAttribPointer( offsetLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 7, (const void *) offset );
offset += sizeof(float) * 3;
int radiusLocation = program->attributeLocation( "a_radius" );
program->enableAttributeArray( radiusLocation );
glVertexAttribPointer( radiusLocation, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 7, (const void *) offset );
}
void AxisRenderer::render(const AxisCamera &camera, QGLShaderProgram &program, QGLBuffer &vertBuffer, QGLBuffer &indexBuffer, bool selected)
{
qDebug()<<"[AxisRender] start of render";
initializeGLFunctions();
//bind the program for use
if(!program.bind()){
QMessageBox::critical(0, "Error", "Could not bind program for use");
qFatal("Could not bind program for use");
}
qDebug()<<"[AxisRender] Drawing";
//set up shader locations
program.bind();
GLint vertLoc = program.attributeLocation("vertex");
Q_ASSERT(vertLoc != -1);
GLint colorLoc = program.uniformLocation("color");
Q_ASSERT(colorLoc != -1);
GLint mvpLoc = program.uniformLocation("modelToCamera");
Q_ASSERT(mvpLoc != -1);
//set default color to a cyan
QVector4D color(0.0f, .5f, 1.0f, 1.0f);
//modify the color for selected geometry
if(selected){
qDebug()<<"[AxisRender] adding selection color";
color = color + QVector4D(1.0f, 0.0f, 0.0f, 0.0f);
}
//set the uniform values
program.setUniformValueArray(colorLoc, &color, 1);
program.setUniformValueArray(mvpLoc, &camera.getProjMatrix(), 1);
//bind and set the vertex buffer for attribute
vertBuffer.bind();
program.enableAttributeArray(vertLoc);
program.setAttributeBuffer(vertLoc, GL_FLOAT, 0, 4);
//bind the index buffer for the draw call
indexBuffer.bind();
qDebug()<<"[AxisRender] Drawing";
//draw the index buffer NOTE: Hard set to 24 values for a box!
glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT, NULL);
}
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 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 );
}
bool GLWidgetRendererPrivate::prepareShaderProgram(const VideoFormat &fmt, ColorTransform::ColorSpace cs)
{
// isSupported(pixfmt)
if (!fmt.isValid())
return false;
releaseShaderProgram();
video_format.setPixelFormatFFmpeg(fmt.pixelFormatFFmpeg());
colorTransform.setInputColorSpace(cs);
// TODO: only to kinds, packed.glsl, planar.glsl
QString frag;
if (fmt.isPlanar()) {
frag = getShaderFromFile("shaders/planar.f.glsl");
} else {
frag = getShaderFromFile("shaders/rgb.f.glsl");
}
if (frag.isEmpty())
return false;
if (fmt.isRGB()) {
frag.prepend("#define INPUT_RGB\n");
} else {
frag.prepend(QString("#define YUV%1P\n").arg(fmt.bitsPerPixel(0)));
}
if (fmt.isPlanar() && fmt.bytesPerPixel(0) == 2) {
if (fmt.isBigEndian())
frag.prepend("#define LA_16BITS_BE\n");
else
frag.prepend("#define LA_16BITS_LE\n");
}
if (cs == ColorTransform::BT601) {
frag.prepend("#define CS_BT601\n");
} else if (cs == ColorTransform::BT709) {
frag.prepend("#define CS_BT709\n");
}
#if NO_QGL_SHADER
program = createProgram(kVertexShader, frag.toUtf8().constData());
if (!program) {
qWarning("Could not create shader program.");
return false;
}
// vertex shader. we can set attribute locations calling glBindAttribLocation
a_Position = glGetAttribLocation(program, "a_Position");
a_TexCoords = glGetAttribLocation(program, "a_TexCoords");
u_matrix = glGetUniformLocation(program, "u_MVP_matrix");
u_bpp = glGetUniformLocation(program, "u_bpp");
u_opacity = glGetUniformLocation(program, "u_opacity");
// fragment shader
u_colorMatrix = glGetUniformLocation(program, "u_colorMatrix");
#else
if (!shader_program->addShaderFromSourceCode(QGLShader::Vertex, kVertexShader)) {
qWarning("Failed to add vertex shader: %s", shader_program->log().toUtf8().constData());
return false;
}
if (!shader_program->addShaderFromSourceCode(QGLShader::Fragment, frag)) {
qWarning("Failed to add fragment shader: %s", shader_program->log().toUtf8().constData());
return false;
}
if (!shader_program->link()) {
qWarning("Failed to link shader program...%s", shader_program->log().toUtf8().constData());
return false;
}
// vertex shader
a_Position = shader_program->attributeLocation("a_Position");
a_TexCoords = shader_program->attributeLocation("a_TexCoords");
u_matrix = shader_program->uniformLocation("u_MVP_matrix");
u_bpp = shader_program->uniformLocation("u_bpp");
u_opacity = shader_program->uniformLocation("u_opacity");
// fragment shader
u_colorMatrix = shader_program->uniformLocation("u_colorMatrix");
#endif //NO_QGL_SHADER
qDebug("glGetAttribLocation(\"a_Position\") = %d\n", a_Position);
qDebug("glGetAttribLocation(\"a_TexCoords\") = %d\n", a_TexCoords);
qDebug("glGetUniformLocation(\"u_MVP_matrix\") = %d\n", u_matrix);
qDebug("glGetUniformLocation(\"u_bpp\") = %d\n", u_bpp);
qDebug("glGetUniformLocation(\"u_opacity\") = %d\n", u_opacity);
qDebug("glGetUniformLocation(\"u_colorMatrix\") = %d\n", u_colorMatrix);
if (fmt.isRGB())
u_Texture.resize(1);
else
u_Texture.resize(fmt.channels());
for (int i = 0; i < u_Texture.size(); ++i) {
QString tex_var = QString("u_Texture%1").arg(i);
#if NO_QGL_SHADER
u_Texture[i] = glGetUniformLocation(program, tex_var.toUtf8().constData());
#else
u_Texture[i] = shader_program->uniformLocation(tex_var);
#endif
qDebug("glGetUniformLocation(\"%s\") = %d\n", tex_var.toUtf8().constData(), u_Texture[i]);
}
return true;
}
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 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 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 );
}
