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.

261 lines
12 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 plMaxNode_inc
#define plMaxNode_inc
#include "plMaxNodeBase.h"
#include "hsTemplates.h"
#include "hsMatrix44.h"
#include "iparamb2.h"
#include "pnKeyedObject/plKey.h"
#include <map>
class plMaxNode;
class plErrorMsg;
class plConvertSettings;
class plExportProgressBar;
class plSceneNode;
class plDrawable;
class plDrawInterface;
class plDrawableSpans;
class plLightInfo;
class plSpotLightInfo;
class plOmniLightInfo;
class plGeometrySpan;
class ISkin;
class plSpotModifier;
class plOmniModifier;
class plLtdDirModifier;
class plLightModifier;
class plController;
class plAGModifier;
class plAGMasterMod;
class plAGAnim;
class plRenderLevel;
class plDrawableCriteria;
class plXImposterComp;
class plPhysicalProps;
class plLightMapComponent;
class plPageInfoComponent;
class plMaxBoneMap;
class plSynchedObject;
typedef hsBool (plMaxNode:: *PMaxNodeFunc) (plErrorMsg *, plConvertSettings *); // Function pointer to a plMaxNode member funtion
class plMaxNodeTab : public Tab<plMaxNode*>
{
};
//-------------------------------------------
// plMaxNode
//-------------------------------------------
// 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 plMaxNode 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 plMaxNode, but currently it is the MakeSceneObject Pass which
// Adds the plMaxNodeData to the Node
class plMaxNode : public plMaxNodeBase
{
public:
hsBool DoRecur(PMaxNodeFunc p,plErrorMsg *, plConvertSettings *, plExportProgressBar*);
hsBool DoAllRecur(PMaxNodeFunc p,plErrorMsg *, plConvertSettings *, plExportProgressBar*);
// DoRecur takes one of the following functions
hsBool ConvertValidate (plErrorMsg *, plConvertSettings *);
hsBool SetupPropertiesPass (plErrorMsg *, plConvertSettings *);
hsBool MakeSceneObject (plErrorMsg *, plConvertSettings *);
hsBool PrepareSkin (plErrorMsg *, plConvertSettings *);
hsBool MakePhysical (plErrorMsg *, plConvertSettings *);
hsBool FirstComponentPass (plErrorMsg *, plConvertSettings *);
hsBool MakeController (plErrorMsg *, plConvertSettings *);
hsBool MakeCoordinateInterface (plErrorMsg *, plConvertSettings *);
hsBool MakeModifiers (plErrorMsg *, plConvertSettings *);
hsBool MakeParentOrRoomConnection (plErrorMsg *, plConvertSettings *);
hsBool MakeMesh (plErrorMsg *, plConvertSettings *);
hsBool MakeLight (plErrorMsg *, plConvertSettings *);
hsBool MakeOccluder (plErrorMsg *, plConvertSettings *);
hsBool ConvertComponents (plErrorMsg *, plConvertSettings *);
hsBool ClearData (plErrorMsg *, plConvertSettings *);
hsBool ShadeMesh (plErrorMsg *, plConvertSettings *);
hsBool MakeIfaceReferences (plErrorMsg *, plConvertSettings *);
hsBool ClearMaxNodeData (plErrorMsg *, plConvertSettings *);
hsBool DeInitComponents (plErrorMsg *, plConvertSettings *);
// Does specified function for all components attached to this node
enum { kSetupProperties, kPreConvert, kConvert };
hsBool DoComponents(int convertType, plErrorMsg *, plConvertSettings *);
plKey AddModifier(plModifier *pMod, const char* name);
hsBool ConvertToOccluder (plErrorMsg* pErrMsg, hsBool twoSided, hsBool isHole);
plDrawableCriteria GetDrawableCriteria(hsBool needBlending, hsBool needSorting);
Point3 GetFlexibility(); // returns Point3(flexibility, interRand, intraRand).
plXImposterComp* GetXImposterComp();
int AlphaHackLayersNeeded(int iSubMtl);
int NumUVWChannels();
hsBool VtxAlphaNotAvailable();
hsBool NonVtxPreshaded();
TriObject* GetTriObject(hsBool& deleteIt);
plAGModifier* HasAGMod();
plAGMasterMod* GetAGMasterMod();
plMaxNode* GetBonesRoot(); // Returns the root of my bones hierarchy, if I have any bones, else nil.
void GetBonesRootsRecur(hsTArray<plMaxNode*>& list);
plSceneObject* MakeCharacterHierarchy(plErrorMsg *pErrMsg);
void SetupBonesAliasesRecur(const char *rootName);
void SetupBoneHierarchyPalette(plMaxBoneMap *bones = nil);
void SetDISceneNodeSpans( plDrawInterface *di, hsBool needBlending );
hsBool IsLegalDecal(hsBool checkParent = true);
bool IsAnimatedLight();
// These are public so the animation component can use them, no one else should need them
void GetRTLightColAnim(IParamBlock2* ProperPB, plAGAnim* anim);
void GetRTConeAnim(IParamBlock2* ProperPB, plAGAnim* anim);
void GetRTLightAttenAnim(IParamBlock2* ProperPB, plAGAnim* anim);
// This is used in the shading pass, where the lightmap component can
// serve as a cache for some shading info. Returns nil if there is no LightMapComponent on this.
plLightMapComponent* GetLightMapComponent();
// Starting at 0, returns an incrementing index for each maxNode. Useful for assigning
// indices to sound objects attached to the node
UInt32 GetNextSoundIdx( void );
hsBool IsPhysical( void );
hsBool CanMakeMesh( Object *obj, plErrorMsg *pErrMsg, plConvertSettings *settings );
plDrawInterface* GetDrawInterface(); // Returns nil if there isn't a sceneobject and a drawinterface.
// Only call during convert
plPhysicalProps *GetPhysicalProps();
// Little helper function. Calls FindKey() in the resManager using the location (page) of this node
plKey FindPageKey( UInt16 classIdx, const char *name );
const char *GetAgeName();
void CheckSynchOptions(plSynchedObject* so);
protected:
INode *GetRootNode() { return GetInterface()->GetRootNode(); }
plDrawableSpans *IGetSceneNodeSpans( plSceneNode *node, hsBool needBlending, hsBool needSorting=true );
plLightInfo* IMakeDirectional(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeOmni(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeSpot(plErrorMsg* pErrMsg, plConvertSettings* settings);
hsBool IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg);
plLightInfo* IMakeRTDirectional(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeRTOmni(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeRTSpot(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeRTProjDirectional( plErrorMsg *pErrMsg, plConvertSettings *settings );
void IGetCone(plSpotLightInfo* liInfo, LightObject* light, LightState& ls);
void IGetLightColors(plLightInfo* liInfo, LightObject* light, LightState& ls);
void IGetLightAttenuation(plOmniLightInfo* liInfo, LightObject* light, LightState& ls);
// RunTime Lights versions
void IGetRTCone(plSpotLightInfo* liInfo, IParamBlock2* ProperPB);
void IGetRTLightColors(plLightInfo* liInfo, IParamBlock2* ProperPB);
void IGetRTLightAttenuation(plOmniLightInfo* liInfo, IParamBlock2* ProperPB);
// RunTime Light animation builders
hsBool IGetRTLightAttenValues(IParamBlock2* ProperPB, hsScalar& attenConst, hsScalar& attenLinear, hsScalar& attenQuadratic,hsScalar &attenCutoff);
void IAdjustRTColorByIntensity(plController* ctl, IParamBlock2* ProperPB);
hsBool IAttachRTLightModifier(plLightModifier* liMod);
plLightInfo* IMakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings);
plSceneNode* IGetDrawableSceneNode(plErrorMsg *pErrMsg);
void IAssignSpansToDrawables( hsTArray<plGeometrySpan *> &spanArray, plDrawInterface *di,
plErrorMsg *pErrMsg, plConvertSettings *settings );
void IAssignSpan( plDrawableSpans *drawable, hsTArray<plGeometrySpan *> &spanArray, UInt32 &index,
hsMatrix44 &l2w, hsMatrix44 &w2l,
plErrorMsg *pErrMsg, plConvertSettings *settings );
void ISetupBones( plDrawableSpans *drawable, hsTArray<plGeometrySpan *> &spanArray,
hsMatrix44 &l2w, hsMatrix44 &w2l,
plErrorMsg *pErrMsg, plConvertSettings *settings );
hsBool IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings);
void IWipeBranchDrawable(hsBool b);
UInt32 IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMaxNode *> &nodes, hsBool beMoreAccurate = false );
hsBool IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan *> &spanArray,
plErrorMsg *pErrMsg, plConvertSettings *settings );
hsBool IMaterialsMatch( plMaxNode *otherNode, hsBool beMoreAccurate );
int IGetCachedAlphaHackValue( int iSubMtl );
void ISetCachedAlphaHackValue( int iSubMtl, int value );
friend class plLocationDlg;
};
class plMaxBoneMap
{
protected:
typedef std::map<plMaxNodeBase*, UInt32> BoneMap;
BoneMap fBones;
typedef std::map<plDrawable*, UInt32> DrawableMap;
DrawableMap fBaseMatrices;
public:
UInt8 fNumBones;
plMaxNodeBase *fOwner; // Make note of which node created us, so they can delete us.
plMaxBoneMap() : fNumBones(0), fOwner(nil) {}
void AddBone(plMaxNodeBase *bone);
UInt8 GetIndex(plMaxNodeBase *bone);
void FillBoneArray(plMaxNodeBase **boneArray);
UInt32 GetBaseMatrixIndex(plDrawable *draw);
void SetBaseMatrixIndex(plDrawable *draw, UInt32 idx);
void SortBones();
};
#endif