/// @overload QGLWidget
void paintGL(){
vao.bind();
program.bind();
{
///--- Update modelview
#ifdef WITH_QGLVIEWER
/// use the trackball to specify the matrices
setup_modelview(camera(), program);
#else
///--- simple unit cube orthographic view
static Eigen::Matrix4f M = Eigen::Matrix4f::Identity();
static Eigen::Matrix4f P = Eigen::ortho(-1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f);
static Eigen::Matrix4f V = Eigen::Matrix4f::Identity();
static Eigen::Matrix4f MV = V*M;
static Eigen::Matrix4f MVP = P*MV;
GLint MVP_id = glGetUniformLocation(program.programId(), "MVP");
glUniformMatrix4fv(MVP_id, 1, GL_FALSE, MVP.data());
GLint MV_id = glGetUniformLocation(program.programId(), "MV");
glUniformMatrix4fv(MV_id, 1, GL_FALSE, MV.data());
#endif
///--- clear & draw
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glDrawElements(GL_TRIANGLES, triangles.size(), GL_UNSIGNED_INT, 0);
}
vao.release();
program.release();
}
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 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 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 Exercise20::paintGL()
{
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
QGLShaderProgram* currentProg;
if (m_shadingMode == Toon_Shading)
{
currentProg = m_prog_toon;
}
else
{
currentProg = m_prog_phong;
}
currentProg->bind();
setupLightUniforms(currentProg);
setupMaterialUniforms(currentProg);
glLoadMatrixf(m_view.data());
glPushMatrix();
glRotatef(static_cast<float>(m_frame % (4 * 360)) * 0.25f, 0.f, 1.f, 0.f);
glScalef(1.f, 1.f, 1.f);
draw();
glPopMatrix();
currentProg->release();
}
/// @overload QGLWidget
void paintGL(){
program.bind();
vao.bind();
glClear(GL_COLOR_BUFFER_BIT);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); ///< we have 4 verts
vao.release();
program.release();
}
// --------------------------------------------------------
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();
}
/// @overload QGLWidget
void initializeGL(){
printf("OpenGL %d.%d\n",this->format().majorVersion(),this->format().minorVersion());
///--- Create an array object to store properties
{
bool success = vao.create();
Q_ASSERT(success);
vao.bind();
}
///--- Load/compile shaders
{
bool vok = program.addShaderFromSourceCode(QGLShader::Vertex, vshader);
bool fok = program.addShaderFromSourceCode(QGLShader::Fragment, fshader);
bool lok = program.link ();
Q_ASSERT(lok && vok && fok);
bool success = program.bind();
Q_ASSERT(success);
}
///--- Create vertex buffer/attributes "position"
{
static float vertices[] = {
-1.0000,-1.0000,+0.0000,
+1.0000,-1.0000,+0.0000,
-1.0000,+1.0000,+0.0000,
+1.0000,+1.0000,+0.0000,};
vertexbuffer = QGLBuffer(QGLBuffer::VertexBuffer);
bool success = vertexbuffer.create();
Q_ASSERT(success);
vertexbuffer.setUsagePattern( QGLBuffer::StaticDraw );
success = vertexbuffer.bind();
Q_ASSERT(success);
vertexbuffer.allocate( vertices, sizeof(vertices) );
program.setAttributeBuffer("position", GL_FLOAT, 0, 3 );
program.enableAttributeArray("position");
}
///--- Unbind to avoid pollution
vao.release();
program.release();
///--- Background
glClearColor(1.0, 1.0, 1.0, 1.0);
///--- Setup opengl flags
glDisable(GL_DEPTH_TEST);
}
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 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 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 );
}
void AxisRenderer::drawBrush(const M3DEditLevel::Box &brush, QGLShaderProgram &program, const AxisCamera &camera)
{
QVector<QVector3D> temp = brush.getVerticies();
QVector<GLfloat> verts;
//fill vector with brush verticies
for(int i = 0; i < temp.size(); ++i){
QVector3D vert = temp[i];
verts.push_back(vert.x());
verts.push_back(vert.y());
verts.push_back(vert.z());
verts.push_back(1.0f);
}
QVector<unsigned int> indicies = brush.getLineIndex();
//bind brush buffer and fill with verticies
QGLBuffer brushBuffer(QGLBuffer::VertexBuffer);
brushBuffer.create();
brushBuffer.bind();
brushBuffer.allocate(verts.data(), sizeof(GLfloat) * verts.size());
//bind index buffer and fill with indicies
QGLBuffer brushIndex(QGLBuffer::IndexBuffer);
brushIndex.create();
brushIndex.bind();
brushIndex.allocate(indicies.data(), sizeof(unsigned int) * indicies.size());
//set up uniforms
program.bind();
program.setUniformValueArray("color", &QVector4D(1.0f, 1.0f, 1.0f, 1.0f), 1);
program.setUniformValueArray("modelToCamera", &camera.getProjMatrix(), 1);
//set up buffers
brushBuffer.bind();
program.enableAttributeArray("vertex");
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
//draw brush. NOTE: Fixed 24 indicies for a box only!
brushIndex.bind();
glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT, 0);
}
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 AxisRenderer::drawCamLine(QVector3D from, QVector3D to, QGLShaderProgram &program, const AxisCamera &camera)
{
const GLfloat color[] ={1.0f, 0.0f, 0.0f, 1.0f}; //default red color
//temp vector to hold line verticies
std::vector<GLfloat> bufferData;
//from verticies
bufferData.push_back(from.x());
bufferData.push_back(from.y());
bufferData.push_back(from.z());
bufferData.push_back(1.0f);
//to verticies
bufferData.push_back(to.x());
bufferData.push_back(to.y());
bufferData.push_back(to.z());
bufferData.push_back(1.0f);
program.bind();
//create and fill line buffer with verticies
QGLBuffer line(QGLBuffer::VertexBuffer);
line.create();
line.bind();
line.allocate(bufferData.data(), sizeof(GLfloat) * 8);
//get locations
GLuint colorLoc = program.uniformLocation("color");
Q_ASSERT(colorLoc != -1);
GLuint mvpLoc = program.uniformLocation("modelToCamera");
Q_ASSERT(mvpLoc != -1);
//setup line for drawing
line.bind();
program.enableAttributeArray("vertex");
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
program.setUniformValueArray(colorLoc, color, 1, 4);
program.setUniformValueArray(mvpLoc, &(camera.getProjMatrix()), 1);
glDrawArrays(GL_LINES, 0, 2);
}
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 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();
}
/*!
\reimp
*/
void QGLPerVertexColorEffect::setActive(QGLPainter *painter, bool flag)
{
#if defined(QGL_FIXED_FUNCTION_ONLY)
Q_UNUSED(painter);
if (flag) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
} else {
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
#else
Q_UNUSED(painter);
Q_D(QGLPerVertexColorEffect);
#if !defined(QGL_SHADERS_ONLY)
if (painter->isFixedFunction()) {
d->isFixedFunction = true;
if (flag) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
} else {
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
return;
}
#endif
static char const pvColorVertexShader[] =
"attribute highp vec4 vertex;\n"
"attribute mediump vec4 color;\n"
"uniform highp mat4 matrix;\n"
"varying mediump vec4 qColor;\n"
"void main(void)\n"
"{\n"
" gl_Position = matrix * vertex;\n"
" qColor = color;\n"
"}\n";
static char const pvColorFragmentShader[] =
"varying mediump vec4 qColor;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = qColor;\n"
"}\n";
QGLShaderProgram *program =
painter->cachedProgram(QLatin1String("qt.color.pervertex"));
d->program = program;
if (!program) {
if (!flag)
return;
program = new QGLShaderProgram();
program->addShaderFromSourceCode(QGLShader::Vertex, pvColorVertexShader);
program->addShaderFromSourceCode(QGLShader::Fragment, pvColorFragmentShader);
program->bindAttributeLocation("vertex", QGL::Position);
program->bindAttributeLocation("color", QGL::Color);
if (!program->link()) {
qWarning("QGLPerVertexColorEffect::setActive(): could not link shader program");
delete program;
program = 0;
return;
}
painter->setCachedProgram(QLatin1String("qt.color.pervertex"), program);
d->program = program;
d->matrixUniform = program->uniformLocation("matrix");
program->bind();
program->enableAttributeArray(QGL::Position);
program->enableAttributeArray(QGL::Color);
} else if (flag) {
d->matrixUniform = program->uniformLocation("matrix");
program->bind();
program->enableAttributeArray(QGL::Position);
program->enableAttributeArray(QGL::Color);
} else {
program->disableAttributeArray(QGL::Position);
program->disableAttributeArray(QGL::Color);
program->release();
}
#endif
}
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 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 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 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 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 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 AxisRenderer::renderOrigin(QGLShaderProgram &program, const AxisCamera &camera)
{
qDebug()<<"[AxisRender] drawing origin lines";
initializeGLFunctions();
//data for the xline
const GLfloat xline[] = {
0.0f, 0.0f, 0.0f, 1.0f,
5.0f, 0.0f, 0.0f, 1.0f
};
//data for the yline
const GLfloat yline[] = {
0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 5.0f, 0.0f, 1.0f
};
//data for the zline
const GLfloat zline[] = {
0.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 5.0f, 1.0f
};
//data for each line color
const GLfloat xcolor[] = { 1.0f, 0.0f, 0.0f, 1.0f};
const GLfloat ycolor[] = { 0.0f, 1.0f, 0.0f, 1.0f};
const GLfloat zcolor[] = { 1.0f, 0.0f, 1.0f, 1.0f};
//fill buffer for xline
QGLBuffer xbuff(QGLBuffer::VertexBuffer);
xbuff.create();
xbuff.bind();
xbuff.setUsagePattern(QGLBuffer::StaticDraw);
xbuff.allocate(xline, sizeof(xline));
//fill buffer for yline
QGLBuffer ybuff(QGLBuffer::VertexBuffer);
ybuff.create();
ybuff.bind();
ybuff.setUsagePattern(QGLBuffer::StaticDraw);
ybuff.allocate(yline, sizeof(yline));
//fill buffer for zline
QGLBuffer zbuff(QGLBuffer::VertexBuffer);
zbuff.create();
zbuff.bind();
zbuff.setUsagePattern(QGLBuffer::StaticDraw);
zbuff.allocate(zline, sizeof(zline));
program.bind();
//set the uniforms
GLuint colorLoc = program.uniformLocation("color");
Q_ASSERT(colorLoc != -1);
GLuint mvpLoc = program.uniformLocation("modelToCamera");
Q_ASSERT(mvpLoc != -1);
program.setUniformValueArray(mvpLoc, &(camera.getProjMatrix()), 1);
//bind then draw xline
xbuff.bind();
program.enableAttributeArray("vertex");
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
program.setUniformValueArray(colorLoc, xcolor, 1, 4);
glDrawArrays(GL_LINES, 0, 2);
//bind then draw yline
ybuff.bind();
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
program.setUniformValueArray(colorLoc, ycolor, 1, 4);
glDrawArrays(GL_LINES, 0, 2);
//bind then draw zline
zbuff.bind();
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
program.setUniformValueArray(colorLoc, zcolor, 1, 4);
glDrawArrays(GL_LINES, 0, 2);
//destroy the buffers(Probably should be created and stored for longer than one call but context issue)
xbuff.bind();
xbuff.destroy();
ybuff.bind();
ybuff.destroy();
zbuff.bind();
zbuff.destroy();
}
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;
}
}
/// @overload QGLWidget
void initializeGL(){
printf("OpenGL %d.%d\n",this->format().majorVersion(),this->format().minorVersion());
///--- Background
glClearColor(1.0, 1.0, 1.0, 1.0);
///--- Viewport (simple, for unresizeable window)
glViewport(0, 0, this->width(), this->height());
///--- Setup opengl flags
glEnable(GL_DEPTH_TEST);
///--- Create the triangle index buffer
{
assert(mesh.is_triangle_mesh());
triangles.clear();
for(auto f: mesh.faces())
for(auto v: mesh.vertices(f))
triangles.push_back(v.idx());
}
///--- Create an array object to store properties
{
bool success = vao.create();
assert(success);
vao.bind();
}
///--- Load/compile shaders
{
bool vok = program.addShaderFromSourceFile(QGLShader::Vertex, ":/vshader.glsl");
bool fok = program.addShaderFromSourceFile(QGLShader::Fragment, ":/fshader.glsl");
bool lok = program.link ();
assert(lok && vok && fok);
bool success = program.bind();
assert(success);
}
///--- Create vertex buffer/attributes "position"
{
auto vpoints = mesh.get_vertex_property<Vec3>("v:point");
bool success = vertexbuffer.create();
assert(success);
vertexbuffer.setUsagePattern( QGLBuffer::StaticDraw );
success = vertexbuffer.bind();
assert(success);
vertexbuffer.allocate( vpoints.data(), sizeof(Vec3) * mesh.n_vertices() );
program.setAttributeBuffer("vpoint", GL_FLOAT, 0, 3 );
program.enableAttributeArray("vpoint");
}
///--- Create vertex buffer/attributes "normal"
{
auto vnormal = mesh.get_vertex_property<Vec3>("v:normal");
bool success = normalbuffer.create();
assert(success);
normalbuffer.setUsagePattern( QGLBuffer::StaticDraw );
success = normalbuffer.bind();
assert(success);
normalbuffer.allocate( vnormal.data(), sizeof(Vec3) * mesh.n_vertices() );
program.setAttributeBuffer("vnormal", GL_FLOAT, 0, 3 );
program.enableAttributeArray("vnormal");
}
///--- Create the index "triangle" buffer
{
bool success = indexbuffer.create();
assert(success);
indexbuffer.setUsagePattern( QGLBuffer::StaticDraw );
success = indexbuffer.bind();
assert(success);
indexbuffer.allocate(&triangles[0], triangles.size()*sizeof(unsigned int));
}
#ifdef WITH_QGLVIEWER
///--- Setup camera
{
Box3 bbox = OpenGP::bounding_box(mesh);
camera()->setType(qglviewer::Camera::ORTHOGRAPHIC);
camera()->setSceneCenter(qglviewer::tr(bbox.center()));
camera()->setSceneRadius(bbox.diagonal().norm()/2.0);
camera()->showEntireScene();
}
#endif
///--- Unbind to avoid pollution
vao.release();
program.release();
}
void AxisRenderer::drawGrid(int gridSize, QGLShaderProgram &program,const AxisCamera &camera)
{
qDebug()<< "[AxisRender] Drawing Grid";
int gridNumber = camera.getGridFactor() * 2; //double size of grid to ensure it covers entire view
float lineLimit = gridNumber * gridSize; //bounds of grid for this size and number
qDebug()<< "[AxisRender] lineLimit = " << lineLimit;
//general xline for grid
float lineX[] = {lineLimit, 0.0f, 0.0f, 1.0f,
-lineLimit, 0.0f, 0.0f, 1.0f};
//general yline for grid
float lineY[] = { 0.0f, lineLimit, 0.0f, 1.0f,
0.0f, -lineLimit, 0.0f, 1.0f};
//general zline for grid
float lineZ[] = {0.0f, 0.0f, lineLimit, 1.0f,
0.0f, 0.0f, -lineLimit, 1.0f};
//bind and fill xline buffer
program.bind();
QGLBuffer bufferX(QGLBuffer::VertexBuffer);
bufferX.setUsagePattern(QGLBuffer::StaticDraw);
bufferX.create();
bufferX.bind();
bufferX.allocate(lineX,sizeof(lineX));
//bind and fill yline buffer
QGLBuffer bufferY(QGLBuffer::VertexBuffer);
bufferY.setUsagePattern(QGLBuffer::StaticDraw);
bufferY.create();
bufferY.bind();
bufferY.allocate(lineY, sizeof(lineY));
//bind and fill zline buffer
QGLBuffer bufferZ(QGLBuffer::VertexBuffer);
bufferZ.setUsagePattern(QGLBuffer::StaticDraw);
bufferZ.create();
bufferZ.bind();
bufferZ.allocate(lineZ, sizeof(lineZ));
QMatrix4x4 mvp;
QMatrix4x4 vp = camera.getProjMatrix();
QMatrix4x4 m;
//find the offest based on camera position
QVector3D pos = camera.getPosistion();
int xoff = pos.x() / gridSize;
int yoff = pos.y() / gridSize;
int zoff = pos.z() / gridSize;
//set color uniform to grey
QVector4D color(0.3f, 0.3f, 0.3f, 1.0f);
program.setUniformValueArray("color", &color, 1);
//draw each line
program.enableAttributeArray("vertex");
for(int i = -gridNumber; i <= gridNumber; ++i){
//x lines only for XY and XZ Axis
if(camera.getLock() == XY || camera.getLock() == XZ)
{
bufferX.bind();
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
//use model matrix to translate each line with offset
m.setToIdentity();
m.translate(0.0f + (xoff * gridSize), (i + yoff) * gridSize, (i + zoff) * gridSize);
mvp = vp * m ;//set mvp up
//set mvp uniform then draw
program.setUniformValueArray("modelToCamera", &mvp, 1);
glDrawArrays(GL_LINES, 0, 2);
}
//y lines for XY and YZ axis only
if(camera.getLock() == XY || camera.getLock() == YZ)
{
bufferY.bind();
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
//use model matrix to translate each line with offset
m.setToIdentity();
m.translate((i + xoff) * gridSize, 0.0f + (yoff * gridSize) ,(i + zoff) * gridSize);
mvp = vp * m;
//set mvp uniform and draw
program.setUniformValueArray("modelToCamera", &mvp, 1);
glDrawArrays(GL_LINES, 0, 2);
}
//z lines
if(camera.getLock() == XZ || camera.getLock() == YZ)
{
bufferZ.bind();
program.setAttributeBuffer("vertex", GL_FLOAT, 0, 4);
//use model matrix to translate each line with offset
m.setToIdentity();
m.translate((i + xoff) * gridSize, (i + yoff) * gridSize ,0.0f + (zoff * gridSize));
mvp = vp * m;
//set mvp uniform then draw
program.setUniformValueArray("modelToCamera", &mvp, 1);
glDrawArrays(GL_LINES, 0, 2);
}
}
}
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 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" );
}
}
}
