C++ QMatrix4x4::transposed方法代码示例

/**
 * @brief      Updates any user interactions and model transformations.
 */
void OGLWidget::update()
{
    Input::update();

    flyThroughCamera();

    if( Input::keyPressed( Qt::Key_Up ) )
        ((PhysicsEntity*)renderables["Cube"])->RigidBody->applyCentralImpulse(
            btVector3( 0, 0, -.2 ) );
    if( Input::keyPressed( Qt::Key_Down ) )
        ((PhysicsEntity*)renderables["Cube"])->RigidBody->applyCentralImpulse(
            btVector3( 0, 0, .2 ) );
    if( Input::keyPressed( Qt::Key_Left ) )
        ((PhysicsEntity*)renderables["Cube"])->RigidBody->applyCentralImpulse(
            btVector3( -.2, 0, 0 ) );
    if( Input::keyPressed( Qt::Key_Right ) )
        ((PhysicsEntity*)renderables["Cube"])->RigidBody->applyCentralImpulse(
            btVector3( .2, 0, 0 ) );

    for( QMap<QString, Renderable*>::iterator iter = renderables.begin();
            iter != renderables.end(); iter++ )
    {
        (*iter)->update();
    }

    m_dynamicsWorld->stepSimulation( 1, 10 );

    {
        btScalar rawMatrix[16];
        ((PhysicsEntity*)renderables["Cube"])->
        RigidBody->getWorldTransform().getOpenGLMatrix(rawMatrix);

        QMatrix4x4 newMatrix = QMatrix4x4(rawMatrix);
        newMatrix = newMatrix.transposed();

        ((PhysicsEntity*)renderables["Cube"])->Transform = newMatrix;
    }

    {
        btScalar rawMatrix[16];
        ((PhysicsEntity*)renderables["Board"])->
        RigidBody->getWorldTransform().getOpenGLMatrix(rawMatrix);

        QMatrix4x4 newMatrix = QMatrix4x4(rawMatrix);
        newMatrix = newMatrix.transposed();

        ((PhysicsEntity*)renderables["Board"])->Transform = newMatrix;
    }

    QOpenGLWidget::update();
}

QVector3D myCam::getPositionFromViewMatrix(QMatrix4x4 matrix)
{
    QMatrix4x4 viewRot = matrix;
    viewRot.setColumn(3, QVector4D(0,0,0,1));
    QVector4D p = -(viewRot.transposed() * matrix.column(3));
    return QVector3D(p.x(), p.y(), p.z());
}

void OpenGLWidget::paintGL() {
    // Clear window color.
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // View matrices.
    QMatrix4x4 mMat, vMat, pMat;
    mMat.rotate(theta, QVector3D(0.0f, 1.0f, 0.0f));
    vMat.lookAt(QVector3D(3.0f, 4.0f, 5.0f), QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 1.0f, 0.0f));
    pMat.perspective(45.0f, (float)width() / (float)height(), 0.1f, 1000.0f);

    QMatrix4x4 mvMat = vMat * mMat;
    QMatrix4x4 mvpMat = pMat * mvMat;
    QMatrix4x4 normMat = mvMat.transposed().inverted();

    // Draw color triangle.
    shader->bind();
    vao->bind();
    
    shader->setUniformValue("u_mvpMat", mvpMat);
    shader->setUniformValue("u_mvMat", mvMat);
    shader->setUniformValue("u_viewMat", vMat);
    shader->setUniformValue("u_normMat", normMat);
    shader->setUniformValue("u_lightPos", lightPos);

    texture->bind(0);
    shader->setUniformValue("u_texture", 0);

    glDrawElements(GL_TRIANGLES, ibo->size() / sizeof(uint32_t), GL_UNSIGNED_INT, 0);

    texture->release();

    shader->release();
    vao->release();
}

// override mouse move event
void Renderer::mouseMoveEvent(QMouseEvent * event)
{
    if(translate)
    {
        m_theta_x += event->x() - initial_x;
        m_theta_y += event->y() - initial_y;
    }
    else if(RMB)
    {
        float fDiameter;
        QMatrix4x4 trans;
        float nWinWidth = width(), nWinHeight=height();
        int iCenterX, iCenterY;
        float  fRotVecX, fRotVecY, fRotVecZ;
        float fNewModX, fNewModY, fOldModX, fOldModY;

        fDiameter = (nWinWidth < nWinHeight) ? nWinWidth * 0.5 : nWinHeight * 0.5;
        iCenterX = nWinWidth / 2;
        iCenterY = nWinHeight / 2;
        fOldModX = initial_x - iCenterX;
        fOldModY = initial_y - iCenterY;
        fNewModX = event->x() - iCenterX;
        fNewModY = event->y() - iCenterY;
        vCalcRotVec(fNewModX, fNewModY,
                        fOldModX, fOldModY,
                        fDiameter,
                        &fRotVecX, &fRotVecY, &fRotVecZ);
        vAxisRotMatrix(fRotVecX, -fRotVecY, fRotVecZ, trans);
        trans.transposed();
        rotation*=trans;
    }
    initial_x=event->x();
    initial_y=event->y();
}

