C++ QVector4D::toVector3D方法代码示例

float Ray::intersectionWithPolygonAlt(Ray &ray, const QVector<QVector4D> polygon, QVector3D &normal, QVector3D &intersection, Ray &mirror)
{
    if(polygon.size() < 3) return std::numeric_limits<float>::max();

    normal = QVector3D::crossProduct((polygon[1] - polygon[0]).toVector3D(), (polygon[2] - polygon[1]).toVector3D());

    float distanceFromOrigin = QVector3D::dotProduct(normal, polygon[1].toVector3D() - polygon[0].toVector3D());

    QVector4D ba = ray.endPoint() - ray.startPoint();
    QVector4D pa = polygon[2] - ray.startPoint();

    float nDotA = QVector3D::dotProduct(normal, pa.toVector3D());
    float nDotBA = QVector3D::dotProduct(normal, ba.toVector3D());

    intersection = ray.startPoint().toVector3D() + (((distanceFromOrigin - nDotA)/nDotBA) * ba.toVector3D());

    QVector3D vector(QVector4D(intersection,1.0f)- ray.startPoint());

    QMatrix4x4 mat;
    mat.rotate(180, normal);

    vector = mat * vector;

    mirror = Ray(QVector4D(intersection,1.0), QVector4D(vector+intersection,1.0f));

    return calcAngleSum(intersection, polygon);
}

ShipCAD::PickRay ViewportView::convertMouseCoordToWorld(QPoint pos, int w, int h) const
{
    float x = (2.0f * pos.x()) / w - 1.0f;
    float y = 1.0f - (2.0f * pos.y()) / h;

    QVector4D from = _worldInv * QVector4D(x, y, -1.0, 1.0);
    QVector4D to = _worldInv * QVector4D(x, y, 1.0, 1.0);

    from /= from.w();
    to /= to.w();

    PickRay ray;
    ray.pt = from.toVector3D();
    ray.dir = to.toVector3D() - from.toVector3D();
    ray.dir.normalize();

#if 0
    cout << "from:" << from.x() << "," << from.y() << "," << from.z() << endl;
    cout << "to:" << to.x() << "," << to.y() << "," << to.z() << endl;

    // find the intersection with the xz plane if possible
    Plane xz(0,1,0,0);
    bool coplanar;
    QVector3D intpt;
    if (!xz.intersectLine(ray.pt, ray.dir, coplanar, intpt))
        cout << "xz intersect:" << intpt.x() << "," << intpt.y() << "," << intpt.z() << endl;
    else
        cout << "parallel to xz" << endl;
    if (coplanar)
        cout << "coplanar" << endl;
    // find the intersection with the yz plane if possible
    Plane yz(1,0,0,0);
    if (!yz.intersectLine(ray.pt, ray.dir, coplanar, intpt))
        cout << "yz intersect:" << intpt.x() << "," << intpt.y() << "," << intpt.z() << endl;
    else
        cout << "parallel to yz" << endl;
    if (coplanar)
        cout << "coplanar" << endl;
    // find the intersection with the xy plane if possible
    Plane xy(0,0,1,0);
    if (!xy.intersectLine(ray.pt, ray.dir, coplanar, intpt))
        cout << "xy intersect:" << intpt.x() << "," << intpt.y() << "," << intpt.z() << endl;
    else
        cout << "parallel to xy" << endl;
    if (coplanar)
        cout << "coplanar" << endl;
#endif

    return ray;
}

QPointF GLScene::mapToScene(const QPointF &p){
//  Code below will work OK while projection is ortogonal
//  For some reason in perspective projection everything is flipped and not accurate
    QVector4D rNear = unproject(QVector3D(p.x(), p.y(), -1));
    QVector4D rFar =  unproject(QVector3D(p.x(), p.y(),  1));

    QVector<QVector3D> triangle;
    triangle << QVector3D(0, 0, 0) << QVector3D(0, 1, 0) << QVector3D(1, 0, 0);
    QVector3D normal = QVector3D::normal(triangle.at(0), triangle.at(1), triangle.at(2));

    qreal d1 = QVector3D::dotProduct(rNear.toVector3D() - triangle.at(0), normal);
    qreal d2 = QVector3D::dotProduct(rFar.toVector3D() - triangle.at(0), normal);

    QVector3D point = rNear.toVector3D() + (rFar.toVector3D() - rNear.toVector3D()) * (-d2 / (d2 - d1));
    return point.toPointF();
}

