void antPlane::generateColors( const antRGBA & color_1, const antRGBA & color_2 )
{
m_colors = ( GLfloat * ) malloc( N_COLOR_ATTRIBS * m_nVertices * sizeof( GLfloat ) );
// for each square ---------------------------------------------------------
for ( int i = 0; i < m_nRows; i++ )
{
for ( int j = 0; j < m_nColumns; j++ )
{
//--------------------------------------------------------------------------
int c = (i * m_nColumns + j) * 6 * N_COLOR_ATTRIBS;
// for each
for ( int n = 0; n < N_COLOR_ATTRIBS; n++ )
{
m_colors[ c + n ] = color_1.v[n];
m_colors[ c + (1 * N_COLOR_ATTRIBS) + n ] = color_1.v[n];
m_colors[ c + (2 * N_COLOR_ATTRIBS) + n ] = color_1.v[n];
m_colors[ c + (3 * N_COLOR_ATTRIBS) + n ] = color_2.v[n];
m_colors[ c + (4 * N_COLOR_ATTRIBS) + n ] = color_2.v[n];
m_colors[ c + (5 * N_COLOR_ATTRIBS) + n ] = color_2.v[n];
}
}
}
m_hasColors = true;
bindVao(0);
bindVbo(1);
setData( m_nVertices * N_COLOR_ATTRIBS * sizeof(GLfloat), m_colors );
attrib( ATTR_COLOR_LOC, N_COLOR_ATTRIBS );
enableColors();
}
void Canvas::paintGL() {
QColor &col = camera.clearColor;
glClearColor(col.redF(),col.greenF(),col.blueF(),1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (model) {
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
QOpenGLVertexArrayObject::Binder bindVao(&vao);
shaderProgram->bind();
shaderProgram->setUniformValue(projMatLoc, camera.projection);
shaderProgram->setUniformValue(modelMatLoc, camera.eye * model->world);
shaderProgram->setUniformValue(normalMatLoc, model->world.normalMatrix());
shaderProgram->setUniformValue(lightPosLoc1, QVector3D(0,0,10));
shaderProgram->setUniformValue(lightPosLoc2, QVector3D(10,0,-10));
shaderProgram->setUniformValue(lightColLoc1, camera.col1);
shaderProgram->setUniformValue(lightColLoc2, camera.col2);
model->drawTriangles();
shaderProgram->release();
}
}
/*
* initializeGL can be called multiple times - every time a new model is set
*/
void Canvas::initializeGL() {
delete shaderProgram;
shaderProgram = new QOpenGLShaderProgram;
initializeOpenGLFunctions();
shaderProgram->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
shaderProgram->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
shaderProgram->bindAttributeLocation("vertex", 0);
shaderProgram->bindAttributeLocation("normal", 1);
shaderProgram->link();
shaderProgram->bind();
projMatLoc = shaderProgram->uniformLocation("projMatrix");
modelMatLoc = shaderProgram->uniformLocation("modelMatrix");
normalMatLoc = shaderProgram->uniformLocation("normalMatrix");
lightPosLoc1 = shaderProgram->uniformLocation("lightPos1");
lightPosLoc2 = shaderProgram->uniformLocation("lightPos2");
lightColLoc1 = shaderProgram->uniformLocation("lightCol1");
lightColLoc2 = shaderProgram->uniformLocation("lightCol2");
if (!vao.isCreated()) vao.create();
QOpenGLVertexArrayObject::Binder bindVao(&vao);
// vertex buffer
if (!glBuffer.isCreated()) glBuffer.create();
glBuffer.bind();
if (model) model->allocate(glBuffer);
// vertex attribute bindings
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), reinterpret_cast<void *>(3 * sizeof(GLfloat)));
shaderProgram->release();
}
void antPlane::generateVertices()
{
float sx = m_width / m_nColumns;
float sz = m_depth / m_nRows;
m_vertices = ( GLfloat * ) malloc( N_VERTEX_ATTRIBS * m_nVertices * sizeof( GLfloat ) );
for ( int i = 0; i < m_nRows; i++ )
{
for ( int j = 0; j < m_nColumns; j++ )
{
antVec3 bl( j * sx - m_width / 2.f, 0.f, i * sz - m_depth / 2.f ); // bottom left
antVec3 tl( j * sx - m_width / 2.f, 0.f, ( i + 1 ) * sz - m_depth / 2.f ); // top left
antVec3 tr( ( j + 1 ) * sx - m_width / 2.f, 0.f, ( i + 1 ) * sz - m_depth / 2.f ); // top right
antVec3 br( ( j + 1 ) * sx - m_width / 2.f, 0.f, i * sz - m_depth / 2.f ); // bottom right
int v = (i * m_nColumns + j) * 6 * N_VERTEX_ATTRIBS;
for ( int n = 0; n < N_VERTEX_ATTRIBS; n++ )
{
m_vertices[ v + n ] = bl.v[n];
m_vertices[ v + (1 * N_VERTEX_ATTRIBS) + n ] = tl.v[n];
m_vertices[ v + (2 * N_VERTEX_ATTRIBS) + n ] = tr.v[n];
m_vertices[ v + (3 * N_VERTEX_ATTRIBS) + n ] = tr.v[n];
m_vertices[ v + (4 * N_VERTEX_ATTRIBS) + n ] = br.v[n];
m_vertices[ v + (5 * N_VERTEX_ATTRIBS) + n ] = bl.v[n];
}
}
}
m_hasVertices = true;
bindVao(0);
bindVbo(0);
setData( m_nVertices * N_VERTEX_ATTRIBS * sizeof(GLfloat), m_vertices );
attrib( ATTR_POSITION_LOC, N_VERTEX_ATTRIBS );
enableVertices();
}
