自学教程：C++ xform函数代码示例

void Graph::plot(QPainter& painter, int funcId) {    if (!funcs.isValid(funcId)) return;    QPen curvepen;    QColor color = funcs.getColor(funcId);    curvepen.setColor(color);    if (funcs.isSelected(funcId))        curvepen.setWidth(4);    else        curvepen.setWidth(2);    float xold = xmin;    QPainterPath path;    bool first = false;    float yold = funcs.eval(funcId, xold);    float xd, yd;    const bool error = false;  // isnan(yold);    xform(xold, yold, xd, yd);    if (error)        first = true;    else {        path.moveTo(xd, yd);        first = false;    }    float x_per_pixel = (xmax - xmin) / width(), y_per_pixel = (ymax - ymin) / height();    int plotted = 0;    float xrate = x_per_pixel * 1;    // fedisableexcept(FE_ALL_EXCEPT);    while (xold < xmax) {        bool disjoint = false;        float x = xold + xrate;        float y = funcs.eval(funcId, x);        if (!error) {            if (fabs(y - yold) > y_per_pixel * 100 && xrate > .1 * x_per_pixel) {                xrate /= 2;                continue;            }            if (fabs(y - yold) < y_per_pixel * 5 && xrate < x_per_pixel) {                xrate *= 2;            }            float xd, yd;            xform(x, y, xd, yd);            if (first || y > ymax || y < ymin) {                path.moveTo(xd, yd);                disjoint = true;            } else                path.lineTo(xd, yd);        }        first = false;        xold = x;        yold = y;        plotted++;    }    painter.strokePath(path, curvepen);    // std::cerr<<"Plottted "<<plotted<<std::endl;}

bool Game::InitializeUniverse() {	bool _ok = true;	if (_ok) {		delete racket_;		racket_ = new Racket(GetResourceManager(), "racket", ui_manager_);		AddContextObject(racket_, cure::kNetworkObjectLocalOnly, 0);		_ok = (racket_ != 0);		deb_assert(_ok);		if (_ok) {			racket_->SetInitialTransform(xform(quat(), vec3(0, 0, 0)));			racket_->EnableRootShadow(false);			racket_->StartLoading();		}	}	if (_ok) {		delete ball_;		ball_ = new Ball(GetResourceManager(), "ball", ui_manager_);		AddContextObject(ball_, cure::kNetworkObjectLocalOnly, 0);		_ok = (ball_ != 0);		deb_assert(_ok);		if (_ok) {			ball_->SetInitialTransform(xform(quat(), vec3(0, 0, 0.4f)));			ball_->EnableRootShadow(false);			ball_->StartLoading();		}	}	return _ok;}

bool GcBaseView::twoFingersMove(const MgMotion& motion){    if (!_zoomEnabled) {        return false;    }    if (motion.gestureState <= kMgGestureBegan) {        _lastScale = xform()->getZoomValue(_lastCenter);    }    else if (motion.gestureState == kMgGestureMoved        && motion.startPt != motion.startPt2        && motion.point != motion.point2) {         // 双指变单指则忽略移动        Point2d at((motion.startPt + motion.startPt2) / 2);        Point2d pt((motion.point + motion.point2) / 2);        float d1 = motion.point.distanceTo(motion.point2);        float d0 = motion.startPt.distanceTo(motion.startPt2);        float scale = d1 / d0;                xform()->zoom(_lastCenter, _lastScale);     // 先恢复        xform()->zoomByFactor(scale - 1, &at);      // 以起始点为中心放缩显示        xform()->zoomPan(pt.x - at.x, pt.y - at.y); // 平移到当前点                _zooming = true;        cmdView()->regenAll(false);    }    else if (_zooming) {        _zooming = false;        cmdView()->regenAll(false);    }        return true;}

/* * Set the clipping rectangle in an output GIF file. */    intGIFsetClip(Metafile *mf, int num, Glimit *rect){    mf_cgmo *cgmo	= mf->cgmo;    GIFmetafile *meta = find_meta(cgmo);    int x1,y1,x2,y2;    xform(meta, rect->xmin, rect->ymin, &x1, &y1);    xform(meta, rect->xmax, rect->ymax, &x2, &y2);    gdSetClip(meta->image, x1,y1,x2,y2);    return OK;}

void Graph::drawY(QPainter& painter, int power, bool label) {    QString format("%1");    float delta = pow(logBase, power - 1) / divs;    float yline = ceil(ymin / delta) * delta;    for (; yline < ymax; yline += delta) {        float x1, x2, y1, y2;        xform(xmin, yline, x1, y1);        xform(xmax, yline, x2, y2);        if (label) {            painter.drawText(QPoint(x1 + 3, y1 - 4), format.arg(yline));        } else {            painter.drawLine(x1, y1, x2, y2);        }    }}

 void Polyhedron::transform(const T &xform) {   for (size_t i = 0; i < vertices.size(); i++) {     vertices[i].v = xform(vertices[i].v);   }   faceRecalc();   init(); }

void Projectile::interpolateTick(F32 delta){   Parent::interpolateTick(delta);   if( mHasExploded )      return;   Point3F interpPos = mCurrDeltaBase + mCurrBackDelta * delta;   Point3F dir = mCurrVelocity;   if(dir.isZero())      dir.set(0,0,1);   else      dir.normalize();   MatrixF xform(true);	xform = MathUtils::createOrientFromDir(dir);   xform.setPosition(interpPos);   setRenderTransform(xform);   // fade out the projectile image   S32 time = (S32)(mCurrTick - delta);   if(time > mDataBlock->fadeDelay)   {      F32 fade = F32(time - mDataBlock->fadeDelay);      mFadeValue = 1.0 - (fade / F32(mDataBlock->lifetime));   }   else      mFadeValue = 1.0;   updateSound();}

voidCacheDrivenTask::process(	PageInfo const& page_info, AbstractFilterDataCollector* collector){	QRectF const initial_rect(QPointF(0.0, 0.0), page_info.metadata().size());	ImageTransformation xform(initial_rect, page_info.metadata().dpi());	xform.setPreRotation(m_ptrSettings->getRotationFor(page_info.imageId()));		if (PageOrientationCollector* col = dynamic_cast<PageOrientationCollector*>(collector)) {		col->process(xform.preRotation());	}	if (m_ptrNextTask) {		m_ptrNextTask->process(page_info, collector, xform);		return;	}		if (ThumbnailCollector* thumb_col = dynamic_cast<ThumbnailCollector*>(collector)) {		thumb_col->processThumbnail(			std::auto_ptr<QGraphicsItem>(				new ThumbnailBase(					thumb_col->thumbnailCache(),					thumb_col->maxLogicalThumbSize(),					page_info.imageId(), xform				)			)		);	}}

/* *******************************************************************************  Function Name : instanceCube()**  Description :**  Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp**  Return Value : int****************************************************************************** */int VRAY_clusterThis::instanceCube(GU_Detail * inst_gdp, GU_Detail * mb_gdp){#ifdef DEBUG   std::cout << "VRAY_clusterThis::instanceCube()" << std::endl;#endif   GEO_Primitive * myCube;   GEO_Point * ppt;   UT_Matrix4 xform(1.0);//   UT_XformOrder xformOrder(UT_XformOrder::TRS,  UT_XformOrder::XYZ);   UT_Matrix3 rot_xform(1.0);//   UT_Vector3 myDir = myPointAttributes.N;   UT_Vector3 myUp = UT_Vector3(0,1,0);   rot_xform.orient(myPointAttributes.N, myUp);   xform = rot_xform;   myCube = (GEO_Primitive *) inst_gdp->cube(               myPointAttributes.myNewPos[0] - ((mySize[0] * myPointAttributes.pscale) / 2),               myPointAttributes.myNewPos[0] + ((mySize[0] * myPointAttributes.pscale) / 2),               myPointAttributes.myNewPos[1] - ((mySize[1] * myPointAttributes.pscale) / 2),               myPointAttributes.myNewPos[1] + ((mySize[1] * myPointAttributes.pscale) / 2),               myPointAttributes.myNewPos[2] - ((mySize[2] * myPointAttributes.pscale) / 2),               myPointAttributes.myNewPos[2] + ((mySize[2] * myPointAttributes.pscale) / 2));   for(int i=0; i < myCube->getVertexCount(); i++) {         ppt = myCube->getVertexElement(i).getPt();         UT_Vector4  P = ppt->getPos();         P *= xform;         ppt->setPos(P);      }   VRAY_clusterThis::setInstanceAttributes(myCube);   if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) {         myCube = (GEO_Primitive *) mb_gdp->cube(myPointAttributes.myMBPos[0] - ((mySize[0] * myPointAttributes.pscale) / 2),                                                 myPointAttributes.myMBPos[0] + ((mySize[0] * myPointAttributes.pscale) / 2),                                                 myPointAttributes.myMBPos[1] - ((mySize[1] * myPointAttributes.pscale) / 2),                                                 myPointAttributes.myMBPos[1] + ((mySize[1] * myPointAttributes.pscale) / 2),                                                 myPointAttributes.myMBPos[2] - ((mySize[2] * myPointAttributes.pscale) / 2),                                                 myPointAttributes.myMBPos[2] + ((mySize[2] * myPointAttributes.pscale) / 2));         for(int i=0; i < myCube->getVertexCount(); i++) {               ppt = myCube->getVertexElement(i).getPt();               UT_Vector4  P = ppt->getPos();               P *= xform;               ppt->setPos(P);            }         VRAY_clusterThis::setInstanceAttributes(myCube);      }   if(myCVEX_Exec)      VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT);   if(myCVEX_Exec_prim)      VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM);   return 0;}

    void transform_seq_set_transform(TransformSequence* seq, const double time, const UnalignedTransformd44& transform)    {        Transformd xform(transform.get_local_to_parent().as_foundation_matrix(),                         transform.get_parent_to_local().as_foundation_matrix());        seq->set_transform(time, xform);    }

xyMultimap_t baseXYData::GetCustom(wxString Xformula, wxString Yformula){	xyMultimap_t map;	double x,y;	xyMultimap_t::iterator it;	gpFormula xform( std::string( Xformula.mb_str()) );	gpFormula yform( std::string( Yformula.mb_str()) );	for(it=m_data.begin(); it!= m_data.end(); it++)	{		if(Xformula.IsEmpty())x=it->first;		else{			xform.AddVariable("X", it->first);			xform.AddVariable("Y", it->second);			x = xform;		}		if(Yformula.IsEmpty())y=it->second;		else{			yform.AddVariable("X", it->first);			yform.AddVariable("Y", it->second);			y = yform;		}		map.insert( pair<double, double>( x, y ) );	}	return map;}

unsigned __int64 PlanEntryModelManager::GetMostRecentEntryTimeByAttribute(const TCHAR *pAttr, const TCHAR *pValue){	unsigned __int64 id = 0;	StringBuffer conv(32);	StringBuffer sb(_T("<?xml version=/"1.0/" encoding=/"UTF-8/" ?>"));	sb.append(_T("<xsl:stylesheet version=/"1.0/" xmlns:xsl=/"http://www.w3.org/1999/XSL/Transform/" xmlns:msxsl=/"urn:schemas-microsoft-com:xslt/">"));	sb.append(_T("<xsl:output method=/"text/" />"));	sb.append(_T("<xsl:template match=/"*/">"));	sb.append(_T("<xsl:variable name=/"entries/">"));	sb.append(_T("<xsl:for-each select=/"timeentry[@"));	sb.append(pAttr);	sb.append(_T("='"));	sb.append(pValue);	sb.append(_T("']/"><xsl:sort select=/"@start/" data-type=/"text/" order=/"descending/" />"));	sb.append(_T("<entry><xsl:value-of select=/"@start/" /></entry>"));	sb.append(_T("</xsl:for-each></xsl:variable>"));	sb.append(_T("<xsl:value-of select=/"msxsl:node-set($entries)/entry[1]/" />"));	sb.append(_T("</xsl:template></xsl:stylesheet>"));	BSTR xslt = SysAllocString(sb);	XMLTransform xform(xslt);	SysFreeString(xslt);	xslt = 0;	HRESULT hr = m_pRoot->transformNode(xform.m_pStyleSheet, &xslt);	if(hr == S_OK && xslt)	{		id = ModelUtils::fromHexString(xslt, _tcslen(xslt));		SysFreeString(xslt);	}	else	{		DebugBreak();	}	return id;}

int  SKY_BOX::DrawGradient(CVIEWptr &v){   //DebugBreak();   update_position(); //center at the eye position            Patch* p = get_patch();   assert(p);   Skybox_Texture* tex = get_tex<Skybox_Texture>(p);   assert(tex);   glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT );   glEnable(GL_DEPTH_TEST);   // set xform:   glMatrixMode(GL_MODELVIEW);   glPushMatrix();   glMultMatrixd(xform().transpose().matrix());    // draw the mesh normally:   int ret= tex->draw(v);             glMatrixMode(GL_MODELVIEW);   glPopMatrix();   glPopAttrib();   GL_VIEW_PRINT_GL_ERRORS("(regular) : ");   return ret;}

voidTestLocalXform::testIOHDF5(){    USING_NK_NS    USING_NKHIVE_NS    LocalXform xform(vec3d(0.1, 0.2, 0.5));    LocalXform xform2;    CPPUNIT_ASSERT(xform != xform2);    remove("testingHDF5.hv");                                       VolumeFile file("testingHDF5.hv", VoidFile::WRITE_TRUNC);          HDF5Group root_group;                                           root_group.open(file.m_id, NK_NS::String("/"));                    HDF5Id root_group_id = root_group.id();                              xform.write(root_group_id);        file.close();                                                       VolumeFile file2("testingHDF5.hv", VoidFile::READ_ONLY);        HDF5Group root_group2;                                          root_group2.open(file2.m_id, NK_NS::String("/"));                  HDF5Id root_group_id2 = root_group2.id();                            xform2.read(root_group_id2);    CPPUNIT_ASSERT(xform == xform2);        file2.close();                                                  remove("testingHDF5.hv");}

bool ON_BezierCageMorph::Create(    ON_3dPoint P0,    ON_3dPoint P1,    ON_3dPoint P2,    ON_3dPoint P3,    int point_countX,    int point_countY,    int point_countZ    ){  if ( point_countX < 2 || point_countY < 2 || point_countZ < 2       || !P0.IsValid()      || !P1.IsValid()      || !P2.IsValid()      || !P3.IsValid() )  {    ON_ERROR("ON_BezierCageMorph::Create - invalid input");  }  m_bValid = false;  ON_3dVector X = P1-P0;  ON_3dVector Y = P2-P0;  ON_3dVector Z = P3-P0;  ON_Xform xform(1.0);  xform[0][0] = X.x;  xform[1][0] = X.y;  xform[2][0] = X.z;  xform[0][1] = Y.x;  xform[1][1] = Y.y;  xform[2][1] = Y.z;  xform[0][2] = Z.x;  xform[1][2] = Z.y;  xform[2][2] = Z.z;  xform[0][3] = P0.x;  xform[1][3] = P0.y;  xform[2][3] = P0.z;  double min_pivot = 0.0;  m_bValid = xform.Invert(&min_pivot);  if (m_bValid)  {    ON_3dPoint box_corners[8];    box_corners[0] = P0;    box_corners[1] = P1;    box_corners[2] = P0+X+Y;    box_corners[3] = P2;    box_corners[4] = P3;    box_corners[5] = P3+X;    box_corners[6] = P3+X+Y;    box_corners[7] = P3+Y;    m_bValid = m_rst2xyz.Create(box_corners,point_countX,point_countY,point_countZ);    m_xyz2rst = xform;  }  else  {    ON_ERROR("ON_BezierCageMorph::Create - invalid input - P0,P1,P2,P3 are coplanar");    m_rst2xyz.Destroy();  }  return m_bValid;}

//------------------------------------------------------------------------------//void GLPickingSelect::processTriangles(    const SubNode::Ptr rootNode,    const double seconds,    const size_t numTriangles,    VBOProxy::VBOMode vboMode){    const unsigned int bufferSize = (unsigned int)std::min(numTriangles,size_t(100000));    boost::shared_array<GLuint>buffer (new GLuint[bufferSize*4]);    M3dView view = fSelectInfo.view();    MMatrix projMatrix;    view.projectionMatrix(projMatrix);    MMatrix modelViewMatrix;    view.modelViewMatrix(modelViewMatrix);    unsigned int x, y, w, h;    view.viewport(x, y, w, h);    double viewportX = static_cast<int>(x);   // can be less than 0    double viewportY = static_cast<int>(y);   // can be less than 0    double viewportW = w;    double viewportH = h;    fSelectInfo.selectRect(x, y, w, h);    double selectX = static_cast<int>(x);  // can be less than 0    double selectY = static_cast<int>(y);  // can be less than 0    double selectW = w;    double selectH = h;    MMatrix selectAdjustMatrix;    selectAdjustMatrix[0][0] = viewportW / selectW;    selectAdjustMatrix[1][1] = viewportH / selectH;    selectAdjustMatrix[3][0] = ((viewportX + viewportW/2.0) - (selectX + selectW/2.0)) /         viewportW * 2.0 * selectAdjustMatrix[0][0];    selectAdjustMatrix[3][1] = ((viewportY + viewportH/2.0) - (selectY + selectH/2.0)) /        viewportH * 2.0 * selectAdjustMatrix[1][1];    MMatrix localToPort = modelViewMatrix * projMatrix * selectAdjustMatrix;    view.beginSelect(buffer.get(), bufferSize*4);    view.pushName(0);    {        Frustum frustum(localToPort.inverse());        MMatrix xform(modelViewMatrix);                DrawShadedState state(frustum, seconds, vboMode);        DrawShadedTraversal traveral(state, xform, false, Frustum::kUnknown);        rootNode->accept(traveral);    }    view.popName();    int nbPick = view.endSelect();    if (nbPick > 0) {        unsigned int Zdepth = closestElem(nbPick, buffer.get());            float depth = float(Zdepth)/MAX_HW_DEPTH_VALUE;        fMinZ = std::min(depth,fMinZ);    }}

bool Game::Render() {	quat orientation;	orientation.RotateAroundOwnX(-PIF/5);	ui_manager_->SetCameraPosition(xform(orientation, vec3(0, -0.4f, 0.6f)));	const PixelRect full_rect(0, 0, ui_manager_->GetCanvas()->GetWidth(), ui_manager_->GetCanvas()->GetHeight());	ui_manager_->Render(full_rect);	return true;}

int CameraMatrix::get_pixels_per_meter(int p_for_pixel_width) const {	Vector3 result = xform(Vector3(1,0,-1));	return int((result.x * 0.5 + 0.5) * p_for_pixel_width);}

void CloudLayer::renderObject( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *mi ){   GFXTransformSaver saver;   const Point3F &camPos = state->getCameraPosition();   MatrixF xfm(true);   xfm.setPosition(camPos);   GFX->multWorld(xfm);      if ( state->isReflectPass() )      GFX->setProjectionMatrix( state->getSceneManager()->getNonClipProjection() );   GFX->setShader( mShader );   GFX->setShaderConstBuffer( mShaderConsts );   GFX->setStateBlock( mStateblock );   // Set all the shader consts...   MatrixF xform(GFX->getProjectionMatrix());   xform *= GFX->getViewMatrix();   xform *= GFX->getWorldMatrix();   mShaderConsts->setSafe( mModelViewProjSC, xform );   mShaderConsts->setSafe( mEyePosWorldSC, camPos );   LightInfo *lightinfo = LIGHTMGR->getSpecialLight(LightManager::slSunLightType);   const ColorF &sunlight = state->getAmbientLightColor();   Point3F ambientColor( sunlight.red, sunlight.green, sunlight.blue );   mShaderConsts->setSafe( mAmbientColorSC, ambientColor );      const ColorF &sunColor = lightinfo->getColor();   Point3F data( sunColor.red, sunColor.green, sunColor.blue );   mShaderConsts->setSafe( mSunColorSC, data );   mShaderConsts->setSafe( mSunVecSC, lightinfo->getDirection() );   for ( U32 i = 0; i < TEX_COUNT; i++ )               mShaderConsts->setSafe( mTexOffsetSC[i], mTexOffset[i] );   Point3F scale( mTexScale[0], mTexScale[1], mTexScale[2] );   mShaderConsts->setSafe( mTexScaleSC, scale );   Point3F color;   color.set( mBaseColor.red, mBaseColor.green, mBaseColor.blue );   mShaderConsts->setSafe( mBaseColorSC, color );   mShaderConsts->setSafe( mCoverageSC, mCoverage );   mShaderConsts->setSafe( mExposureSC, mExposure );   GFX->setTexture( mNormalHeightMapSC->getSamplerRegister(), mTexture );                               GFX->setVertexBuffer( mVB );               GFX->setPrimitiveBuffer( mPB );   GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, smVertCount, 0, smTriangleCount );}

/* *******************************************************************************  Function Name : instanceGrid()**  Description : Instance a grid**  Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp**  Return Value : int****************************************************************************** */int VRAY_clusterThis::instanceGrid(GU_Detail * inst_gdp, GU_Detail * mb_gdp){#ifdef DEBUG   std::cout << "VRAY_clusterThis::instanceGrid()" << std::endl;#endif   GEO_Primitive * myGrid;   GU_GridParms grid_parms;   UT_XformOrder xformOrder(UT_XformOrder::TRS,  UT_XformOrder::XYZ);   UT_Matrix4 xform(1.0);   xform.rotate(myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], xformOrder);   grid_parms.rows = 2;   grid_parms.cols = 2;   grid_parms.xsize = mySize[0] * myPointAttributes.pscale;   grid_parms.ysize = mySize[1] * myPointAttributes.pscale;   grid_parms.xcenter = myPointAttributes.myNewPos[0];   grid_parms.ycenter = myPointAttributes.myNewPos[1];   grid_parms.zcenter = myPointAttributes.myNewPos[2];   grid_parms.plane = GU_PLANE_XY;   myGrid = inst_gdp->buildGrid(grid_parms, GU_GRID_POLY);   for(int i = 0; i < myGrid->getVertexCount(); i++) {         GEO_Point * ppt = myGrid->getVertexElement(i).getPt();         UT_Vector4  P = ppt->getPos();         P *= xform;         ppt->setPos(P);      }   VRAY_clusterThis::setInstanceAttributes(myGrid);   if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) {         grid_parms.xcenter = myPointAttributes.myMBPos[0];         grid_parms.ycenter = myPointAttributes.myMBPos[1];         grid_parms.zcenter = myPointAttributes.myMBPos[2];         myGrid = mb_gdp->buildGrid(grid_parms, GU_GRID_POLY);         for(int i = 0; i < myGrid->getVertexCount(); i++) {               GEO_Point * ppt = myGrid->getVertexElement(i).getPt();               UT_Vector4  P = ppt->getPos();               P *= xform;               ppt->setPos(P);            }         VRAY_clusterThis::setInstanceAttributes(myGrid);      }   if(myCVEX_Exec)      VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT);   if(myCVEX_Exec_prim)      VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM);   return 0;}

void SKY_BOX::update_position() //centers the sky box around the camera{   Wpt eye = VIEW::eye();   if (eye.dist_sqrd(xform().origin()) > 0) { //only update when really needed      set_xform(Wtransf(eye));      err_adv(debug, "SKY_BOX::update_position: updated skybox");   }}

STDMETHODIMP CSubPicAllocatorPresenterImpl::SetVideoAngle(Vector v){    XForm xform(Ray(Vector(), v), Vector(1, 1, 1), false);    if (m_xform != xform) {        m_xform = xform;        Paint(false);        return S_OK;    }    return S_FALSE;}

void bt_soft_body::set_transform(vec3f const &position, quatf const &rotation)    {        vec3f tp = position;        quatf tr = rotation;        btTransform xform(btQuaternion(tr[1], tr[2], tr[3], tr[0]),                          btVector3(tp[0], tp[1], tp[2]));         // m_body->setWorldTransform(xform);		m_body->transform(xform);    }

yo_shapetransform_shape(yo_shape shape, ym_vec3f pos, ym_vec3f rot, ym_vec3f s) {    ym_mat4f xf = xform(pos, rot, s);    for (int i = 0; i < shape.nverts; i++) {        ym_vec3f* pos = (ym_vec3f*)shape.pos + i;        *pos = ym_transform_point3f(xf, *pos);        ym_vec3f* norm = (ym_vec3f*)shape.norm + i;        *norm = ym_transform_direction3f(xf, *norm);    }    return shape;}

void CanvasItem::draw_set_transform(const Point2& p_offset, float p_rot, const Size2& p_scale) {	if (!drawing) {		ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal.");		ERR_FAIL();	}	Matrix32 xform(p_rot,p_offset);	xform.scale_basis(p_scale);	VisualServer::get_singleton()->canvas_item_set_transform(canvas_item,xform);}

bool ON_Plane::SwapCoordinates( int i, int j ){  bool rc = false;  if ( 0 <= i && i < 3 && 0 <= j && j < 3 ) {    ON_Xform xform(1);    xform[i][i] = 0.0;    xform[j][j] = 0.0;    xform[i][j] = 1.0;    xform[j][i] = 1.0;    rc = Transform(xform);  }  return rc;}

/* * generate a transformation that maps the frustum with apex at the origin, * apex angle=fov and clipping planes y=n and y=f into the double-unit cube. * plane y=n maps to y'=-1, y=f maps to y'=1 */int persp(Space *t, double fov, double n, double f){	Matrix m;	double z;	if(n<=0 || f<=n || fov<=0 || 180<=fov) /* really need f!=n && sin(v)!=0 */		return -1;	z=1/tan(radians(fov)/2);	m[0][0]=z; m[0][1]=0;           m[0][2]=0; m[0][3]=0;	m[1][0]=0; m[1][1]=(f+n)/(f-n); m[1][2]=0; m[1][3]=f*(1-m[1][1]);	m[2][0]=0; m[2][1]=0;           m[2][2]=z; m[2][3]=0;	m[3][0]=0; m[3][1]=1;           m[3][2]=0; m[3][3]=0;	xform(t, m);	return 0;}

    Vector2d moveActionsInView(Box2d& rect)    {        Vector2d off;        Box2d viewrect(0.f, 0.f, (float)xform()->getWidth(), (float)xform()->getHeight());        if (!rect.isEmpty() && !viewrect.contains(rect)) {            if (rect.xmin < 0) {                off.x = -rect.xmin;            }            else if (rect.xmax > viewrect.xmax) {                off.x = viewrect.xmax - rect.xmax;            }            if (rect.ymin < 0) {                off.y = -rect.ymin;            }            else if (rect.ymax > viewrect.ymax) {                off.y = viewrect.ymax - rect.ymax;            }        }        return off;    }