示例#1
0
QVector3D ExtraMath::mouse_raycast(int mx,
                                   int my,
                                   int width,
                                   int height,
                                   float invertedy,
                                   QMatrix4x4 view_matrix,
                                   QMatrix4x4 projection_matrix) {
    // normalize the x-mouse position
    float nx = (2.0f * mx) / width - 1.0f;
    // normalize the y-mouse position
    float ny = invertedy*(1.0f - (2.0f * my) / height);
    // clip the x,y,z values between -1:1
    QVector4D ray_clip = QVector4D(nx, ny, -1, 1.0);
    // invert the projection
    QMatrix4x4 pInverse = projection_matrix.inverted(NULL);
    // invert the view
    QMatrix4x4 vInverse = view_matrix.inverted(NULL);
    // "convert" the normalized ray to the projection values
    QVector4D ray_eye = pInverse*ray_clip;
    // change the w-value of the vector for matrix manipulation purposes
    ray_eye = QVector4D(ray_eye.x(), ray_eye.y(), -1.0, 0);
    // "convert" the new ray to the view values
    QVector4D ray_wor4 = vInverse*ray_eye;
    // take the x,y,z values of the new position
    QVector3D ray_wor = ray_wor4.toVector3D();
    ray_wor.normalize();  // make the ray a unit vector
    // return the raycast of the 2D mouse in the 3D world view projection
    return ray_wor;
}
示例#2
0
int GLWidget::glhUnProjectf(float& winx, float& winy, float& winz,
                            QMatrix4x4& modelview, QMatrix4x4& projection,
                            QVector4D& objectCoordinate)
  {
      //Transformation matrices
      QVector4D in,out;
      //Calculation for inverting a matrix, compute projection x modelview
      //and store in A[16]
      QMatrix4x4  A = projection * modelview;
      //Now compute the inverse of matrix A
      QMatrix4x4  m = A.inverted();

      //Transformation of normalized coordinates between -1 and 1
      in[0]=(winx)/(float)width()*2.0-1.0;
      in[1]=(1-(winy)/(float)height())*2.0-1.0;
      in[2]=2.0*winz-1.0;
      in[3]=1.0;
      //Objects coordinates
      out = m * in;

      if(out[3]==0.0)
         return 0;
      out[3]=1.0/out[3];
      objectCoordinate[0]=out[0]*out[3];
      objectCoordinate[1]=out[1]*out[3];
      objectCoordinate[2]=out[2]*out[3];
      return 1;
  }
示例#3
0
QUniformValue *RenderView::inverseProjectionMatrix(const QMatrix4x4 &) const
{
    QMatrix4x4 projection;
    if (m_data->m_renderCamera)
        projection = m_data->m_renderCamera->projection();
    return QUniformValue::fromVariant(projection.inverted(), m_allocator);
}
示例#4
0
void Scene::draw(const Camera& camera, QOpenGLShaderProgram* program,
                 int uniformsFlags, bool bindProgram) const
{
    if(!_models or !_painter) {
        debugWarning("Null scene or painter not set.");
        return;
    }

    if(bindProgram)
        program->bind();

    if(uniformsFlags & ViewMatrix)
        program->setUniformValue("viewMatrix", camera.viewMatrix());
    if(uniformsFlags & ViewInvMatrix)
        program->setUniformValue("viewInvMatrix", camera.viewMatrix().inverted());
    if(uniformsFlags & ProjMatrix)
        program->setUniformValue("projMatrix", camera.projMatrix());
    if(uniformsFlags & ProjInvMatrix)
        program->setUniformValue("projInvMatrix", camera.projMatrix().inverted());

    QList<QGLSceneNode*> nodes= _models->allChildren();
    nodes << _models;

    foreach(QGLSceneNode* n, nodes) {
        if(!n->count())
            continue;

        const QMatrix4x4 modelMatrix= n->localTransform();

        if(uniformsFlags & ModelMatrix)
            program->setUniformValue("modelMatrix", modelMatrix);
        if(uniformsFlags & ModelInvMatrix)
            program->setUniformValue("modelInvMatrix", modelMatrix.inverted());
        if(uniformsFlags & ModelITMatrix)
            program->setUniformValue("modelITMatrix", modelMatrix.inverted().transposed());
        if(uniformsFlags & MVPMatrix)
            program->setUniformValue("mvpMatrix", camera.projMatrix() * camera.viewMatrix() * modelMatrix);

        n->material()->bind(_painter);
        n->geometry().draw(_painter, n->start(), n->count());
    }

    if(bindProgram)
        program->release();
}
示例#5
0
QUniformValue *RenderView::inverseViewportMatrix(const QMatrix4x4 &model) const
{
    Q_UNUSED(model);
    QMatrix4x4 viewportMatrix;
    viewportMatrix.viewport(resolveViewport(*m_viewport, m_surfaceSize));
    QMatrix4x4 inverseViewportMatrix = viewportMatrix.inverted();
    return QUniformValue::fromVariant(QVariant::fromValue(inverseViewportMatrix), m_allocator);

}
void ViewportView::drawCoords(QPainter* painter) const
{
    QPointF mouse_pos = mapToScene(mapFromGlobal(QCursor::pos()));
    if (!sceneRect().contains(mouse_pos))
    {
        return;
    }

    // Get rotate-only transform matrix
    QMatrix4x4 M = getMatrix(ROT);
    const float threshold = 0.98;

    const auto a = M.inverted() * QVector3D(0, 0, 1);

    QList<QPair<char, QVector3D>> axes = {
        {'x', QVector3D(1, 0, 0)},
        {'y', QVector3D(0, 1, 0)},
        {'z', QVector3D(0, 0, 1)}};

    char axis = 0;
    float opacity = 0;
    for (const auto v : axes)
    {
        float dot = fabs(QVector3D::dotProduct(a, v.second));
        if (dot > threshold)
        {
            axis = v.first;
            opacity = (dot - threshold) / (1 - threshold);
        }
    }

    auto p = sceneToWorld(mouse_pos);

    int value = opacity * 200;

    painter->setPen(QPen(QColor(255, 255, 255, value)));
    QString txt;
    if (axis == 'z')
    {
        txt = QString("X: %1\nY: %2").arg(p.x()).arg(p.y());
    }
    else if (axis == 'y')
    {
        txt = QString("X: %1\nZ: %2").arg(p.x()).arg(p.z());
    }
    else if (axis == 'x')
    {
        txt = QString("Y: %1\nZ: %2").arg(p.y()).arg(p.z());
    }

    painter->drawText({-width()/2.0 + 10, -height()/2.0 + 10, 300, 200}, txt);
}
示例#7
0
/**
  \brief When a station has been selected, this updates the shot lines

  This shows the shot lines from the selected station.  If no station is
  currently selected, this will hide the lines
  */
