Пример #1
0
void Tutorial05::initializeGL()
{
  // initialize OpenGL
  initializeOpenGLFunctions();

  // Dark blue background
  glClearColor(0.0f, 0.0f, 0.3f, 0.0f);

  // Enable depth test
  glEnable(GL_DEPTH_TEST);

  // Accept fragment if it closer to the camera than the former one
  glDepthFunc(GL_LESS);

  bool success;
  // load and compile vertex shader
  success = shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex,
                                  ":/TransformVertexShader.vert");

  // load and compile fragment shader
  success = shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment,
                                                 ":/TextureFragmentShader.frag");

  programID = shaderProgram.programId();

  // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
  QMatrix4x4 projection;
  projection.perspective(45.0, 4.0/3.0, 0.1, 100.0);
  // Camera matrix
  QMatrix4x4 view;
  view.lookAt( QVector3D(4,3,3), // Camera is at (4,3,3), in World Space
               QVector3D(0,0,0), // and looks at the origin
               QVector3D(0,1,0)  // Head is up (set to 0,-1,0 to look upside-down)
             );
  // Model matrix : an identity matrix (model will be at the origin)
  QMatrix4x4 model;
  model.setToIdentity();

  // Our ModelViewProjection : multiplication of our 3 matrices
  MVP =  projection * view * model; // Remember, matrix multiplication is the other way around

  shaderProgram.link();

  // Get a handle for our "MVP" uniform
  MatrixID = glGetUniformLocation(programID, "MVP");

  // Get a handle for our buffers
  vertexPosition_modelspaceID = glGetAttribLocation(programID, "vertexPosition_modelspace");
  vertexUVID = glGetAttribLocation(programID, "vertexUV");

  // Load the texture Qt methods
  QImage image = QImage(":/uvtemplate.bmp").mirrored();
  mTexture = new QOpenGLTexture(image);
  mTexture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
  mTexture->setMagnificationFilter(QOpenGLTexture::Linear);
  shaderProgram.setUniformValue("myTextureSampler", 0);

  //enable texturing
  glEnable(GL_TEXTURE_2D);
  //generate textures

  //bind the texture
  mTexture->bind();

  // ... nice trilinear filtering.
  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  //glGenerateMipmap(GL_TEXTURE_2D);

  glGenBuffers(1, &vertexbuffer);
  glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

  glGenBuffers(1, &uvbuffer);
  glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(g_uv_buffer_data), g_uv_buffer_data, GL_STATIC_DRAW);

}
Пример #2
0
void tst_QVectorArray::transform()
{
    QMatrix4x4 m;
    m.translate(-1.0f, 2.5f, 5.0f);
    m.rotate(45.0f, 1.0f, 1.0f, 1.0f);
    m.scale(23.5f);

    QVector2DArray v2array;
    QVector3DArray v3array;
    QVector4DArray v4array;
    QVector2DArray v2arrayb;
    QVector3DArray v3arrayb;
    QVector4DArray v4arrayb;

    for (int index = 0; index < 64; ++index) {
        v2array.append(index * 4, index * 4 + 1);
        v3array.append(index * 4, index * 4 + 1, index * 4 + 2);
        v4array.append(index * 4, index * 4 + 1, index * 4 + 2,
                       index * 4 + 3);
        v2arrayb.append(index * 4, index * 4 + 1);
        v3arrayb.append(index * 4, index * 4 + 1, index * 4 + 2);
        v4arrayb.append(index * 4, index * 4 + 1, index * 4 + 2,
                        index * 4 + 3);
    }

    // Perform a simple in-place transform.

    v2array.transform(m);
    v3array.transform(m);
    v4array.transform(m);

    QCOMPARE(v2array.size(), 64);
    QCOMPARE(v3array.size(), 64);
    QCOMPARE(v4array.size(), 64);

    for (int index = 0; index < 64; ++index) {
        QVector2D v2(index * 4, index * 4 + 1);
        QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2);
        QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3);
        QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D()));
        QVERIFY(fuzzyCompare(v3array[index], m * v3));
        QVERIFY(fuzzyCompare(v4array[index], m * v4));
    }

    // Increase ref-count on an array and check that detach occurs.

    v2array = v2arrayb;
    v3array = v3arrayb;
    v4array = v4arrayb;

    QVERIFY(v2array.constData() == v2arrayb.constData());
    QVERIFY(v3array.constData() == v3arrayb.constData());
    QVERIFY(v4array.constData() == v4arrayb.constData());

    v2array.transform(m);
    v3array.transform(m);
    v4array.transform(m);

    QVERIFY(v2array.constData() != v2arrayb.constData());
    QVERIFY(v3array.constData() != v3arrayb.constData());
    QVERIFY(v4array.constData() != v4arrayb.constData());

    QCOMPARE(v2array.size(), 64);
    QCOMPARE(v3array.size(), 64);
    QCOMPARE(v4array.size(), 64);

    for (int index = 0; index < 64; ++index) {
        QVector2D v2(index * 4, index * 4 + 1);
        QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2);
        QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3);
        QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D()));
        QVERIFY(fuzzyCompare(v3array[index], m * v3));
        QVERIFY(fuzzyCompare(v4array[index], m * v4));
        QVERIFY(fuzzyCompare(v2arrayb[index], v2));
        QVERIFY(fuzzyCompare(v3arrayb[index], v3));
        QVERIFY(fuzzyCompare(v4arrayb[index], v4));
    }

    // Perform the test again, with translated() this time.

    v2array = v2arrayb.transformed(m);
    v3array = v3arrayb.transformed(m);
    v4array = v4arrayb.transformed(m);

    QCOMPARE(v2array.size(), 64);
    QCOMPARE(v3array.size(), 64);
    QCOMPARE(v4array.size(), 64);

    for (int index = 0; index < 64; ++index) {
        QVector2D v2(index * 4, index * 4 + 1);
        QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2);
        QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3);
        QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D()));
        QVERIFY(fuzzyCompare(v3array[index], m * v3));
        QVERIFY(fuzzyCompare(v4array[index], m * v4));
        QVERIFY(fuzzyCompare(v2arrayb[index], v2));
        QVERIFY(fuzzyCompare(v3arrayb[index], v3));
        QVERIFY(fuzzyCompare(v4arrayb[index], v4));
    }
}
Пример #3
0
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);

    }
}
Пример #4
0
bool BrainSurfaceTreeItem::addData(const Surface& tSurface, Qt3DCore::QEntity* parent)
{
    //Create renderable 3D entity
    m_pParentEntity = parent;
    m_pRenderable3DEntity = new Renderable3DEntity(parent);
    m_pRenderable3DEntityActivationOverlay = new Renderable3DEntity(parent);

    QMatrix4x4 m;
    Qt3DCore::QTransform* transform =  new Qt3DCore::QTransform();
    m.rotate(180, QVector3D(0.0f, 1.0f, 0.0f));
    m.rotate(-90, QVector3D(1.0f, 0.0f, 0.0f));
    transform->setMatrix(m);
    m_pRenderable3DEntity->addComponent(transform);
    m_pRenderable3DEntityActivationOverlay->addComponent(transform);

    //Create color from curvature information with default gyri and sulcus colors
    QByteArray arrayCurvatureColor = createCurvatureVertColor(tSurface.curv());

    //Set renderable 3D entity mesh and color data
    m_pRenderable3DEntity->setMeshData(tSurface.rr(), tSurface.nn(), tSurface.tris(), -tSurface.offset(), arrayCurvatureColor);

    //Generate activation overlay surface
//    MatrixX3f overlayAdds = tSurface.rr();
//    for(int i = 0; i<tSurface.nn().rows(); i++) {
//        RowVector3f direction = tSurface.nn().row(i);
//        direction.normalize();

//        overlayAdds.row(i) = direction*0.0001;
//    }

//    m_pRenderable3DEntityActivationOverlay->setMeshData(tSurface.rr()+overlayAdds, tSurface.nn(), tSurface.tris(), -tSurface.offset(), matCurvatureColor);

    //Add data which is held by this BrainSurfaceTreeItem
    QVariant data;

    data.setValue(arrayCurvatureColor);
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceCurrentColorVert);
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceCurvatureColorVert);

    data.setValue(tSurface.rr());
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceVert);

    data.setValue(tSurface.tris());
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceTris);

    data.setValue(tSurface.nn());
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceNorm);

    data.setValue(tSurface.curv());
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceCurv);

    data.setValue(tSurface.offset());
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceOffset);

    data.setValue(m_pRenderable3DEntity);
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceRenderable3DEntity);

    data.setValue(m_pRenderable3DEntityActivationOverlay);
    this->setData(data, BrainSurfaceTreeItemRoles::SurfaceRenderable3DEntityAcivationOverlay);

    //Add surface meta information as item children
    m_pItemSurfColorInfoOrigin = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceColorInfoOrigin, "Color from curvature");
    connect(m_pItemSurfColorInfoOrigin, &BrainTreeMetaItem::colorInfoOriginChanged,
            this, &BrainSurfaceTreeItem::onColorInfoOriginOrCurvColorChanged);
    *this<<m_pItemSurfColorInfoOrigin;
    data.setValue(QString("Color from curvature"));
    m_pItemSurfColorInfoOrigin->setData(data, BrainTreeMetaItemRoles::SurfaceColorInfoOrigin);

    m_pItemSurfColSulci = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceColorSulci, "Sulci color");
    connect(m_pItemSurfColSulci, &BrainTreeMetaItem::curvColorsChanged,
            this, &BrainSurfaceTreeItem::onColorInfoOriginOrCurvColorChanged);
    *this<<m_pItemSurfColSulci;
    data.setValue(QColor(50,50,50));
    m_pItemSurfColSulci->setData(data, BrainTreeMetaItemRoles::SurfaceColorSulci);
    m_pItemSurfColSulci->setData(data, Qt::DecorationRole);

    m_pItemSurfColGyri = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceColorGyri, "Gyri color");
    connect(m_pItemSurfColGyri, &BrainTreeMetaItem::curvColorsChanged,
            this, &BrainSurfaceTreeItem::onColorInfoOriginOrCurvColorChanged);
    *this<<m_pItemSurfColGyri;
    data.setValue(QColor(125,125,125));
    m_pItemSurfColGyri->setData(data, BrainTreeMetaItemRoles::SurfaceColorGyri);
    m_pItemSurfColGyri->setData(data, Qt::DecorationRole);

    BrainTreeMetaItem *itemSurfFileName = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceFileName, tSurface.fileName());
    itemSurfFileName->setEditable(false);
    *this<<itemSurfFileName;
    data.setValue(tSurface.fileName());
    itemSurfFileName->setData(data, BrainTreeMetaItemRoles::SurfaceFileName);

    BrainTreeMetaItem *itemSurfType = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceType, tSurface.surf());
    itemSurfType->setEditable(false);
    *this<<itemSurfType;
    data.setValue(tSurface.surf());
    itemSurfType->setData(data, BrainTreeMetaItemRoles::SurfaceType);

    BrainTreeMetaItem *itemSurfPath = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceFilePath, tSurface.filePath());
    itemSurfPath->setEditable(false);
    *this<<itemSurfPath;
    data.setValue(tSurface.filePath());
    itemSurfPath->setData(data, BrainTreeMetaItemRoles::SurfaceFilePath);

    return true;
}
Пример #5
0
void Patch::translate(const QVector3D &t)
{
    mat.translate(t);
}
Пример #6
0
void TApplication::RenderToFBO() {
    Fbo->bind();

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_MULTISAMPLE);

    Shader.bind();

    glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);


    QMatrix4x4 view;
    view.lookAt(QVector3D(0.0, 0.0, 6.0), QVector3D(0.0, 0.0, 0.0), QVector3D(0.0, 1.0, 0.0));

    QMatrix4x4 projection;
    projection.perspective(45.0f, float(WINDOW_WIDTH) / float(WINDOW_HEIGHT), 0.1f, 10.0f);

    Shader.setUniformValue("projection", projection);
    Shader.setUniformValue("view", view);

    Shader.setUniformValue("lightIntensities", QVector3D(1.0, 1.0, 1.0));
    Shader.setUniformValue("lightPosition", QVector3D(-30.0, 30.0, 30.0));

    QMatrix4x4 model;
    model.translate(0, 0, 0.0);
    model.rotate(AngleX, 1.0, 0.0, 0.0);
    model.rotate(AngleY, 0.0, 1.0, 0.0);
    model.rotate(AngleZ, 0.0, 0.0, 1.0);
    model.scale(0.42);

    QMatrix3x3 normalMatrix = model.normalMatrix();

    Shader.setUniformValue("model", model);
    Shader.setUniformValue("normalMatrix", normalMatrix);


    VertexBuff->bind();

    GLint attribute;
    GLint offset = 0;

    attribute = Shader.attributeLocation("gl_Vertex");
    Shader.enableAttributeArray(attribute);
    Shader.setAttributeBuffer(attribute, GL_FLOAT, offset, 3, sizeof(TVertex));
    offset += sizeof(QVector3D);

    attribute = Shader.attributeLocation("gl_Normal");
    Shader.enableAttributeArray(attribute);
    Shader.setAttributeBuffer(attribute, GL_FLOAT, offset, 3, sizeof(TVertex));
    offset += sizeof(QVector3D);

    attribute = Shader.attributeLocation("vertTexCoord");
    Shader.enableAttributeArray(attribute);
    Shader.setAttributeBuffer(attribute, GL_FLOAT, offset, 2, sizeof(TVertex));
    offset += sizeof(QVector2D);

    attribute = Shader.attributeLocation("tangent");
    Shader.enableAttributeArray(attribute);
    Shader.setAttributeBuffer(attribute, GL_FLOAT, offset, 3, sizeof(TVertex));
    offset += sizeof(QVector3D);

    attribute = Shader.attributeLocation("bitangent");
    Shader.enableAttributeArray(attribute);
    Shader.setAttributeBuffer(attribute, GL_FLOAT, offset, 3, sizeof(TVertex));
    offset += sizeof(QVector3D);

    VertexBuff->release();

    Texture->bind(0, QOpenGLTexture::ResetTextureUnit);
    Shader.setUniformValue("texture", 0);
    NormalMap->bind(1, QOpenGLTexture::ResetTextureUnit);
    Shader.setUniformValue("normalMap", 1);

    glDrawArrays(GL_TRIANGLES, 0, 3 * ObjectSize);

    Shader.disableAttributeArray("gl_Vertex");
    Shader.disableAttributeArray("gl_Normal");
    Shader.disableAttributeArray("vertTexCoord");
    Shader.disableAttributeArray("tangent");
    Shader.disableAttributeArray("bitangent");

    Texture->release(0, QOpenGLTexture::ResetTextureUnit);
    NormalMap->release(1, QOpenGLTexture::ResetTextureUnit);


    Shader.disableAttributeArray("coord2d");
    Shader.disableAttributeArray("v_color");

    Shader.release();

