// Agrega una translacion 3D void EntityTransform::addTranslation(Vector3d position) { //auxMatrix.setIdentity(); transformMatrix(1,4) = -position.x; transformMatrix(2,4) = position.y; transformMatrix(3,4) = position.z; //transformMatrix = transformMatrix * auxMatrix; }
/////////////////////////////////////////////////////////////////////////////// // // return sum of squares of errors, where // // e^2 = (M'^{-1T}RTM^{-1} - F).(M'^{-1T}RTM^{-1} - F) // // where the dot product means element-wise multiplication and summing. // /////////////////////////////////////////////////////////////////////////////// double RTSolver::operator()(VecDoub_I &p) { transformMatrix T(cross_prod,p[0],p[1],p[2]); // translation matrix double e2; int i,j; R = transformMatrix(xrotate,p[3]) * transformMatrix(yrotate,p[4]) * transformMatrix(zrotate,p[5]); T = NPT*R*T*N - F; e2 = elemental_dot_prod(T,T); return(e2); }
void operator()(ResourceDatabase* db) { if (stripfy()) setRemoveDoubles(true); std::vector< vl::ref<vl::Geometry> > geom; db->get<Geometry>(geom); for(unsigned int i=0; i<geom.size(); ++i) { if (discardOriginalNormals()) geom[i]->setNormalArray(NULL); if (computeNormals() && !geom[i]->normalArray()) geom[i]->computeNormals(); if (removeDoubles()) DoubleVertexRemover().removeDoubles(geom[i].get()); if (sortVertices()) geom[i]->sortVertices(); if (stripfy()) TriangleStripGenerator().stripfy(geom[i].get(), 22, true, false, true); if (convertToDrawArrays()) geom[i]->convertDrawCallToDrawArrays(); geom[i]->setDisplayListEnabled(useDisplayLists()); geom[i]->setVBOEnabled(useVBOs()); if (transformGeometry()) geom[i]->transform(transformMatrix(),true); } }
void KGameSvgDocument::setTransformMatrix(QMatrix& matrix, const MatrixOptions& options) { QString transformBuffer, tmp; QMatrix null = QMatrix(); if (options == ApplyToCurrentMatrix) { matrix = transformMatrix() * matrix; } transformBuffer = QLatin1String( "matrix(" ); transformBuffer += tmp.setNum(matrix.m11(),'g',7) + QLatin1Char( ',' ); transformBuffer += tmp.setNum(matrix.m12(),'g',7) + QLatin1Char( ',' ); transformBuffer += tmp.setNum(matrix.m21(),'g',7) + QLatin1Char( ',' ); transformBuffer += tmp.setNum(matrix.m22(),'g',7) + QLatin1Char( ',' ); transformBuffer += tmp.setNum(matrix.dx(),'g',7) + QLatin1Char( ',' ); transformBuffer += tmp.setNum(matrix.dy(),'g',7) + QLatin1Char( ')' ); if ((transform() == QLatin1String( "Element has no transform attribute." )) && (matrix == null)) { // Do not write a meaningless matrix to DOM } else { setTransform(transformBuffer); } }
// Copied with minor modifications from qtdeclarative/src/quick/items/qquickwindow.cpp QMouseEvent *TouchDispatcher::touchToMouseEvent( QEvent::Type type, const QTouchEvent::TouchPoint &p, ulong timestamp, Qt::KeyboardModifiers modifiers, bool transformNeeded) { QQuickItem *item = m_targetItem.data(); // The touch point local position and velocity are not yet transformed. QMouseEvent *me = new QMouseEvent(type, transformNeeded ? item->mapFromScene(p.scenePos()) : p.pos(), p.scenePos(), p.screenPos(), Qt::LeftButton, (type == QEvent::MouseButtonRelease ? Qt::NoButton : Qt::LeftButton), modifiers); me->setAccepted(true); me->setTimestamp(timestamp); QVector2D transformedVelocity = p.velocity(); if (transformNeeded) { QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item); QMatrix4x4 transformMatrix(itemPrivate->windowToItemTransform()); transformedVelocity = transformMatrix.mapVector(p.velocity()).toVector2D(); } // Add these later if needed: //QGuiApplicationPrivate::setMouseEventCapsAndVelocity(me, event->device()->capabilities(), transformedVelocity); //QGuiApplicationPrivate::setMouseEventSource(me, Qt::MouseEventSynthesizedByQt); return me; }
TEST_P(CompositorWorkerTest, applyingMutationsMultipleElements) { registerMockedHttpURLLoad("compositor-proxy-basic.html"); navigateTo(m_baseURL + "compositor-proxy-basic.html"); Document* document = frame()->document(); { forceFullCompositingUpdate(); Element* proxiedElement = document->getElementById("proxied-transform"); WebLayer* proxiedLayer = webLayerFromElement(proxiedElement); EXPECT_TRUE(proxiedLayer->compositorMutableProperties() & CompositorMutableProperty::kTransform); EXPECT_FALSE(proxiedLayer->compositorMutableProperties() & (CompositorMutableProperty::kScrollLeft | CompositorMutableProperty::kScrollTop | CompositorMutableProperty::kOpacity)); EXPECT_TRUE(proxiedLayer->elementId()); TransformationMatrix transformMatrix(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, 44); CompositorMutation mutation; mutation.setTransform(TransformationMatrix::toSkMatrix44(transformMatrix)); proxiedElement->updateFromCompositorMutation(mutation); forceFullCompositingUpdate(); const String& cssValue = document->domWindow() ->getComputedStyle(proxiedElement, String()) ->getPropertyValueInternal(CSSPropertyTransform); EXPECT_EQ( "matrix3d(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, " "44)", cssValue); } { Element* proxiedElement = document->getElementById("proxied-opacity"); WebLayer* proxiedLayer = webLayerFromElement(proxiedElement); EXPECT_TRUE(proxiedLayer->compositorMutableProperties() & CompositorMutableProperty::kOpacity); EXPECT_FALSE(proxiedLayer->compositorMutableProperties() & (CompositorMutableProperty::kScrollLeft | CompositorMutableProperty::kScrollTop | CompositorMutableProperty::kTransform)); EXPECT_TRUE(proxiedLayer->elementId()); CompositorMutation mutation; mutation.setOpacity(0.5); proxiedElement->updateFromCompositorMutation(mutation); forceFullCompositingUpdate(); const String& cssValue = document->domWindow() ->getComputedStyle(proxiedElement, String()) ->getPropertyValueInternal(CSSPropertyOpacity); EXPECT_EQ("0.5", cssValue); } }
void EntityTransform::addRotationY( float angle ) { //10% de mejora de rendimiento if(angle == 0) { return; } angle *= Math::DEGTORAD; // Radianes float cosAngle = Math::cos(angle); float sinAngle = Math::sin(angle); transformMatrix(1,1) = cosAngle; transformMatrix(3,1) = sinAngle * -1; transformMatrix(1,3) = sinAngle; transformMatrix(3,3) = cosAngle; }
void Projection::render() { QMatrix4x4 matrix = transformMatrix() * scaleMatrix(m_scene->width(), -m_scene->height(), 1) * shiftMatrix(0, m_scene->height(), 0); m_scene->clear(); renderFigure(matrix); }
void Projection::render(QGraphicsScene *scene) { QMatrix4x4 matrix = transformMatrix() * scaleMatrix(scene->width(), -scene->height(), 1) * shiftMatrix(0, scene->height(), 0); scene->clear(); renderSegments(scene, unitCube(), matrix); renderSegments(scene, axes(), matrix); }
// NB: From QQuickWindow void TouchDispatcher::transformTouchPoints(QList<QTouchEvent::TouchPoint> &touchPoints, const QTransform &transform) { QMatrix4x4 transformMatrix(transform); for (int i=0; i<touchPoints.count(); i++) { QTouchEvent::TouchPoint &touchPoint = touchPoints[i]; touchPoint.setRect(transform.mapRect(touchPoint.sceneRect())); touchPoint.setStartPos(transform.map(touchPoint.startScenePos())); touchPoint.setLastPos(transform.map(touchPoint.lastScenePos())); touchPoint.setVelocity(transformMatrix.mapVector(touchPoint.velocity()).toVector2D()); } }
void SceneGraph::LeafMeshNode::draw(const glm::mat4x4 &modelViewMatrix, const glm::mat4x4 &projectionMatrix) { glm::mat4x4 localModelView = transformMatrix() * modelViewMatrix; glm::mat4x4 localProjection = projectionMatrix; glm::mat4x4 normalMatrix = glm::transpose(glm::inverse(localModelView)); glm::mat4x4 MVP = localProjection * modelViewMatrix; for (unsigned int i = 0; i < mNumMeshes; ++i) { mRenderStates[i]->bind(localModelView, localProjection, MVP, normalMatrix); mMeshes[i]->draw(); mRenderStates[i]->unbind(); } }
/////////////////////////////////////////////////////////////////////////////// // // Constructor/solver // f = the fundamental matrix between two views // m = the intrinsic matrix of the reference camera // mp = the intrinsic matrix of the second camera (M') // // on construction, 'this' is set to be equal to the camera matrix of // the second view. // // If F is exact, we have that // F = M'^{-1}RTM^{-1} // so, if we let r be the residual matrix: // r = M'^{-1}RTM^{-1} - F // where // M'^{-1T} = transpose of the inverse intrinsic matrix of the 2nd camera // R = rotation matrix (from reference to second view) // T = translation cross-product matrix (TQ = t x Q) // M^{-1} = inverse intrinsic matrix of the reference camera // F = the fundamental matrix // // then R and T are the unknowns with 6 degrees of freedom. // These are calculated by minimising the sum of the squres of the elements // of r. The camera matrix pair is then given by // // P = M[I|0] and P'=M'R[I|-t] // // So P' is the camera matrix we require. // /////////////////////////////////////////////////////////////////////////////// RTSolver::RTSolver(Matrix<double> &f, Matrix<double> &m, Matrix<double> &mp) : transformMatrix(camera), N(inverse_intrinsic, m[0][0], m[1][1], m[0][2], m[1][2]), NPT(inverse_intrinsic, mp[0][0], mp[1][1], mp[0][2], mp[1][2]) { transformMatrix I(identity); Frprmn<RTSolver> mySolver(*this, 1e-8); // solver VecDoub p(6); // parameters for solver coord t(3); // translation vector F = f; NPT.transpose(); // --- initial guess // ----------------- p[0] = 1.2; p[1] = 0.0; p[2] = 0.0; p[3] = 0.0; p[4] = 0.0; p[5] = 0.0; // --- solve // --------- p = mySolver.minimize(p); // --- extract solution // -------------------- t[0] = -p[0]; t[1] = -p[1]; t[2] = -p[2]; R = transformMatrix(xrotate,p[3]) * transformMatrix(yrotate,p[4]) * transformMatrix(zrotate,p[5]); P() = mp*R*(I|t); }
void KGameSvgDocument::shear(double xRadians, double yRadians, const MatrixOptions& options) { QMatrix matrix; if (options == ApplyToCurrentMatrix) { matrix = transformMatrix().QMatrix::shear(xRadians, yRadians); } else { matrix = QMatrix(); matrix.QMatrix::shear(xRadians, yRadians); } setTransformMatrix(matrix, ReplaceCurrentMatrix); }
void KGameSvgDocument::translate(int xPixels, int yPixels, const MatrixOptions& options) { QMatrix matrix; if (options == ApplyToCurrentMatrix) { matrix = transformMatrix().QMatrix::translate(xPixels, yPixels); } else { matrix = QMatrix(); matrix.QMatrix::translate(xPixels, yPixels); } setTransformMatrix(matrix, ReplaceCurrentMatrix); }
void KGameSvgDocument::rotate(double degrees, const MatrixOptions& options) { QMatrix matrix; if (options == ApplyToCurrentMatrix) { matrix = transformMatrix().QMatrix::rotate(degrees); } else { matrix = QMatrix(); matrix.QMatrix::rotate(degrees); } setTransformMatrix(matrix, ReplaceCurrentMatrix); }
void EntityTransform::addOpenGLMatrix() { // Convierte la matriz a formato GLfLoat GLfloat matrix[16]; int num_celda = 0; for(int i = 1; i <= 4; i++) { for(int j = 1; j <= 4; j++) { matrix[num_celda] = transformMatrix(j,i); num_celda++; } } //glMultTransposeMatrixf(matrix); // casca :( glMultMatrixf(matrix); }
//------------------------------------------------------------------------------------ // Creates and initializes the main window for application //------------------------------------------------------------------------------------ Window::Window(QWidget *parent):QDialog(parent) { //We create an instance of GLWidget component we built in glwidget.h m_glWidget = new GLWidget; //Setup application interface. Creates all the required components and sliders. setupUi(this); //We need to attach our m_glWidget to glWidgetArea //All our drawings will be on glWidgetArea glWidgetArea->setWidget(m_glWidget); stack_size = 0; //Setting up all the SIGNALS and SLOTS doubleSpinBox->setRange(-1000,1000); doubleSpinBox_2->setRange(-1000,1000); doubleSpinBox_3->setRange(-1000,1000); doubleSpinBox_4->setRange(-1000,1000); doubleSpinBox_5->setRange(-1000,1000); doubleSpinBox_6->setRange(-1000,1000); doubleSpinBox_7->setRange(-1000,1000); doubleSpinBox_8->setRange(-1000,1000); doubleSpinBox_9->setRange(-1000,1000); connect(clearButton, SIGNAL(clicked()), m_glWidget, SLOT(ClearInput())); connect(doubleSpinBox, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM11(double))); connect(doubleSpinBox_2, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM12(double))); connect(doubleSpinBox_3, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM13(double))); connect(doubleSpinBox_4, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM21(double))); connect(doubleSpinBox_5, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM22(double))); connect(doubleSpinBox_6, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM23(double))); connect(doubleSpinBox_7, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM31(double))); connect(doubleSpinBox_8, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM32(double))); connect(doubleSpinBox_9, SIGNAL(valueChanged(double)), m_glWidget, SLOT(setM33(double))); connect(btnTransform,SIGNAL(clicked()), m_glWidget, SLOT(transformMatrix())); connect(store, SIGNAL(clicked()), this, SLOT(on_store())); connect(push, SIGNAL(clicked()), this, SLOT(on_push())); connect(pop, SIGNAL(clicked()), this, SLOT(on_pop())); connect(apply, SIGNAL(clicked()), this, SLOT(on_stack())); }
void KGameSvgDocument::scale(double xFactor, double yFactor, const MatrixOptions& options) { QMatrix matrix; if ((xFactor == 0) || (yFactor == 0)) { kWarning () << "KGameSvgDocument::scale: You cannnot scale by zero"; } if (options == ApplyToCurrentMatrix) { matrix = transformMatrix().QMatrix::scale(xFactor, yFactor); } else { matrix = QMatrix(); matrix.QMatrix::scale(xFactor, yFactor); } setTransformMatrix(matrix, ReplaceCurrentMatrix); }
TEST_P(CompositorWorkerTest, applyingMutationsMultipleProperties) { registerMockedHttpURLLoad("compositor-proxy-basic.html"); navigateTo(m_baseURL + "compositor-proxy-basic.html"); Document* document = frame()->document(); forceFullCompositingUpdate(); Element* proxiedElement = document->getElementById("proxied-transform-and-opacity"); WebLayer* proxiedLayer = webLayerFromElement(proxiedElement); EXPECT_TRUE(proxiedLayer->compositorMutableProperties() & CompositorMutableProperty::kTransform); EXPECT_TRUE(proxiedLayer->compositorMutableProperties() & CompositorMutableProperty::kOpacity); EXPECT_FALSE(proxiedLayer->compositorMutableProperties() & (CompositorMutableProperty::kScrollLeft | CompositorMutableProperty::kScrollTop)); EXPECT_TRUE(proxiedLayer->elementId()); TransformationMatrix transformMatrix(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, 44); std::unique_ptr<CompositorMutation> mutation = wrapUnique(new CompositorMutation); mutation->setTransform(TransformationMatrix::toSkMatrix44(transformMatrix)); mutation->setOpacity(0.5); proxiedElement->updateFromCompositorMutation(*mutation); { const String& transformValue = document->domWindow() ->getComputedStyle(proxiedElement, String()) ->getPropertyValueInternal(CSSPropertyTransform); EXPECT_EQ( "matrix3d(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, " "44)", transformValue); const String& opacityValue = document->domWindow() ->getComputedStyle(proxiedElement, String()) ->getPropertyValueInternal(CSSPropertyOpacity); EXPECT_EQ("0.5", opacityValue); } // Verify that updating one property does not impact others mutation = wrapUnique(new CompositorMutation); mutation->setOpacity(0.8); proxiedElement->updateFromCompositorMutation(*mutation); { const String& transformValue = document->domWindow() ->getComputedStyle(proxiedElement, String()) ->getPropertyValueInternal(CSSPropertyTransform); EXPECT_EQ( "matrix3d(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, " "44)", transformValue); const String& opacityValue = document->domWindow() ->getComputedStyle(proxiedElement, String()) ->getPropertyValueInternal(CSSPropertyOpacity); EXPECT_EQ("0.8", opacityValue); } }
/////////////////////////////////////////////////////////////////////////////// // // calculate rate of change of error with parameters, de2/dp, at p and // put result in 'deriv'. // // Uses the identity d(sum_n(y_n^2))/dx = sum_n(2y_n * dy_n/dx) // // and the identities d(sin(t))/dt = sin(t + PI/2) and // d(cos(t))/dt = cos(t + PI/2) // /////////////////////////////////////////////////////////////////////////////// void RTSolver::df(VecDoub_I &p, VecDoub_O &deriv) { transformMatrix T(cross_prod,p[0],p[1],p[2]); // translation matrix transformMatrix e; transformMatrix NPT_R; transformMatrix T_N; transformMatrix de_dp; R = transformMatrix(xrotate,p[3]) * transformMatrix(yrotate,p[4]) * transformMatrix(zrotate,p[5]); NPT_R = NPT*R; T_N = T*N; e = NPT_R*T_N - F; de_dp = 0.0; de_dp[1][2] = -1.0; de_dp[2][1] = 1.0; deriv[0] = 2.0*elemental_dot_prod(e, NPT_R*de_dp*N); de_dp = 0.0; de_dp[0][2] = 1.0; de_dp[2][0] = -1.0; deriv[1] = 2.0*elemental_dot_prod(e, NPT_R*de_dp*N); de_dp = 0.0; de_dp[0][1] = -1.0; de_dp[1][0] = 1.0; deriv[2] = 2.0*elemental_dot_prod(e, NPT_R*de_dp*N); de_dp = transformMatrix(xrotate,p[3] + PI/2) * transformMatrix(yrotate,p[4]) * transformMatrix(zrotate,p[5]); deriv[3] = 2.0*elemental_dot_prod(e, NPT*de_dp*T_N); de_dp = transformMatrix(xrotate,p[3]) * transformMatrix(yrotate,p[4] + PI/2) * transformMatrix(zrotate,p[5]); deriv[4] = 2.0*elemental_dot_prod(e, NPT*de_dp*T_N); de_dp = transformMatrix(xrotate,p[3]) * transformMatrix(yrotate,p[4]) * transformMatrix(zrotate,p[5] + PI/2); deriv[5] = 2.0*elemental_dot_prod(e, NPT*de_dp*T_N); }