CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/CoreLib/plViewTransform.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "hsBounds.h"
#include "hsStream.h"
#include "plViewTransform.h"

const hsScalar plViewTransform::kMinHither = 0.25f;

plViewTransform::plViewTransform()
:	fFlags(kViewPortRelative),
	fWidth(0),
	fHeight(0)
{
	fCameraToWorld.Reset();
	fWorldToCamera.Reset();

	fViewPortX.Set(0,1.f,1.f);
	fViewPortY.Set(0,1.f,1.f);

	fMapMin.Set(0.f, 0.f, 0.f);
	fMapMax.Set(1.f, 1.f, 1.f);
}

void plViewTransform::Reset()
{
	fFlags = kViewPortRelative;
	fCameraToWorld.Reset();
	fWorldToCamera.Reset();

	fViewPortX.Set(0,1.f,1.f);
	fViewPortY.Set(0,1.f,1.f);
}

void plViewTransform::ISetCameraToNDC() const
{
	fCameraToNDC.Reset();
	fCameraToNDC.NotIdentity();

	if( GetOrthogonal() )
	{
		hsPoint3	worldSizeInv;

		worldSizeInv.fX = hsScalarInvert( fMax.fX - fMin.fX ) * 2.f;
		worldSizeInv.fY = hsScalarInvert( fMax.fY - fMin.fY ) * 2.f;
		worldSizeInv.fZ = hsScalarInvert( fMax.fZ - fMin.fZ );

		fCameraToNDC.fMap[0][0] = worldSizeInv.fX;
		fCameraToNDC.fMap[0][3] = -fMin.fX * worldSizeInv.fX - hsScalar1;

		fCameraToNDC.fMap[1][1] = worldSizeInv.fY;
		fCameraToNDC.fMap[1][3] = -fMin.fY * worldSizeInv.fY - hsScalar1;

		// Map Screen Z to range 0 (at hither) to 1 (at yon)
		fCameraToNDC.fMap[2][2] = worldSizeInv.fZ;
		fCameraToNDC.fMap[2][3] = -fMin.fZ * worldSizeInv.fZ;
	}
	else
	{

		fCameraToNDC.fMap[0][0] = 2.f / (fMax.fX - fMin.fX);
		fCameraToNDC.fMap[0][2] = (fMax.fX + fMin.fX) / (fMax.fX - fMin.fX);

		fCameraToNDC.fMap[1][1] = 2.f / (fMax.fY - fMin.fY);
		fCameraToNDC.fMap[1][2] = (fMax.fY + fMin.fY) / (fMax.fY - fMin.fY);

		fCameraToNDC.fMap[2][2] = fMax.fZ / (fMax.fZ - fMin.fZ);
		fCameraToNDC.fMap[2][3] = -fMax.fZ * fMin.fZ / (fMax.fZ - fMin.fZ);

		fCameraToNDC.fMap[3][2] = 1.f;
		fCameraToNDC.fMap[3][3] = 0.f;

	}
	ISetFlag(kCameraToNDCSet);
}

void plViewTransform::SetViewPort(const hsPoint2& mins, const hsPoint2& maxs, hsBool relative)
{ 
	fViewPortX.Set(mins.fX, maxs.fX, 1.f / (maxs.fX - mins.fX)); 
	fViewPortY.Set(mins.fY, maxs.fY, 1.f / (maxs.fY - mins.fY)); 
	ISetFlag(kViewPortRelative, relative);
}

hsScalarTriple plViewTransform::ScreenToNDC(const hsScalarTriple& scrP) const
{
	hsPoint2 vpMin, vpMax;
	GetViewPort(vpMin, vpMax);
	hsPoint3 ndc;

	ndc.fX = (scrP.fX - vpMin.fX) / (vpMax.fX - vpMin.fX) * 2.f - 1.f;

	ndc.fY = (vpMax.fY - scrP.fY) / (vpMax.fY - vpMin.fY) * 2.f - 1.f;

	ndc.fZ = scrP.fZ;
	
	return ndc;
}

