C++ Transformation::GetMatrix方法代码示例

	const Vec3 GetDirection() const
	{
		if (mOverridingCamera){
			return mOverridingCamera->GetDirection();
		}
		return mTransformation.GetMatrix().Column(1);
	}

void
Custom::AppendTransformation(Transformation const& Trafo)
{
    Matrix const& TrafoMatrix = Trafo.GetMatrix();
    if (TrafoMatrix.size2() != m_Matrix.size1())
    {
        throw std::invalid_argument("Matrix bounds do not match.");
    }

    Matrix Result(m_Matrix.size1(), TrafoMatrix.size2());
    boost::numeric::ublas::axpy_prod(m_Matrix, TrafoMatrix, Result, true);
    m_Matrix = std::move(Result);
}

void DrawPrimitiveQuad(Transformation &QuadTransformation, const EBlendMode &Mode, const ColorRGB &Color)
{
    Image::BindNull();
    WindowFrame.SetUniform(U_COLOR, Color.Red, Color.Green, Color.Blue, Color.Alpha);

    SetBlendingMode(Mode);

    Mat4 Mat = QuadTransformation.GetMatrix();
    WindowFrame.SetUniform(U_MVP, &(Mat[0][0]));

    // Assign position attrib. pointer
    SetPrimitiveQuadVBO();
    DoQuadDraw();
    FinalizeDraw();

    Image::ForceRebind();
}

	//----------------------------------------------------------------------------
	void Update()
	{
		if (mOverridingCamera){
			mOverridingCamera->Update();
		}
		// world coordinates (Blender style)
		// x: right
		// y: forward
		// z: up
		bool viewChanged = mViewPropertyChanged;
		if (mViewPropertyChanged)
		{
			mViewPropertyChanged = false;
			Vec3 right = mTransformation.GetMatrix().Column(0);
			Vec3 forward = mTransformation.GetMatrix().Column(1);
			Vec3 up = mTransformation.GetMatrix().Column(2);
			const Vec3& pos = mTransformation.GetTranslation();
			mMatrices[View] = fb::MakeViewMatrix(pos, right, forward, up);			
			mTransformation.GetHomogeneous(mMatrices[InverseView]);
			mFrustum.mOrigin = mTransformation.GetTranslation();
			mFrustum.mOrientation = mTransformation.GetRotation();
		}

		bool projChanged = mProjPropertyChanged;
		if (mProjPropertyChanged)
		{
			mAspectRatio = GetWidth() / (Real)GetHeight();
			mProjPropertyChanged = false;
			if (!mOrthogonal)
			{
				mMatrices[ProjBeforeSwap] = mMatrices[Proj] = 
					MakeProjectionMatrix(mFov, mAspectRatio, mNear, mFar);
			}
			else
			{
				mMatrices[ProjBeforeSwap] = mMatrices[Proj] = 
					MakeOrthogonalMatrix((Real)mOrthogonalData.left, (Real)mOrthogonalData.top,
					(Real)mOrthogonalData.right, (Real)mOrthogonalData.bottom,
					mNear, mFar);
			}
			if (mYZSwap)
			{
				Mat44 swapMat(
					1, 0, 0, 0,
					0, 0, 1, 0,
					0, 1, 0, 0,
					0, 0, 0, 1);
				mMatrices[Proj] = mMatrices[Proj] * swapMat;
			}
			mMatrices[InverseProj] = mMatrices[Proj].Inverse();	
			mFrustum.SetData(mNear, mFar, mFov, mAspectRatio);
		}

		if (projChanged || viewChanged)
		{
			
			mMatrices[ViewProj] = mMatrices[Proj] * mMatrices[View];
			mMatrices[InverseViewProj] = mMatrices[ViewProj].Inverse();

			UpdateFrustum();

			if (viewChanged && !mSelf->mObservers_.empty()){
				auto& observers = mSelf->mObservers_[TransformChanged];
				for (auto it = observers.begin(); it != observers.end(); /**/){
					auto observer = it->lock();
					if (!observer){
						it = observers.erase(it);
						continue;
					}
					++it;
					observer->OnViewMatrixChanged();
				}				
			}
			if (projChanged && !mSelf->mObservers_.empty()){
				auto& observers = mSelf->mObservers_[TransformChanged];
				for (auto it = observers.begin(); it != observers.end(); /**/){
					auto observer = it->lock();
					if (!observer){
						it = observers.erase(it);
						continue;
					}
					++it;
					observer->OnProjMatrixChanged();
				}
			}		
			mRayCache.clear();
		}
	}