/*
    /// DEBUG INFO

    QMatrix4x4 modelView = view * model;

    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(projection.data());
    glMatrixMode(GL_MODELVIEW);
    glLoadMatrixf(modelView.data());

//    glDisable(GL_DEPTH_TEST);

    glColor3f(1, 1, 1);
    glBegin(GL_LINES);
    for (size_t i = 0; i < Obj.size(); i += 3) {
        const TVertex& v1 = Obj[i];
        const TVertex& v2 = Obj[i + 1];
        const TVertex& v3 = Obj[i + 2];
        glVertex3f(v1.Position.x(), v1.Position.y(), v1.Position.z());
        glVertex3f(v2.Position.x(), v2.Position.y(), v2.Position.z());

        glVertex3f(v1.Position.x(), v1.Position.y(), v1.Position.z());
        glVertex3f(v3.Position.x(), v3.Position.y(), v3.Position.z());

        glVertex3f(v2.Position.x(), v2.Position.y(), v2.Position.z());
        glVertex3f(v3.Position.x(), v3.Position.y(), v3.Position.z());
    }
    glEnd();

    // normals
    glColor3f(0,0,1);
    glBegin(GL_LINES);
    for (size_t i = 0; i < Obj.size(); ++i) {
        const TVertex& v = Obj[i];
        QVector3D p = v.Position;
        p *= 1.02;
        glVertex3f(p.x(), p.y(), p.z());
        QVector3D n = v.Normal.normalized();
        p += n * 0.8;
        glVertex3f(p.x(), p.y(), p.z());
    }
    glEnd();

    // tangent
    glColor3f(1,0,0);
    glBegin(GL_LINES);
    for (size_t i = 0; i < Obj.size(); ++i) {
        const TVertex& v = Obj[i];
        QVector3D p = v.Position;
        p *= 1.02;
        glVertex3f(p.x(), p.y(), p.z());
        QVector3D n = v.Tangent.normalized();
        p += n * 0.8;
        glVertex3f(p.x(), p.y(), p.z());
    }
    glEnd();

    // bitangent
    glColor3f(0,1,0);
    glBegin(GL_LINES);
    for (size_t i = 0; i < Obj.size(); ++i) {
        const TVertex& v = Obj[i];
        QVector3D p = v.Position;
        p *= 1.02;
        glVertex3f(p.x(), p.y(), p.z());
        QVector3D n = v.Bitangent.normalized();
        p += n * 0.3;
        glVertex3f(p.x(), p.y(), p.z());
    }
    glEnd();
*/
    Fbo->release();
}
void GLWidget::paintMesh()
{

    QMatrix4x4 mMatrix;
    QMatrix4x4 vMatrix;

    QMatrix4x4 cameraTransformation;
    cameraTransformation.rotate(alpha, 0, 1, 0);
    cameraTransformation.rotate(beta, 1, 0, 0);

    QVector3D cameraPosition = cameraTransformation * QVector3D(0, 0, distance);
    QVector3D cameraUpDirection = cameraTransformation * QVector3D(0, 1, 0);

    vMatrix.lookAt(cameraPosition, lastCenterPosition, cameraUpDirection);

    mMatrix.setToIdentity();

    QMatrix4x4 mvMatrix;
    mvMatrix = vMatrix * mMatrix;

    QMatrix3x3 normalMatrix;
    normalMatrix = mvMatrix.normalMatrix();

    QMatrix4x4 lightTransformation;
    lightTransformation.rotate(lightAngle, 0, 1, 0);

    QVector3D lightPosition = lightTransformation * QVector3D(0, 10, 10);

    shaderProgram.bind();

    shaderProgram.setUniformValue("mvpMatrix", pMatrix * mvMatrix);
    shaderProgram.setUniformValue("mvMatrix", mvMatrix);
    shaderProgram.setUniformValue("normalMatrix", normalMatrix);
    shaderProgram.setUniformValue("lightPosition", vMatrix * lightPosition);

    shaderProgram.setUniformValue("ambientColor", QColor(32, 32, 32));
    shaderProgram.setUniformValue("diffuseColor", QColor(128, 128, 128));
    shaderProgram.setUniformValue("specularColor", QColor(255, 255, 255));
    shaderProgram.setUniformValue("ambientReflection", (GLfloat) 1.0);
    shaderProgram.setUniformValue("diffuseReflection", (GLfloat) 1.0);
    shaderProgram.setUniformValue("specularReflection", (GLfloat) 1.0);
    shaderProgram.setUniformValue("shininess", (GLfloat) 100.0);

    glPointSize(INITIAL_POINT_SIZE);

    renderGrid();
    renderMesh(mode);

    shaderProgram.release();

    mMatrix.setToIdentity();
    mMatrix.translate(lightPosition);
    mMatrix.rotate(lightAngle, 0, 1, 0);
    mMatrix.rotate(45, 1, 0, 0);
    //    mMatrix.scale(0.1);

    coloringShaderProgram.bind();

    coloringShaderProgram.setUniformValue("mvpMatrix", pMatrix * vMatrix * mMatrix);

    coloringShaderProgram.setAttributeArray("vertex", lightSource.getSpotlightVertices().constData());
    coloringShaderProgram.enableAttributeArray("vertex");

    coloringShaderProgram.setAttributeArray("color", lightSource.getSpotlightColors().constData());
    coloringShaderProgram.enableAttributeArray("color");

    glDrawArrays(GL_TRIANGLES, 0, lightSource.getSpotlightVertices().size());

    coloringShaderProgram.disableAttributeArray("vertex");
    coloringShaderProgram.disableAttributeArray("color");

    coloringShaderProgram.release();
}
Пример #8
0
bool SegmentListOLCI::TestForSegmentGLerr(int x, int realy, float distance, const QMatrix4x4 &m, bool showallsegments, QString &segmentname)
{

    bool isselected = false;

    qDebug() << QString("Nbr of segments = %1").arg(segmentlist.count());

    QList<Segment*>::iterator segit = segmentlist.begin();
    QVector2D winvec1, winvec2, winvecend1, winvecend2, winvecend3, winvecend4;

    QVector3D vecZ = m.row(2).toVector3D();

    segmentname = "";

    while ( segit != segmentlist.end() )
    {
        if(showallsegments ? true : (*segit)->segmentshow)
        {
            for(int i = 0; i < (*segit)->winvectorfirst.length()-1; i++)
            {
                winvecend1.setX((*segit)->winvectorfirst.at(i).x()); winvecend1.setY((*segit)->winvectorfirst.at(i).y());
                winvecend2.setX((*segit)->winvectorfirst.at(i+1).x()); winvecend2.setY((*segit)->winvectorfirst.at(i+1).y());
                winvecend3.setX((*segit)->winvectorlast.at(i).x()); winvecend3.setY((*segit)->winvectorlast.at(i).y());
                winvecend4.setX((*segit)->winvectorlast.at(i+1).x()); winvecend4.setY((*segit)->winvectorlast.at(i+1).y());

                //     first                                          last
                //  winvecend1 ------------------------------------ winvecend3
                //      | p01                                           | p03
                //      |                                               |
                //      |                                               |
                //      |                                               |
                //      |                                               |
                //      |                                               |
                //      | p02                                           | p04
                //  winvecend2 ------------------------------------ winvecend4
                //


                qreal angle = ArcCos(QVector3D::dotProduct( vecZ, (*segit)->vecvector.at(i)));
                //qDebug() << QString("angle = %1").arg(angle * 180.0 / PI);

                if (angle < PI/2 + (asin(1/distance)))
                {


                    struct point p01;
                    p01.x = (int)winvecend1.x();
                    p01.y = (int)winvecend1.y();

                    struct point p02;
                    p02.x = (int)winvecend2.x();
                    p02.y = (int)winvecend2.y();

                    struct point p03;
                    p03.x = (int)winvecend3.x();
                    p03.y = (int)winvecend3.y();

                    struct point p04;
                    p04.x = (int)winvecend4.x();
                    p04.y = (int)winvecend4.y();



                    QPoint points[4] = {
                        QPoint(p01.x, p01.y),
                        QPoint(p02.x, p02.y),
                        QPoint(p04.x, p04.y),
                        QPoint(p03.x, p03.y)
                    };


                    int result = pnpoly( 4, points, x, realy);

                    if (result)
                    {
                        if((*segit)->ToggleSelected())
                        {
                            qDebug() << QString("segment selected is = %1").arg((*segit)->fileInfo.fileName());
                            isselected = true;
                            segmentname = (*segit)->fileInfo.fileName();
                            qApp->processEvents();
                        }
                        break;
                    }
                }

            }
        }
        ++segit;
    }
    return isselected;
}
Пример #9
0
void RayCastRenderer::render_impl(const QQuaternion & rotation,
                                  const QVector3D & scale,
                                  const QVector3D & translation,
                                  const QQuaternion & /* camera_rotation */,
                                  GLuint /* vbo_positions */,
                                  GLuint /* vbo_colors */,
                                  size_t /* part_cnt */,
                                  const QVector3D & volume_size)
                                  //float peel_depth,
                                  //int detail
{
  if (!isDataValid())
  {
    WARNM("Not rendering because: Failed to create 3D texture for data");
    return;
  }

  // Transformacna model-view matica
  QMatrix4x4 mv;

  mv.translate(0.0f, 0.0f, -1.0f);
  mv.translate(translation);
  mv.rotate(rotation);
  mv.scale(scale);

  // Uprava rozmerov volumetrickych dat, tak aby presne sedeli na jednotkovu kocku
  float max_size = std::max(volume_size.x(), std::max(volume_size.y(), volume_size.z()));
  mv.scale((volume_size.x() / max_size),
           (volume_size.y() / max_size),
           (volume_size.z() / max_size));

  mv.scale(volume_size.x(), volume_size.y(), volume_size.z());
  //mv.scale(volume_size.x() / 2.0f, volume_size.y() / 2.0f, volume_size.z() / 2.0f);
  //mv.scale(volume_size.x() / 4.0f, volume_size.y() / 4.0f, volume_size.z() / 4.0f);
  //mv.scale(volume_size.x() / 8.0f, volume_size.y() / 8.0f, volume_size.z() / 8.0f);

  // nabindovanie textur, geometrie, povolenie cullingu, depth testovania a HW blendingu (robi sa v shaderi)
  OGLF->glActiveTexture(GL_TEXTURE0);
  OGLF->glBindTexture(GL_TEXTURE_1D, m_transfer_func.textureId());
  OGLF->glActiveTexture(GL_TEXTURE1);
  OGLF->glBindTexture(GL_TEXTURE_2D, m_color_attach);
  OGLF->glActiveTexture(GL_TEXTURE2);
  OGLF->glBindTexture(GL_TEXTURE_3D, m_data.textureId());

  m_vao.bind();

  OGLF->glEnable(GL_DEPTH_TEST);
  OGLF->glDepthMask(GL_FALSE);
  OGLF->glEnable(GL_CULL_FACE);
  // blending je potreba povolit, aby neboli casti ciar z bounding box-u prekryte
  // farbou vzduchu vo volumetrickych datach
  OGLF->glEnable(GL_BLEND);
  //OGLF->glDisable(GL_BLEND);

  // Kreslenie sceny do framebufferu (vygenerovanie exit pointov)s
  OGLF->glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
  OGLF->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  OGLF->glCullFace(GL_FRONT);

  m_prog_gen_back_faces.bind();
  m_prog_gen_back_faces.setUniformValue("mvp", m_proj * mv);

  OGLF->glDrawElements(GL_TRIANGLES, g_cube_indices_cnt, GL_UNSIGNED_INT, nullptr);

  // Ray-casting
  OGLF->glBindFramebuffer(GL_FRAMEBUFFER, m_default_fbo);
  // Toto uz netreba, pretoze defaultny frame buffer clearuje base class
  // a pripadne este aj kresli bounding box ak treba
  //OGLF->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  OGLF->glCullFace(GL_BACK);

  int detail = 1000; //5000;
  float default_step = 1.0f / max_size;
  float step;

  if (detail <= 0)
    step = default_step;
  else
    step = 1.0f / float(detail);

  //qDebug() << "step=" << step << ", default_step=" << default_step << ", correction factor=" << (step / default_step);

  m_prog_ray_cast.bind();
  m_prog_ray_cast.setUniformValue("mvp", m_proj * mv);
  m_prog_ray_cast.setUniformValue("step", step);
  //m_prog_ray_cast.setUniformValue("offset", peel_depth);
  m_prog_ray_cast.setUniformValue("offset", 0.0f);
  m_prog_ray_cast.setUniformValue("alpha_correction_factor", step / default_step);
  m_prog_ray_cast.setUniformValue("tex_transfer_func", 0);
  m_prog_ray_cast.setUniformValue("tex_back_faces", 1);
  m_prog_ray_cast.setUniformValue("tex_volume_data", 2);
  //m_prog_ray_cast.setUniformValue("use_tf", m_use_transfer_func);

  if (m_use_lighting && m_use_transfer_func)
  {
    m_prog_ray_cast.setUniformValue("method", 1);
    m_prog_ray_cast.setUniformValue("La", m_light_ambient_col);
    m_prog_ray_cast.setUniformValue("Ld", m_light_diffuse_col);
    m_prog_ray_cast.setUniformValue("light_pos", m_light_pos);
  }
  else if (m_use_transfer_func)
  {
    m_prog_ray_cast.setUniformValue("method", 2);
  }
  else
  {
    m_prog_ray_cast.setUniformValue("method", 3);
  }

  OGLF->glEnable(GL_DEPTH_TEST);
  OGLF->glDrawElements(GL_TRIANGLES, g_cube_indices_cnt, GL_UNSIGNED_INT, nullptr);

  // Odbindovanie programu, geometrie, textur a zakazanie cullingu
  OGLF->glUseProgram(0);

  OGLF->glDisable(GL_BLEND);
  OGLF->glDisable(GL_CULL_FACE);
  OGLF->glDepthMask(GL_TRUE);
  OGLF->glDisable(GL_DEPTH_TEST);

  OGLF->glBindVertexArray(0);

  OGLF->glActiveTexture(GL_TEXTURE2);
  OGLF->glBindTexture(GL_TEXTURE_3D, 0);
  OGLF->glActiveTexture(GL_TEXTURE1);
  OGLF->glBindTexture(GL_TEXTURE_2D, 0);
  OGLF->glActiveTexture(GL_TEXTURE0);
  OGLF->glBindTexture(GL_TEXTURE_1D, 0);
}
Пример #10
0
void TriangleWindow::render()
{
    const qreal retinaScale = devicePixelRatio();
    glViewport(0, 0, width() * retinaScale, height() * retinaScale);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);

    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    m_program->bind();

    QMatrix4x4 matrix;
    matrix.perspective(60.0f, 1.0 * _width/_height, 0.1f, 300.0f);
    matrix.translate(_camX, _camY, _camZ);
    matrix.rotate(20, 1, 0, 0);
    matrix.rotate(_angle, 0, 1, 0);
    matrix.translate(-70, 0, -60);

    m_program->setUniformValue(m_matrixUniform, matrix);

    vao.bind();

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture->textureId());

    glDrawArrays(GL_TRIANGLES, 0, _map.size());

    vao.release();
    m_program->release();

    if(allSeasons[currentSeason] == "WINTER")
    {
        _fall->setPointSize(4.0);
        _fall->setFaster(0.0);
        _fall->setPointColor(QVector4D(0.9, 0.9, 0.9, 0.0));
    }
    else if(allSeasons[currentSeason] == "AUTUMN")
    {
        _fall->setPointSize(1.0);
        _fall->setFaster(1.0);
        _fall->setPointColor(QVector4D(0.0, 0.9, 0.9, 0.5));
    }
    else
        return;

    particuleShader->bind();
    particuleShader->setUniformValue(particuleMatrixUniform, matrix);
    particuleShader->setUniformValue(particulePointSize, _fall->getPointSize());
    particuleShader->setUniformValue(particulePointColor, _fall->getPointColor());

    fallVao.bind();
    fallVbo.bind();
    size_t fallSize = _fall->getParticules().size()*sizeof(QVector3D);
    fallVbo.write(0, _fall->getParticules().constData(), fallSize);
    glDrawArrays(GL_POINTS, 0, _fall->getParticules().size());
    fallVao.release();

    particuleShader->release();

    ++m_frame;
}
Пример #11
0
void SegmentListOLCI::ShowWinvec(QPainter *painter, float distance, const QMatrix4x4 modelview)
{

    QList<Segment*>::iterator segit = segmentlist.begin();
    QVector2D winvecend1, winvecend2, winvecend3, winvecend4;

    QVector3D vecZ = modelview.row(2).toVector3D();

//    static GLfloat mat[16];
//    const float *data = modelview.constData();
//    for (int index = 0; index < 16; ++index)
//         mat[index] = data[index];

    //modelview.inverted( &ok );

    while ( segit != segmentlist.end() )
    {
        if( (*segit)->segmentshow)
        {
            for(int i = 0; i < (*segit)->winvectorfirst.length()-1; i++)
            {
                winvecend1.setX((*segit)->winvectorfirst.at(i).x()); winvecend1.setY((*segit)->winvectorfirst.at(i).y());
                winvecend2.setX((*segit)->winvectorfirst.at(i+1).x()); winvecend2.setY((*segit)->winvectorfirst.at(i+1).y());
                winvecend3.setX((*segit)->winvectorlast.at(i).x()); winvecend3.setY((*segit)->winvectorlast.at(i).y());
                winvecend4.setX((*segit)->winvectorlast.at(i+1).x()); winvecend4.setY((*segit)->winvectorlast.at(i+1).y());

                //qDebug() << "winvec1 x = " << winvec1.x() << "  y = " << winvec1.y();


                //     first                                          last
                //  winvecend1 ------------------------------------ winvecend3
                //      | p01                                           | p03
                //      |                                               |
                //      |                                               |
                //      |                                               |
                //      |                                               |
                //      |                                               |
                //      | p02                                           | p04
                //  winvecend2 ------------------------------------ winvecend4
                //


                qreal angle = ArcCos(QVector3D::dotProduct( vecZ, (*segit)->vecvector.at(i)));

                if (angle < PI/2) //  + (asin(1/distance)))
                {

                    painter->drawLine((int)winvecend1.x(), (painter->device())->height() - (int)winvecend1.y(), (int)winvecend3.x(), (painter->device())->height() - (int)winvecend3.y() );

                    painter->drawLine((int)winvecend1.x(), (painter->device())->height() - (int)winvecend1.y(), (int)winvecend2.x(), (painter->device())->height() - (int)winvecend2.y() );
                    painter->drawLine((int)winvecend3.x(), (painter->device())->height() - (int)winvecend3.y(), (int)winvecend4.x(), (painter->device())->height() - (int)winvecend4.y() );

                    //                painter->drawLine((int)winvec1.x(), (painter->device())->height() - (int)winvec1.y(), (int)winvecend1.x(), (painter->device())->height() - (int)winvecend1.y() );
                    //                painter->drawLine((int)winvec2.x(), (painter->device())->height() - (int)winvec2.y(), (int)winvecend2.x(), (painter->device())->height() - (int)winvecend2.y() );
                    //                painter->drawLine((int)winvec1.x(), (painter->device())->height() - (int)winvec1.y(), (int)winvecend3.x(), (painter->device())->height() - (int)winvecend3.y() );
                    //                painter->drawLine((int)winvec2.x(), (painter->device())->height() - (int)winvec2.y(), (int)winvecend4.x(), (painter->device())->height() - (int)winvecend4.y() );

                }
            }
        }
        ++segit;
    }
}
Пример #12
0
void Canvas::paintGL()
{
#ifndef NDEBUG
    logToFile("Painting started.");
#endif

    gl()->glClear(GL_COLOR_BUFFER_BIT);

    if (ready())
    {
        // Calculate the transformMatrix.
        double ratio = samplesRecorded/getInfoTable()->getVirtualWidth();

        QMatrix4x4 matrix;
        matrix.ortho(QRectF(getInfoTable()->getPosition()*ratio, 0, width()*ratio, height()));

        gl()->glUseProgram(signalProgram->getGLProgram());

        GLuint location = gl()->glGetUniformLocation(signalProgram->getGLProgram(), "transformMatrix");
        checkNotErrorCode(location, static_cast<GLuint>(-1), "glGetUniformLocation() failed.");
        gl()->glUniformMatrix4fv(location, 1, GL_FALSE, matrix.data());

        gl()->glUseProgram(eventProgram->getGLProgram());

        location = gl()->glGetUniformLocation(eventProgram->getGLProgram(), "transformMatrix");
        checkNotErrorCode(location, static_cast<GLuint>(-1), "glGetUniformLocation() failed.");
        gl()->glUniformMatrix4fv(location, 1, GL_FALSE, matrix.data());

        location = gl()->glGetUniformLocation(eventProgram->getGLProgram(), "divideBy");
        checkNotErrorCode(location, static_cast<GLuint>(-1), "glGetUniformLocation() failed.");
        gl()->glUniform1i(location, eventMode);

        location = gl()->glGetUniformLocation(eventProgram->getGLProgram(), "eventWidth");
        checkNotErrorCode(location, static_cast<GLuint>(-1), "glGetUniformLocation() failed.");
        gl()->glUniform1f(location, 0.45*height()/signalProcessor->getTrackCount());

        gl()->glUseProgram(rectangleLineProgram->getGLProgram());

        location = gl()->glGetUniformLocation(rectangleLineProgram->getGLProgram(), "transformMatrix");
        checkNotErrorCode(location, static_cast<GLuint>(-1), "glGetUniformLocation() failed.");
        gl()->glUniformMatrix4fv(location, 1, GL_FALSE, matrix.data());

        // Create the data block range needed.
        int firstSample = static_cast<unsigned int>(floor(getInfoTable()->getPosition()*ratio));
        int lastSample = static_cast<unsigned int>(ceil((getInfoTable()->getPosition() + width())*ratio));

        auto fromTo = DataFile::sampleRangeToBlockRange(make_pair(firstSample, lastSample), signalProcessor->getBlockSize());

        set<int> indexSet;

        for (int i = fromTo.first; i <= fromTo.second; ++i)
        {
            indexSet.insert(i);
        }

        // Get events.
        vector<tuple<int, int, int>> allChannelEvents;
        vector<tuple<int, int, int, int>> singleChannelEvents;
        currentEventTable()->getEventsForRendering(firstSample, lastSample, &allChannelEvents, &singleChannelEvents);

        // Draw.
        drawTimeLines();
        drawAllChannelEvents(allChannelEvents);

        while (indexSet.empty() == false)
        {
            SignalBlock block = signalProcessor->getAnyBlock(indexSet);

            drawSingleChannelEvents(block, singleChannelEvents);
            drawSignal(block);

            gl()->glFlush();

            indexSet.erase(block.getIndex());

            //logToFile("Block " << block.getIndex() << " painted.");
        }

        drawPositionIndicator();
        drawCross();

        glBindVertexArray(0);
    }

    gl()->glFinish();

    checkGLMessages();

#ifndef NDEBUG
    logToFile("Painting finished.");
#endif
}
Пример #13
0
void GraphicsLayer13::setModelview(const QMatrix4x4& matrix)
{
	GLfloat modelview[16];
	convertMatrix(matrix.constData(), modelview);
	glLoadMatrixf(modelview);
}
Пример #14
0
/*!
    Returns the spotDirection() for this light after transforming it
    from world co-ordinates to eye co-ordinates using the top-left
    3x3 submatrix within \a transform.

    The returned result is suitable to be applied to the GL_SPOT_DIRECTION
    property of \c{glLight()}, assuming that the modelview transformation
    in the GL context is set to the identity.

    \sa eyePosition()
*/
QVector3D QGLLightParameters::eyeSpotDirection
    (const QMatrix4x4& transform) const
{
    Q_D(const QGLLightParameters);
    return transform.mapVector(d->spotDirection);
}
Пример #15
0
//! [3]
void GlWidget::paintGL()
{
    //! [3]
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    QMatrix4x4 mMatrix;
    QMatrix4x4 vMatrix;

    QMatrix4x4 cameraTransformation;
    cameraTransformation.rotate(alpha, 0, 1, 0);
    cameraTransformation.rotate(beta, 1, 0, 0);

    QVector3D cameraPosition = cameraTransformation * QVector3D(0, 0, distance);
    QVector3D cameraUpDirection = cameraTransformation * QVector3D(0, 1, 0);

    vMatrix.lookAt(cameraPosition, QVector3D(0, 0, 0), cameraUpDirection);

    mMatrix.setToIdentity();

    QMatrix4x4 mvMatrix;
    mvMatrix = vMatrix * mMatrix;

    QMatrix3x3 normalMatrix;
    normalMatrix = mvMatrix.normalMatrix();

    QMatrix4x4 lightTransformation;
    lightTransformation.rotate(lightAngle, 0, 1, 0);

    QVector3D lightPosition = lightTransformation * QVector3D(0, 1, 1);

    lightingShaderProgram.bind();

    lightingShaderProgram.setUniformValue("mvpMatrix", pMatrix * mvMatrix);
    lightingShaderProgram.setUniformValue("mvMatrix", mvMatrix);
    lightingShaderProgram.setUniformValue("normalMatrix", normalMatrix);
    lightingShaderProgram.setUniformValue("lightPosition", vMatrix * lightPosition);

    lightingShaderProgram.setUniformValue("ambientColor", QColor(32, 32, 32));
    lightingShaderProgram.setUniformValue("diffuseColor", QColor(128, 128, 128));
    lightingShaderProgram.setUniformValue("specularColor", QColor(255, 255, 255));
    lightingShaderProgram.setUniformValue("ambientReflection", (GLfloat) 1.0);
    lightingShaderProgram.setUniformValue("diffuseReflection", (GLfloat) 1.0);
    lightingShaderProgram.setUniformValue("specularReflection", (GLfloat) 1.0);
    lightingShaderProgram.setUniformValue("shininess", (GLfloat) 100.0);
    lightingShaderProgram.setUniformValue("texture", 0);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, cubeTexture);
    glActiveTexture(0);

    //! [4]
    cubeBuffer.bind();
    int offset = 0;
    lightingShaderProgram.setAttributeBuffer("vertex", GL_FLOAT, offset, 3, 0);
    lightingShaderProgram.enableAttributeArray("vertex");
    offset += numCubeVertices * 3 * sizeof(GLfloat);
    lightingShaderProgram.setAttributeBuffer("normal", GL_FLOAT, offset, 3, 0);
    lightingShaderProgram.enableAttributeArray("normal");
    offset += numCubeVertices * 3 * sizeof(GLfloat);
    lightingShaderProgram.setAttributeBuffer("textureCoordinate", GL_FLOAT, offset, 2, 0);
    lightingShaderProgram.enableAttributeArray("textureCoordinate");
    cubeBuffer.release();

    glDrawArrays(GL_TRIANGLES, 0, numCubeVertices);
    //! [4]

    lightingShaderProgram.disableAttributeArray("vertex");
    lightingShaderProgram.disableAttributeArray("normal");
    lightingShaderProgram.disableAttributeArray("textureCoordinate");

    lightingShaderProgram.release();

    mMatrix.setToIdentity();
    mMatrix.translate(lightPosition);
    mMatrix.rotate(lightAngle, 0, 1, 0);
    mMatrix.rotate(45, 1, 0, 0);
    mMatrix.scale(0.1);

    coloringShaderProgram.bind();

    coloringShaderProgram.setUniformValue("mvpMatrix", pMatrix * vMatrix * mMatrix);

    //! [5]
    spotlightBuffer.bind();
    offset = 0;
    coloringShaderProgram.setAttributeBuffer("vertex", GL_FLOAT, offset, 3, 0);
    coloringShaderProgram.enableAttributeArray("vertex");
    offset += numSpotlightVertices * 3 * sizeof(GLfloat);
    coloringShaderProgram.setAttributeBuffer("color", GL_FLOAT, offset, 3, 0);
    coloringShaderProgram.enableAttributeArray("color");
    spotlightBuffer.release();

    glDrawArrays(GL_TRIANGLES, 0, numSpotlightVertices);
    //! [5]

    coloringShaderProgram.disableAttributeArray("vertex");
    coloringShaderProgram.disableAttributeArray("color");

    coloringShaderProgram.release();
    //! [6]
}
Пример #16
0
void MainWidget::paintGL()
{

    makeCurrent();

    QPainter painter;
    painter.begin(this);
    painter.beginNativePainting();

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    // Enable depth buffer

    if(bDepthTest)
        glEnable(GL_DEPTH_TEST);

    QQuaternion quat = this->trackball.rotation();

    // Calculate model view transformation
    QMatrix4x4 modelviewearth;
    modelviewearth.translate(0.0, 0.0, distance);
    modelviewearth.rotate(quat);

    QMatrix4x4 rotmatrix;
    rotmatrix.rotate(quat);

    programskybox.bind();
    skybox->render(projection, modelviewearth, rotmatrix);
    programskybox.release();


    if(bWireFrame) // Draw as wireframe
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    else
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

    if(bTexture)
    {
        if(bNoBump)
        {
            programearthnobump.bind();
            textureearth->bind(0);
            geometries->render(projection, modelviewearth, bNoBump);
            textureearth->release();
            programearthnobump.release();
        }
        else
        {
            programearth.bind();
            textureearth->bind(0);
            texturenormal->bind(1);
            geometries->render(projection, modelviewearth, bNoBump);

            texturenormal->release();
            textureearth->release();
            programearth.release();
        }
    }

    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

    if(bBorders)
    {
        programgshhs.bind();
        gshhs->render(projection, modelviewearth);
        gshhs->rendersoc(projection, modelviewearth);
        programgshhs.release();
    }

    glDisable(GL_DEPTH_TEST);

    painter.endNativePainting();

    QString framesPerSecond;
    if (const int elapsed = m_time.elapsed()) {
        framesPerSecond.setNum(m_frames /(elapsed / 1000.0), 'f', 2);
        painter.setPen(Qt::white);
        painter.drawText(20, 40, framesPerSecond + " paintGL calls / s");
    }

    //this->setWindowTitle(framesPerSecond + " paintGL calls / s" );

    painter.end();

    if (!(m_frames % 100)) {
        m_time.start();
        m_frames = 0;
    }
    ++m_frames;

}
Пример #17
0
void MyGLWidget::draw()
{
#ifdef MOBILE_OS
    const qreal retinaScale = devicePixelRatio();
    glViewport(0, 0, width() * retinaScale, height() * retinaScale);

    glClear(GL_COLOR_BUFFER_BIT);

    m_program->bind();

    QMatrix4x4 matrix;

    matrix.ortho(0.0f,width(), 0.f,height(), -1, 1);
    m_program->setUniformValue(m_matrixUniform, matrix);


    GLfloat vertices[] = {
        0.0f, 0.f,
        0.0f, 100.f,
        100.0f, 0.0f,
    };

    GLfloat colors[] = {
        1.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 1.0f,
    };

    GLfloat texts[] = {
        0.0f, 0.f,
        0.0f, 1.f,
        1.0f, 0.0f
    };





    auto obj = m_app_seg.get_dsc_obj();

    static GLfloat vptr[100000];// = new GLfloat[obj.get_no_faces()*3*2];
    static GLfloat cptr[100000];// = new GLfloat[obj.get_no_faces()*3*3];

    int idx = 0;
    for(auto fkey : obj->faces()){
        auto tris = obj->get_pos(fkey);
        for(int i = 0; i < 3; i++){
            auto v = tris[i];

            vptr[idx*6 + i*2 + 0] = v[0];
            vptr[idx*6 + i*2 + 1] = v[1];

            cptr[idx*9 + i*3 + 0] = v[0]/600.f;
            cptr[idx*9 + i*3 + 1] = v[0]/600.f;
            cptr[idx*9 + i*3 + 2] = v[0]/600.f;
        }
        idx ++;
    }


//    for(int i = 0; i < obj.get_no_faces()*3; i++){
//        printf("%f %f %f %f %f\n", vptr[i*2], vptr[i*2 + 1],
//                        cptr[i*3], cptr[i*3 + 1], cptr[i*3 + 2]);
//    }


//    glVertexAttribPointer(m_posAttr, 2, GL_FLOAT, GL_FALSE, 0, vptr);
//    glVertexAttribPointer(m_colAttr, 3, GL_FLOAT, GL_FALSE, 0, cptr);


//    glEnableVertexAttribArray(0);
//    glEnableVertexAttribArray(1);

//    glDrawArrays(GL_TRIANGLES, 0, obj->get_no_faces()*3);

//    glDisableVertexAttribArray(1);
//    glDisableVertexAttribArray(0);

    static GLfloat edge_v[10000];
    GLfloat edge_cl[10000];

    int eidx = 0;
    for(auto ekey : obj->halfedges()){
        auto hew = obj->walker(ekey);
        {
            Vec2 v0 = obj->get_pos(hew.vertex());
            Vec2 v1 = obj->get_pos(hew.opp().vertex());
            edge_v[eidx*4] = v0[0];
            edge_v[eidx*4 + 1] = v0[1];
            edge_v[eidx*4 + 2] = v1[0];
            edge_v[eidx*4 + 3] = v1[1];

            for(int i = 0; i < 2; i++){
                edge_cl[eidx*6 + i*3] = 1.0;
                edge_cl[eidx*6 + i*3 + 1] = 0.0;
                edge_cl[eidx*6 + i*3 + 2] = 0.0;
            }
        }
        eidx++;
    }

    int num = obj->get_no_halfedges();
    cout << num;

//    for(int i = 0; i < obj->get_no_halfedges(); i++){
//        printf("%f %f %f %f %f\n", edge_v[i*2], edge_v[i*2 + 1],
//                        edge_cl[i*3], edge_cl[i*3 + 1], edge_cl[i*3 + 2]);
//    }

    glVertexAttribPointer(m_posAttr, 2, GL_FLOAT, GL_FALSE, 0, edge_v);
    glVertexAttribPointer(m_colAttr, 3, GL_FLOAT, GL_FALSE, 0, edge_cl);

    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);

    glDrawArrays(GL_LINES, 0, 2*obj->get_no_halfedges());

    glDisableVertexAttribArray(1);
    glDisableVertexAttribArray(0);


    m_program->release();


    ++m_frame;
    printf("Display: %d \n", m_frame);
