void SatHorizon::render(QMatrix4x4 projection, float distance, QQuaternion quat, QVector3D posnorm, float alt, QColor rendercolor)
{
float radius = sqrt( alt * alt - 1 ) / alt;
float theta = acos(QVector3D::dotProduct(QVector3D(0,0,1), posnorm));
QVector3D vecnorm = QVector3D::crossProduct(QVector3D(0,0,1), posnorm);
vecnorm.normalize();
createCircleBuffer(radius, SEGMENTS);
QMatrix4x4 modelview;
modelview.translate(0.0, 0.0, distance);
modelview.rotate(quat);
modelview.translate(posnorm * (1/alt) * (alt > 1.5 ? 1.0015 : 1.0001));
modelview.rotate(theta * 180.0f/ PI, vecnorm );
posBuf.bind();
posBuf.write(0, vertexData, SEGMENTS * sizeof(QVector3D));
posBuf.release();
program->bind();
program->setUniformValue("MVP", projection * modelview);
QMatrix3x3 norm = modelview.normalMatrix();
program->setUniformValue("NormalMatrix", norm);
program->setUniformValue("outcolor", QVector4D(rendercolor.redF(), rendercolor.greenF(), rendercolor.blueF(), 1.0f));
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
glDrawArrays(GL_LINE_LOOP, 0, SEGMENTS);
}
void CGLWidget::initializeGL()
{
qDebug() << "init gl...";
this->initializeOpenGLFunctions();
this->glClearColor(0, 0, 0, 1);
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/glsl/basic.vert");
m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/glsl/basic.frag");
m_program->link();
m_program->bind();
m_mvpLoc = m_program->uniformLocation("mvp");
m_modelMatLoc = m_program->uniformLocation("m");
m_viewMatLoc = m_program->uniformLocation("v");
m_lightPosLoc = m_program->uniformLocation("lightPosition_worldspace");
m_vbo.create();
m_vbo.bind();
m_uvBuff.create();
m_uvBuff.bind();
m_normalBuff.create();
m_normalBuff.bind();
m_indexBuff.create();
m_indexBuff.bind();
setupVertexAttribs();
loadGLTexture();
}
void CGLWidget::initializeGL()
{
qDebug() << "init gl...";
this->initializeOpenGLFunctions();
this->glClearColor(0, 0, 0, 1);
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/glsl/basic.vert");
m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/glsl/basic.frag");
m_program->link();
m_program->bind();
m_mvpLoc = m_program->uniformLocation("mvp");
m_vbo.create();
m_vbo.bind();
m_vbo.setUsagePattern(QOpenGLBuffer::UsagePattern::StaticDraw);
m_uvBuff.create();
m_uvBuff.bind();
setupVertexAttribs();
loadGLTexture();
}
void GLRasterTexture::initializeGL(bool coreProfile) {
if(m_data.size() == 0) return;
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, coreProfile ? vertexShaderSourceCore : vertexShaderSource);
m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, coreProfile ? fragmentShaderSourceCore : fragmentShaderSource);
m_program->bindAttributeLocation("vertex", 0);
m_program->bindAttributeLocation("texCoord", 1);
m_program->link();
m_program->bind();
m_projMatrixLoc = m_program->uniformLocation("projMatrix");
m_mvMatrixLoc = m_program->uniformLocation("mvMatrix");
m_textureSamplerLoc = m_program->uniformLocation("texture");
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
// Setup our vertex buffer object.
m_vbo.create();
m_vbo.bind();
m_vbo.allocate(constData(), m_count * sizeof(GLfloat));
// Store the vertex attribute bindings for the program.
setupVertexAttribs();
m_program->setUniformValue(m_textureSamplerLoc, 0);
m_program->release();
m_built = true;
}
SegmentGL::SegmentGL(QOpenGLShaderProgram *prog, SatelliteList *satlist, AVHRRSatellite *seglist )
{
sats = satlist;
segs = seglist;
program = prog;
initializeOpenGLFunctions();
program->bind();
vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
positionsBuf.create();
positionsBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
positionsBuf.bind();
nbrOfVertices = 50;
positionsBuf.allocate( nbrOfVertices * 3 * sizeof(GLfloat));
vertexPosition = program->attributeLocation("VertexPosition");
program->enableAttributeArray(vertexPosition);
program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 3);
}
void CGLWidget::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
QMatrix4x4 m,v,p;
m.setToIdentity();
v.lookAt(QVector3D(0, 0, 5), QVector3D(0, 0, 0), QVector3D(0, 1, 0));
p.perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
QMatrix4x4 mvp = p * v * m;
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
m_program->setUniformValue(m_mvpLoc, mvp);
m_program->setUniformValue(m_modelMatLoc, m);
m_program->setUniformValue(m_viewMatLoc, v);
QVector3D lightPos_worldspace(4, 4, 4);
m_program->setUniformValue(m_lightPosLoc, lightPos_worldspace);
m_texture->bind();
m_indexBuff.bind();
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, (void*)0);
m_program->release();
}
TextureWriter::TextureWriter(QOpenGLShaderProgram *prog)
{
program = prog;
initializeOpenGLFunctions();
program->bind();
vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
positionsBuf.create();
positionsBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
positionsBuf.bind();
vertexPosition = program->attributeLocation("VertexPosition");
program->enableAttributeArray(vertexPosition);
program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 2);
texcoordBuf.create();
texcoordBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
texcoordBuf.bind();
vertexTexCoord = program->attributeLocation("VertexTexCoord");
program->enableAttributeArray(vertexTexCoord);
program->setAttributeBuffer(vertexTexCoord, GL_FLOAT, 0, 1);
glGenTextures(1, &texturelineId);
}
void CGLWidget::paintGL()
{
std::cout << "paint gl..." << std::endl;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
glDrawArrays(GL_TRIANGLES, 0, 3);//total 3 vertices
}
void CompasWidget::paintGL(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
m_world.setToIdentity();
m_world.rotate(180.0f - (m_xRot / 16.0f), 1, 0, 0);
m_world.rotate(m_yRot / 16.0f, 0, 1, 0);
m_world.rotate(m_zRot / 16.0f, 0, 0, 1);
/*
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
m_program->setUniformValue(m_projMatrixLoc, m_proj);
m_program->setUniformValue(m_mvMatrixLoc, m_camera * m_world);
QMatrix3x3 normalMatrix = m_world.normalMatrix();
m_program->setUniformValue(m_normalMatrixLoc, normalMatrix);
glDrawArrays(GL_TRIANGLES, 0, m_logo.vertexCount());
m_program->release();
*/
QOpenGLFunctions *f = context()->functions();
const bool newFrameReady=true;
if (newFrameReady) {//new frame ready
f->glFrontFace(GL_CW); // because our cube's vertex data is such
f->glBindTexture(GL_TEXTURE_2D, m_fbo2->texture());
m_program2->bind();
QOpenGLVertexArrayObject::Binder vaoBinder(m_vao2);
// If VAOs are not supported, set the vertex attributes every time.
if (!m_vao2->isCreated()){
setupVertexAttribs2();
}
static GLfloat angle = 0;
QMatrix4x4 m;
m.translate(0, 0, -20);
m.rotate(90, 0, 0, 1);
m.rotate(angle, 0.5, 1, 0);
angle += 0.5f;
m_program2->setUniformValue(m_matrixLoc, m_proj * m);
// Draw the cube.
f->glDrawArrays(GL_TRIANGLES, 0, 36);
m_program2->release();
}
}
bool QOpenGLTextureBlitter::create()
{
QOpenGLContext *currentContext = QOpenGLContext::currentContext();
if (!currentContext)
return false;
Q_D(QOpenGLTextureBlitter);
if (d->program)
return true;
d->program.reset(new QOpenGLShaderProgram());
QSurfaceFormat format = currentContext->format();
if (format.profile() == QSurfaceFormat::CoreProfile && format.version() >= qMakePair(3,2)) {
d->program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertex_shader150);
d->program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragment_shader150);
} else {
d->program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertex_shader);
d->program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragment_shader);
}
d->program->link();
if (!d->program->isLinked()) {
qWarning() << Q_FUNC_INFO << "Could not link shader program:\n" << d->program->log();
return false;
}
d->program->bind();
// Create and bind the VAO, if supported.
QOpenGLVertexArrayObject::Binder vaoBinder(d->vao.data());
d->vertexBuffer.create();
d->vertexBuffer.bind();
d->vertexBuffer.allocate(vertex_buffer_data, sizeof(vertex_buffer_data));
d->vertexBuffer.release();
d->textureBuffer.create();
d->textureBuffer.bind();
d->textureBuffer.allocate(texture_buffer_data, sizeof(texture_buffer_data));
d->textureBuffer.release();
d->vertexCoordAttribPos = d->program->attributeLocation("vertexCoord");
d->vertexTransformUniformPos = d->program->uniformLocation("vertexTransform");
d->textureCoordAttribPos = d->program->attributeLocation("textureCoord");
d->textureTransformUniformPos = d->program->uniformLocation("textureTransform");
d->swizzleUniformPos = d->program->uniformLocation("swizzle");
d->opacityUniformPos = d->program->uniformLocation("opacity");
d->program->setUniformValue(d->swizzleUniformPos,false);
return true;
}
void GLWidget::initializeGL()
{
// In this example the widget's corresponding top-level window can change
// several times during the widget's lifetime. Whenever this happens, the
// QOpenGLWidget's associated context is destroyed and a new one is created.
// Therefore we have to be prepared to clean up the resources on the
// aboutToBeDestroyed() signal, instead of the destructor. The emission of
// the signal will be followed by an invocation of initializeGL() where we
// can recreate all resources.
connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup);
initializeOpenGLFunctions();
glClearColor(0, 0, 0, m_transparent ? 0 : 1);
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, m_core ? vertexShaderSourceCore : vertexShaderSource);
m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, m_core ? fragmentShaderSourceCore : fragmentShaderSource);
m_program->bindAttributeLocation("vertex", 0);
m_program->bindAttributeLocation("normal", 1);
m_program->link();
m_program->bind();
m_projMatrixLoc = m_program->uniformLocation("projMatrix");
m_mvMatrixLoc = m_program->uniformLocation("mvMatrix");
m_normalMatrixLoc = m_program->uniformLocation("normalMatrix");
m_lightPosLoc = m_program->uniformLocation("lightPos");
// Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
// implementations this is optional and support may not be present
// at all. Nonetheless the below code works in all cases and makes
// sure there is a VAO when one is needed.
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
// Setup our vertex buffer object.
m_logoVbo.create();
m_logoVbo.bind();
m_logoVbo.allocate(m_logo.constData(), m_logo.count() * sizeof(GLfloat));
// Store the vertex attribute bindings for the program.
setupVertexAttribs();
// Our camera never changes in this example.
m_camera.setToIdentity();
m_camera.translate(0, 0, -1);
// Light position is fixed.
m_program->setUniformValue(m_lightPosLoc, QVector3D(0, 0, -1));
m_program->release();
std::cout<<" gl version : "<<glGetString( GL_VERSION )<<" glsl version: "<<glGetString( GL_SHADING_LANGUAGE_VERSION )<<std::endl;
}
void GLDynamicLine::paintGL(const QMatrix4x4 &m_mProj, const QMatrix4x4 &m_mView, const QMatrix4x4 &m_mModel, const QMatrix2x2 &m_selectionBounds)
{
if(!m_built) return;
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
m_program->setUniformValue(m_projMatrixLoc, m_mProj);
m_program->setUniformValue(m_mvMatrixLoc, m_mView * m_mModel);
m_program->setUniformValue(m_diagVertices2DLoc, m_selectionBounds);
m_program->setUniformValue(m_colourVectorLoc, m_colour_stroke);
glDrawArrays(GL_LINE_LOOP, 0, vertexCount());
m_program->release();
}
void GLRasterTexture::paintGL(const QMatrix4x4 &m_mProj, const QMatrix4x4 &m_mView, const QMatrix4x4 &m_mModel)
{
if(!m_built) return;
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
m_program->setUniformValue(m_projMatrixLoc, m_mProj);
m_program->setUniformValue(m_mvMatrixLoc, m_mView * m_mModel);
m_texture.bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount());
m_program->release();
}
void TextureWriter::render()
{
glBindFramebuffer(GL_FRAMEBUFFER, imageptrs->fboId);
//set the viewport to be the size of the texture
glViewport(0,0, imageptrs->pmOut->width(), imageptrs->pmOut->height());
glBindTexture(GL_TEXTURE_1D, texturelineId);
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
program->bind();
glDrawArrays(GL_LINE_STRIP, 0, nbrVerticesinBuffer);
//glDrawArrays(GL_TRIANGLES, 0, nbrVertices);
glBindTexture(GL_TEXTURE_1D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void CGLWidget::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
QMatrix4x4 m, v, p;
m.setToIdentity();
v.lookAt(QVector3D(0, 0, 5), QVector3D(0, 0, 0), QVector3D(0, 1, 0));
p.perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
QMatrix4x4 mvp = p * v * m;
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
m_program->setUniformValue(m_mvpLoc, mvp);
m_texture->bind();
glDrawArrays(GL_TRIANGLES, 0, vertices.size());
m_program->release();
}
SatHorizon::SatHorizon(QOpenGLShaderProgram *prog)
{
program = prog;
initializeOpenGLFunctions();
program->bind();
vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
posBuf.create();
posBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
posBuf.bind();
posBuf.allocate(sizeof(QVector3D) * SEGMENTS);
vertexPosition = program->attributeLocation("VertexPosition");
program->enableAttributeArray(vertexPosition);
program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 3);
}
void view::initializeGL()
{
connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &view::cleanup);
initializeOpenGLFunctions();
glClearColor(0, 0, 0, m_transparent ? 0 : 1);
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, m_core ? vertexShaderSourceCore : vertexShaderSource);
m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, m_core ? fragmentShaderSourceCore : fragmentShaderSource);
m_program->bindAttributeLocation("vertex", 0);
m_program->bindAttributeLocation("normal", 1);
m_program->link();
m_program->bind();
m_projMatrixLoc = m_program->uniformLocation("projMatrix");
m_mvMatrixLoc = m_program->uniformLocation("mvMatrix");
m_normalMatrixLoc = m_program->uniformLocation("normalMatrix");
m_lightPosLoc = m_program->uniformLocation("lightPos");
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
// Setup our vertex buffer object.
m_logoVbo.create();
m_logoVbo.bind();
m_logoVbo.allocate(m_logo.constData(), m_logo.count() * sizeof(GLfloat));
// Store the vertex attribute bindings for the program.
setupVertexAttribs();
// Our camera never changes in this example.
m_camera.setToIdentity();
m_camera.translate(0, 0, -1);
// Light position is fixed.
m_program->setUniformValue(m_lightPosLoc, QVector3D(0, 0, 70));
m_program->release();
}
void CGLWidget::initializeGL()
{
std::cout << "init gl..." << std::endl;
this->initializeOpenGLFunctions();
this->glClearColor(0, 0, 1, 1);
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/glsl/basic.vert");
m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/glsl/basic.frag");
m_program->link();
m_program->bind();
m_vbo.create();
m_vbo.bind();
m_vbo.allocate(vertexData, sizeof(vertexData));
setupVertexAttribs();
}
void GLWidget::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
m_world.setToIdentity();
m_world.rotate(180.0f - (m_xRot / 16.0f), 1, 0, 0);
m_world.rotate(m_yRot / 16.0f, 0, 1, 0);
m_world.rotate(m_zRot / 16.0f, 0, 0, 1);
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
m_program->setUniformValue(m_projMatrixLoc, m_proj);
m_program->setUniformValue(m_mvMatrixLoc, m_camera * m_world);
QMatrix3x3 normalMatrix = m_world.normalMatrix();
m_program->setUniformValue(m_normalMatrixLoc, normalMatrix);
glDrawArrays(GL_TRIANGLES, 0, m_logo.vertexCount());
m_program->release();
}
void CompasWidget::initializeGL(){
// In this example the widget's corresponding top-level window can change
// several times during the widget's lifetime. Whenever this happens, the
// QOpenGLWidget's associated context is destroyed and a new one is created.
// Therefore we have to be prepared to clean up the resources on the
// aboutToBeDestroyed() signal, instead of the destructor. The emission of
// the signal will be followed by an invocation of initializeGL() where we
// can recreate all resources.
connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &CompasWidget::cleanup);
initializeOpenGLFunctions();
glClearColor(0, 0, 0, m_transparent ? 0 : 1);
m_program = new QOpenGLShaderProgram;
m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, m_core ? vertexShaderSourceCore : vertexShaderSource);
m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, m_core ? fragmentShaderSourceCore : fragmentShaderSource);
m_program->bindAttributeLocation("vertex", 0);
m_program->bindAttributeLocation("normal", 1);
m_program->link();
m_program->bind();
m_projMatrixLoc = m_program->uniformLocation("projMatrix");
m_mvMatrixLoc = m_program->uniformLocation("mvMatrix");
m_normalMatrixLoc = m_program->uniformLocation("normalMatrix");
m_lightPosLoc = m_program->uniformLocation("lightPos");
// Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
// implementations this is optional and support may not be present
// at all. Nonetheless the below code works in all cases and makes
// sure there is a VAO when one is needed.
m_vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
// Setup our vertex buffer object.
m_logoVbo.create();
m_logoVbo.bind();
m_logoVbo.allocate(m_logo.constData(), m_logo.count() * sizeof(GLfloat));
// Store the vertex attribute bindings for the program.
setupVertexAttribs();
// Our camera never changes in this example.
m_camera.setToIdentity();
m_camera.translate(0, 0, -1);
// Light position is fixed.
m_program->setUniformValue(m_lightPosLoc, QVector3D(0, 0, 70));
m_program->release();
QSize sz=size();
m_fbo2 = new QOpenGLFramebufferObject(sz, QOpenGLFramebufferObject::CombinedDepthStencil);
m_program2 = new QOpenGLShaderProgram;
m_program2->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderVideoStreamSource);
m_program2->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderVideoStreamSource);
m_program2->bindAttributeLocation("vertex", 0);
m_program2->bindAttributeLocation("coord", 1);
m_program2->link();
m_matrixLoc = m_program->uniformLocation("matrix");
m_vao2 = new QOpenGLVertexArrayObject;
m_vao2->create();
m_vao2->bind();
m_vbo2 = new QOpenGLBuffer;
m_vbo2->create();
m_vbo2->bind();
GLfloat v[] = {
-0.5, 0.5, 0.5, 0.5,-0.5,0.5,-0.5,-0.5,0.5,
0.5, -0.5, 0.5, -0.5,0.5,0.5,0.5,0.5,0.5,
-0.5, -0.5, -0.5, 0.5,-0.5,-0.5,-0.5,0.5,-0.5,
0.5, 0.5, -0.5, -0.5,0.5,-0.5,0.5,-0.5,-0.5,
0.5, -0.5, -0.5, 0.5,-0.5,0.5,0.5,0.5,-0.5,
0.5, 0.5, 0.5, 0.5,0.5,-0.5,0.5,-0.5,0.5,
-0.5, 0.5, -0.5, -0.5,-0.5,0.5,-0.5,-0.5,-0.5,
-0.5, -0.5, 0.5, -0.5,0.5,-0.5,-0.5,0.5,0.5,
0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5,
-0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5,
-0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5,
0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5
};
GLfloat texCoords[] = {
0.0f,0.0f, 1.0f,1.0f, 1.0f,0.0f,
1.0f,1.0f, 0.0f,0.0f, 0.0f,1.0f,
1.0f,1.0f, 1.0f,0.0f, 0.0f,1.0f,
0.0f,0.0f, 0.0f,1.0f, 1.0f,0.0f,
1.0f,1.0f, 1.0f,0.0f, 0.0f,1.0f,
0.0f,0.0f, 0.0f,1.0f, 1.0f,0.0f,
0.0f,0.0f, 1.0f,1.0f, 1.0f,0.0f,
1.0f,1.0f, 0.0f,0.0f, 0.0f,1.0f,
0.0f,1.0f, 1.0f,0.0f, 1.0f,1.0f,
1.0f,0.0f, 0.0f,1.0f, 0.0f,0.0f,
1.0f,0.0f, 1.0f,1.0f, 0.0f,0.0f,
0.0f,1.0f, 0.0f,0.0f, 1.0f,1.0f
};
const int vertexCount = 36;
m_vbo2->allocate(sizeof(GLfloat) * vertexCount * 5);
m_vbo2->write(0, v, sizeof(GLfloat) * vertexCount * 3);
m_vbo2->write(sizeof(GLfloat) * vertexCount * 3, texCoords, sizeof(GLfloat) * vertexCount * 2);
m_vbo2->release();
if (m_vao2->isCreated()){
setupVertexAttribs2();
}
m_vao2->release();
}
void SegmentGL::RenderContour(Segment *seg, QMatrix4x4 projection, QMatrix4x4 modelview, int width, int height)
{
QVector3D vec;
QVector3D pos;
QVector<GLfloat> positions;
QEci qeci;
CalculateSegmentContour(&positions, seg->cornerpointfirst1.latitude, seg->cornerpointfirst1.longitude, seg->cornerpointlast1.latitude, seg->cornerpointlast1.longitude);
CalculateSegmentContour(&positions,seg->cornerpointlast1.latitude, seg->cornerpointlast1.longitude, seg->cornerpointlast2.latitude, seg->cornerpointlast2.longitude);
CalculateSegmentContour(&positions, seg->cornerpointlast2.latitude, seg->cornerpointlast2.longitude, seg->cornerpointfirst2.latitude, seg->cornerpointfirst2.longitude);
CalculateSegmentContour(&positions,seg->cornerpointfirst2.latitude, seg->cornerpointfirst2.longitude, seg->cornerpointfirst1.latitude, seg->cornerpointfirst1.longitude);
seg->qsgp4->getPosition(seg->minutes_since_state_vector, qeci);
QGeodetic qgeo = qeci.ToGeo();
double lat1 = qgeo.latitude;
double lon1 = qgeo.longitude;
seg->qsgp4->getPosition(seg->minutes_since_state_vector + seg->minutes_sensing, qeci);
qgeo = qeci.ToGeo();
double lat2 = qgeo.latitude;
double lon2 = qgeo.longitude;
CalculateSegmentContour(&positions, lat1, lon1, lat2, lon2);
positionsBuf.bind();
positionsBuf.write(0, positions.data(), positions.size() * sizeof(GLfloat));
positionsBuf.release();
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
program->bind();
program->setUniformValue("MVP", projection * modelview);
QColor rendercolor(opts.satsegmentcolor);
QColor rendercolorsel(opts.satsegmentcolorsel);
if((*seg).segmentselected)
program->setUniformValue("outcolor", QVector4D(rendercolorsel.redF(), rendercolorsel.greenF(), rendercolorsel.blueF(), 1.0f));
else
program->setUniformValue("outcolor", QVector4D(rendercolor.redF(), rendercolor.greenF(), rendercolor.blueF(), 1.0f));
QMatrix3x3 norm = modelview.normalMatrix();
program->setUniformValue("NormalMatrix", norm);
glDrawArrays(GL_LINE_LOOP, 0, nbrOfVertices - 10);
glDrawArrays(GL_LINE_STRIP, nbrOfVertices - 10, 10);
float mvmatrix[16], projmatrix[16];
QMatrix4x4 MVP;
MVP = projection * modelview;
float *ptr = modelview.data();
for(int i = 0; i < 16; i++)
mvmatrix[i] = *(ptr + i);
ptr = projection.data();
for(int i = 0; i < 16; i++)
projmatrix[i] = *(ptr + i);
QVector2D win;
LonLat2PointRad((float)seg->cornerpointfirst1.latitude, (float)seg->cornerpointfirst1.longitude, &vec, 1.0);
win = glhProjectf (vec, mvmatrix, projmatrix, width, height);
seg->winvecend1 = win;
LonLat2PointRad((float)seg->cornerpointfirst2.latitude, (float)seg->cornerpointfirst2.longitude, &vec, 1.0);
win = glhProjectf (vec, mvmatrix, projmatrix, width, height);
seg->winvecend2 = win;
LonLat2PointRad((float)seg->cornerpointlast1.latitude, (float)seg->cornerpointlast1.longitude, &vec, 1.0);
win = glhProjectf (vec, mvmatrix, projmatrix, width, height);
seg->winvecend3 = win;
LonLat2PointRad((float)seg->cornerpointlast2.latitude, (float)seg->cornerpointlast2.longitude, &vec, 1.0);
win = glhProjectf (vec, mvmatrix, projmatrix, width, height);
seg->winvecend4 = win;
win = glhProjectf (seg->vec1, mvmatrix, projmatrix, width, height);
seg->winvec1 = win;
win = glhProjectf (seg->vec2, mvmatrix, projmatrix, width, height);
seg->winvec2 = win;
}
SatGL::SatGL(QOpenGLShaderProgram *prog, SatelliteList *satlist, AVHRRSatellite *seglist)
{
sats = satlist;
segs = seglist;
tdiff = 0;
program = prog;
initializeOpenGLFunctions();
program->bind();
vao.create();
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
positionsBuf.create();
positionsBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
positionsBuf.bind();
// QVector<GLfloat> positions;
// QList<Satellite>::iterator sat = sats->GetSatlist()->begin();
nbrActiveSats = 0;
// while ( sat != sats->GetSatlist()->end() )
// {
// if( (*sat).active == true)
// {
// QVector3D pos, posssp;
// (*sat).GetSatellitePosition(pos, posssp, alt);
// positions.append(0.0f);
// positions.append(0.0f);
// positions.append(0.0f);
// positions.append(pos.x());
// positions.append(pos.y());
// positions.append(pos.z());
// qDebug() << (*sat).sat_name;
// nbrActiveSats++;
// }
// ++sat;
// }
// positionsBuf.allocate(positions.data(), positions.size() * sizeof(GLfloat));
// qDebug() << "SatGL : satposBufsize " << positionsBuf.size() << " nbr of vertices = " << positionsBuf.size() / (3 * sizeof(GLfloat));
// qDebug() << "SatGL : nbrActiveSats " << nbrActiveSats;
// qDebug() << "SatGL : nbrActiveSats = " << nbrActiveSats << " positions.size = " << positions.size() << " positionsBuf.size() = " << positionsBuf.size();
vertexPosition = program->attributeLocation("VertexPosition");
program->enableAttributeArray(vertexPosition);
program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 3);
vaotrail.create();
QOpenGLVertexArrayObject::Binder vaoBinder1(&vaotrail);
positionsTrail.create();
positionsTrail.setUsagePattern(QOpenGLBuffer::DynamicDraw);
positionsTrail.bind();
positionsTrail.allocate(tdiff * 2 * 3 *sizeof(GLfloat));
program->enableAttributeArray(vertexPosition);
program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 3);
octa = new Octahedron(program);
horizon = new SatHorizon(program);
}
void SatGL::render(QMatrix4x4 projection, float distance, QQuaternion quat )
{
QMatrix4x4 modelview;
modelview.translate(0.0, 0.0, distance);
modelview.rotate(quat);
QVector<GLfloat> positions;
QList<Satellite>::iterator sat = sats->GetSatlist()->begin();
int nbrSats = 0;
int nbrVertices;
QMatrix4x4 modelocta;
QColor col(255, 0, 0);
float alt;
while ( sat != sats->GetSatlist()->end() )
{
if( (*sat).active == true)
{
QVector3D pos, posnorm;
(*sat).GetSatellitePosition(pos, posnorm, alt);
positions.append(0.0f);
positions.append(0.0f);
positions.append(0.0f);
positions.append(pos.x());
positions.append(pos.y());
positions.append(pos.z());
modelocta = modelview;
modelocta.translate(posnorm.x(), posnorm.y(), posnorm.z());
modelocta.scale(0.005f);
octa->render(projection, modelocta, col);
QColor horizoncolour(opts.sathorizoncolor);
horizon->render(projection, distance, quat, posnorm, alt, horizoncolour);
nbrSats++;
}
++sat;
}
positionsBuf.bind();
if(nbrSats != nbrActiveSats)
{
nbrActiveSats = nbrSats;
positionsBuf.allocate(positions.data(), positions.size() * sizeof(GLfloat));
qDebug() << "positionsBuf.size() != nbrActiveSats * 2 * 3 * sizeof(GLfloat)";
qDebug() << "nbrActiveSats = " << nbrActiveSats << " positionsBuf.size() = " << positionsBuf.size();
}
else
{
positionsBuf.write(0, positions.data(), positions.size() * sizeof(GLfloat));
}
nbrVertices = positionsBuf.size() / (3 * sizeof(GLfloat));
positionsBuf.release();
QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
program->bind();
program->setUniformValue("MVP", projection * modelview);
QMatrix3x3 norm = modelview.normalMatrix();
program->setUniformValue("NormalMatrix", norm);
QColor rendercolor(255, 0, 0);
program->setUniformValue("outcolor", QVector4D(rendercolor.redF(), rendercolor.greenF(), rendercolor.blueF(), 1.0f));
glDrawArrays(GL_LINES, 0, nbrVertices);
sat = sats->GetSatlist()->begin();
while ( sat != sats->GetSatlist()->end() )
{
if( (*sat).active == true)
{
if( (*sat).GetCatalogueNbr() == sats->GetSelectedSat() )
RenderTrail(&(*sat), projection, distance, quat, true);
else
RenderTrail(&(*sat), projection, distance, quat, false);
}
++sat;
}
// QMatrix4x4 mod;
// mod.setToIdentity();
// mod.translate(0.0, 0.0, distance);
// mod.rotate(quat);
// modelocta = mod;
// modelocta.translate(0.0, 1.0, 0.0);
// modelocta.scale(0.009f);
// octa->render(projection, modelocta, col);
// modelocta = mod;
// modelocta.translate(0.0, 0.0, 1.0);
// modelocta.scale(0.009f);
// octa->render(projection, modelocta, col);
// modelocta = mod;
// modelocta.translate(1.0, 0.0, 0.0);
// modelocta.scale(0.009f);
// octa->render(projection, modelocta, col);
}
void SatGL::RenderTrail(Satellite *sat, QMatrix4x4 projection, float distance, QQuaternion quat, bool trackon) // QMatrix4x4 modelview, bool trackon)
{
QVector<GLfloat> postrail;
double
tsince, // Time since epoch (in minutes)
jul_epoch, // Julian date of epoch
jul_utc; // Julian UTC date
QSgp4Date nowutc = QSgp4Date::NowUTC();
jul_utc = nowutc.Julian();
jul_epoch = Julian_Date_of_Epoch(sat->GetEpoch());
QMatrix4x4 model;
model.translate(0.0, 0.0, distance);
model.rotate(quat);
QMatrix4x4 modelview;
modelview = model;
QMatrix4x4 modelocta;
QColor col(0,255,255);
QEci qeci;
QVector3D pos;
double id;
int nbrVertices = 0;
tsince = (jul_utc - jul_epoch) * MIN_PER_DAY; // in minutes
for( id = tsince - 5; id < tsince; id++ )
{
(*sat).qsgp4->getPosition(id, qeci);
QGeodetic qgeo = qeci.ToGeo();
LonLat2PointRad(qgeo.latitude, qgeo.longitude, &pos, 1.001f);
if(id < tsince && id >= tsince - 5 )
{
modelocta = model;
modelocta.translate(pos.x(), pos.y(), pos.z());
modelocta.scale(0.004f);
octa->render(projection, modelocta, col);
}
}
if(trackon)
{
for( id = tsince - opts.realminutesshown + 1; id <= tsince + opts.realminutesshown; id++ ) // nbr of id's = 2 * opts.realminutesshown
{
(*sat).qsgp4->getPosition(id, qeci);
QGeodetic qgeo = qeci.ToGeo();
LonLat2PointRad(qgeo.latitude, qgeo.longitude, &pos, 1.001f);
postrail.append(pos.x());
postrail.append(pos.y());
postrail.append(pos.z());
}
positionsTrail.bind();
if(tdiff != opts.realminutesshown)
{
tdiff = opts.realminutesshown;
positionsTrail.allocate(postrail.data(), postrail.size() * sizeof(GLfloat));
}
else
{
positionsTrail.write(0, postrail.data(), postrail.size() * sizeof(GLfloat));
}
nbrVertices = positionsTrail.size() / (3 * sizeof(GLfloat));
positionsTrail.release();
QOpenGLVertexArrayObject::Binder vaoBinder(&vaotrail);
program->bind();
program->setUniformValue("MVP", projection * modelview);
QMatrix3x3 norm = modelview.normalMatrix();
program->setUniformValue("NormalMatrix", norm);
QColor rendercolor(opts.sattrackcolor);
program->setUniformValue("outcolor", QVector4D(rendercolor.redF(), rendercolor.greenF(), rendercolor.blueF(), 1.0f));
glDrawArrays(GL_LINE_STRIP, 0, nbrVertices);
}
}
