You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
451 lines
16 KiB
451 lines
16 KiB
/*==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/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
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==*/ |
|
|
|
#ifndef plMaxNodeData_inc |
|
#define plMaxNodeData_inc |
|
|
|
#include "hsTypes.h" |
|
#include "hsTemplates.h" |
|
#include "hsColorRGBA.h" |
|
#include "plRenderLevel.h" |
|
#include "plPhysicalProps.h" |
|
#include "hsBitVector.h" |
|
#include "../pnKeyedObject/plKey.h" |
|
#include "plLoadMask.h" |
|
|
|
class plMaxNodeBase; |
|
class plMaxNode; |
|
class plLocation; |
|
class plSceneObject; |
|
class hsGMesh; |
|
class plGeometrySpan; |
|
class plMaxBoneMap; |
|
class plSharedMesh; |
|
|
|
class plMaxNodeBaseTab : public Tab<plMaxNodeBase*> |
|
{ |
|
}; |
|
|
|
|
|
// |
|
// Created hoping to trim some fat so to speak for all the bools that |
|
// we are tossing around. |
|
// |
|
|
|
class DataBF |
|
{ |
|
public: |
|
enum DatBit |
|
{ |
|
kCanConvert = 0x0, |
|
kForceLocal, |
|
kDrawable, // Absence of this prop forbids making this drawable |
|
kBlendToFB, |
|
kItinerant, |
|
kRunTimeLight, |
|
kMovable, |
|
kIsBarney, |
|
kForceMatCopy, |
|
kNoPreShade, |
|
kIsInstanced, |
|
kParticleRelated, |
|
kNoSpanReSort, |
|
kHasFade, |
|
kNoFaceSort, |
|
kNoSpanSort, |
|
kNoDeferDraw, |
|
kBLevelSet, |
|
kOLevelSet, |
|
kDup2Sided, |
|
kRadiateNorms, |
|
kGeoDice, |
|
kForcePreShade, |
|
kIsGUI, |
|
kSwappableGeomTarget, |
|
kNoShadow, |
|
kForceShadow, |
|
kFilterInherit, |
|
kReverseSort, |
|
kVS, |
|
kConcave, |
|
kCalcEdgeLens, |
|
kEnviron, |
|
kEnvironOnly, |
|
kPhysical, // Absence of this prop forbids making this physical |
|
kSmoothAll, |
|
kForceSortable, |
|
kOverrideHighLevelSDL, |
|
kDisableNormal, |
|
kHasLoadMask, |
|
kWaterDecEnv, |
|
kWaterHeight, |
|
kAlphaTestHigh, |
|
kForceMatShade, |
|
kUnBounded, |
|
kForceVisLOS, |
|
kSortAsOpaque, |
|
}; |
|
|
|
hsBitVector* fBitVector; |
|
|
|
DataBF() |
|
{ |
|
fBitVector = TRACKED_NEW hsBitVector; |
|
fBitVector->SetBit(kDrawable); |
|
fBitVector->SetBit(kPhysical); |
|
} |
|
virtual ~DataBF() { delete fBitVector; } |
|
|
|
DataBF& operator=(const DataBF& ot) |
|
{ |
|
*fBitVector = *ot.fBitVector; |
|
return *this; |
|
} |
|
DataBF(const DataBF& ot) |
|
{ |
|
fBitVector = TRACKED_NEW hsBitVector; |
|
*fBitVector = *ot.fBitVector; |
|
} |
|
|
|
void Init() |
|
{ |
|
fBitVector = TRACKED_NEW hsBitVector; |
|
fBitVector->SetBit(kDrawable); |
|
fBitVector->SetBit(kPhysical); |
|
} |
|
void DeInit() { delete fBitVector; fBitVector = nil; } |
|
|
|
hsBool CanBF(DatBit bitChoice) { return fBitVector->IsBitSet(bitChoice); } |
|
void SetBF(hsBool b, DatBit bitChoice) { fBitVector->SetBit(bitChoice, b); } |
|
}; |
|
|
|
|
|
class plMaxNodeData |
|
{ |
|
public: |
|
plMaxNodeData() : |
|
fpKey(nil), |
|
fpSO(nil) , |
|
fDecalLevel(0), |
|
fpMesh(nil), |
|
fpRoomKey(nil), |
|
fSoundIdxCounter( 0 ), |
|
fAvatarSO(nil), |
|
fFade(Point3(0,0,0), Point3(0,0,0)), |
|
fNormalChan(0), |
|
fWaterHeight(0), |
|
fGDMaxFaces(0), fGDMaxSize(0), fGDMinFaces(0), |
|
fSwapMesh(nil), |
|
fSwapTargetID((UInt32)-1), |
|
fCachedAlphaHackLayerCounts(nil), |
|
fBoneMap(nil), |
|
fAnimCompression(1), // Should be plAnimCompressComp::kCompressionLow, |
|
// but I don't want to include the entire header. |
|
fKeyReduceThreshold(0.0002) |
|
{ } |
|
~plMaxNodeData() |
|
{ |
|
fpKey = nil; |
|
fpRoomKey = nil; |
|
fpSO = 0; |
|
fAvatarSO = nil; |
|
delete fCachedAlphaHackLayerCounts; |
|
MaxDatBF.DeInit(); |
|
} |
|
|
|
// Call init on MaxNodeData whose constructor was never called, e.g. if it was malloc'd. |
|
plMaxNodeData& Init() |
|
{ |
|
memset( &fpKey, 0, sizeof( plKey ) ); |
|
memset( &fpRoomKey, 0, sizeof( plKey ) ); |
|
fRenderDependencies.Init(); |
|
fBones.Init(); |
|
fCachedAlphaHackLayerCounts = nil; |
|
MaxDatBF.Init(); |
|
return *this; |
|
} |
|
// Ditto |
|
void DeInit( void ) |
|
{ |
|
fpKey = nil; |
|
fpRoomKey = nil; |
|
fpSO = 0; fAvatarSO = nil; |
|
delete fCachedAlphaHackLayerCounts; |
|
fCachedAlphaHackLayerCounts = nil; |
|
MaxDatBF.DeInit(); |
|
} |
|
|
|
plKey GetKey() { return fpKey; } |
|
void SetKey(plKey p ) { fpKey = p; } |
|
plSceneObject * GetSceneObject() { return fpSO; } |
|
void SetSceneObject(plSceneObject *p) { fpSO = p; } |
|
|
|
hsBool CanConvert() { return MaxDatBF.CanBF(MaxDatBF.kCanConvert); } |
|
void SetCanConvert(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kCanConvert); } |
|
|
|
hsBool GetForceLocal() { return MaxDatBF.CanBF(MaxDatBF.kForceLocal); } |
|
void SetForceLocal(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceLocal); } |
|
|
|
void * GetMesh() { return fpMesh; } // void pointer for header simplicity |
|
void SetMesh(hsGMesh *p) { fpMesh = p; } |
|
|
|
hsBool GetDrawable() {return MaxDatBF.CanBF(MaxDatBF.kDrawable); } |
|
void SetDrawable(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kDrawable); } |
|
|
|
hsBool GetPhysical() {return MaxDatBF.CanBF(MaxDatBF.kPhysical); } |
|
void SetPhysical(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kPhysical); } |
|
|
|
hsBool GetRunTimeLight() {return MaxDatBF.CanBF(MaxDatBF.kRunTimeLight); } |
|
void SetRunTimeLight(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kRunTimeLight); } |
|
|
|
hsBool GetForceMatShade() {return MaxDatBF.CanBF(MaxDatBF.kForceMatShade); } |
|
void SetForceMatShade(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceMatShade); } |
|
|
|
hsBool GetForceVisLOS() {return MaxDatBF.CanBF(MaxDatBF.kForceVisLOS); } |
|
void SetForceVisLOS(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceVisLOS); } |
|
|
|
hsBool GetEnviron() {return MaxDatBF.CanBF(MaxDatBF.kEnviron); } |
|
void SetEnviron(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kEnviron); } |
|
|
|
hsBool GetEnvironOnly() {return MaxDatBF.CanBF(MaxDatBF.kEnvironOnly); } |
|
void SetEnvironOnly(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kEnvironOnly); } |
|
|
|
hsBool GetWaterDecEnv() { return MaxDatBF.CanBF(MaxDatBF.kWaterDecEnv); } |
|
void SetWaterDecEnv(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kWaterDecEnv); } |
|
|
|
hsBool GetItinerant() {return MaxDatBF.CanBF(MaxDatBF.kItinerant); } |
|
void SetItinerant(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kItinerant); } |
|
|
|
hsBool GetUnBounded() {return MaxDatBF.CanBF(MaxDatBF.kUnBounded); } |
|
void SetUnBounded(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kUnBounded); } |
|
|
|
hsBool GetDisableNormal() {return MaxDatBF.CanBF(MaxDatBF.kDisableNormal); } |
|
void SetDisableNormal(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kDisableNormal); } |
|
|
|
hsBool GetMovable() {return MaxDatBF.CanBF(MaxDatBF.kMovable); } |
|
void SetMovable(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kMovable); } |
|
|
|
hsBool GetNoPreShade() {return MaxDatBF.CanBF(MaxDatBF.kNoPreShade); } |
|
void SetNoPreShade(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoPreShade); } |
|
|
|
hsBool GetForcePreShade() {return MaxDatBF.CanBF(MaxDatBF.kForcePreShade); } |
|
void SetForcePreShade(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForcePreShade); } |
|
|
|
hsBool GetNoShadow() {return MaxDatBF.CanBF(MaxDatBF.kNoShadow); } |
|
void SetNoShadow(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoShadow); } |
|
|
|
hsBool GetForceShadow() {return MaxDatBF.CanBF(MaxDatBF.kForceShadow); } |
|
void SetForceShadow(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceShadow); } |
|
|
|
hsBool GetAlphaTestHigh() {return MaxDatBF.CanBF(MaxDatBF.kAlphaTestHigh); } |
|
void SetAlphaTestHigh(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kAlphaTestHigh); } |
|
|
|
hsBool GetFilterInherit() {return MaxDatBF.CanBF(MaxDatBF.kFilterInherit); } |
|
void SetFilterInherit(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kFilterInherit); } |
|
|
|
hsBool GetIsBarney() {return MaxDatBF.CanBF(MaxDatBF.kIsBarney); } |
|
void SetIsBarney(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsBarney); } |
|
|
|
hsBool GetNoSpanSort() {return MaxDatBF.CanBF(MaxDatBF.kNoSpanSort); } |
|
void SetNoSpanSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoSpanSort); } |
|
|
|
hsBool GetNoSpanReSort() {return MaxDatBF.CanBF(MaxDatBF.kNoSpanReSort); } |
|
void SetNoSpanReSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoSpanReSort); } |
|
|
|
hsBool GetNoFaceSort() {return MaxDatBF.CanBF(MaxDatBF.kNoFaceSort); } |
|
void SetNoFaceSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoFaceSort); } |
|
|
|
hsBool GetReverseSort() {return MaxDatBF.CanBF(MaxDatBF.kReverseSort); } |
|
void SetReverseSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kReverseSort); } |
|
|
|
hsBool GetSortAsOpaque() {return MaxDatBF.CanBF(MaxDatBF.kSortAsOpaque); } |
|
void SetSortAsOpaque(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kSortAsOpaque); } |
|
|
|
hsBool GetVS() {return MaxDatBF.CanBF(MaxDatBF.kVS); } |
|
void SetVS(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kVS); } |
|
|
|
hsBool GetHasWaterHeight() { return MaxDatBF.CanBF(MaxDatBF.kWaterHeight); } |
|
void SetHasWaterHeight(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kWaterHeight); } |
|
hsScalar GetWaterHeight() { return fWaterHeight; } |
|
void SetWaterHeight(hsScalar f) { SetHasWaterHeight(true); fWaterHeight = f; } |
|
|
|
hsBool GetSmoothAll() {return MaxDatBF.CanBF(MaxDatBF.kSmoothAll); } |
|
void SetSmoothAll(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kSmoothAll); } |
|
|
|
hsBool GetForceSortable() {return MaxDatBF.CanBF(MaxDatBF.kForceSortable); } |
|
void SetForceSortable(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceSortable); } |
|
|
|
hsBool GetConcave() {return MaxDatBF.CanBF(MaxDatBF.kConcave); } |
|
void SetConcave(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kConcave); } |
|
|
|
hsBool GetCalcEdgeLens() {return MaxDatBF.CanBF(MaxDatBF.kCalcEdgeLens); } |
|
void SetCalcEdgeLens(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kCalcEdgeLens); } |
|
|
|
hsBool GetNoDeferDraw() {return MaxDatBF.CanBF(MaxDatBF.kNoDeferDraw); } |
|
void SetNoDeferDraw(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoDeferDraw); } |
|
|
|
hsBool GetBlendToFB() {return MaxDatBF.CanBF(MaxDatBF.kBlendToFB); } |
|
void SetBlendToFB(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kBlendToFB); } |
|
|
|
hsBool GetForceMaterialCopy() {return MaxDatBF.CanBF(MaxDatBF.kForceMatCopy); } |
|
void SetForceMaterialCopy(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceMatCopy); } |
|
|
|
hsBool GetInstanced() {return MaxDatBF.CanBF(MaxDatBF.kIsInstanced); } |
|
void SetInstanced(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsInstanced); } |
|
|
|
hsBool GetParticleRelated() {return MaxDatBF.CanBF(MaxDatBF.kParticleRelated); } |
|
void SetParticleRelated(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kParticleRelated); } |
|
|
|
hsBool GetDup2Sided() {return MaxDatBF.CanBF(MaxDatBF.kDup2Sided); } |
|
void SetDup2Sided(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kDup2Sided); } |
|
|
|
hsBool GetRadiateNorms() {return MaxDatBF.CanBF(MaxDatBF.kRadiateNorms); } |
|
void SetRadiateNorms(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kRadiateNorms); } |
|
|
|
hsBool GetGeoDice() {return MaxDatBF.CanBF(MaxDatBF.kGeoDice); } |
|
void SetGeoDice(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kGeoDice); } |
|
|
|
hsBool GetIsGUI() {return MaxDatBF.CanBF(MaxDatBF.kIsGUI); } |
|
void SetIsGUI(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsGUI); } |
|
|
|
plSharedMesh* GetSwappableGeom() { return fSwapMesh;} |
|
void SetSwappableGeom(plSharedMesh *sm) { fSwapMesh = sm; } |
|
|
|
UInt32 GetSwappableGeomTarget() { return fSwapTargetID;} |
|
void SetSwappableGeomTarget(UInt32 id) { fSwapTargetID = id;} |
|
|
|
plMaxBoneMap* GetBoneMap() { return fBoneMap;} |
|
void SetBoneMap(plMaxBoneMap *bones) { fBoneMap = bones;} |
|
|
|
int GetGeoDiceMaxFaces() { return fGDMaxFaces; } |
|
void SetGeoDiceMaxFaces(int f) { fGDMaxFaces = f; } |
|
|
|
float GetGeoDiceMaxSize() { return fGDMaxSize; } |
|
void SetGeoDiceMaxSize(float f) { fGDMaxSize = f; } |
|
|
|
int GetGeoDiceMinFaces() { return fGDMinFaces; } |
|
void SetGeoDiceMinFaces(int f) { fGDMinFaces = f; } |
|
|
|
plKey GetRoomKey() { return fpRoomKey; } |
|
void SetRoomKey(plKey p) { fpRoomKey = p; } |
|
|
|
UInt32 GetDecalLevel() { return fDecalLevel; } |
|
void SetDecalLevel(UInt32 i) { fDecalLevel = i; } |
|
|
|
UInt32 GetSoundIdxCounter() { return fSoundIdxCounter; } |
|
void SetSoundIdxCounter( UInt32 i ) { fSoundIdxCounter = i; } |
|
|
|
plSceneObject * GetAvatarSO() { return fAvatarSO; } |
|
void SetAvatarSO(plSceneObject *so) { fAvatarSO = so; } |
|
|
|
int NumRenderDependencies() { return fRenderDependencies.Count(); } |
|
plMaxNodeBase* GetRenderDependency(int i) { return fRenderDependencies[i]; } |
|
void AddRenderDependency(plMaxNodeBase* m) { fRenderDependencies.Append(1, &m); } |
|
void ClearRenderDependencies() { fRenderDependencies.ZeroCount(); } |
|
|
|
int NumBones() { return fBones.Count(); } |
|
plMaxNodeBase* GetBone(int i) { return fBones[i]; } |
|
void AddBone(plMaxNodeBase* m) { fBones.Append(1, &m); } |
|
void ClearBones() { fBones.ZeroCount(); } |
|
|
|
hsBool HasFade() { return MaxDatBF.CanBF(MaxDatBF.kHasFade); } |
|
void SetFade(const Box3& b) { MaxDatBF.SetBF((b.Min()[2] != 0)||(b.Max()[2] != 0), MaxDatBF.kHasFade); fFade = b; } |
|
Box3 GetFade() { return fFade; } |
|
|
|
hsBool HasLoadMask() { return MaxDatBF.CanBF(MaxDatBF.kHasLoadMask); } |
|
plLoadMask GetLoadMask() { return HasLoadMask() ? fLoadMask : plLoadMask::kAlways; } |
|
void AddLoadMask(const plLoadMask& m) { if( !HasLoadMask() ) { fLoadMask = m; MaxDatBF.SetBF(true, MaxDatBF.kHasLoadMask); }else{ fLoadMask |= m; } } |
|
|
|
hsBool HasNormalChan() { return fNormalChan > 0; } |
|
void SetNormalChan(int n) { fNormalChan = n; } |
|
int GetNormalChan() { return fNormalChan; } |
|
|
|
hsBool BlendLevelSet() { return MaxDatBF.CanBF(MaxDatBF.kBLevelSet); } |
|
void SetBlendLevel(const plRenderLevel& l) { fBlendLevel = l; MaxDatBF.SetBF(true, MaxDatBF.kBLevelSet); } |
|
const plRenderLevel& GetBlendLevel() { return fBlendLevel; } |
|
hsBool OpaqueLevelSet() { return MaxDatBF.CanBF(MaxDatBF.kOLevelSet); } |
|
void SetOpaqueLevel(const plRenderLevel& l) { fOpaqueLevel = l; MaxDatBF.SetBF(true, MaxDatBF.kOLevelSet); } |
|
const plRenderLevel& GetOpaqueLevel() { return fOpaqueLevel; } |
|
|
|
plPhysicalProps* GetPhysicalProps() { return &fPhysicalProps; } |
|
|
|
hsTArray<int> *GetAlphaHackLayersCache( void ) { return fCachedAlphaHackLayerCounts; } |
|
void SetAlphaHackLayersCache( hsTArray<int> *cache ) { fCachedAlphaHackLayerCounts = cache; } |
|
hsBool GetOverrideHighLevelSDL() { return MaxDatBF.CanBF(MaxDatBF.kOverrideHighLevelSDL); } |
|
void SetOverrideHighLevelSDL(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kOverrideHighLevelSDL); } |
|
UInt8 GetAnimCompress() { return fAnimCompression; } |
|
void SetAnimCompress(UInt8 v) { fAnimCompression = v; } |
|
hsScalar GetKeyReduceThreshold() { return fKeyReduceThreshold; } |
|
void SetKeyReduceThreshold(hsScalar v) { fKeyReduceThreshold = v; } |
|
|
|
protected: |
|
plKey fpKey; |
|
plSceneObject * fpSO; |
|
// hacking this in here temporarily because everything's about to change in the mesh world... |
|
hsGMesh* fpMesh; |
|
plKey fpRoomKey; |
|
UInt32 fDecalLevel; |
|
Int32 fNormalChan; |
|
UInt32 fSoundIdxCounter; |
|
plSceneObject * fAvatarSO; |
|
plMaxNodeBaseTab fRenderDependencies; |
|
plMaxNodeBaseTab fBones; |
|
Box3 fFade; |
|
int fGDMaxFaces; |
|
float fGDMaxSize; |
|
int fGDMinFaces; |
|
plRenderLevel fBlendLevel; |
|
plRenderLevel fOpaqueLevel; |
|
plPhysicalProps fPhysicalProps; |
|
UInt32 fSwapTargetID; |
|
hsTArray<int> *fCachedAlphaHackLayerCounts; |
|
plSharedMesh *fSwapMesh; |
|
plMaxBoneMap *fBoneMap; |
|
plLoadMask fLoadMask; |
|
hsScalar fWaterHeight; |
|
UInt8 fAnimCompression; |
|
hsScalar fKeyReduceThreshold; |
|
DataBF MaxDatBF; |
|
}; |
|
|
|
|
|
#endif // plSimpleConvert_inc
|