#else
    qglColor(Qt::red);
    glBegin(GL_QUADS);
        glNormal3f(0,0,-1);
        glVertex3f(-1,-1,0);
        glVertex3f(-1,1,0);
        glVertex3f(1,1,0);
        glVertex3f(1,-1,0);

    glEnd();
    glBegin(GL_TRIANGLES);
        glNormal3f(0,-1,0.707);
        glVertex3f(-1,-1,0);
        glVertex3f(1,-1,0);
        glVertex3f(0,0,1.2);
    glEnd();
    glBegin(GL_TRIANGLES);
        glNormal3f(1,0, 0.707);
        glVertex3f(1,-1,0);
        glVertex3f(1,1,0);
        glVertex3f(0,0,1.2);
    glEnd();
    glBegin(GL_TRIANGLES);
        glNormal3f(0,1,0.707);
        glVertex3f(1,1,0);
        glVertex3f(-1,1,0);
        glVertex3f(0,0,1.2);
    glEnd();
    glBegin(GL_TRIANGLES);
        glNormal3f(-1,0,0.707);
        glVertex3f(-1,1,0);
        glVertex3f(-1,-1,0);
        glVertex3f(0,0,1.2);
    glEnd();
#endif
}
Пример #18
0
void Renderer::render()
{
    if (m_exiting)
        return;

    QOpenGLContext *ctx = m_glwidget->context();
    if (!ctx) // QOpenGLWidget not yet initialized
        return;

    // Grab the context.
    m_grabMutex.lock();
    emit contextWanted();
    m_grabCond.wait(&m_grabMutex);
    QMutexLocker lock(&m_renderMutex);
    m_grabMutex.unlock();

    if (m_exiting)
        return;

    Q_ASSERT(ctx->thread() == QThread::currentThread());

    // Make the context (and an offscreen surface) current for this thread. The
    // QOpenGLWidget's fbo is bound in the context.
    m_glwidget->makeCurrent();

    if (!m_inited) {
        m_inited = true;
        initializeOpenGLFunctions();

        QMutexLocker initLock(initMutex());
        QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
        const char *vsrc =
            "attribute highp vec4 vertex;\n"
            "attribute mediump vec3 normal;\n"
            "uniform mediump mat4 matrix;\n"
            "varying mediump vec4 color;\n"
            "void main(void)\n"
            "{\n"
            "    vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));\n"
            "    float angle = max(dot(normal, toLight), 0.0);\n"
            "    vec3 col = vec3(0.40, 1.0, 0.0);\n"
            "    color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);\n"
            "    color = clamp(color, 0.0, 1.0);\n"
            "    gl_Position = matrix * vertex;\n"
            "}\n";
        vshader->compileSourceCode(vsrc);

        QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
        const char *fsrc =
            "varying mediump vec4 color;\n"
            "void main(void)\n"
            "{\n"
            "    gl_FragColor = color;\n"
            "}\n";
        fshader->compileSourceCode(fsrc);

        program.addShader(vshader);
        program.addShader(fshader);
        program.link();

        vertexAttr = program.attributeLocation("vertex");
        normalAttr = program.attributeLocation("normal");
        matrixUniform = program.uniformLocation("matrix");

        m_fAngle = 0;
        m_fScale = 1;
        createGeometry();

        vbo.create();
        vbo.bind();
        const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
        vbo.allocate(verticesSize * 2);
        vbo.write(0, vertices.constData(), verticesSize);
        vbo.write(verticesSize, normals.constData(), verticesSize);

        m_elapsed.start();
    }

    //qDebug("%p elapsed %lld", QThread::currentThread(), m_elapsed.restart());

    glClearColor(0.1f, 0.2f, 0.2f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glFrontFace(GL_CW);
    glCullFace(GL_FRONT);
    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);

    QMatrix4x4 modelview;
    modelview.rotate(m_fAngle, 0.0f, 1.0f, 0.0f);
    modelview.rotate(m_fAngle, 1.0f, 0.0f, 0.0f);
    modelview.rotate(m_fAngle, 0.0f, 0.0f, 1.0f);
    modelview.scale(m_fScale);
    modelview.translate(0.0f, -0.2f, 0.0f);

    program.bind();
    program.setUniformValue(matrixUniform, modelview);
    paintQtLogo();
    program.release();

    glDisable(GL_DEPTH_TEST);
    glDisable(GL_CULL_FACE);

    m_fAngle += 1.0f;

    // Make no context current on this thread and move the QOpenGLWidget's
    // context back to the gui thread.
    m_glwidget->doneCurrent();
    ctx->moveToThread(qGuiApp->thread());

    // Schedule composition. Note that this will use QueuedConnection, meaning
    // that update() will be invoked on the gui thread.
    QMetaObject::invokeMethod(m_glwidget, "update");
}
Пример #19
0
 void set_transform(QMatrix4x4 m)
 {
   m_trans = m;
   m_invtrans = m.inverted();
 }