void FormImageProp::colorPicked(QVector4D color){

    if(imageProp.bRoughnessColorPickingToggled){

        ui->pushButtonRoughnessPickColor->setChecked(false);
        imageProp.bRoughnessColorPickingToggled = false;
        imageProp.pickedColor                   = color.toVector3D()/255.0;
        QPalette palette = ui->labelRoughnessPickedColor->palette();
        palette.setColor(ui->labelRoughnessPickedColor->backgroundRole(), QColor(color.x(),color.y(),color.z()));
        palette.setColor(ui->labelRoughnessPickedColor->foregroundRole(), QColor(color.x(),color.y(),color.z()));
        ui->labelRoughnessPickedColor->setPalette(palette);
        update();
        emit imageChanged();
    }
}

static QVector3D unproject( QVector3D v, const QMatrix4x4 &modelView, const QMatrix4x4 &projection, QRect viewport )
{
  // Reimplementation of QVector3D::unproject() - see qtbase/src/gui/math3d/qvector3d.cpp
  // The only difference is that the original implementation uses tolerance 1e-5
  // (see qFuzzyIsNull()) as a protection against division by zero. For us it is however
  // common to get lower values (e.g. as low as 1e-8 when zoomed out to the whole Earth with web mercator).

  QMatrix4x4 inverse = QMatrix4x4( projection * modelView ).inverted();

  QVector4D tmp( v, 1.0f );
  tmp.setX( ( tmp.x() - float( viewport.x() ) ) / float( viewport.width() ) );
  tmp.setY( ( tmp.y() - float( viewport.y() ) ) / float( viewport.height() ) );
  tmp = tmp * 2.0f - QVector4D( 1.0f, 1.0f, 1.0f, 1.0f );

  QVector4D obj = inverse * tmp;
  if ( qgsDoubleNear( obj.w(), 0, 1e-10 ) )
    obj.setW( 1.0f );
  obj /= obj.w();
  return obj.toVector3D();
}

void CubeMapRefractionScene::render()
{
    // Clear the buffer with the current clearing color
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    // Set up the view matrix
    QVector3D eye( 0.0f, 0.0f, 0.0f );
    QVector3D center( 0.0f, 0.0f, 1.0f );
    QVector3D up( 0.0f, 1.0f, 0.0f );
    m_viewMatrix.setToIdentity();
    m_viewMatrix.lookAt( eye, center, up );
    m_viewMatrix.rotate( m_phi, 1.0f, 0.0f, 0.0f );
    m_viewMatrix.rotate( m_theta, 0.0f, 1.0f, 0.0f );

    m_modelMatrix.setToIdentity();
    QMatrix4x4 modelViewMatrix = m_viewMatrix * m_modelMatrix;
    QMatrix4x4 mvp = m_projectionMatrix * modelViewMatrix;

    // We need a pointer to the material's shader to set uniform variables
    QOpenGLShaderProgramPtr shader = m_skyBox->material()->shader();

    // Draw the skybox
    shader->setUniformValue( "drawSkyBox", true );
    glDepthFunc(GL_LEQUAL);
    m_skyBox->render( mvp );
    glDepthFunc(GL_LESS);

    eye = QVector3D( 0.0f, 0.0f, -4.0f );
    m_viewMatrix.setToIdentity();
    m_viewMatrix.lookAt( eye, center, up );
    m_viewMatrix.rotate( m_phi, 1.0f, 0.0f, 0.0f );
    m_viewMatrix.rotate( m_theta, 0.0f, 1.0f, 0.0f );

    // Calculate the position of the camera in world coordinates
    QMatrix4x4 rot;
    rot.rotate( -m_theta, 0.0f, 1.0f, 0.0f );
    rot.rotate( -m_phi, 1.0f, 0.0f, 0.0f );
    QVector4D worldEye = rot * eye;
    QVector3D worldCamera = worldEye.toVector3D();

    // Rotate (and scale the model)
    m_modelMatrix.setToIdentity();
    static float theta = 0.0f;
    theta += 0.3f;
    m_modelMatrix.rotate( theta, 0.0f, 1.0f, 0.0f );
    m_modelMatrix.scale( 0.05f ); // Scale the toyplane mesh down to a reasonable size

    modelViewMatrix = m_viewMatrix * m_modelMatrix;
    mvp = m_projectionMatrix * modelViewMatrix;
    QMatrix3x3 normalMatrix = modelViewMatrix.normalMatrix();

    shader->setUniformValue( "worldCameraPosition", worldCamera );
    shader->setUniformValue( "modelViewMatrix", modelViewMatrix );
    shader->setUniformValue( "modelMatrix", m_modelMatrix );
    shader->setUniformValue( "normalMatrix", normalMatrix );
    shader->setUniformValue( "projectionMatrix", m_projectionMatrix );
    shader->setUniformValue( "mvp", mvp );

    // Draw the reflective mesh
    shader->setUniformValue( "drawSkyBox", false );
    shader->setUniformValue( "material.eta", 0.96f );
    shader->setUniformValue( "material.reflectionFactor", 0.0f );

    m_mesh->render();
}