hsScalarTriple plViewTransform::NDCToScreen(const hsScalarTriple& ndc) const
{
	hsPoint2 vpMin, vpMax;
	GetViewPort(vpMin, vpMax);

	hsPoint3 scrP;
	scrP.fX = (ndc.fX + 1.f) * 0.5f * (vpMax.fX - vpMin.fX) + vpMin.fX;
	scrP.fY = (-ndc.fY + 1.f) * 0.5f * (vpMax.fY - vpMin.fY) + vpMin.fY;
	scrP.fZ = ndc.fZ;

	return scrP;
}

hsScalarTriple plViewTransform::NDCToCamera(const hsScalarTriple& ndc) const
{
	hsPoint3 camP;
	hsScalar w = ndc.fZ;

	const hsMatrix44& c2NDC = GetCameraToNDC();

	camP.fX = (ndc.fX - c2NDC.fMap[0][2]) * w / c2NDC.fMap[0][0];

	camP.fY = (ndc.fY - c2NDC.fMap[1][2]) * w / c2NDC.fMap[1][1];

	camP.fZ = ndc.fZ;

	return camP;
}

hsScalarTriple plViewTransform::CameraToNDC(const hsScalarTriple& camP) const
{
	const hsMatrix44& c2NDC = GetCameraToNDC();
	
#ifdef MF_FLIP_SPARSE
	// We count on the fact that we set up CameratToNDC, so we know where the
	// zeros are. Also, note that the proper "* camP.fZ"'s are missing off the
	// c2NDC.fMap[i][2] terms, because they just get cancelled out by the invW.

	hsPoint3 ndc;
	if( GetOrthogonal() )
	{
		ndc.fX = c2NDC.fMap[0][0] * camP.fX 
			+ c2NDC.fMap[0][2];

		ndc.fY = c2NDC.fMap[1][1] * camP.fY 
			+ c2NDC.fMap[1][2];

		ndc.fZ = c2NDC.fMap[2][2] * camP.fZ 
			+ c2NDC.fMap[2][3];
	}
	else
	{
		hsScalar invW = 1.f / camP.fZ;
		ndc.fX = c2NDC.fMap[0][0] * camP.fX * invW
			+ c2NDC.fMap[0][2];

		ndc.fY = c2NDC.fMap[1][1] * camP.fY * invW
			+ c2NDC.fMap[1][2];

		ndc.fZ = c2NDC.fMap[2][2] * camP.fZ 
			+ c2NDC.fMap[2][3];
		ndc.fZ *= invW;
	}
#else // MF_FLIP_SPARSE
	hsPoint3 ndc = c2NDC * hsPoint3(camP);
	if( !GetOrthogonal() )
	{
		hsScalar invW = 1.f / camP.fZ;
		ndc *= invW;
	}
#endif // MF_FLIP_SPARSE

	return ndc;
}

hsScalarTriple plViewTransform::NDCToMap(const hsScalarTriple& ndcP) const
{
	hsPoint3 map;
	map.fX = fMapMin.fX + (ndcP.fX + 1.f) * 0.5f * (fMapMax.fX - fMapMin.fX);
	map.fY = fMapMin.fY + (ndcP.fY + 1.f) * 0.5f * (fMapMax.fY - fMapMin.fY);
	map.fZ = fMapMin.fZ + (ndcP.fZ + 1.f) * 0.5f * (fMapMax.fZ - fMapMin.fZ);

	return map;
}

hsBool plViewTransform::SetProjection(const hsBounds3& bnd)
{
	hsPoint3 maxs;
	hsPoint3 mins;
	if( IGetMaxMinsFromBnd(bnd, mins, maxs) )
	{
		SetView(mins, maxs);
		return true;
	}
	return false;
}

hsBool plViewTransform::SetProjectionWorld(const hsBounds3& wBnd)
{
	hsBounds3Ext cBnd = wBnd;
	cBnd.Transform(&GetWorldToCamera());
	return SetProjection(cBnd);
}