void cwScrapStationView::updateShotLines() {
    if(scrap() == nullptr) { return; }
    if(scrap()->parentNote() == nullptr) { return; }
    if(scrap()->parentNote()->parentTrip() == nullptr) { return; }
    if(transformUpdater() == nullptr) { return; }

    cwNoteStation noteStation = scrap()->station(selectedItemIndex());
    //Get the current trip
    cwNote* note = scrap()->parentNote();
    cwTrip* trip = note->parentTrip();
    cwCave* cave = trip->parentCave();
    cwStationPositionLookup stationPositionLookup = cave->stationPositionLookup();

    //Clear all the lines
    ShotLines.clear();

    if(noteStation.isValid() && stationPositionLookup.hasPosition(noteStation.name())) {
        QString stationName = noteStation.name();
        QSet<cwStation> neighboringStations = trip->neighboringStations(stationName);

        //The position of the selected station
        QVector3D selectedStationPos = stationPositionLookup.position(noteStation.name());

        //Create the matrix to covert global position into note position
        QMatrix4x4 noteTransformMatrix = scrap()->noteTransformation()->matrix(); //Matrix from page coordinates to cave coordinates
        noteTransformMatrix = noteTransformMatrix.inverted(); //From cave coordinates to page coordinates

        QMatrix4x4 notePageAspect = note->scaleMatrix().inverted(); //The note's aspect ratio

        QMatrix4x4 offsetMatrix;
        offsetMatrix.translate(-selectedStationPos);

        QMatrix4x4 dotPerMeter;
        dotPerMeter.scale(note->dotPerMeter(), note->dotPerMeter(), 1.0);

        QMatrix4x4 noteStationOffset;
        noteStationOffset.translate(QVector3D(noteStation.positionOnNote()));

        QMatrix4x4 toNormalizedNote = noteStationOffset *
                dotPerMeter *
                notePageAspect *
                noteTransformMatrix *
                offsetMatrix;

        //Go through all the neighboring stations and add the position to the line
        foreach(cwStation station, neighboringStations) {

            QVector3D currentPos = stationPositionLookup.position(station.name());
            QVector3D normalizeNotePos = toNormalizedNote.map(currentPos);

            ShotLines.append(QLineF(noteStation.positionOnNote(), normalizeNotePos.toPointF()));
        }
示例#8
0
/*!
    Maps \a point from viewport co-ordinates to eye co-ordinates.
    The size of the viewport is given by \a viewportSize, and its
    aspect ratio by \a aspectRatio.

    The returned vector will have its x and y components set to the
    position of the point on the near plane, and the z component
    set to -nearPlane().

    This function is used for converting a mouse event's position
    into eye co-ordinates within the current camera view.
*/
QVector3D QGLCamera::mapPoint
    (const QPoint& point, float aspectRatio, const QSize& viewportSize) const
{
    Q_D(const QGLCamera);

    // Rotate the co-ordinate system to account for the screen rotation.
    int x = point.x();
    int y = point.y();
    int width = viewportSize.width();
    int height = viewportSize.height();
    if (!d->adjustForAspectRatio)
        aspectRatio = 1.0f;
    if (d->screenRotation == 90) {
        if (aspectRatio != 0.0f)
            aspectRatio = 1.0f / aspectRatio;
        qSwap(x, y);
        qSwap(width, height);
        y = height - 1 - y;
    } else if (d->screenRotation == 180) {
        x = width - 1 - x;
        y = height - 1 - y;
    } else if (d->screenRotation == 270) {
        if (aspectRatio != 0.0f)
            aspectRatio = 1.0f / aspectRatio;
        qSwap(x, y);
        qSwap(width, height);
    }

    // Determine the relative distance from the middle of the screen.
    // After this xrel and yrel are typically between -1.0 and +1.0
    // (unless the point was outside the viewport).  The yrel is
    // flipped upside down to account for the incoming co-ordinate
    // being left-handed, but the world being right-handed.
    float xrel, yrel;
    if (width)
        xrel = ((float(x * 2)) - float(width)) / float(width);
    else
        xrel = 0.0f;
    if (height)
        yrel = -((float(y * 2)) - float(height)) / float(height);
    else
        yrel = 0.0f;

    // Reverse the projection and return the point in world co-ordinates.
    QMatrix4x4 m = projectionMatrix(aspectRatio);
    QMatrix4x4 invm = m.inverted();
    return invm.map(QVector3D(xrel, yrel, -1.0f));
}
示例#9
0
void BinghamRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, PropertyGroup& props )
{
    if ( renderMode != 1 ) // we are drawing opaque objects
    {
        // obviously not opaque
        return;
    }

    setRenderParams( props );

    if ( m_orient == 0 )
    {
        return;
    }

    m_pMatrix = p_matrix;
    m_mvMatrix = mv_matrix;


    initGeometry( props );

    QGLShaderProgram* program = GLFunctions::getShader( "qball" );
    program->bind();

    program->setUniformValue( "u_alpha", 1.0f );
    program->setUniformValue( "u_renderMode", renderMode );
    program->setUniformValue( "u_canvasSize", width, height );
    program->setUniformValue( "D0", 9 );
    program->setUniformValue( "D1", 10 );
    program->setUniformValue( "D2", 11 );
    program->setUniformValue( "P0", 12 );

    // Set modelview-projection matrix
    program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
    program->setUniformValue( "mv_matrixInvert", mv_matrix.inverted() );
    program->setUniformValue( "u_hideNegativeLobes", m_minMaxScaling );
    program->setUniformValue( "u_scaling", m_scaling );

    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboIds[ 0 ] );
    glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 1 ] );
    setShaderVars( props );
    glDrawElements( GL_TRIANGLES, m_tris1, GL_UNSIGNED_INT, 0 );

    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
    glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
