Tr0n/client
1
0
Fork 0
forked from metin2/client
Code Pull Requests Activity

Cleaned up unused libraries

Browse Source
This commit is contained in:
Exynox
2024-03-28 22:27:41 +02:00
parent a21139193e
commit d90f123059
159 changed files with 0 additions and 228278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

548
extern/include/speedtree/SpeedTreeRT.h vendored Normal file
View File

@ -0,0 +1,548 @@
///////////////////////////////////////////////////////////////////////
// Name: SpeedTreeRT.h
//
// *** INTERACTIVE DATA VISUALIZATION (IDV) PROPRIETARY INFORMATION ***
//
// Copyright (c) 2001-2003 IDV, Inc.
// All Rights Reserved.
//
// IDV, Inc.
// 1233 Washington St. Suite 610
// Columbia, SC 29201
// Voice: (803) 799-1699
// Fax: (803) 931-0320
// Web: http://www.idvinc.com
//
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Interactive Data Visualization and may not
// be copied or disclosed except in accordance with the terms of that
// agreement.
//
// Release version 1.6.0 (December 19, 2003)
#pragma once
// define static or dynamic library build
#ifdef SPEEDTREERT_DYNAMIC_LIB
#ifdef IDV_SPEEDTREERT_EXPORTS
#define BUILD_SPEED_TREE_RT_SET __declspec(dllexport)
#else
#define BUILD_SPEED_TREE_RT_SET __declspec(dllimport)
#endif
#else
#define BUILD_SPEED_TREE_RT_SET
#endif
// big or little endian system
#ifdef __ppc__
#define ST_BIG_ENDIAN
#else
#define ST_LITTLE_ENDIAN
#endif
// Macintosh-specific
#ifdef __ppc__
#pragma export on
#endif
// forward refernces
class CIndexedGeometry;
class CTreeEngine;
class CLeafGeometry;
class CLightingEngine;
class CWindEngine;
class CTreeFileAccess;
class CSimpleBillboard;
class CFrondEngine;
struct STreeInstanceData;
struct SInstanceList;
struct SEmbeddedTexCoords;
struct SCollisionObjects;
class CProjectedShadow;
///////////////////////////////////////////////////////////////////////
// class SpeedTreeRT
//
// In an effort to make the SpeedTreeRT.h header file dependency free
// and easy to include into almost any project, a number of steps have
// been taken:
//
// 1. No external header files need to be included by SpeedTreeRT.h
// or by the application before including it.
//
// 2. Most of the implementation of the class is hidden by pointers
// to the major sections of the library (the internal classes
// can then just be forward-referenced)
//
// 3. Where possible, basic C++ datatypes are used to define the
// member functions' parameters.
//
// Because almost all of the implementation details are hidden, none of
// the functions for CSpeedTreeRT are inlined. However, inlined functions
// were copiously used within the library.
class BUILD_SPEED_TREE_RT_SET CSpeedTreeRT
{
public:
///////////////////////////////////////////////////////////////////////
// Enumerations
enum EWindMethod
{
WIND_GPU, WIND_CPU, WIND_NONE
};
enum ELodMethod
{
LOD_POP, LOD_SMOOTH, LOD_NONE = 3
};
enum ELightingMethod
{
LIGHT_DYNAMIC, LIGHT_STATIC
};
enum EStaticLightingStyle
{
SLS_BASIC, SLS_USE_LIGHT_SOURCES, SLS_SIMULATE_SHADOWS
};
enum ECollisionObjectType
{
CO_SPHERE, CO_CYLINDER, CO_BOX
};
///////////////////////////////////////////////////////////////////////
// SGeometry bit vectors
//
// Passed into GetGeometry() in order to mask out unneeded geometric elements
#define SpeedTree_BranchGeometry (1 << 0)
#define SpeedTree_FrondGeometry (1 << 1)
#define SpeedTree_LeafGeometry (1 << 2)
#define SpeedTree_BillboardGeometry (1 << 3)
#define SpeedTree_SimpleBillboardOverride (1 << 4)
#define SpeedTree_AllGeometry SpeedTree_BranchGeometry + SpeedTree_FrondGeometry + SpeedTree_LeafGeometry + SpeedTree_BillboardGeometry
///////////////////////////////////////////////////////////////////////
// struct SGeometry declaration
struct BUILD_SPEED_TREE_RT_SET SGeometry
{
SGeometry( );
~SGeometry( );
///////////////////////////////////////////////////////////////////////
// struct SGeometry::SIndexed declaration
struct BUILD_SPEED_TREE_RT_SET SIndexed
{
SIndexed( );
~SIndexed( );
// these values change depending on the active discrete LOD level
int m_nDiscreteLodLevel; // range: [0, GetNumBranch/FrondLodLevels( ) - 1], -1 if inactive
unsigned short m_usNumStrips; // total number of strips in current LOD
const unsigned short* m_pStripLengths; // lengths of strips in current LOD (m_usNumStrips in length)
const unsigned short** m_pStrips; // triangle strip indices (m_usNumStrips in length)
// these values are shared across all discete LOD levels
unsigned short m_usVertexCount; // total vertex count in tables, referenced by all LOD levels
const unsigned long* m_pColors; // RGBA values for each leaf - static lighting only (m_usVertexCount in length)
const float* m_pNormals; // normals for each vertex (3 * m_usVertexCount in length)
const float* m_pBinormals; // binormals (bump mapping) for each vertex (3 * m_usVertexCount in length)
const float* m_pTangents; // tangents (bump mapping) for each vertex (3 * m_usVertexCount in length)
const float* m_pCoords; // coordinates for each vertex (3 * m_usVertexCount in length)
const float* m_pTexCoords0; // 1st layer (s,t) texcoords for each vertex (2 * m_usVertexCount in length)
const float* m_pTexCoords1; // 2nd layer (s,t) texcoords for each vertex (2 * m_usVertexCount in length)
const float* m_pWindWeights; // values from from 0.0 for rigid to 1.0 for flexible (m_usVertexCount in length)
const unsigned char* m_pWindMatrixIndices; // table of wind matrix indices (m_usVertexCount in length)
};
///////////////////////////////////////////////////////////////////////
// struct SGeometry::SLeaf declaration
struct BUILD_SPEED_TREE_RT_SET SLeaf
{
SLeaf( );
~SLeaf( );
// active LOD level data
bool m_bIsActive; // flag indicating visibility
float m_fAlphaTestValue; // 0.0 to 255.0 alpha testing value, used for fading
int m_nDiscreteLodLevel; // range: [0, GetNumLeafLodLevels( ) - 1]
unsigned short m_usLeafCount; // number of leaves stored in this structure
// tables for referencing the leaf cluster table
const unsigned char* m_pLeafMapIndices; // references which leaf texture map used for each leaf (m_usLeafCount in length)
const unsigned char* m_pLeafClusterIndices; // references which leaf cluster used for each leaf (m_usLeafCount in length)
const float* m_pCenterCoords; // (x,y,z) values for the centers of leaf clusters (3 * m_usLeafCount in length)
const float** m_pLeafMapTexCoords; // table of unique leaf cluster texcoords (m_usLeafCount in length) - each entry
// points to 4 pairs of (s,t) texcoords stored in one contiguous array
const float** m_pLeafMapCoords; // table of unique leaf cluster coordinates (m_usLeafCount in length) - each entry
// points to 4 sets of (x,y,z,0) coordinates stored in one contiguous array
// remaining vertex attributes
const unsigned long* m_pColors; // RGBA values for each leaf (m_usLeafCount in length)
const float* m_pNormals; // normals for each leaf (3 * m_usLeafCount in length)
const float* m_pBinormals; // binormals (bump mapping) for each leaf (3 * m_usLeafCount in length)
const float* m_pTangents; // tangents (bump mapping) for each leaf (3 * m_usLeafCount in length)
const float* m_pWindWeights; // values from from 0.0 for rigid to 1.0 for flexible (m_usLeafCount in length)
const unsigned char* m_pWindMatrixIndices; // table of wind matrix indices (m_usLeafCount in length)
};
///////////////////////////////////////////////////////////////////////
// struct SGeometry::SBillboard declaration
struct BUILD_SPEED_TREE_RT_SET SBillboard
{
SBillboard( );
~SBillboard( );
bool m_bIsActive; // flag indicating visibility
const float* m_pTexCoords; // 4 pairs of (s,t) texcoords stored in one contiguous array
const float* m_pCoords; // 4 sets of (x,y,z) coordindates stored in one contiguous array
float m_fAlphaTestValue; // 0.0 to 255.0 alpha testing value, used for fading
};
///////////////////////////////////////////////////////////////////////
// branch geometry
SIndexed m_sBranches; // holds the branch vertices and index buffers for all
// of the discrete LOD levels
float m_fBranchAlphaTestValue; // 0.0 to 255.0 alpha testing value, used for fading
///////////////////////////////////////////////////////////////////////
// frond geometry
SIndexed m_sFronds; // holds the frond vertices and index buffers for all
// of the discrete LOD levels
float m_fFrondAlphaTestValue; // 0.0 to 255.0 alpha testing value, used for fading
///////////////////////////////////////////////////////////////////////
// leaf geometry
SLeaf m_sLeaves0; // holds the primary leaf geometry, alpha fades into
SLeaf m_sLeaves1; // m_sLeaves1 during LOD transitions
///////////////////////////////////////////////////////////////////////
// billboard geometry
SBillboard m_sBillboard0; // holds the main simple billboard geometry, alpha fades
SBillboard m_sBillboard1; // into m_sBillboard1 in 360 degree mode
SBillboard m_sHorizontalBillboard; // optional horizontal billboard used for aerial views
};
///////////////////////////////////////////////////////////////////////
// struct SGeometry::STextures declaration
struct BUILD_SPEED_TREE_RT_SET STextures
{
STextures( );
~STextures( );
// branches
const char* m_pBranchTextureFilename; // null-terminated string
// leaves
unsigned int m_uiLeafTextureCount; // the number of char* elements in m_pLeafTextureFilenames
const char** m_pLeafTextureFilenames; // array of null-terminated strings m_uiLeafTextureCount in size
// fronds
unsigned int m_uiFrondTextureCount; // the number of char* elements in m_pFrondTextureFilenames
const char** m_pFrondTextureFilenames; // array of null-terminated strings m_uiFrondTextureCount in size
// composite
const char* m_pCompositeFilename; // null-terminated string
// self-shadow
const char* m_pSelfShadowFilename; // null-terminated string
};
///////////////////////////////////////////////////////////////////////
// Constructor/Destructor
CSpeedTreeRT( );
~CSpeedTreeRT( );
///////////////////////////////////////////////////////////////////////
// Memory allocation
static void* operator new(size_t nSize);
static void* operator new[](size_t nSize);
static void operator delete(void* pRawMemory);
static void operator delete[](void* pRawMemory);
///////////////////////////////////////////////////////////////////////
// Specifying a tree model
bool Compute(const float* pTransform = 0, unsigned int nSeed = 1, bool bCompositeStrips = true);
CSpeedTreeRT* Clone(float x = 0.0f, float y = 0.0f, float z = 0.0f, unsigned int nSeed = 0) const;
const CSpeedTreeRT* InstanceOf(void) const;
CSpeedTreeRT* MakeInstance(void);
void DeleteTransientData(void);
bool LoadTree(const char* pFilename);
bool LoadTree(const unsigned char* pBlock, unsigned int nNumBytes);
unsigned char* SaveTree(unsigned int& nNumBytes, bool bSaveLeaves = false) const;
void GetTreeSize(float& fSize, float& fVariance) const;
void SetTreeSize(float fNewSize, float fNewVariance = 0.0f);
unsigned int GetSeed( ) const;
const float* GetTreePosition(void) const;
void SetTreePosition(float x, float y, float z);
void SetLeafTargetAlphaMask(unsigned char ucMask = 0x54);
///////////////////////////////////////////////////////////////////////
// Lighting
// lighting style
ELightingMethod GetBranchLightingMethod(void) const;
void SetBranchLightingMethod(ELightingMethod eMethod);
ELightingMethod GetLeafLightingMethod(void) const;
void SetLeafLightingMethod(ELightingMethod eMethod);
ELightingMethod GetFrondLightingMethod(void) const;
void SetFrondLightingMethod(ELightingMethod eMethod);
EStaticLightingStyle GetStaticLightingStyle(void) const;
void SetStaticLightingStyle(EStaticLightingStyle eStyle);
float GetLeafLightingAdjustment( ) const;
void SetLeafLightingAdjustment(float fScalar);
// global lighting state
static bool GetLightState(unsigned int nLightIndex);
static void SetLightState(unsigned int nLightIndex, bool bLightOn);
static const float* GetLightAttributes(unsigned int nLightIndex);
static void SetLightAttributes(unsigned int nLightIndex, const float* pLightAttributes);
// branch material
const float* GetBranchMaterial(void) const;
void SetBranchMaterial(const float* pMaterial);
// leaf material
const float* GetLeafMaterial(void) const;
void SetLeafMaterial(const float* pMaterial);
// frond material
const float* GetFrondMaterial(void) const;
void SetFrondMaterial(const float* pMaterial);
///////////////////////////////////////////////////////////////////////
// Camera
static void GetCamera(float* pPosition, float* pDirection);
static void SetCamera(const float* pPosition, const float* pDirection);
///////////////////////////////////////////////////////////////////////
// Wind
static void SetTime(float fTime);
void ComputeWindEffects(bool bBranches, bool bLeaves, bool bFronds = true);
void ResetLeafWindState(void);
bool GetLeafRockingState(void) const;
void SetLeafRockingState(bool bFlag);
void SetNumLeafRockingGroups(unsigned int nRockingGroups);
EWindMethod GetLeafWindMethod(void) const;
void SetLeafWindMethod(EWindMethod eMethod);
EWindMethod GetBranchWindMethod(void) const;
void SetBranchWindMethod(EWindMethod eMethod);
EWindMethod GetFrondWindMethod(void) const;
void SetFrondWindMethod(EWindMethod eMethod);
float GetWindStrength(void) const;
float SetWindStrength(float fNewStrength, float fOldStrength = -1.0f, float fFrequencyTimeOffset = -1.0f);
static void SetNumWindMatrices(unsigned int nNumMatrices);
static void SetWindMatrix(unsigned int nMatrixIndex, const float* pMatrix);
void GetLocalMatrices(unsigned int& nStartingIndex, unsigned int& nMatrixSpan);
void SetLocalMatrices(unsigned int nStartingMatrix, unsigned int nMatrixSpan);
///////////////////////////////////////////////////////////////////////
// LOD
void ComputeLodLevel(void);
float GetLodLevel(void) const;
void SetLodLevel(float fLodLevel);
static void SetDropToBillboard(bool bFlag);
void GetLodLimits(float& fNear, float& fFar) const;
void SetLodLimits(float fNear, float fFar);
short GetDiscreteBranchLodLevel(float fLodLevel = -1.0f) const;
unsigned short GetDiscreteLeafLodLevel(float fLodLevel = -1.0f) const;
short GetDiscreteFrondLodLevel(float fLodLevel = -1.0f) const;
unsigned short GetNumBranchLodLevels(void) const;
unsigned short GetNumLeafLodLevels(void) const;
unsigned short GetNumFrondLodLevels(void) const;
///////////////////////////////////////////////////////////////////////
// Geometry
void DeleteBranchGeometry(void);
void DeleteFrondGeometry(void);
unsigned char* GetFrondGeometryMapIndexes(int nLodLevel) const;
const float* GetLeafBillboardTable(unsigned int& nEntryCount) const;
const float* GetLeafLodSizeAdjustments(void);
void GetGeometry(SGeometry& sGeometry, unsigned long ulBitVector = SpeedTree_AllGeometry, short sOverrideBranchLodValue = -1, short sOverrideFrondLodValue = -1, short sOverrideLeafLodValue = -1);
///////////////////////////////////////////////////////////////////////
// Textures
void GetTextures(STextures& sTextures) const;
void SetLeafTextureCoords(unsigned int nLeafMapIndex, const float* pTexCoords);
void SetFrondTextureCoords(unsigned int nFrondMapIndex, const float* pTexCoords);
static bool GetTextureFlip(void);
static void SetTextureFlip(bool bFlag);
void SetBranchTextureFilename(const char* pFilename);
void SetLeafTextureFilename(unsigned int nLeafMapIndex, const char* pFilename);
void SetFrondTextureFilename(unsigned int nFrondMapIndex, const char* pFilename);
///////////////////////////////////////////////////////////////////////
// Statistics & information
static void Authorize(const char* pKey);
static bool IsAuthorized(void);
static const char* GetCurrentError(void);
static void ResetError(void);
void GetBoundingBox(float* pBounds) const;
unsigned int GetLeafTriangleCount(float fLodLevel = -1.0f) const;
unsigned int GetBranchTriangleCount(float fLodLevel = -1.0f) const;
unsigned int GetFrondTriangleCount(float fLodLevel = -1.0f) const;
///////////////////////////////////////////////////////////////////////
// Collision objects
unsigned int GetCollisionObjectCount(void);
void GetCollisionObject(unsigned int nIndex, ECollisionObjectType& eType, float* pPosition, float* pDimensions);
///////////////////////////////////////////////////////////////////////
// User Data
const char* GetUserData(void) const;
private:
CSpeedTreeRT(const CSpeedTreeRT* pOrig);
void ComputeLeafStaticLighting(void);
void ComputeSelfShadowTexCoords(void);
static void ComputeUnitBillboard(void);
static void NotifyAllTreesOfEvent(int nMessage);
static void SetError(const char* pError);
///////////////////////////////////////////////////////////////////////
// File I/O
void ParseLodInfo(CTreeFileAccess* pFile);
void ParseWindInfo(CTreeFileAccess* pFile);
void ParseTextureCoordInfo(CTreeFileAccess* pFile);
void ParseCollisionObjects(CTreeFileAccess* pFile);
void SaveTextureCoords(CTreeFileAccess* pFile) const;
void SaveCollisionObjects(CTreeFileAccess* pFile) const;
void ParseShadowProjectionInfo(CTreeFileAccess* pFile);
void SaveUserData(CTreeFileAccess* pFile) const;
void ParseUserData(CTreeFileAccess* pFile);
void SaveSupplementalTexCoordInfo(CTreeFileAccess* pFile) const;
void ParseSupplementalTexCoordInfo(CTreeFileAccess* pFile);
static char* CopyUserData(const char* pData);
///////////////////////////////////////////////////////////////////////
// Geometry
void GetBranchGeometry(SGeometry& sGeometry, short sOverrideLodValue = -1);
void GetFrondGeometry(SGeometry& sGeometry, short sOverrideLodValue = -1);
void GetLeafGeometry(SGeometry& sGeometry, unsigned long ulBitVector, short sOverrideLodValue = -1);
void Get360BillboardGeometry(SGeometry& sGeometry);
void GetSimpleBillboardGeometry(SGeometry& sGeometry);
void GetHorizontalBillboardGeometry(SGeometry& sGeometry);
static void GetTransitionValues(float fLodLevel, unsigned short usLodCount, float fOverlapRadius,
float fTransitionFactor, float fCurveExponent, float fTargetAlphaValue,
float& fHighValue, float& fLowValue, short& sHighLod, short& sLowLod);
void SetupHorizontalBillboard( );
///////////////////////////////////////////////////////////////////////
// Member variables
// general
CTreeEngine* m_pEngine; // core tree-generating engine
CIndexedGeometry* m_pBranchGeometry; // abstraction mechanism for branch geometry
CLeafGeometry* m_pLeafGeometry; // abstraction mechanism for leaf geometry
CLightingEngine* m_pLightingEngine; // engine for computing static/dynamic lighting data
CWindEngine* m_pWindEngine; // engine for computing CPU/GPU wind effects
CSimpleBillboard* m_pSimpleBillboard;
// leaf lod
ELodMethod m_eLeafLodMethod; // which leaf wind method is currently being used
float m_fLeafLodTransitionRadius; // determines how much blending occurs between two separate leaf LOD levels
float m_fLeafLodCurveExponent; // exponent value used in the leaf LOD blending equation
float m_fLeafSizeIncreaseFactor; // value that controls how much larger leaf clusters get as LOD decreases
float m_fLeafTransitionFactor; // value that controls the intersection point of SMOOTH_1 transitions
float* m_pLeafLodSizeFactors; // array, GetNumLeafLodLevels()'s in size, containing leaf LOD scale factors
// instancing
unsigned int* m_pRefCount; // single value shared among instances - number of active instances
STreeInstanceData* m_pInstanceData; // if instance, differntiating data is stored here
SInstanceList* m_pInstanceList; // each tree contains a list of its instances
// other
int m_nFrondLevel; // from SpeedTreeCAD - branch level where fronds begin
float* m_pTreeSizes; // contains all tree extents, including billboard sizes
unsigned char m_ucTargetAlphaValue; // value used for leaf alpha mask function
bool m_bTreeComputed; // some operations are not valid once the geometry has been computed
int m_nBranchWindLevel; // from SpeedTreeCAD - branch level where wind effects are active
// texture coords
SEmbeddedTexCoords* m_pEmbeddedTexCoords; // embedded leaf and billboard texture coords
static bool m_bTextureFlip; // used to flip coordinates for DirectX, Gamebryo, etc.
// shadow projection
CProjectedShadow* m_pProjectedShadow; // self-shadow projection
// billboard
static bool m_bDropToBillboard; // flag specifying if last LOD will be simple single billboard
// collision objects
SCollisionObjects* m_pCollisionObjects; // collision objects
// fronds
CFrondEngine* m_pFrondEngine; // engine for computing fronds based on branch geometry
CIndexedGeometry* m_pFrondGeometry; // abstraction mechanism for frond geometry
unsigned short m_usNumFrondLodLevels; // place to store LOD count after m_pFrondGeometry is deleted
// user data
char* m_pUserData; // user specified data
// horizontal billboard
bool m_b360Billboard; // indicates that a 360 degree billboard sequence is present
bool m_bHorizontalBillboard; // indicates that a horizontal billboard is present in the embedded tex coords
float m_afHorizontalCoords[12]; // vertices of the horizontal billboard
};
// Macintosh-specific
#ifdef __ppc__
#pragma export off
#endif