/*==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 . 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 PL_COMPONENT_BASE_H #define PL_COMPONENT_BASE_H #include "Max.h" #include "iparamb2.h" #include "iparamm2.h" #include "hsTypes.h" #include "../pnKeyedObject/plKey.h" extern TCHAR *GetString(int id); extern HINSTANCE hInstance; #define COMPONENT_CLASSID Class_ID(0x758e5142, 0x66c748a) #define EXT_COMPONENT_CLASSID Class_ID(0x6c277b63, 0x6c626b3f) class plMaxNodeBase; class plKey; class plMaxNode; class plAGAnim; class plComponentBase : public HelperObject { protected: ClassDesc2 *fClassDesc; // Must set in derived classes constructor IParamBlock2 *fCompPB; // The derived component's paramblock (optional) IParamBlock2 *fTargsPB; // Nodes this component is attached to // Get a unique name based on this components name and the index of this target // Return value points to a static, so don't try to hold on to it const char* IGetUniqueName(plMaxNodeBase* target); public: // Permanent Block ID's enum { kBlkComp, kBlkTargs = 10, // To avoid any conflicts with legacy blocks }; // Ref numbers enum { kRefComp, kRefTargs, }; plComponentBase(); virtual ~plComponentBase(); void DeleteThis() { delete this; } UInt32 NumTargets(); plMaxNodeBase *GetTarget(UInt32 i); virtual void AddTarget(plMaxNodeBase *target); virtual void DeleteTarget(plMaxNodeBase *target); virtual void DeleteAllTargets(); bool IsTarget(plMaxNodeBase *node); plMaxNodeBase *GetINode(); virtual void AddReceiverKey(plKey key, plMaxNode* node=nil) {;} virtual plKey GetLogicKey(plMaxNode* node) {return nil;} // Return true if you want to allow yourself to be unhidden. This is for components // with animatable parameters they want to expose in the TrackView. virtual bool AllowUnhide() { return false; } // Collect up all the non-runtime renderable geometry that's going to wind up // physical proxies, trigger boxes, soft regions etc. This is normally everything // that this component is going to call SetDrawable(false) on. The list returned might // be selected, hidden, have max's renderable property set to false, whatever, you don't // have to worry about that. All you have to do is, if your component SetDrawable(false)'s // on anything, try to remember to override this function and add the MaxNodes you're // making non-drawable to this list when called. Remember, just append to the list. // If you're going to add everything you're attached to to the list, you can just // call AddTargetsToList(nonDrawables), so you're overriding function just looks like: // virtual void CollectNonDrawables(INodeTab& nonDrawables) { AddTargetsToList(nonDrawables); } virtual void CollectNonDrawables(INodeTab& nonDrawables) { return; } virtual void AddTargetsToList(INodeTab& list); // Return the minimum graphics capability required by objects created by this component. // Unless a component is generating an object that uses shaders, or has some other // specific graphics requirement, the default of 0 (meaning no special requirements) // should not be overriden. virtual int GetMinCap() { return 0; } hsBool IsExternal(); // Returns true if the msg that was just sent out was local or from something // this component ref's. Used by the SceneWatcher to determine if a component // needs to be reconverted. virtual bool IsCurMsgLocal(); bool IsObsolete(); // Returns true if this component has a reference to node (being attached doesn't count) virtual bool DoReferenceNode(INode* node); virtual void CreateRollups(); virtual void DestroyRollups(); /////////////////////////////////////////////////////////////////////////////////////// // Required Max functions // TCHAR* GetObjectName() { return (TCHAR*)fClassDesc->ClassName(); } void InitNodeName(TSTR& s) { s = fClassDesc->InternalName(); } void GetClassName(TSTR& s) { s = fClassDesc->ClassName(); } Class_ID ClassID() { return fClassDesc->ClassID(); } RefTargetHandle Clone(RemapDir &remap); int NumRefs(); RefTargetHandle GetReference(int i); void SetReference(int i, RefTargetHandle rtarg); RefResult NotifyRefChanged(Interval changeInt,RefTargetHandle hTarget, PartID& partID, RefMessage message); // allow retreival of our paramblock from other plug-ins // and the max core int NumParamBlocks(); IParamBlock2* GetParamBlock(int i); IParamBlock2* GetParamBlockByID(BlockID id); // So our animatables will show up in the trackview int NumSubs(); Animatable* SubAnim(int i); TSTR SubAnimName(int i); virtual hsBool AddToAnim(plAGAnim *anim, plMaxNode *node) { return false; } // plug-in mouse creation callback CreateMouseCallBack* GetCreateMouseCallBack(); void BeginEditParams(IObjParam *ip, ULONG flags, Animatable *prev); void EndEditParams(IObjParam *ip, ULONG flags, Animatable *next); void BuildMesh(TimeValue t); void FreeCaches(); void GetLocalBoundBox(TimeValue t, INode *node, ViewExp *vpt, Box3 &box); void GetWorldBoundBox(TimeValue t, INode *node, ViewExp *vpt, Box3 &box); int Display(TimeValue t, INode *node, ViewExp *vpt, int flags); int HitTest(TimeValue t, INode *node, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt); ObjectState Eval(TimeValue t) { return ObjectState(this); } IOResult Save(ISave* isave); IOResult Load(ILoad* iload); int CanConvertToType(Class_ID obtype) { return (obtype == COMPONENT_CLASSID) ? 1 : 0; } const char *GetCategory() { return fClassDesc->Category(); } }; // Look through the nodes in 'nodes' and find components that they all share. // Store those in 'components'. // Returns the number of shared components int plSharedComponents(INodeTab& nodes, INodeTab& components); // Takes care of the dirty little secrets of components class plComponentShow { public: static void Init(); // Call this to update the visibility of the components in the scene, ie, if you // changed the return value of your AllowUnhide function static void Update(); }; #endif /************************************************************************************************ ** ** Information regarding the development of Components for Plasma 2.0 ** ** Date: 3/2/2001 ** Version: Plasma 2.00 ** Needs: A working knowledge of max sdk (Specifically the ParamBlocks...) ** A working knowledge of C++ ** ** ** As the components are heavily reliant on the use of the MAX paramblock, the following methodology ** should be used in their implementation: ** ** In order for the paramblock to not be thrown away during linking, we have started the use of a ** dummy function such as: ** ** void DummyCodeIncludeStartPointFunc() ** { ** } ** ** This is called within the code for the GlobalUtility function, currently. ** ** Next create a derived class from the plComponent class with three public functions, ** being its constunctor, its custom destructor and the converter. Currently, we have the ** converter returning an hsBool to let you know how successful the conversion process has been ** during export to the .prd format. ** ** After the class above has been declared, the param block stuff follows: ** ** (Note all the imformation specifics regarding how to develop the paramblocks can be found ** in the help included in the maxsdk.) ** ** CLASS_DESC is a macro that Max has created that helps stuff your data into a param block. It ** takes in the following formal parameters: ** ** CLASS_DESC(plStartingPointComponent, gStartPtDesc, "StartingPoint", "StartingPointComp", Class_ID(0x2a127b68, 0xdc7367a)) ** ** 1st parameter : The C++ class that is going to be accessing this function (assumed to be passed by reference) ** 2nd parameter : The Instance of the class descriptor that will be used specifically for ** the following param block. It is type int. ** 3rd parameter : The Short name description string for this paramblock. ** 4th parameter : The long name description string for this paramblock. ** 5th parameter : The unique CLASS_ID created via the included GEN_ID.exe that comes with maxsdk. ** ** Following this macro, an enum array is useful to store the relatively unique ID constants for the paramblock. ** ** The format of the definitions in this shown below, but basically is in the form of a sequence of fixed specs followed by a variable number of tagged optional specs for each parameter. ** ** ** Next, the actual param block is declared such as the following: ** ** ParamBlockDesc2 gStartPtBk ** ( ** 1, _T(""), 0, &gStartPtDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, 0, ** ** //rollout ** IDD_COMP_STARTINGPOINT, IDS_COMP_STARTINGPOINTS, 0, 0, NULL, ** ** // params ** kPlayerStartingPoint, _T("Start Point:"), TYPE_STRING, 0, 0, ** p_ui, TYPE_EDITBOX, IDC_COMP_STARTPOINT, ** end, ** ** end ** ); ** ** First is the name of the descriptor method that is to be used, in this case the ParamBlockDesc2 ** type. Second is the unique name of this this paramblock. Following, a collection of comma delimited ** parameters ensue. The exact details as well as other flags to use herein can be found in the MaxR4 sdk ** Help file. We shall explain the above parameters to help give you an idea of the layout. ** All paramblocks have the following format: ** ** 1. Required block specs & per-block flags, followed by, ** 2. Optional owning object reference number for the block if auto-construct, followed by, ** 3. Optional parameter map specs if auto-ui, followed by, ** 4. Zero or more parameter specs, comprising: ** a. Required parameter specs, followed by, ** b. Zero or more optional parameter specs, each with is own leading tag, ** the list terminated by an 'end' tag, followed by, ** 5. an 'end' tag ** ** THE BLOCK SPECS: ** ** BlockParameter 1: ** "1" is the permanent block ID for the parameter block2. It must be unique ** to the block. Considering that you can have several blocks stored together in the same window, ** you may want to enum this as well. THIS IS A REQUIRED FIELD. ** ** BlockParameter 2: ** The internal name string. This name is not localized. Internal names are meant ** to be parsable as identifiers. As such they should begin with an alpha character, have only ** alphanumerics, and have no spaces, punctuations, etc. The convention for multi-word names ** is to use studly-caps, eg, paintRadius. THIS IS A REQUIRED FIELD. ** ** BlockParameter 3: ** The resource ID of the localized (sub-anim) name string. It is of type int. THIS IS ** A REQUIRED FIELD. ** ** BlockParameter 4: ** Points to the class descriptor2 of the owning class. This is used to add this ** descriptor to the ClassDesc2's table of block descriptors for the class. Note: This value may ** be passed as NULL for situations where the blocks owning ClassDesc2 is not available for static ** initializations (such as in a separate file). Before using the descriptor for any block ** construction, the ClassDesc2* must be initialized with the method: ** ** void ParamBlockDesc2::SetClassDesc(ClassDesc2* cd); ** ** You can only call this method once on a descriptor and then only if it has been ** constructed initially with a NULL cd. ** ** BlockParameter 5: One or more BYTE flags. In this instance, we are only using: ** ** P_AUTO_CONSTRUCT ** Indicates the parameter block2 will be constructed and referenced automatically ** to its owner in the call to ClassDesc2::MakeAutoParamBlocks(). If this flag is ** set, the parameter block's reference number in the owning object should be given ** immediately following the flag word in the descriptor constructor. See ** . ** ** P_AUTO_UI ** Indicates this block supports automatic UI rollout management in calls to ** ClassDesc2::BeginEditParams(), ClassDesc2::EndEditParams(),ClassDesc2::CreateParamDlg(), ** ClassDesc2::CreateParamDialog(), etc. ** *8 The must be supplied in the descriptor constructor. ** ** BlockParameter 6: Because we used the AUTO_UI the following parameters are REQUIRED. ** ** int dialog_template_ID, ** (in this case IDD_COMP_something from an .rc file) ** int dialog_title_res_ID, ** (in this case IDS_COMP_something from the String Table) ** int flag_mask, ** (This is used by ClassDesc2::BeginEditParams() and ClassDesc2::EndEditParams() ** to determine whether the ParamMap2 shold be created/deleted on this call. ** All the bits in the supplied mask must be on in the Begin/EndEditParams ** flag longword for the action to take place. For this example we have 0.) ** int rollup_flags ** (This flag is used to control rollup creation. You may pass ** APPENDROLL_CLOSED to have the rollup added in the closed (rolled up) state. ** Otherwise pass 0.) ** ParamMap2UserDlgProc* proc ** (If there are controls in the dialog that require special processing this user ** If not used then NULL should be passed.) ** ** THE PARAM SPECS: ** ** Param Parameter 1: ParamID id ** (The permanent, position-independent ID for the parameter. In this case, it is ** the constant kStartingPoint.) ** Param Parameter 2: TCHAR* internal_name ** (The internal name for the parameter. In our case "Start Point:". This is what is written on the ** button, spinner, whizbang, foozle, etc.) ** Param Parameter 3: ParamType type ** (The type of parameter. See List of ParamType Choices. In this case it is TYPE_STRING. It could be ** TYPE_INT, TYPE_FLOAT, etc, etc, etc.) ** Param Parameter 4: [int table_size] ** (If the type is one of the Tab<> types, you need to supply an initial table size ** which can be 0. Which it is in our case above.) ** Param Parameter 5: int flags ** (These flags are ORed together. We don't use any, hence 0. They include useful things such as ** p_SubAnim which allow track view acess...) ** Param Parameter 6: int local_name_res_ID ** (Here lies that relatively unique enum mentioned above. Hence, the kStartingPoint.) ** ** OPTIONAL STUFF: ** ** As param blocks don't necessarily need a visual GUI, any that you include are optional. ** ** p_ui, ** (This declares that a GUI will be instantiated. The parameter hereafter will declare the type.) ** GUI_Type ** (This is the type of GUI that you are going to use. In our case it is a CUSTOM editbox. ** ** NOTE: MAX prefers that you create CUSTOM instances of all GUI resources (such as spinners, ** editboxes, etc) ** ) ** ** ID ** (This is the implementor defined name that this GUI is using. It is the name of the object that ** you created a resource of. We created an IDC_COMP_STARTINGPOINT which was of a CustEdit type.) ** ** end ** (This lets the constructor that makes uses to know that you have finished one of the p_ui param ** blocks.) ** ** ** FINAL REQUISITE STUFF: ** ** end ** ); ** (This is the conclusion of the Block descriptor. Sort of intuitive...) ** *************************************************************************************************/