tf2/tf2_src/public/panorama/transformations.h

//=========== Copyright Valve Corporation, All rights reserved. ===============//
//
// Purpose: 
//=============================================================================//

#ifndef TRANSFORMATIONS_H
#define TRANSFORMATIONS_H

#ifdef _WIN32
#pragma once
#endif

#include "mathlib/mathlib.h"
#include "mathlib/vmatrix.h"
#include "tier1/utlbuffer.h"
#include "panorama.h"
#include "panoramatypes.h"
#include "layout/uilength.h"

namespace panorama
{

class CTransform3D
{
public:
	virtual ~CTransform3D() {}

	virtual ETransform3DType GetType() const = 0;
	virtual VMatrix GetTransformMatrix( float flParentWidth, float flParentHeight ) const = 0;
	virtual CTransform3D *Clone() const = 0;
	virtual void ScaleLengthValues( float flScaleFactor ) = 0;
	virtual bool BOnlyImpacts2DValues() = 0;

	virtual bool operator==( const CTransform3D &rhs ) const = 0;
	bool operator!=( const CTransform3D &rhs ) const { return !(*this == rhs); }
};

// Helpers for interpolating 3d transform matrixes
struct DecomposedMatrix_t
{
	DecomposedMatrix_t() 
	{ 
		m_flTranslationXYZ[0] = 0.0f;
		m_flTranslationXYZ[1] = 0.0f;
		m_flTranslationXYZ[2] = 0.0f;
		m_flScaleXYZ[0] = 1.0;
		m_flScaleXYZ[1] = 1.0;
		m_flScaleXYZ[2] = 1.0;
		m_flSkewXY = 0.0f;
		m_flSkewXZ = 0.0f;
		m_flSkewYZ = 0.0f;

		m_quatTransform.Init();
	}
	float m_flTranslationXYZ[3];
	float m_flScaleXYZ[3];
	float m_flSkewXY;
	float m_flSkewXZ;
	float m_flSkewYZ;
	Quaternion m_quatTransform;


};
DecomposedMatrix_t DecomposeTransformMatrix( VMatrix matrix );
VMatrix RecomposeTransformMatrix( const DecomposedMatrix_t &decomposed );
VMatrix InterpolateTransformMatrix( VMatrix from, VMatrix to, float flTimeProgress );

class CTransformRotate3D : public CTransform3D
{
public:
	// Transform in 3D space:
	// PITCH: Clockwise rotation around the Y axis.
	// YAW: Counterclockwise rotation around the Z axis.
	// ROLL: Counterclockwise rotation around the X axis.
	CTransformRotate3D( float flDegreesPitch, float flDegreesYaw, float flDegreesRoll )
	{
		QAngle angle( flDegreesPitch, flDegreesYaw, flDegreesRoll );
		AngleQuaternion( angle, m_quatTransform );
	}

	ETransform3DType GetType() const { return k_ETransform3DRotate; }

	VMatrix GetTransformMatrix( float flParentWidth, float flParentHeight ) const
	{ 
		matrix3x4_t mat;
		QuaternionMatrix( m_quatTransform, mat );
		return VMatrix( mat );
	}

	bool BOnlyImpacts2DValues()
	{
		return false;
	}

	virtual CTransform3D *Clone() const
	{
		CTransformRotate3D *pRet = new CTransformRotate3D();
		pRet->m_quatTransform = m_quatTransform;

		return pRet;
	}

	QAngle GetAngles() const
	{
		QAngle angle;
		QuaternionAngles( m_quatTransform, angle );

		return angle;
	}

	virtual void ScaleLengthValues( float flScaleFactor ) { }

	virtual bool operator==( const CTransform3D &other ) const
	{
		if ( other.GetType() != k_ETransform3DRotate )
			return false;

		const CTransformRotate3D &rhs = (const CTransformRotate3D &)other;
		return (m_quatTransform == rhs.m_quatTransform);
	}

protected:
	CTransformRotate3D() {}

private:

	Quaternion m_quatTransform;
};

class CTransformTranslate3D : public CTransform3D
{
public:
	// Translate in 3D space
	CTransformTranslate3D( float x, float y, float z )
	{
		m_x.SetLength( x );
		m_y.SetLength( y );
		m_z.SetLength( z );
	}

	CTransformTranslate3D( const CUILength &x, const CUILength &y, const CUILength &z )
	{
		m_x = x;
		m_y = y;
		m_z = z;
	}

	bool BOnlyImpacts2DValues()
	{
		if( fabs( m_z.GetValueAsLength( 100 ) - 0.0f ) < 0.0001f )
			return true;

		return false;
	}

	ETransform3DType GetType() const { return k_ETransform3DTranslate; }

	VMatrix GetTransformMatrix( float flParentWidth, float flParentHeight ) const
	{ 

		VMatrix mat = VMatrix::GetIdentityMatrix();
		mat.SetTranslation( Vector( m_x.GetValueAsLength( flParentWidth ), m_y.GetValueAsLength( flParentHeight ), m_z.GetValueAsLength( 0 ) ) );
		return mat;
	}

	virtual CTransform3D *Clone() const
	{
		return new CTransformTranslate3D( m_x, m_y, m_z );
	}

	virtual void ScaleLengthValues( float flScaleFactor ) 
	{
		m_x.ScaleLengthValue( flScaleFactor );
		m_y.ScaleLengthValue( flScaleFactor );
		m_z.ScaleLengthValue( flScaleFactor );
	}

	CUILength GetX() const { return m_x; }
	CUILength GetY() const { return m_y; }
	CUILength GetZ() const { return m_z; }

	virtual bool operator==( const CTransform3D &other ) const
	{
		if ( other.GetType() != k_ETransform3DTranslate )
			return false;

		const CTransformTranslate3D &rhs = (const CTransformTranslate3D &)other;
		return ( m_x == rhs.m_x && m_y == rhs.m_y && m_z == rhs.m_z );
	}

private:
	CUILength m_x;
	CUILength m_y;
	CUILength m_z;
};


class CTransformScale3D : public CTransform3D
{
public:
	// Scale in 3D space
	CTransformScale3D( float x, float y, float z ) : m_VecScale( x, y, z )
	{
	}

	ETransform3DType GetType() const { return k_ETransform3DScale; }

	bool BOnlyImpacts2DValues()
	{
		return false;
	}

	VMatrix GetTransformMatrix( float flParentWidth, float flParentHeight ) const
	{ 
		VMatrix mat;
		MatrixBuildScale( mat, m_VecScale.x, m_VecScale.y, m_VecScale.z );
		return mat;
	}

	virtual CTransform3D *Clone() const
	{
		return new CTransformScale3D( m_VecScale.x, m_VecScale.y, m_VecScale.z );
	}

	virtual void ScaleLengthValues( float flScaleFactor ) { }

	float GetX() const { return m_VecScale.x; }
	float GetY() const { return m_VecScale.y; }
	float GetZ() const { return m_VecScale.z; }

	virtual bool operator==( const CTransform3D &other ) const
	{
		if ( other.GetType() != k_ETransform3DScale )
			return false;

		const CTransformScale3D &rhs = (const CTransformScale3D &)other;
		return ( m_VecScale == rhs.m_VecScale );
	}

private:
	Vector m_VecScale;
};

} // namespace panorama

#endif // TRANSFORMATIONS_H