hsBool plViewTransform::IGetMaxMinsFromBnd(const hsBounds3& bnd, hsPoint3& mins, hsPoint3& maxs) const
{
	if( bnd.GetMaxs().fZ <= kMinHither )
		return false;

	hsPoint3 minBnd = bnd.GetMins();
	hsPoint3 maxBnd = bnd.GetMaxs();
	// If the box intersects the hither plane, we'll need to chop it
	// off.
	if( minBnd.fZ < kMinHither )
	{
		minBnd.fZ = kMinHither;		
	}
	mins.Set(minBnd.fX / minBnd.fZ, minBnd.fY / minBnd.fZ, minBnd.fZ);
	maxs.Set(maxBnd.fX / minBnd.fZ, maxBnd.fY / minBnd.fZ, maxBnd.fZ);

	return true;
}

hsBool plViewTransform::Intersect(const plViewTransform& view)
{
	hsPoint3 mins;
	hsPoint3 maxs;

	hsBool retVal = true;
	int i;
	for( i = 0; i < 3; i++ )
	{
		mins[i] = hsMaximum(fMin[i], view.fMin[i]);

		maxs[i] = hsMinimum(fMax[i], view.fMax[i]);

		if( mins[i] >= maxs[i] )
		{
			mins[i] = maxs[i] = (mins[i] + maxs[i]) * 0.5f;
			retVal = false;
		}
	}
	SetView(mins, maxs);
	return retVal;
}

hsBool plViewTransform::Union(const plViewTransform& view)
{
	hsPoint3 mins;
	hsPoint3 maxs;

	int i;
	for( i = 0; i < 3; i++ )
	{
		mins[i] = hsMinimum(fMin[i], view.fMin[i]);

		maxs[i] = hsMaximum(fMax[i], view.fMax[i]);

	}
	SetView(mins, maxs);
	return true;
}

hsScalar plViewTransform::GetFovX() const
{
	hsScalar minAng = hsATan2(fMin.fX, 1.f);
	hsScalar maxAng = hsATan2(fMax.fX, 1.f);

	return maxAng - minAng;
}

hsScalar plViewTransform::GetFovY() const
{
	hsScalar minAng = hsATan2(fMin.fY, 1.f);
	hsScalar maxAng = hsATan2(fMax.fY, 1.f);

	return maxAng - minAng;
}

void plViewTransform::GetViewPort(hsPoint2& mins, hsPoint2& maxs) const 
{ 
	if( GetViewPortRelative() )
	{
		mins.Set(fViewPortX.fX * fWidth, fViewPortY.fX * fHeight); 
		maxs.Set(fViewPortX.fY * fWidth, fViewPortY.fY * fHeight); 
	}
	else
	{
		mins.Set(fViewPortX.fX, fViewPortY.fX); 
		maxs.Set(fViewPortX.fY, fViewPortY.fY); 
	}
}

void plViewTransform::GetViewPort(int& loX, int& loY, int& hiX, int& hiY) const 
{ 
	if( GetViewPortRelative() )
	{
		loX = int(fViewPortX.fX * fWidth); 
		loY = int(fViewPortY.fX * fHeight); 
		hiX = int(fViewPortX.fY * fHeight); 
		hiY = int(fViewPortY.fY * fWidth); 
	}
	else
	{
		loX = int(fViewPortX.fX); 
		loY = int(fViewPortY.fX); 
		hiX = int(fViewPortX.fY); 
		hiY = int(fViewPortY.fY); 
	}
}

void plViewTransform::Read(hsStream* s)
{
	fFlags = s->ReadSwap32();
	fFlags &= ~kSetMask;

	fCameraToWorld.Read(s);
	fWorldToCamera.Read(s);

	fMin.Read(s);
	fMax.Read(s);

	fWidth = s->ReadSwap16();
	fHeight = s->ReadSwap16();

	fViewPortX.Read(s);
	fViewPortY.Read(s);

	fMapMin.Read(s);
	fMapMin.Read(s);
}

void plViewTransform::Write(hsStream* s)
{
	s->WriteSwap32(fFlags & ~kSetMask);

	fCameraToWorld.Write(s);
	fWorldToCamera.Write(s);

	fMin.Write(s);
	fMax.Write(s);

	s->WriteSwap16(fWidth);
	s->WriteSwap16(fHeight);

	fViewPortX.Write(s);
	fViewPortY.Write(s);

	fMapMin.Write(s);
	fMapMin.Write(s);
}