Пример #20
0
// handles zoom and translation
QMatrix4x4 OrthographicCamera::getViewMatrix(int width, int height)
{
    QMatrix4x4 m;
    m.setToIdentity();
    return m;
}
Пример #21
0
void Scene::deferredRendering(RenderTarget * target)
{
    if(target->isEnableClipPlane ())
    {
        glEnable(GL_CLIP_PLANE0);
        glClipPlane(GL_CLIP_PLANE0, target->getClipPlane());
    }
    if(!this->spotLights.empty ())
    {
        this->shadowPassForSpot(spotLights[0],target);
    }
    if(this->directionLight.getIntensity ()>0)
    {
        this->shadowPassDirectional (target);
    }

    geometryPass(target);
    if(target->isEnableClipPlane ())
    {
        glDisable(GL_CLIP_PLANE0);
    }
    glEnable(GL_BLEND);
    glBlendEquation(GL_FUNC_ADD);
    glBlendFunc(GL_ONE, GL_ONE);
    target->getGBuffer ()->BindForReading(bloom_fbo1->buffer ());

    lightPass(target);

    bloom_fbo1->BindForReading (bloom_fbo2);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    pickBright();
    bloom_fbo2->BindForReading (bloom_fbo3);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    gaussianBlur_H (2);
    bloom_fbo3->BindForReading (NULL);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    gaussianBlur_V (2);

    if(target->type () == RenderTarget::TargetType::ON_SCREEN)
    {
        bloom_fbo1->BindForReading (NULL);
    }
    else
    {
        bloom_fbo1->BindForReading (target->resultBuffer ());
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    ShaderProgram * shader =ShaderPool::getInstance ()->get("deffered_simple");
    shader->use ();
    QMatrix4x4 m;
    m.setToIdentity ();
    m_quad->setShaderProgram (shader);
    auto camera =target->camera ();
    shader->setUniformMat4v ("g_MVP_matrix",m.data ());
    shader->setUniform2Float ("g_screen_size",1024,768);
    shader->setUniformInteger ("g_color_map",0);
    shader->setUniformInteger ("g_position_map",1);
    shader->setUniformInteger ("g_normal_map",2);
    if(camera)
    {
        shader->setUniform3Float ("g_eye_position",
                                  camera->pos ().x(),
                                  camera->pos ().y(),
                                  camera->pos ().z());
    }
    m_quad->draw (true);
}
Пример #22
0
QMatrix4x4 PerspectiveCamera::getViewMatrix(int width, int height)
{
    QMatrix4x4 m;
    m.lookAt(eye(), lookat(), upDir());
    return m;
}
Пример #23
0
void Patch::rotate(qreal deg, QVector3D axis)
{
    mat.rotate(deg, axis);
}
Пример #24
0
void Viewer::drawVisualHints()
{

    CGAL::QGLViewer::drawVisualHints();

    if(d->distance_is_displayed)
    {
        glDisable(GL_DEPTH_TEST);
        QMatrix4x4 mvpMatrix;
        double mat[16];
        camera()->getModelViewProjectionMatrix(mat);
        for(int i=0; i < 16; i++)
        {
          mvpMatrix.data()[i] = (float)mat[i];
        }
        if(!isOpenGL_4_3())
        {
          //draws the distance
          //nullifies the translation
          d->rendering_program_dist.bind();
          d->rendering_program_dist.setUniformValue("mvp_matrix", mvpMatrix);
          d->rendering_program_dist.setUniformValue("point_size", GLfloat(6.0f));
          d->vao.bind();
          glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(2));
          glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(2));
          d->vao.release();
          d->rendering_program_dist.release();
          glEnable(GL_DEPTH_TEST);
        }
        else
        {          
          QOpenGLShaderProgram* program = getShaderProgram(PROGRAM_SOLID_WIREFRAME);
          program->bind();
          QVector2D vp(width(), height());
          program->setUniformValue("viewport", vp);
          program->setUniformValue("near",(GLfloat)camera()->zNear());
          program->setUniformValue("far",(GLfloat)camera()->zFar());
          program->setUniformValue("width", GLfloat(3.0f));
          program->setAttributeValue("colors", QColor(Qt::black));
          program->setUniformValue("mvp_matrix", mvpMatrix);
          QMatrix4x4 f_mat;
          f_mat.setToIdentity();
          program->setUniformValue("f_matrix", f_mat);
          d->vao.bind();
          glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(2));
          d->vao.release();
          program->release();
          
          program = getShaderProgram(PROGRAM_NO_SELECTION);
          program->bind();
          program->setAttributeValue("colors", QColor(Qt::black));
          program->setAttributeValue("point_size", 6.0f);
          program->setUniformValue("mvp_matrix", mvpMatrix);
          program->setUniformValue("f_matrix", f_mat);
          d->vao.bind();
          glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(2));
          d->vao.release();
          program->release();
        }

    }
    if (!d->painter->isActive())
      d->painter->begin(this);
    //So that the text is drawn in front of everything
    d->painter->beginNativePainting();
    glDisable(GL_DEPTH_TEST);
    d->painter->endNativePainting();
    //Prints the displayMessage
    QFont font = QFont();
    QFontMetrics fm(font);
    TextItem *message_text = new TextItem(float(10 + fm.width(d->message)/2),
                                          float(height()-20),
                                          0, d->message, false,
                                          QFont(), Qt::gray );
    if (d->_displayMessage)
    {
      d->textRenderer->addText(message_text);
    }
    d->textRenderer->draw(this);
    
    if (d->_displayMessage)
      d->textRenderer->removeText(message_text);
}
Пример #25
0
void CoverSwitchEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
{
    effects->paintScreen(mask, region, data);

    if (mActivated || stop || stopRequested) {
        QMatrix4x4 origProjection;
        QMatrix4x4 origModelview;
        ShaderManager *shaderManager = ShaderManager::instance();
        if (effects->numScreens() > 1) {
            // unfortunatelly we have to change the projection matrix in dual screen mode
            QRect fullRect = effects->clientArea(FullArea, activeScreen, effects->currentDesktop());
            float fovy = 60.0f;
            float aspect = 1.0f;
            float zNear = 0.1f;
            float zFar = 100.0f;
            float ymax = zNear * tan(fovy  * M_PI / 360.0f);
            float ymin = -ymax;
            float xmin =  ymin * aspect;
            float xmax = ymax * aspect;
            float xTranslate = 0.0;
            float yTranslate = 0.0;
            float xminFactor = 1.0;
            float xmaxFactor = 1.0;
            float yminFactor = 1.0;
            float ymaxFactor = 1.0;
            if (area.x() == 0 && area.width() != fullRect.width()) {
                // horizontal layout: left screen
                xminFactor = (float)area.width() / (float)fullRect.width();
                xmaxFactor = ((float)fullRect.width() - (float)area.width() * 0.5f) / ((float)fullRect.width() * 0.5f);
                xTranslate = (float)fullRect.width() * 0.5f - (float)area.width() * 0.5f;
            }
            if (area.x() != 0 && area.width() != fullRect.width()) {
                // horizontal layout: right screen
                xminFactor = ((float)fullRect.width() - (float)area.width() * 0.5f) / ((float)fullRect.width() * 0.5f);
                xmaxFactor = (float)area.width() / (float)fullRect.width();
                xTranslate = (float)fullRect.width() * 0.5f - (float)area.width() * 0.5f;
            }
            if (area.y() == 0 && area.height() != fullRect.height()) {
                // vertical layout: top screen
                yminFactor = ((float)fullRect.height() - (float)area.height() * 0.5f) / ((float)fullRect.height() * 0.5f);
                ymaxFactor = (float)area.height() / (float)fullRect.height();
                yTranslate = (float)fullRect.height() * 0.5f - (float)area.height() * 0.5f;
            }
            if (area.y() != 0 && area.height() != fullRect.height()) {
                // vertical layout: bottom screen
                yminFactor = (float)area.height() / (float)fullRect.height();
                ymaxFactor = ((float)fullRect.height() - (float)area.height() * 0.5f) / ((float)fullRect.height() * 0.5f);
                yTranslate = (float)fullRect.height() * 0.5f - (float)area.height() * 0.5f;
            }
            QMatrix4x4 projection;
            projection.frustum(xmin * xminFactor, xmax * xmaxFactor, ymin * yminFactor, ymax * ymaxFactor, zNear, zFar);
            QMatrix4x4 modelview;
            modelview.translate(xTranslate, yTranslate, 0.0);
            if (shaderManager->isShaderBound()) {
                GLShader *shader = shaderManager->pushShader(ShaderManager::GenericShader);
                origProjection = shader->getUniformMatrix4x4("projection");
                origModelview = shader->getUniformMatrix4x4("modelview");
                shader->setUniform("projection", projection);
                shader->setUniform("modelview", origModelview * modelview);
                shaderManager->popShader();
            } else {
#ifndef KWIN_HAVE_OPENGLES
                glMatrixMode(GL_PROJECTION);
                pushMatrix();
                loadMatrix(projection);
                glMatrixMode(GL_MODELVIEW);
                pushMatrix(modelview);
#endif
            }
        }

        QList< EffectWindow* > tempList = currentWindowList;
        int index = tempList.indexOf(selected_window);
        if (animation || start || stop) {
            if (!start && !stop) {
                if (direction == Right)
                    index++;
                else
                    index--;
                if (index < 0)
                    index = tempList.count() + index;
                if (index >= tempList.count())
                    index = index % tempList.count();
            }
            foreach (Direction direction, scheduled_directions) {
                if (direction == Right)
                    index++;
                else
                    index--;
                if (index < 0)
                    index = tempList.count() + index;
                if (index >= tempList.count())
                    index = index % tempList.count();
            }
        }
        int leftIndex = index - 1;
        if (leftIndex < 0)
            leftIndex = tempList.count() - 1;
        int rightIndex = index + 1;
        if (rightIndex == tempList.count())
            rightIndex = 0;

        EffectWindow* frontWindow = tempList[ index ];
        leftWindows.clear();
        rightWindows.clear();

        bool evenWindows = (tempList.count() % 2 == 0) ? true : false;
        int leftWindowCount = 0;
        if (evenWindows)
            leftWindowCount = tempList.count() / 2 - 1;
        else
            leftWindowCount = (tempList.count() - 1) / 2;
        for (int i = 0; i < leftWindowCount; i++) {
            int tempIndex = (leftIndex - i);
            if (tempIndex < 0)
                tempIndex = tempList.count() + tempIndex;
            leftWindows.prepend(tempList[ tempIndex ]);
        }
        int rightWindowCount = 0;
        if (evenWindows)
            rightWindowCount = tempList.count() / 2;
        else
            rightWindowCount = (tempList.count() - 1) / 2;
        for (int i = 0; i < rightWindowCount; i++) {
            int tempIndex = (rightIndex + i) % tempList.count();
            rightWindows.prepend(tempList[ tempIndex ]);
        }

        if (reflection) {
            // no reflections during start and stop animation
            // except when using a shader
            if ((!start && !stop) || ShaderManager::instance()->isValid())
                paintScene(frontWindow, leftWindows, rightWindows, true);
            glEnable(GL_BLEND);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#ifndef KWIN_HAVE_OPENGLES
            glPolygonMode(GL_FRONT, GL_FILL);
#endif
            QRect fullRect = effects->clientArea(FullArea, activeScreen, effects->currentDesktop());
            // we can use a huge scale factor (needed to calculate the rearground vertices)
            // as we restrict with a PaintClipper painting on the current screen
            float reflectionScaleFactor = 100000 * tan(60.0 * M_PI / 360.0f) / area.width();
            float vertices[] = {
                -area.width() * 0.5f, area.height(), 0.0,
                area.width() * 0.5f, area.height(), 0.0,
                (float)area.width()*reflectionScaleFactor, area.height(), -5000,
                -(float)area.width()*reflectionScaleFactor, area.height(), -5000
            };
            // foreground
            if (start) {
                mirrorColor[0][3] = timeLine.currentValue();
            } else if (stop) {
                mirrorColor[0][3] = 1.0 - timeLine.currentValue();
            } else {
                mirrorColor[0][3] = 1.0;
            }

            int y = 0;
            // have to adjust the y values to fit OpenGL
            // in OpenGL y==0 is at bottom, in Qt at top
            if (effects->numScreens() > 1) {
                QRect fullArea = effects->clientArea(FullArea, 0, 1);
                if (fullArea.height() != area.height()) {
                    if (area.y() == 0)
                        y = fullArea.height() - area.height();
                    else
                        y = fullArea.height() - area.y() - area.height();
                }
            }
            // use scissor to restrict painting of the reflection plane to current screen
            glScissor(area.x(), y, area.width(), area.height());
            glEnable(GL_SCISSOR_TEST);

            if (shaderManager->isValid() && m_reflectionShader->isValid()) {
                shaderManager->pushShader(m_reflectionShader);
                QMatrix4x4 windowTransformation;
                windowTransformation.translate(area.x() + area.width() * 0.5f, 0.0, 0.0);
                m_reflectionShader->setUniform("windowTransformation", windowTransformation);
                m_reflectionShader->setUniform("u_frontColor", QVector4D(mirrorColor[0][0], mirrorColor[0][1], mirrorColor[0][2], mirrorColor[0][3]));
                m_reflectionShader->setUniform("u_backColor", QVector4D(mirrorColor[1][0], mirrorColor[1][1], mirrorColor[1][2], mirrorColor[1][3]));
                // TODO: make this one properly
                QVector<float> verts;
                QVector<float> texcoords;
                verts.reserve(18);
                texcoords.reserve(12);
                texcoords << 1.0 << 0.0;
                verts << vertices[6] << vertices[7] << vertices[8];
                texcoords << 1.0 << 0.0;
                verts << vertices[9] << vertices[10] << vertices[11];
                texcoords << 0.0 << 0.0;
                verts << vertices[0] << vertices[1] << vertices[2];
                texcoords << 0.0 << 0.0;
                verts << vertices[0] << vertices[1] << vertices[2];
                texcoords << 0.0 << 0.0;
                verts << vertices[3] << vertices[4] << vertices[5];
                texcoords << 1.0 << 0.0;
                verts << vertices[6] << vertices[7] << vertices[8];
                GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
                vbo->reset();
                vbo->setData(6, 3, verts.data(), texcoords.data());
                vbo->render(GL_TRIANGLES);

                shaderManager->popShader();
            } else {
#ifndef KWIN_HAVE_OPENGLES
                glPushMatrix();
                if (effects->numScreens() > 1 && area.x() != fullRect.x()) {
                    // have to change the reflection area in horizontal layout and right screen
                    glTranslatef(-area.x(), 0.0, 0.0);
                }
                glTranslatef(area.x() + area.width() * 0.5f, 0.0, 0.0);
                glColor4fv(mirrorColor[0]);
                glBegin(GL_POLYGON);
                glVertex3f(vertices[0], vertices[1], vertices[2]);
                glVertex3f(vertices[3], vertices[4], vertices[5]);
                // rearground
                glColor4fv(mirrorColor[1]);
                glVertex3f(vertices[6], vertices[7], vertices[8]);
                glVertex3f(vertices[9], vertices[10], vertices[11]);
                glEnd();

                glPopMatrix();
#endif
            }
            glDisable(GL_SCISSOR_TEST);
            glDisable(GL_BLEND);
        }
        paintScene(frontWindow, leftWindows, rightWindows);

        if (effects->numScreens() > 1) {
            if (shaderManager->isShaderBound())  {
                GLShader *shader = shaderManager->pushShader(ShaderManager::GenericShader);
                shader->setUniform("projection", origProjection);
                shader->setUniform("modelview", origModelview);
                shaderManager->popShader();
            } else {
#ifndef KWIN_HAVE_OPENGLES
                popMatrix();
                // revert change of projection matrix
                glMatrixMode(GL_PROJECTION);
                popMatrix();
                glMatrixMode(GL_MODELVIEW);
#endif
            }
        }

        // Render the caption frame
        if (windowTitle) {
            double opacity = 1.0;
            if (start)
                opacity = timeLine.currentValue();
            else if (stop)
                opacity = 1.0 - timeLine.currentValue();
            if (animation)
                captionFrame->setCrossFadeProgress(timeLine.currentValue());
            captionFrame->render(region, opacity);
        }

        if ((thumbnails && (!dynamicThumbnails ||
                           (dynamicThumbnails && currentWindowList.size() >= thumbnailWindows)))
                && !(start || stop)) {
            BoxSwitchEffectProxy *proxy =
                static_cast<BoxSwitchEffectProxy*>(effects->getProxy("boxswitch"));
            if (proxy)
                proxy->paintWindowsBox(region);
        }
    }
Пример #26
0
void QtWebPageSGNode::setScale(float scale)
{
    QMatrix4x4 matrix;
    matrix.scale(scale);
    setMatrix(matrix);
}
Пример #27
0
/**
 * @brief GlSphere::makeSurface North pole is (0,radius, 0), south pole is (0, -radius, 0)
 * We use true normals. On a sphere vertex and normal have the same direction.
 * @param pointContainer
 */
void GLSphere::makeSurface(QVector<GLPoint> *pointContainer, QVector<GLuint> *indexContainer)
{
    GLBody::makeSurface(pointContainer, indexContainer);
    QVector3D southPole = -v_Z; //unit vector, must be scaled by radius later
    QVector3D northPole = v_Z;
    QVector3D vertex;
    QVector3D normal;
    QVector3D texCoord;
    QMatrix4x4 longitudeMatrix;
    QMatrix4x4 latitudeMatrix;
    int iSouthPole = 0; //indices for the poles
    int iNorthPole = 0;

    //start with south pole
    m_firstPoint = m_points->size();
    m_firstIndex = m_indices->size();
    iSouthPole = m_firstPoint;
    m_points->append(GLPoint(southPole * m_radius,  //vertex
                           southPole,               //normal
                           QVector3D(0.5, 0.0, 0.0),//texCoord at 0 longitude
                           m_color));

    int firstRow = 1;
    int lastRow = m_stacks - 1;
    int slice;
    int duplicates = 1;
    for(slice = 0; slice < m_slices; slice ++)
    {
        longitudeMatrix.setToIdentity();//always start from scratch
        longitudeMatrix.rotate(slice * 360.0 / m_slices, -v_Z);
        if(slice == m_slices / 2) //we need to switch from end of texture to start of texture here
            duplicates = 2;
        else duplicates = 1;
        for(int duplicate = 0; duplicate < duplicates; duplicate++) // create an extra column of points
        for(int stack = firstRow; stack <= lastRow; stack ++)       // to switch from end of texture to start of texture
        {
           latitudeMatrix.setToIdentity(); //always start from scratch
           latitudeMatrix.rotate(stack * 180.0 / m_stacks, v_Y);
           vertex = (southPole * latitudeMatrix) * longitudeMatrix;
           normal = vertex;
           vertex *= m_radius;
           double texX = (double)slice / (double) m_slices + 0.5;
           if(texX > 1.01)
               texX -= 1.0;
           if(duplicate == 1)
               texX = 0.0;
           texCoord = QVector3D(texX, (double)stack / (double)m_stacks, 0.0);  //floats required!!
           m_points->append(GLPoint(vertex, normal, texCoord, m_color));
        }
    }
    //end with north pole
    iNorthPole = m_points->size();
    m_points->append(GLPoint(northPole * m_radius,  //vertex
                           northPole,               //normal
                           QVector3D(0.5, 1.0, 0.0),//texCoord at 0 longitude
                           m_color));
    m_nextPoint = m_points->size();

    for(int i = m_firstPoint; i < m_nextPoint; i++) //move to final position
        (*m_points)[i].move(m_center);


    int rows = m_stacks - 1;
    for(slice = 0; slice < m_slices; slice += 2)
    {
        //go upwards from south pole to north pole
        m_indices->append(iSouthPole);
        for(int stack = firstRow; stack <= lastRow; stack ++)
        {
           m_indices->append(iSouthPole + rows * slice + stack); //left meridian
           m_indices->append(iSouthPole + rows * slice + rows + stack ); //right meridian
        }
        m_indices->append(iNorthPole);

        //now go downwards back to southpole
        for(int stack = lastRow; stack >= firstRow; stack --)
        {
           m_indices->append(iSouthPole + rows * slice + rows + stack); //left meridian
           m_indices->append(iSouthPole + rows * slice + rows + rows + stack); //right meridian
        }
        //southpole will be added in next slice
    }

    //Close the sphere
    //go upwards from south pole to north pole
    m_indices->append(iSouthPole);
    for(int stack = firstRow; stack <= lastRow; stack ++)
    {
       m_indices->append(iSouthPole + rows * slice + stack); //left meridian = last meridian
       m_indices->append(iSouthPole + stack ); //right meridian = first meridian
    }
    m_indices->append(iNorthPole);

    m_indices->append(iSouthPole); //finally add south pole

    m_nextIndex = m_indices->size();

}
Пример #28
0
void NormalMapScene::render()
{
    //dumpTextureUnitConfiguration();

    // Enable depth buffer writes (QQ2 disables them)
    glDepthMask( true );

    // Clear the buffer with the current clearing color
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    m_mesh->material()->bind();
    QOpenGLShaderProgramPtr shader = m_mesh->material()->shader();

    {
        QMutexLocker locker( &m_mutex );

        // Set the usual view/projection matrices
        QMatrix4x4 modelViewMatrix = m_camera->viewMatrix() * m_modelMatrix;
        QMatrix3x3 normalMatrix = modelViewMatrix.normalMatrix();
        QMatrix4x4 mvp = m_camera->viewProjectionMatrix() * m_modelMatrix;

        shader->setUniformValue( "modelViewMatrix", modelViewMatrix );
        shader->setUniformValue( "normalMatrix", normalMatrix );
        shader->setUniformValue( "projectionMatrix", m_camera->projectionMatrix() );
        shader->setUniformValue( "mvp", mvp );
    }

    // Set the lighting parameters
    shader->setUniformValue( "light.position", QVector4D( 0.0f, 0.0f, 0.0f, 1.0f ) );
    shader->setUniformValue( "light.intensity", QVector3D( 1.0f, 1.0f, 1.0f ) );

    // Set the material properties
    shader->setUniformValue( "material.Ka", QVector3D( 0.1f, 0.1f, 0.1f ) );
    shader->setUniformValue( "material.Kd", QVector3D( 0.9f, 0.9f, 0.9f ) );
    shader->setUniformValue( "material.Ks", QVector3D( 0.2f, 0.2f, 0.2f ) );
    shader->setUniformValue( "material.shininess", 20.0f );

    // Let the mesh setup the remainder of its state and draw itself
#if !defined(Q_OS_MAC)
    m_mesh->render();
#else
    glPushClientAttrib( GL_CLIENT_VERTEX_ARRAY_BIT );
    m_mesh->bindBuffers();
    m_mesh->render();
    glPopClientAttrib();
#endif

    // Unbind shader
    shader->release();

    // Restore texture unit state
    //  - remove sampler objects
    //  - set active texture unit back to the first unit
#if !defined(Q_OS_MAC)
    m_funcs->glBindSampler( 0, 0 );
    m_funcs->glBindSampler( 1, 0 );
#endif
    m_funcs->glActiveTexture( GL_TEXTURE0 );

    //dumpTextureUnitConfiguration();
}
Пример #29
0
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);


}
Пример #30
0
void PSMoveForm::parseMoveData(MoveData d)
{
	setButtons(d.buttons);
	ui->tempLcdNumber->display(d.temperature);
	if (d.battery <= 5) {
		for (int i = 0; i < 5; i++) {
			mBatteryCheckBoxes[i].setChecked(i < d.battery);
		}
		mBatteryLayout->setCurrentIndex(0);
	} else {
		mBatteryLayout->setCurrentIndex(1);
	}
	//emit setRumble(d.buttons.trigger);
	/*const QVector3D acc = d.accelerometer.normalized() * 128 + QVector3D(128, 128, 128);
	const QColor rgb(acc.x(), acc.y(), acc.z());
	static int w = 0;
	if (w++ == 10) {
		w = 0;
		emit setRgb(rgb);
	}*/

	//QVector3D normalisedAcc = d.accelerometer / 32768;
	//QVector3D normalisedMag = d.mag / 32768;
	//normalisedAcc.normalize();
	//normalisedMag = QVector3D::crossProduct(normalisedMag.normalized(), normalisedAcc).normalized();
	//QVector3D north = QVector3D::crossProduct(normalisedMag, normalisedAcc).normalized();

	bool movePressedB = d.buttons.buttonsPressed.contains(MoveButtons::Move);
	if (!mPrevMovePressed && movePressedB) {

		//mOne = normalisedAcc;
		//mTwo = normalisedMag;
		//mThree = north;

		qDebug() << "acc:" << d.accelerometer;
		qDebug() << "mag:" << d.mag;
		emit movePressed();
	}
	mPrevMovePressed = movePressedB;
	/*float one = std::acos(QVector3D::dotProduct(normalisedAcc, mOne));
	float two = std::acos(QVector3D::dotProduct(normalisedMag, mTwo));
	float three = std::acos(QVector3D::dotProduct(north, mThree));*/
	//qDebug() << QString::number(one, 'g', 4) << QString::number(two, 'g', 4) << QString::number(three, 'g', 4);
	/*ui->accXProgressBar->setValue(one * 180 / M_PI);
	ui->accYProgressBar->setValue(two * 180 / M_PI);
	ui->accZProgressBar->setValue(three * 180 / M_PI);*/

	if (ui->accGroupBox->isChecked()) {
		ui->accXProgressBar->setValue(d.accelerometer.x());
		ui->accYProgressBar->setValue(d.accelerometer.y());
		ui->accZProgressBar->setValue(d.accelerometer.z());
	}

	if (ui->gyroGroupBox->isChecked()) {
		ui->gyroXProgressBar->setValue(d.gyro.x());
		ui->gyroYProgressBar->setValue(d.gyro.y());
		ui->gyroZProgressBar->setValue(d.gyro.z());
	}

	if (ui->magGroupBox->isChecked()) {
		ui->magXProgressBar->setValue(d.mag.x());
		ui->magYProgressBar->setValue(d.mag.y());
		ui->magZProgressBar->setValue(d.mag.z());
	}

	bool triPressed = d.buttons.buttonsPressed.contains(MoveButtons::Triangle);
	if (triPressed && !mPrevTriPressed) {
		emit setTopRightCorner();
	}
	mPrevTriPressed = triPressed;

	bool squPressed = d.buttons.buttonsPressed.contains(MoveButtons::Square);
	if (squPressed && !mPrevSquPressed) {
		emit setBottomLeftCorner();
	}
	mPrevSquPressed = squPressed;
#if 0
	QVector3D acc = d.accelerometer;
	QVector3D mag = d.mag;
	acc.normalize();
	mag.normalize();
	QMatrix4x4 m;
	m.setRow(2, acc);
	QVector3D east = QVector3D::crossProduct(acc, -mag);
	m.setRow(0, east);
	QVector3D north = QVector3D::crossProduct(acc, -mag);
	m.setRow(1, north);
	//qDebug() << mag;

//    QVector3D gyro = d.gyro / 32768;
//    acc.setX(mAccFilters[0]->step(acc.x()));
//    acc.setY(mAccFilters[1]->step(acc.y()));
//    acc.setZ(mAccFilters[2]->step(acc.z()));

//    mag.setX(mMagFilters[0]->step(mag.x()));
//    mag.setY(mMagFilters[1]->step(mag.y()));
//    mag.setZ(mMagFilters[2]->step(mag.z()));

	QVector3D newY = acc;
	QVector3D newZ = mag;
	newZ.setZ(-newZ.z());
	QVector3D newX = QVector3D::crossProduct(newZ, newY).normalized();
	QMatrix4x4 newMat;
	newMat.setRow(0, newX);
	newMat.setRow(1, newY);
	newMat.setRow(2, newZ);
	newMat.setRow(3, QVector4D(0, 0, 0, 1));
	float qq1 = q0;
	float qq2 = q1;
	float qq3 = q2;
	float qq4 = q3;
	QQuaternion quat(qq1, qq2, qq3, qq4);
	QVector3D vec(1, 1, 1);
	emit setMatrix(newMat);
	//emit setVector(quat.rotatedVector(vec));
#endif
}