void SeaNode::draw(std::stack<QMatrix4x4> &MVStack, QMatrix4x4 cameraMatrix, QMatrix4x4 projectionMatrix, QOpenGLShaderProgram *shader) {
	QOpenGLShaderProgram *sh = Shaders::waterGeometryProgram;
	MVStack.push(MVStack.top());

	MVStack.top().translate(this->translation);

	//Convert the quat to a matrix, may be a performance leak.
	QMatrix4x4 tempRot;
	tempRot.rotate(this->rotation.normalized());
	MVStack.top() *= tempRot;

	//If the node is a leaf, draw its contents
	if(leaf) {
		Shaders::bind(sh);
		glUniformMatrix4fv(sh->uniformLocation("modelViewMatrix"), 1, GL_FALSE, MVStack.top().constData());
		glUniformMatrix4fv(sh->uniformLocation("cameraInverseMatrix"), 1, GL_FALSE, cameraMatrix.inverted().constData());
		glUniformMatrix4fv(sh->uniformLocation("perspectiveMatrix"), 1, GL_FALSE, projectionMatrix.constData());
		glUniformMatrix4fv(sh->uniformLocation("normalMatrix"), 1, GL_FALSE, MVStack.top().inverted().transposed().constData());
		int r = (id & 0x000000FF) >>  0;
		int g = (id & 0x0000FF00) >>  8;
		int b = (id & 0x00FF0000) >> 16;
		glUniform4f(sh->uniformLocation("id"), r/255.0f, g/255.0f, b/255.0f, 1.0f);

		glUniform4fv(sh->uniformLocation("color"), 1, color);

		struct timeval start;
		gettimeofday(&start, NULL);
		float seconds = ((start.tv_sec % (int) periodicity) + start.tv_usec / 1000000.0) / (periodicity / 4);

		glActiveTexture(GL_TEXTURE5);
		glBindTexture(GL_TEXTURE_3D, noiseTexture);
		//glUniform1i(sh->uniformLocation("noiseTexture"), 5);

		glUniform1i(sh->uniformLocation("seaWidth"), seaWidth);
		glUniform1i(sh->uniformLocation("seaHeight"), seaHeight);
		glUniform1f(sh->uniformLocation("time"), seconds);

		this->primitive->draw();
		Shaders::release(sh);
	} else {
void VolRenRaycastCuda::updateCUDALights(const QMatrix4x4& matView)
{
    CudaLight cudaLights[10];
    for (unsigned int i = 0; i < lights.size(); ++i)
    {
        QVector3D lightDir(matView.inverted() * QVector4D(lights[i].direction, 0.f));
        lightDir.normalize();
        cudaLights[i].direction.x = lightDir.x();
        cudaLights[i].direction.y = lightDir.y();
        cudaLights[i].direction.z = lightDir.z();
        cudaLights[i].ambient.x = lights[i].color.x() * lights[i].ambient;
        cudaLights[i].ambient.y = lights[i].color.y() * lights[i].ambient;
        cudaLights[i].ambient.z = lights[i].color.z() * lights[i].ambient;
        cudaLights[i].diffuse.x = lights[i].color.x() * lights[i].diffuse;
        cudaLights[i].diffuse.y = lights[i].color.y() * lights[i].diffuse;
        cudaLights[i].diffuse.z = lights[i].color.z() * lights[i].diffuse;
        cudaLights[i].specular.x = lights[i].color.x() * lights[i].specular;
        cudaLights[i].specular.y = lights[i].color.y() * lights[i].specular;
        cudaLights[i].specular.z = lights[i].color.z() * lights[i].specular;
        cudaLights[i].shininess = lights[i].shininess;
    }
    cudaSetLights(lights.size(), cudaLights);
}
示例#12
0
    // TODO: optimize for other color spaces
    void compute() const {
        recompute = false;
        //http://docs.rainmeter.net/tips/colormatrix-guide
        //http://www.graficaobscura.com/matrix/index.html
        //http://beesbuzz.biz/code/hsv_color_transforms.php
        // ??
        const float b = brightness;
        // brightness R,G,B
        QMatrix4x4 B(1, 0, 0, b,
                     0, 1, 0, b,
                     0, 0, 1, b,
                     0, 0, 0, 1);
        // Contrast (offset) R,G,B
        const float c = contrast+1.0;
        const float t = (1.0 - c) / 2.0;
        QMatrix4x4 C(c, 0, 0, t,
                     0, c, 0, t,
                     0, 0, c, t,
                     0, 0, 0, 1);
        // Saturation
        const float wr = 0.3086f;
        const float wg = 0.6094f;
        const float wb = 0.0820f;
        float s = saturation + 1.0f;
        QMatrix4x4 S(
            (1.0f - s)*wr + s, (1.0f - s)*wg    , (1.0f - s)*wb    , 0.0f,
            (1.0f - s)*wr    , (1.0f - s)*wg + s, (1.0f - s)*wb    , 0.0f,
            (1.0f - s)*wr    , (1.0f - s)*wg    , (1.0f - s)*wb + s, 0.0f,
                         0.0f,              0.0f,              0.0f, 1.0f
        );
        // Hue
        const float n = 1.0f / sqrtf(3.0f);       // normalized hue rotation axis: sqrt(3)*(1 1 1)
        const float h = hue*M_PI;               // hue rotation angle
        const float hc = cosf(h);
        const float hs = sinf(h);
        QMatrix4x4 H(     // conversion of angle/axis representation to matrix representation
            n*n*(1.0f - hc) + hc  , n*n*(1.0f - hc) - n*hs, n*n*(1.0f - hc) + n*hs, 0.0f,
            n*n*(1.0f - hc) + n*hs, n*n*(1.0f - hc) + hc  , n*n*(1.0f - hc) - n*hs, 0.0f,
            n*n*(1.0f - hc) - n*hs, n*n*(1.0f - hc) + n*hs, n*n*(1.0f - hc) + hc  , 0.0f,
                              0.0f,                   0.0f,                   0.0f, 1.0f
        );

        // B*C*S*H*rgb_range_mat(*yuv2rgb*yuv_range_mat)*bpc_scale
        M = B*C*S*H;
        // M *= rgb_range_translate*rgb_range_scale
        // TODO: transform to output color space other than RGB
        switch (cs_out) {
        case ColorSpace_XYZ:
            M = kXYZ2sRGB.inverted() * M;
            break;
        case ColorSpace_RGB:
            M *= ColorRangeRGB(ColorRange_Full, range_out);
            break;
        case ColorSpace_GBR:
            M *= ColorRangeRGB(ColorRange_Full, range_out);
            M = kGBR2RGB.inverted() * M;
            break;
        default:
            M = YUV2RGB(cs_out).inverted() * M;
            break;
        }

        switch (cs_in) {
        case ColorSpace_XYZ:
            M *= kXYZ2sRGB;
            break;
        case ColorSpace_RGB:
            break;
        case ColorSpace_GBR:
            M *= kGBR2RGB;
            break;
        default:
            M *= YUV2RGB(cs_in)*ColorRangeYUV(range_in, ColorRange_Full);
            break;
        }
        if (bpc_scale != 1.0 && cs_in != ColorSpace_XYZ) { // why no range correction for xyz?
            //qDebug("bpc scale: %f", bpc_scale);
            M *= QMatrix4x4(bpc_scale, 0, 0, 0,
                            0, bpc_scale, 0, 0,
                            0, 0, bpc_scale, 0,
                            0, 0, 0, a_bpc_scale ? bpc_scale : 1); // scale alpha channel too
        }
        //qDebug() << "color mat: " << M;
    }
示例#13
0
QPoint CubeItem::cubeIntersection
    (QWidget *widget, const QPoint &point, int *actualFace) const
{
    // Bail out if no scene.
    if (!mScene) {
        *actualFace = -1;
        return QPoint();
    }

    // Get the combined matrix for the projection.
    int dpiX = widget->logicalDpiX();
    int dpiY = widget->logicalDpiY();
    QRectF bounds = boundingRect();
    qreal aspectRatio = (bounds.width() * dpiY) / (bounds.height() * dpiX);
    QMatrix4x4 mv = camera()->modelViewMatrix();
    QMatrix4x4 proj = camera()->projectionMatrix(aspectRatio);
    QMatrix4x4 combined = proj * mv;

    // Find the relative position of the point within (-1, -1) to (1, 1).
    QPointF relativePoint =
        QPointF((point.x() - bounds.center().x()) * 2 / bounds.width(),
                -(point.y() - bounds.center().y()) * 2 / bounds.height());

    // Determine which face of the cube contains the point.
    QVector3D pt1, pt2, pt3, pt4;
    bool singleFace = (pressedFace != -1);
    for (int face = 0; face < 6; ++face) {
        if (singleFace && face != pressedFace)
            continue;

        // Create a polygon from the projected version of the face
        // so that we can test for point membership.
        pt1 = QVector3D(vertexData[face * 4 * 3],
                        vertexData[face * 4 * 3 + 1],
                        vertexData[face * 4 * 3 + 2]);
        pt2 = QVector3D(vertexData[face * 4 * 3 + 3],
                        vertexData[face * 4 * 3 + 4],
                        vertexData[face * 4 * 3 + 5]);
        pt3 = QVector3D(vertexData[face * 4 * 3 + 6],
                        vertexData[face * 4 * 3 + 7],
                        vertexData[face * 4 * 3 + 8]);
        pt4 = QVector3D(vertexData[face * 4 * 3 + 9],
                        vertexData[face * 4 * 3 + 10],
                        vertexData[face * 4 * 3 + 11]);
        QVector<QPointF> points2d;
        points2d.append((combined * pt1).toPointF());
        points2d.append((combined * pt2).toPointF());
        points2d.append((combined * pt3).toPointF());
        points2d.append((combined * pt4).toPointF());
        QPolygonF polygon(points2d);
        if (!singleFace) {
            if (!polygon.containsPoint(relativePoint, Qt::OddEvenFill))
                continue;
        }

        // We want the face that is pointing towards the user.
        QVector3D v = mv.mapVector
            (QVector3D::crossProduct(pt2 - pt1, pt3 - pt1));
        if (!singleFace && v.z() <= 0.0f)
            continue;

        // Determine the intersection between the cube face and
        // the ray coming from the eye position.
        QVector3D eyept = proj.inverted().map
            (QVector3D(relativePoint.x(), relativePoint.y(), -1.0f));
        QLine3D ray(QVector3D(0, 0, 0), eyept);
        QPlane3D plane(mv * pt1, v);
        QResult<QVector3D> intersection = plane.intersection(ray);
        if (!intersection.isValid())
            continue;
        QVector3D worldpt = mv.inverted().map(intersection.value());

        // Map the world point to the range 0..1.
        worldpt = (worldpt / CubeSize) + QVector3D(0.5f, 0.5f, 0.5f);

        // Figure out the texture co-ordinates on the face that
        // correspond to the point.
        qreal xtex, ytex;
        switch (face) {
        case 0:
            xtex = 1.0f - worldpt.y();
            ytex = 1.0f - worldpt.z();
            break;
        case 1:
            xtex = 1.0f - worldpt.x();
            ytex = 1.0f - worldpt.z();
            break;
        case 2:
            xtex = worldpt.y();
            ytex = 1.0f - worldpt.z();
            break;
        case 3:
            xtex = worldpt.x();
            ytex = 1.0f - worldpt.z();
            break;
        case 4:
            xtex = worldpt.x();
            ytex = 1.0f - worldpt.y();
            break;
        case 5: default:
            xtex = worldpt.x();
            ytex = worldpt.y();
            break;
        }

        // Turn the texture co-ordinates into scene co-ordinates.
        bounds = mScene->sceneRect();
        xtex *= bounds.width();
        ytex *= bounds.height();
        int x = qRound(xtex);
        int y = qRound(ytex);
        if (x < 0)
            x = 0;
        else if (x >= bounds.width())
            x = qRound(bounds.width() - 1);
        if (y < 0)
            y = 0;
        else if (y >= bounds.height())
            y = qRound(bounds.height() - 1);
        *actualFace = face;
        return QPoint(x, y);
    }

    *actualFace = -1;
    return QPoint();
}
示例#14
0
void SelectionPointer::renderSelectionPointer(GLuint defaultFboHandle, bool useOrtho)
{
    Q_UNUSED(defaultFboHandle)

    glViewport(m_mainViewPort.x(), m_mainViewPort.y(),
               m_mainViewPort.width(), m_mainViewPort.height());

    Q3DCamera *camera = m_cachedScene->activeCamera();

    QMatrix4x4 itModelMatrix;

    // Get view matrix
    QMatrix4x4 viewMatrix;
    QMatrix4x4 projectionMatrix;
    GLfloat viewPortRatio = (GLfloat)m_mainViewPort.width() / (GLfloat)m_mainViewPort.height();
    if (m_cachedIsSlicingActivated) {
        GLfloat sliceUnitsScaled = sliceUnits / m_autoScaleAdjustment;
        viewMatrix.lookAt(QVector3D(0.0f, 0.0f, 1.0f), zeroVector, upVector);
        projectionMatrix.ortho(-sliceUnitsScaled * viewPortRatio, sliceUnitsScaled * viewPortRatio,
                               -sliceUnitsScaled, sliceUnitsScaled,
                               -1.0f, 4.0f);
    } else if (useOrtho) {
        viewMatrix = camera->d_ptr->viewMatrix();
        GLfloat orthoRatio = 2.0f;
        projectionMatrix.ortho(-viewPortRatio * orthoRatio, viewPortRatio * orthoRatio,
                               -orthoRatio, orthoRatio,
                               0.0f, 100.0f);
    } else {
        viewMatrix = camera->d_ptr->viewMatrix();
        projectionMatrix.perspective(45.0f, viewPortRatio, 0.1f, 100.0f);
    }

    QMatrix4x4 modelMatrix;
    QMatrix4x4 MVPMatrix;

    // Position the pointer ball
    modelMatrix.translate(m_position);

    if (!m_rotation.isIdentity()) {
        modelMatrix.rotate(m_rotation);
        itModelMatrix.rotate(m_rotation);
    }

    // Scale the point with fixed values (at this point)
    QVector3D scaleVector(0.05f, 0.05f, 0.05f);
    modelMatrix.scale(scaleVector);
    itModelMatrix.scale(scaleVector);

    MVPMatrix = projectionMatrix * viewMatrix * modelMatrix;

    QVector3D lightPos =  m_cachedScene->activeLight()->position();

    //
    // Draw the point
    //
    m_pointShader->bind();
    m_pointShader->setUniformValue(m_pointShader->lightP(), lightPos);
    m_pointShader->setUniformValue(m_pointShader->view(), viewMatrix);
    m_pointShader->setUniformValue(m_pointShader->model(), modelMatrix);
    m_pointShader->setUniformValue(m_pointShader->nModel(), itModelMatrix.inverted().transposed());
    m_pointShader->setUniformValue(m_pointShader->color(), m_highlightColor);
    m_pointShader->setUniformValue(m_pointShader->MVP(), MVPMatrix);
    m_pointShader->setUniformValue(m_pointShader->ambientS(),
                                   m_cachedTheme->ambientLightStrength());
    m_pointShader->setUniformValue(m_pointShader->lightS(), m_cachedTheme->lightStrength() * 2.0f);
    m_pointShader->setUniformValue(m_pointShader->lightColor(),
                                   Utils::vectorFromColor(m_cachedTheme->lightColor()));

    m_drawer->drawObject(m_pointShader, m_pointObj);
}
示例#15
0
void Scene::paintGL(){
    setStates();                    // включаем буфер глубины, свет и прочее (возможно можно вынести в initGL)

    //glClear(GL_COLOR_BUFFER_BIT); // если включен буфер глубины, то без его очистки мы ничего не увидим
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    //glMatrixMode(GL_PROJECTION);
    //qgluPerspective(60.0, width / height, 0.01, 15.0);

    //glMatrixMode(GL_MODELVIEW);

    //пишем матрицы преобразований
    QMatrix4x4 LMM; // Local Model matrix (делает преобразования в локальных координатах объекта, для одного объекта их может быть несколько для разных частей объекта)
    QMatrix4x4 MM; // Model matrix (выносит координаты объекта в координаты пространства сцены,
                  //выполняется в следующем порядке - масштабирование, поворот, перенос)
                  // TranslationMatrix * RotationMatrix * ScaleMatrix * OriginalVector; (в коде это выглядит в обратном порядке)
    QMatrix4x4 MVM; // ModelView matrix (View matrix)("масштабирует крутит и перемещает весь мир")
    QMatrix4x4 CameraView; // тоже самое что и MVM, но для использования функции LookAt
    QMatrix4x4 PM; // Projection matrix // проекционная матрица
    QMatrix4x4 MVPM; // ModelViewProjection matrix (projection * view * model)
    if (perspective) {
        // устанавливаем трёхмерную канву (в перспективной проекции) для рисования (плоскости отсечения)
        // угол перспективы, отношение сторон, расстояние до ближней отсекающей плоскости и дальней
        PM.perspective(cameraFocusAngle,ratio,0.1f,100.0f);  // glFrustum( xmin, xmax, ymin, ymax, near, far)  // gluPerspective(fovy, aspect, near, far)
    }
    else {
        // устанавливаем трёхмерную канву (в ортогональной проекции) для рисования (плоскости отсечения)
        PM.ortho(-2.0f,2.0f,-2.0f,2.0f,-8.0f,8.0f); // glOrtho(left,right,bottom,top,near,far) // увеличение значений уменьшает фигуры на сцене (по Z задаём больше, чтобы не видеть отсечение фигур)
        // переносим по z дальше, обязательное условие для перспективной проекции // по оси z 0 это "глаз", - движение камеры назад, + вперёд.
    }
    ///MVM.translate(0.0f,0.0f,-6.0f); // переносим по z от "глаз", сдвигаем камеру на минус, т.е. в сторону затылка.
    // не работает в ортогональной проекции если перенести слишком далеко, за пределы куба отсечения
    // оппа, мы видим передние границы пирамиды отсечения, где всё отсекается (тут-то шейдерным сферам и конец)
    // изменяем масштаб фигуры (увеличиваем)
    ///MVM.scale(10.0f);  // отрицательное число переворачивает проекцию // влияет только на ортогональную проекцию // убивает Шферы
    // указываем угол поворота и ось поворота смотрящую из центра координат к точке x,y,z,
    MVM.rotate(m_angle,0.0f,1.0f,0.0f);  // поворот вокруг оси центра координат
    CameraView.lookAt(cameraEye,cameraCenter,cameraUp); // установка камеры (матрицы трансфрмации)
    MVM=CameraView*MVM;  // получаем матрицу трансформации итогового вида

    // находим проекционную инверсную мтрицу
    bool inverted;
    QMatrix4x4 PMi=PM.inverted(&inverted);
    if (!inverted)
        qDebug() << "PMi не конвертится";
    MVPM=PM*MVM;
    QMatrix4x4 MVPMi=MVPM.inverted(&inverted);
    if (!inverted)
        qDebug() << "MVPMi не конвертится";

    // РИСУЕМ ТРЕУГОЛЬНИК
    // инициализируем данные программы матрицы и атрибуты
    m_triangle->init();
    // зaпихиваем в его программу матрицу ориентации
    m_triangle->m_program.setUniformValue(m_triangle->m_matrixUniform, MVPM);
    // вызываем функцию рисования объекта (или объектов в for)
    m_triangle->draw();
    // проводим сброс инициализации параметров
    m_triangle->drop();//*/

    //РИСУЕМ СФЕРЫ
    m_shphere->init();
    m_shphere->m_program->setUniformValue(m_shphere->m_matrixUniform, MVPM);
    m_shphere->m_program->setUniformValue("PMi", PMi);
    m_shphere->m_program->setUniformValue("MVM", MVM);
    m_shphere->m_program->setUniformValue("MVPMi", MVPMi);
    m_shphere->m_program->setUniformValue("viewport",viewport);
    m_shphere->draw();
    m_shphere->drop();//*/

}
void FiberRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, PropertyGroup* props )
{
    float alpha = props->get( Fn::Property::ALPHA ).toFloat();
    if ( renderMode != 1 ) // we are not picking
    {
        if ( renderMode == 4 || renderMode == 5 ) // we are drawing opaque objects
        {
            if ( alpha < 1.0 )
            {
                // obviously not opaque
                return;
            }
        }
        else // we are drawing tranparent objects
        {
            if ( !(alpha < 1.0 ) )
            {
                // not transparent
                return;
            }
        }
    }

    QGLShaderProgram* program = GLFunctions::getShader( "fiber" );
    program->bind();

    GLFunctions::setupTextures();
    GLFunctions::setTextureUniforms( GLFunctions::getShader( "fiber" ) );

    // Set modelview-projection matrix
    program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
    program->setUniformValue( "mv_matrixInvert", mv_matrix.inverted() );

    initGeometry();

    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboIds[ 0 ] );
    glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 1 ] );
    setShaderVars( props );

    program->setUniformValue( "u_alpha", alpha );
    program->setUniformValue( "u_renderMode", renderMode );
    program->setUniformValue( "u_canvasSize", width, height );
    program->setUniformValue( "D0", 9 );
    program->setUniformValue( "D1", 10 );
    program->setUniformValue( "D2", 11 );

    glLineWidth( props->get( Fn::Property::FIBER_THICKNESS ).toFloat() );

    QVector<bool>*selected = m_selector->getSelection();

    if ( props->get( Fn::Property::COLORMODE ).toInt() != 2 )
    {
        for ( int i = 0; i < m_data.size(); ++i )
        {
            if ( selected->at( i ) )
            {
                glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
            }
        }
    }
    else
    {
        for ( int i = 0; i < m_data.size(); ++i )
        {
            if ( selected->at( i ) )
            {
                program->setUniformValue( "u_color", m_colorField[i].redF(),
                                                                                 m_colorField[i].greenF(),
                                                                                 m_colorField[i].blueF(), 1.0 );
                glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
            }
        }
    }

    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
    glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