void MyWindow::printMatrix(const QMatrix4x4& mat)
{
    const float *locMat = mat.transposed().constData();

    for (int i=0; i<4; i++)
    {
        qDebug() << locMat[i*4] << " " << locMat[i*4+1] << " " << locMat[i*4+2] << " " << locMat[i*4+3];
    }
}

void RemoteGL::paintGL()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	
	QMatrix4x4 mrot = realToOGL(quatToRotMatrix(rotationQuat));
	glLoadIdentity();
	glTranslatef(offset.x(), offset.y(), offset.z());

#ifdef KDMODE
	glRotatef(-90,0,1,0);
#else
	glRotatef(90,0,1,0);
#endif

	glMultMatrixd((const double*)mrot.transposed().constData());
	
	glDisable(GL_CULL_FACE);
	glEnable(GL_TEXTURE_2D);
	//glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, m_texture);
	
	float wi = 575;
	float he = 1127;
	float d = 200;

	glRotatef(90,0,1,0);

	drawPhone(wi / d, 100 / d, he / d);

	glDisable(GL_TEXTURE_2D);
	glColor3f(1,0,0);

	glPushMatrix();
	QColor colorsX[] = { Qt::red, Qt::red, Qt::red, Qt::red, Qt::red, Qt::red };
	glTranslatef(5, 0, 0);
	drawBox(colorsX, 5, 0.3, 0.3, offset);
	glPopMatrix();

	glPushMatrix();
	QColor colorsY[] = { Qt::green, Qt::green, Qt::green, Qt::green, Qt::green, Qt::green };
	glTranslatef(0, -5, 0);
	drawBox(colorsY, 0.3, 5, 0.3, offset);
	glPopMatrix();

	glPushMatrix();
	QColor colorsZ[] = { Qt::blue, Qt::blue, Qt::blue, Qt::blue, Qt::blue, Qt::blue };
	glTranslatef(0, 0, 5);
	drawBox(colorsZ, 0.3, 0.3, 5, offset);
	glPopMatrix();
}

void ObjectTransform::updateTransformMatrix()
{
	m_rotMatrix.setToIdentity();
	m_rotMatrix.rotate(m_rotation);
	m_transformMatrix.setToIdentity();
	m_transformMatrix.translate(m_translation);
	m_transformMatrix *= m_rotMatrix;
	m_norTransformMatrix = m_transformMatrix;
	m_transRotMatrix = m_transformMatrix;
	m_transformMatrix.scale(m_scale);
	m_norTransformMatrix.scale(1 / m_scale.x(), 1 / m_scale.y(), 1 / m_scale.z());

	m_invTransformMatrix.setToIdentity();
	m_invTransformMatrix.scale(1 / m_scale.x(), 1 / m_scale.y(), 1 / m_scale.z());
	QMatrix4x4 transposeRot = m_rotMatrix;
	m_invTransformMatrix *= transposeRot.transposed();
	m_invTransformMatrix.translate(-m_translation);
	// 还要更新场景的GeometryImage
	paint3DApp->scene->updateGeometryImage();
}

void Sphere::render(QMatrix4x4& projection, QMatrix4x4& matrix, Light* light){

    program->addShader(&vShader);
    program->addShader(&fShader);
    program->link();
    program->bind();

    program->setUniformValue("mvp_matrix", projection * matrix);
    program->setUniformValue("mv_matrix", matrix);
    program->setUniformValue("normal_matrix", matrix.transposed().inverted());

    tt += delta;
    if(tt > 1.0f){
        delta = -delta;
        tt += delta;
    }
    if(tt < 0.0f){
        delta = -delta;
        tt += delta;
    }

    int timeLocation = program->attributeLocation("a_time");
    program->setAttributeValue(timeLocation, tt);

    // Tell OpenGL which VBOs to use
    arrayBuf.bind();
    indexBuf.bind();

    // Offset for position
    quintptr offset = 0;

    // Tell OpenGL programmable pipeline how to locate vertex position data
    int vertexLocation = program->attributeLocation("a_position");
    program->enableAttributeArray(vertexLocation);
    program->setAttributeBuffer(vertexLocation, GL_FLOAT, offset, 3, sizeof(VertexData));


    // Offset for texture coordinate
    offset += sizeof(QVector3D);

    // Tell OpenGL programmable pipeline how to locate vertex texture coordinate data
    int texcoordLocation = program->attributeLocation("a_texcoord");
    program->enableAttributeArray(texcoordLocation);
    program->setAttributeBuffer(texcoordLocation, GL_FLOAT, offset, 2, sizeof(VertexData));

    offset += sizeof(QVector2D);

    int normalLocation = program->attributeLocation("a_normal");
    program->enableAttributeArray(normalLocation);
    program->setAttributeBuffer(normalLocation, GL_FLOAT, offset, 3, sizeof(VertexData));


    light->load(program);
    material->load(program);


    // Draw cube geometry using indices from VBO 1
    glDrawElements(mode, indicesSize, GL_UNSIGNED_INT, 0);

    program->release();
}

void GLClass::uniformMatrix4fv(const QString& location, bool transpose, const QMatrix4x4& value)
{
    if (transpose)
        d_ptr->renderWidget->shaderProgram()->setUniformValue(location.toLatin1().constData(), value.transposed());
    else
        d_ptr->renderWidget->shaderProgram()->setUniformValue(location.toLatin1().constData(), value);
}

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 );
//.........这里部分代码省略.........