Solution refactoring and restructuring, removed Boost dependency, removed unused tools

src/GameLib/TerrainPatch.h

@@ -0,0 +1,250 @@
+// TerrainPatch.h: interface for the CTerrainPatch class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_TERRAINPATCH_H__CDD52438_D542_433C_8748_3A15C910A65E__INCLUDED_)
+#define AFX_TERRAINPATCH_H__CDD52438_D542_433C_8748_3A15C910A65E__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include "../eterlib/GrpVertexBuffer.h"
+#include "../PRTerrainLib/Terrain.h"
+
+#pragma pack(push)
+#pragma pack(1)
+
+struct HardwareTransformPatch_SSourceVertex
+{
+	D3DXVECTOR3 kPosition;
+	D3DXVECTOR3 kNormal;
+};
+
+struct SoftwareTransformPatch_SSourceVertex
+{
+	D3DXVECTOR3 kPosition;
+	D3DXVECTOR3 kNormal;
+	DWORD		dwDiffuse;
+};
+
+struct SWaterVertex
+{
+    float x, y, z;          // position
+	DWORD dwDiffuse;
+};
+#pragma pack(pop)
+
+class CTerrainPatch
+{
+public:
+	enum
+	{
+		PATCH_TYPE_PLAIN = 0,
+		PATCH_TYPE_HILL,
+		PATCH_TYPE_CLIFF,
+	};
+
+	enum
+	{
+		TERRAIN_VERTEX_COUNT = (CTerrainImpl::PATCH_XSIZE+1)*(CTerrainImpl::PATCH_YSIZE+1)
+	};
+
+	static bool SOFTWARE_TRANSFORM_PATCH_ENABLE;
+	
+public:
+	CTerrainPatch()									{ Clear(); }
+	~CTerrainPatch()									{ Clear(); }
+	
+	void Clear();
+
+	void ClearID()											{ SetID(0xFFFFFFFF); }
+	
+	void SetMinX(float fMinX)								{ m_fMinX = fMinX; }
+	float GetMinX()											{ return m_fMinX; }
+	
+	void SetMaxX(float fMaxX)								{ m_fMaxX = fMaxX; }
+	float GetMaxX()											{ return m_fMaxX; }
+	
+	void SetMinY(float fMinY)								{ m_fMinY = fMinY; }
+	float GetMinY()											{ return m_fMinY; }
+	
+	void SetMaxY(float fMaxY)								{ m_fMaxY = fMaxY; }
+	float GetMaxY()											{ return m_fMaxY; }
+	
+	void SetMinZ(float fMinZ)								{ m_fMinZ = fMinZ; }
+	float GetMinZ()											{ return m_fMinZ; }
+	
+	void SetMaxZ(float fMaxZ)								{ m_fMaxZ = fMaxZ; }
+	float GetMaxZ()											{ return m_fMaxZ; }
+	
+	bool IsUse()											{ return m_bUse; }
+	void SetUse(bool bUse)									{ m_bUse = bUse; }
+	
+	bool IsWaterExist()										{ return m_bWaterExist; }
+	void SetWaterExist(bool bWaterExist)					{ m_bWaterExist = bWaterExist; }
+	
+	DWORD GetID()											{ return m_dwID; }
+	void SetID(DWORD dwID)									{ m_dwID = dwID; }
+	
+	void SetType(BYTE byType)								{ m_byType = byType; }
+	BYTE GetType()											{ return m_byType; }
+
+	void NeedUpdate(bool bNeedUpdate)						{ m_bNeedUpdate = bNeedUpdate;}
+	bool NeedUpdate()										{ return m_bNeedUpdate; }
+
+	UINT GetWaterFaceCount();
+
+	void SoftwareTransformPatch_UpdateTerrainLighting(DWORD dwVersion, const D3DLIGHT8& c_rkLight, const D3DMATERIAL8& c_rkMtrl);
+	
+	void BuildTerrainVertexBuffer(HardwareTransformPatch_SSourceVertex* akSrcVertex);
+	void BuildWaterVertexBuffer(SWaterVertex* akSrcVertex, UINT uWaterVertexCount);
+	
+protected:
+	void __BuildHardwareTerrainVertexBuffer(HardwareTransformPatch_SSourceVertex* akSrcVertex);
+	void __BuildSoftwareTerrainVertexBuffer(HardwareTransformPatch_SSourceVertex* akSrcVertex);
+	
+private:
+	float					m_fMinX;
+	float					m_fMaxX;
+	float					m_fMinY;
+	float					m_fMaxY;
+	float					m_fMinZ;
+	float					m_fMaxZ;
+	bool					m_bUse;
+	bool					m_bWaterExist;
+	DWORD					m_dwID;
+	DWORD m_dwWaterPriCount;
+	
+	CGraphicVertexBuffer	m_WaterVertexBuffer;
+	BYTE					m_byType;
+
+	bool					m_bNeedUpdate;
+	DWORD					m_dwVersion;
+
+public:
+	CGraphicVertexBuffer* GetWaterVertexBufferPointer()	{ return &m_WaterVertexBuffer;}
+
+public:
+	CGraphicVertexBuffer* HardwareTransformPatch_GetVertexBufferPtr() {return &m_kHT.m_kVB;}
+
+protected:
+	struct SHardwareTransformPatch
+	{
+		CGraphicVertexBuffer	m_kVB;
+	} m_kHT;
+
+
+public:
+	SoftwareTransformPatch_SSourceVertex* SoftwareTransformPatch_GetTerrainVertexDataPtr()	
+	{return m_kST.m_akTerrainVertex;}
+
+protected:
+	struct SSoftwareTransformPatch
+	{
+		SoftwareTransformPatch_SSourceVertex*	m_akTerrainVertex;
+		
+		SSoftwareTransformPatch();
+		~SSoftwareTransformPatch();
+
+		void Create();
+		void Destroy();
+
+		void __Initialize();
+	} m_kST;
+
+};
+
+class CTerrainPatchProxy  
+{
+public:
+	CTerrainPatchProxy();
+	virtual ~CTerrainPatchProxy();
+
+	void Clear();
+
+	void SetCenterPosition(const D3DXVECTOR3& c_rv3Center);
+
+	bool IsIn(const D3DXVECTOR3& c_rv3Target, float fRadius);
+
+	bool isUsed()																	{ return m_bUsed; }
+	void SetUsed(bool bUsed)														{ m_bUsed = bUsed; }
+
+	short GetPatchNum()																{ return m_sPatchNum; }
+	void SetPatchNum(short sPatchNum)												{ m_sPatchNum = sPatchNum; }
+
+	BYTE GetTerrainNum()															{ return m_byTerrainNum; }
+	void SetTerrainNum(BYTE byTerrainNum)											{ m_byTerrainNum = byTerrainNum; }
+
+	void SetTerrainPatch(CTerrainPatch * pTerrainPatch)								{ m_pTerrainPatch = pTerrainPatch;}
+
+	bool isWaterExists();
+
+	UINT GetWaterFaceCount();
+
+	float GetMinX();
+	float GetMaxX();
+	float GetMinY();
+	float GetMaxY();
+	float GetMinZ();
+	float GetMaxZ();
+
+	// Vertex Buffer
+	CGraphicVertexBuffer * GetWaterVertexBufferPointer();
+	SoftwareTransformPatch_SSourceVertex* SoftwareTransformPatch_GetTerrainVertexDataPtr();
+	CGraphicVertexBuffer* HardwareTransformPatch_GetVertexBufferPtr();
+
+	void SoftwareTransformPatch_UpdateTerrainLighting(DWORD dwVersion, const D3DLIGHT8& c_rkLight, const D3DMATERIAL8& c_rkMtrl);
+	
+protected:
+	bool					m_bUsed;
+	short					m_sPatchNum;	// Patch Number
+
+	BYTE					m_byTerrainNum;	
+
+	CTerrainPatch *			m_pTerrainPatch;
+
+	D3DXVECTOR3				m_v3Center;
+};
+
+inline bool CTerrainPatchProxy::isWaterExists()
+{
+	return m_pTerrainPatch->IsWaterExist();
+}
+
+inline float CTerrainPatchProxy::GetMinX()
+{
+	return m_pTerrainPatch->GetMinX();
+}
+
+inline float CTerrainPatchProxy::GetMaxX()
+{
+	return m_pTerrainPatch->GetMaxX();
+}
+
+inline float CTerrainPatchProxy::GetMinY()
+{
+	return m_pTerrainPatch->GetMinY();
+}
+
+inline float CTerrainPatchProxy::GetMaxY()
+{
+	return m_pTerrainPatch->GetMaxY();
+}
+
+inline float CTerrainPatchProxy::GetMinZ()
+{
+	return m_pTerrainPatch->GetMinZ();
+}
+
+inline float CTerrainPatchProxy::GetMaxZ()
+{
+	return m_pTerrainPatch->GetMaxZ();
+}
+
+inline CGraphicVertexBuffer * CTerrainPatchProxy::GetWaterVertexBufferPointer()
+{
+	return m_pTerrainPatch->GetWaterVertexBufferPointer();
+}
+
+#endif // !defined(AFX_TERRAINPATCH_H__CDD52438_D542_433C_8748_3A15C910A65E__INCLUDED_)