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.

316 lines
11 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 plMaxNodeBase_inc
#define plMaxNodeBase_inc
#include "hsTypes.h"
#include "hsTemplates.h"
#include "max.h"
#include "hsMatrix44.h"
#include "hsColorRGBA.h"
#include "../pnKeyedObject/plKey.h"
#include "plLoadMask.h"
class plLocation;
class plSceneObject;
class plModifier;
class plComponentBase;
class ISkin;
class plMaxNodeData;
class hsGMesh;
class plRenderLevel;
class plGeometrySpan;
class plSharedMesh;
class plMaxBoneMap;
//-------------------------------------------
// plMaxNodeBase
//-------------------------------------------
// CAREFUL! This class is different, it is derived from Max's INode (as you can see)
// But we can only add (NON Virtual) functions to plMaxNodeBase directly
// If you want some new Data members, you can add them by adding to the class
// plMaxNodeData This data is stored in each INode through some mechanisms supplied
// It would be nice of you to add GetFunctions for each new data member you add (see below)
//--------------------------------------------
// NOTE: an INode can be cast to a plMaxNodeBase, but currently it is the MakeSceneObject Pass which
// Adds the plMaxNodeData to the Node
//
// This class should only reference classes that are in the nucleus. Anything
// that needs more should go into plMaxNode
class plMaxNodeBase : public INode
{
public:
plMaxNodeData *GetMaxNodeData(); // perhaps with full getters and Setters, we can make this protected
void SetMaxNodeData(plMaxNodeData * pDat);
//------------------------------
// Get Data from MaxNodeData
//------------------------------
// If recalculate is true the cached value is ignored. (Useful in the SceneViewer)
hsBool CanConvert(bool recalculate=false);
plLocation GetLocation();
plKey GetKey();
plSceneObject* GetSceneObject();
hsBool GetForceLocal();
hsBool GetReverseSort();
hsBool GetSortAsOpaque();
hsBool GetRunTimeLight();
hsBool GetForceMatShade();
hsBool GetForceVisLOS();
hsBool GetEnviron();
hsBool GetEnvironOnly();
hsBool GetWaterDecEnv();
hsBool GetVS();
hsBool GetHasWaterHeight();
hsScalar GetWaterHeight();
hsBool GetSmoothAll();
hsBool GetForceSortable();
hsBool GetConcave();
hsBool GetCalcEdgeLens();
hsBool GetNoPreShade();
hsBool GetForcePreShade();
plKey GetRoomKey();
hsBool GetDrawable();
hsBool GetPhysical();
hsBool GetItinerant();
hsBool GetUnBounded();
hsBool GetDisableNormal();
UInt32 GetDecalLevel();
hsBool GetMovable();
hsBool GetNoShadow();
hsBool GetForceShadow();
hsBool GetAlphaTestHigh();
hsBool GetFilterInherit();
hsBool GetIsBarney();
hsBool GetNoSpanSort();
hsBool GetNoSpanReSort();
hsBool GetNoFaceSort();
hsBool GetNoDeferDraw();
hsBool GetBlendToFB();
hsBool GetForceMaterialCopy();
hsBool GetInstanced();
hsBool GetParticleRelated();
UInt32 GetSoundIdxCounter();
plSceneObject* GetAvatarSO();
BOOL HasFade();
Box3 GetFade();
hsBool GetDup2Sided();
hsBool GetRadiateNorms();
BOOL HasNormalChan();
int GetNormalChan();
BOOL GetGeoDice(int& maxFaces, float& maxSize, int& minFaces);
hsBool GetIsGUI();
plSharedMesh* GetSwappableGeom();
UInt32 GetSwappableGeomTarget();
plMaxBoneMap* GetBoneMap();
hsBool GetOverrideHighLevelSDL();
UInt8 GetAnimCompress();
hsScalar GetKeyReduceThreshold();
int NumRenderDependencies();
plMaxNodeBase* GetRenderDependency(int i);
int NumBones();
plMaxNodeBase* GetBone(int i);
//------------------------------
// Set Data from MaxNodeData
//------------------------------
void SetCanConvert(hsBool b);
void SetMesh(hsGMesh *p);
void SetRoomKey(plKey p);
void SetDrawable(hsBool b);
void SetPhysical(hsBool b);
void SetItinerant(hsBool b);
void SetUnBounded(hsBool b);
void SetDisableNormal(hsBool b);
void SetDecalLevel(UInt32 i);
void SetMovable(hsBool b);
void SetNoPreShade(hsBool b);
void SetForcePreShade(hsBool b);
void SetReverseSort(hsBool b);
void SetSortAsOpaque(hsBool b);
void SetVS(hsBool b);
void SetHasWaterHeight(hsBool b);
void SetWaterHeight(hsScalar h);
void SetSmoothAll(hsBool b);
void SetForceSortable(hsBool b);
void SetConcave(hsBool b);
void SetCalcEdgeLens(hsBool b);
void SetRunTimeLight(hsBool b);
void SetForceMatShade(hsBool b);
void SetForceVisLOS(hsBool b);
void SetEnviron(hsBool b);
void SetEnvironOnly(hsBool b);
void SetWaterDecEnv(hsBool b);
void SetForceLocal(hsBool b);
void SetIsBarney(hsBool b);
void SetForceShadow(hsBool b);
void SetAlphaTestHigh(hsBool b);
void SetFilterInherit(hsBool b);
void SetNoShadow(hsBool b);
void SetNoSpanSort(hsBool b);
void SetNoSpanReSort(hsBool b);
void SetNoFaceSort(hsBool b);
void SetNoDeferDraw(hsBool b);
void SetBlendToFB(hsBool b);
void SetForceMaterialCopy(hsBool b);
void SetInstanced(hsBool b);
void SetParticleRelated(hsBool b);
void SetSoundIdxCounter(UInt32 ctr);
void SetAvatarSO(plSceneObject *so);
void SetFade(const Box3& b);
void SetDup2Sided(hsBool b);
void SetRadiateNorms(hsBool b);
void SetNormalChan(int n);
void SetGeoDice(BOOL on, int maxFaces, float maxSize, int minFaces);
void SetIsGUI(hsBool b);
void SetSwappableGeom(plSharedMesh *sm);
void SetSwappableGeomTarget(UInt32 id);
void SetBoneMap(plMaxBoneMap *bones);
void SetOverrideHighLevelSDL(hsBool b);
void SetAnimCompress(UInt8 v);
void SetKeyReduceThreshold(hsScalar v);
hsBool AddRenderDependency(plMaxNodeBase* m);
hsBool RenderDependsOn(plMaxNodeBase* m);
void ClearRenderDependencies();
void AddBone(plMaxNodeBase* m);
void ClearBones();
// Dirty flags for SceneWatcher use
enum { kGeomDirty = 0x1, kMatDirty = 0x2, kAllDirty = 0xFF };
hsBool GetDirty(UInt8 i);
void SetDirty(UInt8 i, hsBool b);
plKey GetParentKey() { plMaxNodeBase *pPar = (plMaxNodeBase*)GetParentNode(); hsAssert(pPar, "No Parent"); return pPar->GetKey(); }
ISkin* FindSkinModifier(); // Returns the object's skin modifier if it has one, else nil
const plRenderLevel& GetRenderLevel(hsBool forBlend);
hsBool HasLoadMask();
plLoadMask GetLoadMask();
void AddLoadMask(const plLoadMask& m);
hsBool IsTMAnimated();
hsBool IsTMAnimatedRecur();
hsBool IsMovable(); // Checks to see whether this node will ever move in the scene
bool IsXRef(); // Returns true if object is an XRef or part of an XRef'd scene
//----------
// Component
//----------
hsBool IsComponent(Object *obj=nil); // Object pointer is only necessary for internal use,
hsBool IsExternComponent(Object *obj=nil);
plComponentBase *ConvertToComponent(); // Returns nil if node is not a component
// Normally you will only want the components that are attached to you
// because you are in their targets list. However, in some cases a
// component will want to know what other components are attached to it. In
// that case, set all to true, so that the attached components won't be
// verified to be in your target list.
UInt32 NumAttachedComponents(bool all=false);
plComponentBase *GetAttachedComponent(UInt32 i, bool all=false);
hsBool Contains(const Point3& worldPt); // is the world space point inside my (CONVEX) geometry or dummy box?
hsBool Contains(const Box3& bnd, const Matrix3& l2w); // is the box contained entirely inside my (CONVEX) geometry or dummy box?
hsScalar BoxVolume(const Box3& bnd, const Matrix3& l2w);
hsScalar RegionPriority(); // returns a dominance factor. If a point is in more than one environmental
// region, the region with highest priority wins.
Interface *GetInterface() { return ::GetCOREInterface(); }
static hsMatrix44 Matrix3ToMatrix44(const Matrix3& m3);
static Matrix3 Matrix44ToMatrix3(const hsMatrix44& m44);
// Don't use these two functions, they probably don't return what
// you think they do. See code comments.
Matrix3 GetWorldToParent(TimeValue t);
Matrix3 GetParentToWorld(TimeValue t);
hsMatrix44 GetLocalToParent44(TimeValue t = TimeValue(0));
hsMatrix44 GetParentToLocal44(TimeValue t = TimeValue(0));
hsMatrix44 GetLocalToWorld44(TimeValue t = TimeValue(0));
hsMatrix44 GetWorldToLocal44(TimeValue t = TimeValue(0));
hsMatrix44 GetOTM44(TimeValue t = TimeValue(0));
hsMatrix44 GetVertToLocal44(TimeValue t = TimeValue(0));
hsMatrix44 GetLocalToVert44(TimeValue t = TimeValue(0));
hsMatrix44 GetOBBToLocal44(TimeValue t = TimeValue(0));
hsMatrix44 GetLocalToOBB44(TimeValue t = TimeValue(0));
Matrix3 GetLocalToParent(TimeValue t = TimeValue(0));
Matrix3 GetParentToLocal(TimeValue t = TimeValue(0));
Matrix3 GetLocalToWorld(TimeValue t = TimeValue(0));
Matrix3 GetWorldToLocal(TimeValue t = TimeValue(0));
Matrix3 GetOTM(TimeValue t = TimeValue(0));
Matrix3 GetVertToLocal(TimeValue t = TimeValue(0));
Matrix3 GetLocalToVert(TimeValue t = TimeValue(0));
Matrix3 GetOBBToLocal(TimeValue t = TimeValue(0));
Matrix3 GetLocalToOBB(TimeValue t = TimeValue(0));
protected:
// AppDataChunk sub-chunk id's
enum
{
kPlasmaAgeChunk, // No longer in use, but cleared from old files
kPlasmaDistChunk, // No longer in use, but cleared from old files
kPlasmaRoomChunk, // No longer in use, but cleared from old files
kPlasmaMaxNodeDataChunk,
kPlasmaSceneViewerChunk,
kPlasmaLightChunk, // No longer in use, but cleared from old files
};
UInt8 *IGetSceneViewerChunk();
// Attempts to convert a RefMaker pointer to a component. Returns nil if it is not a component.
plComponentBase *IRefMakerToComponent(ReferenceMaker *maker, bool all);
UInt32 IGetMajorRenderLevel(hsBool forBlend);
UInt32 IGetMinorRenderLevel(hsBool forBlend);
hsBool IRenderLevelSet(hsBool forBlend);
void ISetRenderLevel(const plRenderLevel& l, hsBool forBlend);
const plRenderLevel& IGetRenderLevel(hsBool forBlend);
plRenderLevel ICalcRenderLevel(hsBool forBlend);
};
#endif //plMaxNodeBase_inc