示例#17
0
void FiberRenderer::draw( QMatrix4x4 p_matrix, QMatrix4x4 mv_matrix, int width, int height, int renderMode, PropertyGroup& props )
{
    float alpha = props.get( Fn::Property::D_ALPHA ).toFloat();
    if ( renderMode == 0 ) // picking
    {
        return;
    }
    else if ( renderMode == 1 ) // we are drawing opaque objects
    {
        if ( alpha < 1.0 )
        {
            // obviously not opaque
            return;
        }
    }
    else // we are drawing tranparent objects
    {
        if ( !(alpha < 1.0 ) )
        {
            // not transparent
            return;
        }
    }

    if ( m_updateExtraData )
    {
    	updateExtraData( m_selectedExtraData );
    }

    QGLShaderProgram* program = GLFunctions::getShader( "fiber" );
    program->bind();

    GLFunctions::setupTextures();
    GLFunctions::setTextureUniforms( GLFunctions::getShader( "fiber" ), "maingl" );

    // Set modelview-projection matrix
    program->setUniformValue( "mvp_matrix", p_matrix * mv_matrix );
    program->setUniformValue( "mv_matrixInvert", mv_matrix.inverted() );
    program->setUniformValue( "mv_matrixTI", mv_matrix.transposed().inverted() );
    program->setUniformValue( "userTransformMatrix", props.get( Fn::Property::D_TRANSFORM ).value<QMatrix4x4>() );

    initGeometry();

    glBindBuffer( GL_ARRAY_BUFFER, vbo );
    setShaderVars( props );

    glBindBuffer( GL_ARRAY_BUFFER, dataVbo );
    int extraLocation = program->attributeLocation( "a_extra" );
    program->enableAttributeArray( extraLocation );
    glVertexAttribPointer( extraLocation, 1, GL_FLOAT, GL_FALSE, sizeof(float), 0 );

    glBindBuffer( GL_ARRAY_BUFFER, indexVbo );
    int indexLocation = program->attributeLocation( "a_indexes" );
    program->enableAttributeArray( indexLocation );
    glVertexAttribPointer( indexLocation, 1, GL_FLOAT, GL_FALSE, sizeof(float), 0 );

    program->setUniformValue( "u_alpha", alpha );
    program->setUniformValue( "u_renderMode", renderMode );
    program->setUniformValue( "u_canvasSize", width, height );
    program->setUniformValue( "D0", 9 );
    program->setUniformValue( "D1", 10 );
    program->setUniformValue( "D2", 11 );
    program->setUniformValue( "P0", 12 );
    program->setUniformValue( "C5", 13 );
    program->setUniformValue( "u_fibGrowth", props.get( Fn::Property::D_FIBER_GROW_LENGTH).toFloat() );

    program->setUniformValue( "u_lighting", props.get( Fn::Property::D_LIGHT_SWITCH ).toBool() );
    program->setUniformValue( "u_lightAmbient", props.get( Fn::Property::D_LIGHT_AMBIENT ).toFloat() );
    program->setUniformValue( "u_lightDiffuse", props.get( Fn::Property::D_LIGHT_DIFFUSE ).toFloat() );
    program->setUniformValue( "u_materialAmbient", props.get( Fn::Property::D_MATERIAL_AMBIENT ).toFloat() );
    program->setUniformValue( "u_materialDiffuse", props.get( Fn::Property::D_MATERIAL_DIFFUSE ).toFloat() );
    program->setUniformValue( "u_materialSpecular", props.get( Fn::Property::D_MATERIAL_SPECULAR ).toFloat() );
    program->setUniformValue( "u_materialShininess", props.get( Fn::Property::D_MATERIAL_SHININESS ).toFloat() );

    glLineWidth( props.get( Fn::Property::D_FIBER_THICKNESS ).toFloat() );

    std::vector<bool>*selected = m_selector->getSelection();

    int percent = props.get( Fn::Property::D_FIBER_THIN_OUT ).toFloat() * 10;

    for ( unsigned int i = 0; i < m_fibs->size(); ++i )
    {
        if ( ( i % 1000 ) > percent )
        {
            continue;
        }

        if ( selected->at( i ) )
        {
            QColor c = m_fibs->at( i ).customColor();
            program->setUniformValue( "u_color", c.redF(), c.greenF(), c.blueF(), 1.0 );
            c = m_fibs->at( i ).globalColor();
            program->setUniformValue( "u_globalColor", c.redF(), c.greenF(), c.blueF(), 1.0 );
            glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
        }
        else
        {
            if ( Models::getGlobal( Fn::Property::G_UNSELECTED_FIBERS_GREY ).toBool() )
            {
                program->setUniformValue( "u_color", .4f, .4f, .4f, 1.0 );
                program->setUniformValue( "u_globalColor", .4f, .4f, .4f, 1.0 );
                glDrawArrays( GL_LINE_STRIP, m_startIndexes[i], m_pointsPerLine[i] );
            }
        }
    }


    glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
示例#18
0
/**
  \brief When a station has been selected, this updates the shot lines

  This shows the shot lines from the selected station.  If no station is
  currently selected, this will hide the lines
  */
void cwScrapStationView::updateShotLines() {
    if(scrap() == nullptr) { return; }
    if(scrap()->parentNote() == nullptr) { return; }
    if(scrap()->parentNote()->parentTrip() == nullptr) { return; }
    if(transformUpdater() == nullptr) { return; }

    cwNoteStation noteStation = scrap()->station(selectedItemIndex());
    //Get the current trip
    cwNote* note = scrap()->parentNote();
    cwTrip* trip = note->parentTrip();
    cwCave* cave = trip->parentCave();
    cwStationPositionLookup stationPositionLookup = cave->stationPositionLookup();

    //Clear all the lines
    ShotLines.clear();

    if(noteStation.isValid() && stationPositionLookup.hasPosition(noteStation.name())) {
        QString stationName = noteStation.name();
        QSet<cwStation> neighboringStations = trip->neighboringStations(stationName);

        //The position of the selected station
        QVector3D selectedStationPos = stationPositionLookup.position(noteStation.name());

        //Create the matrix to covert global position into note position
        QMatrix4x4 noteTransformMatrix = scrap()->noteTransformation()->matrix(); //Matrix from page coordinates to cave coordinates
        noteTransformMatrix = noteTransformMatrix.inverted(); //From cave coordinates to page coordinates

        QMatrix4x4 notePageAspect = note->scaleMatrix().inverted(); //The note's aspect ratio

        QMatrix4x4 offsetMatrix;
        offsetMatrix.translate(-selectedStationPos);

        QMatrix4x4 dotPerMeter;
        dotPerMeter.scale(note->dotPerMeter(), note->dotPerMeter(), 1.0);

        QMatrix4x4 noteStationOffset;
        noteStationOffset.translate(QVector3D(noteStation.positionOnNote()));

        QMatrix4x4 toNormalizedNote = noteStationOffset *
                dotPerMeter *
                notePageAspect *
                noteTransformMatrix *
                offsetMatrix;

        //Only used if the scrap is in running profile
        QMatrix4x4 profileDirection = runningProfileDirection();

        //Go through all the neighboring stations and add the position to the line
        foreach(cwStation station, neighboringStations) {

            QVector3D currentPos = stationPositionLookup.position(station.name());

            if(scrap()->type() == cwScrap::RunningProfile) {
                bool foundStation = false;
                foreach(cwNoteStation currentNoteStation, scrap()->stations()) {
                    if(currentNoteStation.name().toLower() == station.name().toLower()) {
                        foundStation = true;
                    }
                }

                if(foundStation) { continue; }

                //Caluclate the running profile rotation based on the stations
                QMatrix4x4 toProfileRotation = cwScrap::toProfileRotation(selectedStationPos, currentPos);

                toNormalizedNote = noteStationOffset *
                        dotPerMeter *
                        notePageAspect *
                        noteTransformMatrix *
                        profileDirection *
                        toProfileRotation *
                        offsetMatrix;
            }
示例#19
0
void ARCameraCalibrator::drawCalibrationGrid()
{
    using namespace QScrollEngine;
    QMutexLocker ml(&m_mutex);

    if (scene() == nullptr)
        return;

    if (m_lastCalibrationFrame->isCreated()) {
        QScrollEngineContext* context = scene()->parentContext();
        AR::Point2i frameSize = m_lastCalibrationFrame->imageSize();

        context->glDepthMask(GL_FALSE);
        context->glDisable(GL_DEPTH_TEST);
        context->glDisable(GL_BLEND);

        if (m_flagUpdateFrameTexture) {
            if (m_tempFrameTexture->isCreated()) {
                if ((m_tempFrameTexture->width() != m_lastImage.width()) ||
                        (m_tempFrameTexture->height() != m_lastImage.height())) {
                    m_tempFrameTexture->bind();
                    m_tempFrameTexture->destroy();
                    m_tempFrameTexture->setFormat(QOpenGLTexture::RGBA8_UNorm);
                    m_tempFrameTexture->setSize(m_lastImage.width(), m_lastImage.height(), 4);
                    m_tempFrameTexture->allocateStorage();
                } else {
                    m_tempFrameTexture->bind();
                }
            } else {
                m_tempFrameTexture->create();
                m_tempFrameTexture->bind();
                m_tempFrameTexture->setFormat(QOpenGLTexture::RGBA8_UNorm);
                m_tempFrameTexture->setSize(m_lastImage.width(), m_lastImage.height(), 4);
                m_tempFrameTexture->allocateStorage();
            }
            if (m_lastPixelFormat == QVideoFrame::Format_BGR32) {
                m_tempFrameTexture->setData(QOpenGLTexture::RGBA, QOpenGLTexture::UInt8, m_lastImage.data());
            } else {
                m_tempFrameTexture->setData(QOpenGLTexture::BGRA, QOpenGLTexture::UInt8, m_lastImage.data());
            }
            m_tempFrameTexture->generateMipMaps();
        }

        m_textureRenderer->draw(m_tempFrameTexture->textureId(), m_textureMatrix);

        QMatrix4x4 textureMatrix;
        textureMatrix.fill(0.0f);
        for (int i=0; i<2; ++i) {
            textureMatrix(i, 0) = m_textureMatrix(i, 0);
            textureMatrix(i, 1) = m_textureMatrix(i, 1);
            textureMatrix(i, 3) = m_textureMatrix(i, 2);
        }
        textureMatrix(3, 0) = m_textureMatrix(2, 0);
        textureMatrix(3, 1) = m_textureMatrix(2, 1);
        textureMatrix(3, 3) = m_textureMatrix(2, 2);

        QMatrix4x4 t;
        t.setToIdentity();
        t(0, 0) = 0.5f;
        t(1, 1) = -0.5f;
        t(0, 3) = 0.5f;
        t(1, 3) = 0.5f;

        QMatrix4x4 transformMatrix;
        transformMatrix.ortho(0.0f, (float)(frameSize.x),
                              0.0f, (float)(frameSize.y), 0.0f, 1.0f);
        transformMatrix = t.inverted() * textureMatrix * t * transformMatrix;

        int countLineVertices;
        QVector2D* lineVertices;

        context->glLineWidth(4.0f);

        countLineVertices = (int)(m_linesOfImageGrid.size() * 2);
        lineVertices = new QVector2D[countLineVertices];
        for (int i=0; i<(int)m_linesOfImageGrid.size(); ++i) {
            std::pair<AR::Point2f, AR::Point2f>& line = m_linesOfImageGrid[i];
            lineVertices[i * 2].setX(line.first.x);
            lineVertices[i * 2].setY(line.first.y);
            lineVertices[i * 2 + 1].setX(line.second.x);
            lineVertices[i * 2 + 1].setY(line.second.y);
        }
        context->drawLines(lineVertices, countLineVertices, QColor(0, 155, 255), transformMatrix);
        delete[] lineVertices;

        context->glEnable(GL_BLEND);

        /*countLineVertices = (int)(m_linesOf3DGrid.size() * 2);
        lineVertices = new QVector2D[countLineVertices];
        for (int i=0; i<(int)m_linesOf3DGrid.size(); ++i) {
            std::pair<AR::Point2f, AR::Point2f>& line = m_linesOf3DGrid[i];
            lineVertices[i * 2].setX(line.first.x);
            lineVertices[i * 2].setY(line.first.y);
            lineVertices[i * 2 + 1].setX(line.second.x);
            lineVertices[i * 2 + 1].setY(line.second.y);
        }
        context->drawLines(lineVertices, countLineVertices, QColor(155, 0, 255, 100), transformMatrix);
        delete[] lineVertices;*/

        context->glLineWidth(4.0f);

        countLineVertices = (int)(m_errors.size() * 2);
        lineVertices = new QVector2D[countLineVertices];
        for (int i=0; i<(int)m_errors.size(); ++i) {
            std::pair<AR::Point2f, AR::Point2f>& line = m_errors[i];
            lineVertices[i * 2].setX(line.first.x);
            lineVertices[i * 2].setY(line.first.y);
            lineVertices[i * 2 + 1].setX(line.second.x);
            lineVertices[i * 2 + 1].setY(line.second.y);
        }
        context->drawLines(lineVertices, countLineVertices, QColor(255, 255, 0, 200), transformMatrix);
        delete[] lineVertices;

        context->glDisable(GL_BLEND);
    }
}
void HeightMap3DRenderer::render(){
    if(!m_initialized)initialize();

    QMatrix4x4 modelMatrix;
    modelMatrix.rotate(-90, {1,0,0});
    const float rootSize = 50;
    modelMatrix.scale(rootSize);

    //select terrain patches of different lod levels here
    //TODO maybe this is not the right place for this kind of code...
    std::vector<float> ranges;
    {
        ranges.push_back(0.125);
        float lowestLodRes = rootSize;
        while(lowestLodRes > 0.25){
            ranges.push_back(ranges.back()*2);
            lowestLodRes /= 2;
        }
    }
    std::vector<TerrainPatchSelection> selections;
    const int lodLevelCount = ranges.size()+1;
    const float rootScale = rootSize;
    TerrainPatchSelection rootQuad{lodLevelCount-1,{0,0,0},rootScale};
    QVector3D observerPosition = modelMatrix.inverted() * m_state.camera.position();
    observerPosition.setZ(0);//TODO don't ignore height
    rootQuad.lodSelect(ranges,observerPosition,selections);


    glClearColor(0.6, 0.85, 1, 1);
    glDepthMask(GL_TRUE);
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    if(!m_program || m_sourceDirty){
        recompileProgram();
    }
    m_program->bind();

    m_program->enableAttributeArray(0);

    //set gl states for terrain rendering
    //TODO maybe some of these are remembered by vao?
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_CULL_FACE);
    glDisable(GL_BLEND);
    glCullFace(GL_BACK);


    QMatrix4x4 viewMatrix = m_state.camera.worldToLocalMatrix();
    QMatrix4x4 projectionMatrix;
    projectionMatrix.perspective(65, m_aspectRatio, 1.0, 10024);
//    projectionMatrix.ortho(-10,10,-10,10,0.10,10);
    projectionMatrix.scale({1,-1,1}); //flip Y coordinates because otherwise Qt will render it upside down

    QMatrix4x4 modelViewMatrix = viewMatrix * modelMatrix;
    QMatrix4x4 mvp = projectionMatrix * modelViewMatrix;

    //uniforms shared between patches
    m_program->setUniformValue("modelViewMatrix", modelViewMatrix);
    m_program->setUniformValue("normalMatrix", modelViewMatrix.normalMatrix());
    m_program->setUniformValue("projectionMatrix", projectionMatrix);
    m_program->setUniformValue("mvp", mvp);
    m_program->setUniformValue("sampleOffset", QVector2D(m_state.center.x(), m_state.center.y()));

    m_program->setUniformValue("scaling", QVector3D(
                                   1.0/m_state.widthScale * 0.1, //TODO get rid of these magic constants
                                   1.0/m_state.widthScale * 0.1,
                                   m_state.heightScale //height scaling
                                   )
                               );

    //this is where the magic happens
    {
        QOpenGLVertexArrayObject::Binder binder(&m_vao);
        //loop through all selected terrain patches
        for (TerrainPatchSelection selection : selections) {
            QVector2D patchOffset{selection.position.x(),
                                  selection.position.y()};
            m_program->setUniformValue("patchOffset", patchOffset);
            m_program->setUniformValue("patchSize", selection.size);
            glDrawArrays(GL_TRIANGLE_STRIP, 0, m_vertexCount);
        }
    }
    m_program->release();
}
示例#21
0
// ドロップ時のスロット
// レイヤ追加
void AnimationForm::slot_dropedImage( QRectF rect, QPoint pos, int imageIndex )
{
	CObjectModel *pModel = m_pEditData->getObjectModel() ;
	int frameNum  = ui->label_frame->value() ;
	QModelIndex index = ui->treeView->currentIndex() ;

	if ( !index.isValid() ) {
		qWarning() << "slot_dropedImage current index invalid 0" ;
		return ;
	}

	ObjectItem *pObjItem = pModel->getObject(index) ;
	if ( !pObjItem ) {
		qWarning() << "slot_dropedImage current obj 0" ;
		return ;
	}

	if ( !m_pSetting->getLayerHierarchy() ) {
		index = pObjItem->getIndex() ;
	}

	pos -= QPoint((m_pSetting->getAnmWindowW()/2), (m_pSetting->getAnmWindowH()/2)) ;	// GLWidgetのローカルポスに変換

	ObjectItem *pItem = pModel->getItemFromIndex(index) ;
	bool valid ;
	QMatrix4x4 mat = pItem->getDisplayMatrix(frameNum, &valid) ;
	if ( valid ) {
		QMatrix4x4 inv = mat.inverted(&valid) ;
		if ( valid ) {
			pos = inv.map(pos) ;
		}
	}

	index = m_pEditData->cmd_addItem(QString("Layer %1").arg(pObjItem->childCount()), index) ;
	ui->treeView->setCurrentIndex(index) ;
//	m_pEditData->setSelIndex(index) ;

	// ツリービューに追加
    FrameData frameData ;
	frameData.pos_x = pos.x() ;
	frameData.pos_y = pos.y() ;
	frameData.pos_z = 0 ;
	frameData.rot_x =
	frameData.rot_y =
	frameData.rot_z = 0 ;
	frameData.center_x = (rect.width()) / 2 ;
	frameData.center_y = (rect.height()) / 2 ;
	frameData.frame = frameNum ;
	frameData.fScaleX = frameData.fScaleY = 1.0f ;
	frameData.setRect(rect);
	frameData.nImage = imageIndex ;
	frameData.bUVAnime = false ;
	frameData.rgba[0] =
	frameData.rgba[1] =
	frameData.rgba[2] =
	frameData.rgba[3] = 255 ;

	QList<QWidget *> updateWidget ;
	updateWidget << m_pGlWidget ;
	updateWidget << m_pDataMarker ;

	m_pEditData->cmd_addFrameData(index, frameData, updateWidget) ;
}
示例#22
0
void GLViewer::setViewPoint(QMatrix4x4 new_vp){
    ///Moving the camera is inverse to moving the points to draw
    viewpoint_tf_ = new_vp.inverted();
}
示例#23
0
 void set_transform(QMatrix4x4 m)
 {
   m_trans = m;
   m_invtrans = m.inverted();
 }
示例#24
0
void DrawContext::ActivateMaterial() {
  program_->bind();

  glFrontFace(GL_CCW);

  // set OpenGL attributes based on material properties.
  const bool mat_two_sided = material_->TwoSided();
  if (mat_two_sided != gl_two_sided_) {
    gl_two_sided_ = mat_two_sided;
    if (gl_two_sided_) {
      glDisable(GL_CULL_FACE);
    } else {
      glCullFace(GL_BACK);
      glEnable(GL_CULL_FACE);
    }
  }

  const bool mat_depth_test = material_->DepthTest();
  if (mat_depth_test != gl_depth_test_) {
    gl_depth_test_ = mat_depth_test;
    if (gl_depth_test_) {
      glEnable(GL_DEPTH_TEST);
    } else {
      glDisable(GL_DEPTH_TEST);
    }
  }

  const GLenum mat_depth_func = material_->DepthFunc();
  if (mat_depth_func != gl_depth_func_) {
    gl_depth_func_ = mat_depth_func;
    glDepthFunc(gl_depth_func_);
  }

  const bool mat_depth_write = material_->DepthWrite();
  if (gl_depth_write_ != mat_depth_write) {
    gl_depth_write_ = mat_depth_write;
    if (gl_depth_write_) {
      glDepthMask(GL_TRUE);
    } else {
      glDepthMask(GL_FALSE);
    }
  }

  const bool mat_color_write = material_->ColorWrite();
  if (gl_color_write_ != mat_color_write) {
    gl_color_write_ = mat_color_write;
    if (gl_color_write_) {
      glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    } else {
      glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    }
  }

  const float mat_point_size = material_->PointSize();
  if (gl_point_size_ != mat_point_size) {
    gl_point_size_ = mat_point_size;
    glPointSize(gl_point_size_);
  }

  const float mat_line_width = material_->LineWidth();
  if (gl_line_width_ != mat_line_width) {
    gl_line_width_ = mat_line_width;
    glLineWidth(gl_line_width_);
  }

  const bool mat_blend = material_->Blend();
  if (gl_blend_ != mat_blend) {
    gl_blend_ = mat_blend;
    if (gl_blend_) {
      glEnable(GL_BLEND);
    } else {
      glDisable(GL_BLEND);
    }
  }

  GLenum mat_sfactor;
  GLenum mat_dfactor;
  material_->BlendFunc(&mat_sfactor, &mat_dfactor);
  if (gl_sfactor_ != mat_sfactor || gl_dfactor_ != mat_dfactor) {
    gl_sfactor_ = mat_sfactor;
    gl_dfactor_ = mat_dfactor;
    glBlendFunc(gl_sfactor_, gl_dfactor_);
  }

  // Set shader standard variables
  const ShaderStandardVariables& locs = shader_->StandardVariables();
  const QMatrix4x4 proj_mat = cur_camera_->GetProjectionMatrix();
  const QMatrix4x4 view_mat = cur_camera_->GetViewMatrix();

  // Set uniform variables
  if (locs.sv_proj_mat >= 0) {
    program_->setUniformValue(locs.sv_proj_mat, proj_mat);
  }
  if (locs.sv_view_mat >= 0) {
    program_->setUniformValue(locs.sv_view_mat, view_mat);
  }
  if (locs.sv_view_mat_inv >= 0) {
    program_->setUniformValue(locs.sv_view_mat_inv, view_mat.inverted());
  }
  if (locs.sv_model_mat >= 0) {
    program_->setUniformValue(locs.sv_model_mat, model_mat_);
  }
  if (locs.sv_mvp_mat >= 0) {
    program_->setUniformValue(locs.sv_mvp_mat,
        proj_mat * view_mat * model_mat_);
  }
  if (locs.sv_mv_mat >= 0) {
    program_->setUniformValue(locs.sv_mv_mat, view_mat * model_mat_);
  }
  if (locs.sv_model_normal_mat >= 0) {
    program_->setUniformValue(locs.sv_model_normal_mat,
        model_mat_.normalMatrix());
  }

  const std::vector<LightNode*>& lights = scene_->Lights();
  int num_lights = lights.size();
  if (num_lights > kShaderMaxLights) {
    printf("Too many lights. Max: %d\n", kShaderMaxLights);
    num_lights = kShaderMaxLights;
  }

  for (int light_ind = 0; light_ind < num_lights; ++light_ind) {
    const LightNode* light_node = lights[light_ind];
    const ShaderLightLocation light_loc = locs.sv_lights[light_ind];
    LightType light_type = light_node->GetLightType();

    if (light_loc.is_directional >= 0) {
      const bool is_directional = light_type == LightType::kDirectional;
      program_->setUniformValue(light_loc.is_directional, is_directional);
    }

    if (light_loc.direction >= 0) {
      const QVector3D light_dir = light_node->Direction();
      program_->setUniformValue(light_loc.direction, light_dir);
    }

    if (light_loc.position >= 0) {
      const QVector3D light_pos = light_node->Translation();
      program_->setUniformValue(light_loc.position, light_pos);
    }

    if (light_loc.ambient >= 0) {
      const float ambient = light_node->Ambient();
      program_->setUniformValue(light_loc.ambient, ambient);
    }

    if (light_loc.specular >= 0) {
      const float specular = light_node->Specular();
      program_->setUniformValue(light_loc.specular, specular);
    }

    if (light_loc.color >= 0) {
      const QVector3D color = light_node->Color();
      program_->setUniformValue(light_loc.color, color);
    }

    if (light_loc.attenuation >= 0) {
      const float attenuation = light_node->Attenuation();
      program_->setUniformValue(light_loc.attenuation, attenuation);
    }

    if (light_loc.cone_angle >= 0) {
      const float cone_angle = light_node->ConeAngle() * M_PI / 180;
      program_->setUniformValue(light_loc.cone_angle, cone_angle);
    }
  }

  // Load shader uniform variables from the material
  for (auto& item : material_->ShaderParameters()) {
    ShaderUniform& uniform = item.second;
    uniform.LoadToProgram(program_);
  }

  // Load textures
  unsigned int texunit = 0;
  for (auto& item : material_->GetTextures()) {
    const QString& texname = item.first;
    const std::shared_ptr<QOpenGLTexture>& texture = item.second;
    texture->bind(texunit);
    program_->setUniformValue(texname.toStdString().c_str(), texunit);
  }
}
示例#25
0
 void set_transform(const QMatrix4x4& m)
 {
   m_trans = m;
   m_invtrans = m.inverted();
 }
示例#26
0
#include <fugio/context_interface.h>

MatrixInverseNode::MatrixInverseNode( QSharedPointer<fugio::NodeInterface> pNode )
	: NodeControlBase( pNode )
{
	FUGID( PIN_INPUT_MATRIX, "9e154e12-bcd8-4ead-95b1-5a59833bcf4e" );
	FUGID( PIN_OUTPUT_MATRIX, "1b5e9ce8-acb9-478d-b84b-9288ab3c42f5" );

	mPinMatrixInput = pinInput( "Matrix", PIN_INPUT_MATRIX );

	mPinMatrixInput->registerPinInputType( PID_MATRIX4 );

	mValMatrixOutput = pinOutput<fugio::VariantInterface *>( "Matrix", mPinMatrixOutput, PID_MATRIX4, PIN_OUTPUT_MATRIX );
}

void MatrixInverseNode::inputsUpdated( qint64 pTimeStamp )
{
	Q_UNUSED( pTimeStamp )

	bool			IOK;
	QMatrix4x4		Mat = variant( mPinMatrixInput ).value<QMatrix4x4>();
	QMatrix4x4		Inv = Mat.inverted( &IOK );

	if( IOK && Inv != mValMatrixOutput->variant().value<QMatrix4x4>() )
	{
		mValMatrixOutput->setVariant( Inv );

		pinUpdated( mPinMatrixOutput );
	}
}