//----------------------------------------------------------------------------
void Sample5::OnIdle()
{
	Double time = System::GetTime();
	Double elapsedTime = time - mLastTime;
	mLastTime = time;
	mAngle += static_cast<Float>(elapsedTime);
	mAngle = MathF::FMod(mAngle, MathF::TWO_PI * 2);

	// scene graph transformations
	//
	Node* pLitGroup = DynamicCast<Node>(mspRoot->GetChild(0));
	WIRE_ASSERT(pLitGroup);

	// rotate the 2 cubes
	Matrix3F rotate1(Vector3F(0.75F, 0.25F, 0.5F), -mAngle * 0.5F);
	Spatial* pCube1 = pLitGroup->GetChild(0);
	pCube1->Local.SetRotate(rotate1);

	Matrix3F rotate2(Vector3F(-0.75F, -0.25F, -0.5F), -mAngle * 0.5F);
	Spatial* pCube2 = pLitGroup->GetChild(1);
	pCube2->Local.SetRotate(rotate2);

	// move the green light up and down
	Float y = MathF::FMod(static_cast<Float>(time), MathF::TWO_PI);
	Vector3F lightPos1(0, MathF::Sin(y*2) * 1.5F, 2);
	Node* pLightNode1 = DynamicCast<Node>(mspRoot->GetChild(1));
	WIRE_ASSERT(pLightNode1);
	pLightNode1->Local.SetTranslate(lightPos1);

	// rotate the red light about the y axis
	Node* pLightNode2 = DynamicCast<Node>(mspRoot->GetChild(2));
	WIRE_ASSERT(pLightNode2);
	Matrix34F rotateLight2(Vector3F::UNIT_Y, -mAngle);
	Vector3F lightPos2 = rotateLight2 * Vector3F(5, 0, 0);
	pLightNode2->Local.SetTranslate(lightPos2);

	mspRoot->UpdateGS(time);
	mCuller.ComputeVisibleSet(mspRoot);

	// manual transformation from local to world space of 
	// the non-scene graph part
	Transformation transformation;
	Float angle = MathF::Sin(mAngle*2);
	angle = angle * MathF::HALF_PI*0.3F + MathF::PI;
	Matrix34F rotateLocalLight3(Vector3F(0, 1, 0), angle);
	Matrix34F rotateWorldLight3(Vector3F(1, 0, 0), -0.5F);
	transformation.SetTranslate(Vector3F(0.5F, -1.0F, 4+MathF::Sin(y*1.0F)*2));
	transformation.SetRotate(rotateWorldLight3 * rotateLocalLight3);
	transformation.SetUniformScale(0.15F);
	mspSpotLight->Position = transformation.GetTranslate();
	mspSpotLight->Direction = transformation.GetMatrix().GetColumn(2);

	GetRenderer()->ClearBuffers();
	GetRenderer()->PreDraw(mspCamera);

	// render the scene graph
	GetRenderer()->Draw(mCuller.GetVisibleSets());

	// before we start drawing objects in 'manual' mode, release all resources
	// cached by the Renderer to return the renderer to its default state.
	// This is necessary when identical resources (mspTexture in this case)
	// are used by the scene graph and other objects that are being draw
	// manually.
	GetRenderer()->ReleaseResources();

	// render the white cube representing the spot light
	GetRenderer()->Draw(mspWhiteCube, transformation);

	Matrix34F matrix(Vector3F(1.0F, 0, 0), -1.0F, Vector3F(0, -2.5F, 0));
	transformation.SetMatrix(matrix, false);
	transformation.SetUniformScale(1);

	// render the bottom plane which is being lit by the spot light
	GetRenderer()->SetLight(mspSpotLight);
	GetRenderer()->EnableLighting(mspSpotLight->Ambient);
	GetRenderer()->Draw(mspPlane, transformation);
	GetRenderer()->DisableLighting();

	GetRenderer()->PostDraw();
	GetRenderer()->DisplayBackBuffer();
}