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 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);
}
/*!
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);
}
}
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;
}
/*!
\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 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();
}
