CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxMain/plMaxNodeData.h

/*==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