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

	const Vec3& GetPosition() const
	{
		if (mOverridingCamera){
			return mOverridingCamera->GetPosition();
		}
		return mTransformation.GetTranslation();
	}

void SpatialObject::SetLocation(const Transformation& t){
	mBoundingVolumeWorld->SetCenter(mBoundingVolume->GetCenter() + t.GetTranslation());
	mBoundingVolumeWorld->SetRadius(mBoundingVolume->GetRadius() * t.GetScale().GetMax());
	mLocation = t;
	if (mAnimatedLocation){
		*mAnimatedLocation = mLocation * mAnim->GetResult();
	}
	mTransformChanged = true;
}

void BVaabb::TransformBy(const Transformation& transform,
	BoundingVolumePtr result)
{
	assert(result);
	BVaabb* pNewBound = (BVaabb*)result.get();
	AABB newAABB = mAABB;
	newAABB.Translate(transform.GetTranslation());
	pNewBound->SetAABB(newAABB);
}

	void SetPosition(const Vec3& pos)
	{
		if (mOverridingCamera){
			mOverridingCamera->SetPosition(pos);
			return;
		}
		if (mTransformation.GetTranslation() == pos)
			return;
		mTransformation.SetTranslation(pos);
		mViewPropertyChanged = true;
	}

	void GatherPointLightData(const BoundingVolume* aabb, const Transformation& transform, POINT_LIGHT_CONSTANTS* plConst)
	{
		struct GatheredData
		{
			GatheredData(Real distSQ, unsigned idx)
				:mDistanceSQ(distSQ), mIndex(idx)
			{

			}
			Real mDistanceSQ;
			unsigned mIndex;
		};
		static std::vector<GatheredData> gathered;
		gathered.reserve(50);

		unsigned i = 0;
		for (auto it = mPointLights.begin(); it != mPointLights.end(); /**/)
		{		
			IteratingWeakContainer(mPointLights, it, p);
			if (!p->GetEnabled())
				continue;
			Ray3 ray(p->GetPosition(), transform.GetTranslation() - p->GetPosition());
			Ray3 localRay = transform.ApplyInverse(ray);
			auto iresult = localRay.Intersects(aabb);
			Real distSQ = Squared(iresult.second);
			Real range = p->GetRange();
			if (distSQ < (range*range))
			{
				gathered.push_back(GatheredData(distSQ, i));
			}
			++i;
		}

		std::sort(gathered.begin(), gathered.end(), [](const GatheredData& a, const GatheredData& b){
			return a.mDistanceSQ < b.mDistanceSQ;
		}
		);

		plConst->gPointLightColor[0].w = 0;
		int count = std::min(3, (int)gathered.size());
		unsigned validNumber = 0;
		for (int i = 0; i < count; i++)
		{
			PointLightPtr p = mPointLights[gathered[i].mIndex].lock();
			if (p){
				plConst->gPointLightPos[validNumber] = Vec4(p->GetPosition(), p->GetRange());
				plConst->gPointLightColor[validNumber] = Vec4(p->GetColorPowered(), (Real)count);
				++validNumber;
			}
		}

		gathered.clear();
	}

	//----------------------------------------------------------------------------
	Ray3 ScreenPosToRay(long x, long y)
	{
		Update();
		auto it = mRayCache.Find(Vec2I(x, y));
		if (it != mRayCache.end()){
			return it->second;
		}

		Real fx = 2.0f * x / GetWidth() - 1.0f;
		Real fy = 1.0f - 2.0f * y / GetHeight();
		Vec3 screenPos((Real)fx, (Real)fy, -1.0f);
		Vec3 screenMidPos((Real)fx, (Real)fy, 0.0f);
		Vec3 origin = mMatrices[InverseViewProj]* screenPos;
		Vec3 target = mMatrices[InverseViewProj] * screenMidPos;
		Vec3 dir = target - origin;
		dir.Normalize();

		Ray3 ray(mTransformation.GetTranslation(), dir);
		mRayCache[Vec2I(x, y)] = ray;
		return ray;
	}

	Vec3 GetOffset() const{
		return mTransformation.GetTranslation();
	}

	//----------------------------------------------------------------------------
	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 MeshObject::UpdateModelViewTransformation(Transformation const & model_view)
{
	// TODO: _scale and _local_transformation constitutes way too much transformation data
	Transformation transformation(model_view.GetTranslation(), model_view.GetRotation(), _scale);
	SetModelViewTransformation(transformation);
}