source: golgotha/src/max_plugin/sdk_inc/inode.h @ 80

Last change on this file since 80 was 80, checked in by Sam Hocevar, 14 years ago
  • Adding the Golgotha source code. Not sure what's going to be interesting in there, but since it's all public domain, there's certainly stuff to pick up.
  • Property svn:keywords set to Id
File size: 16.5 KB
RevLine 
[80]1/**********************************************************************
2 *<
3        FILE: inode.h
4
5        DESCRIPTION:
6
7        CREATED BY: Dan Silva
8
9        HISTORY:
10
11 *>     Copyright (c) 1994, All Rights Reserved.
12 **********************************************************************/
13
14#ifndef __INODE__H
15#define __INODE__H
16
17class ObjectState;
18class Object;
19class Control;
20class ScaleValue;
21class Mtl;
22class RenderData;
23
24
25// Transform modes -- passed to Move/Rotate/Scale
26#define  PIV_NONE                       0
27#define  PIV_PIVOT_ONLY         1
28#define  PIV_OBJECT_ONLY        2
29
30
31// Node interface                                                                                                         
32class INode: public ReferenceTarget {
33        public:
34                // If this was a temporary INode (like an INodeTransformed) this will delete it.
35                virtual void DisposeTemporary() {}
36
37                // In the case of INodeTransformed, this gets a pointer to the real node.
38                virtual INode *GetActualINode() {return this;}
39
40                virtual TCHAR*  GetName()=0;
41                virtual void    SetName(TCHAR *s)=0;           
42               
43                // Get/Set node's transform ( without object-offset or WSM affect)
44                virtual Matrix3 GetNodeTM(TimeValue t, Interval* valid=NULL)=0;
45                virtual void    SetNodeTM(TimeValue t, Matrix3& tm)=0;
46               
47                // Invalidate node's caches
48                virtual void InvalidateTreeTM()=0;
49                virtual void InvalidateTM()=0;
50                virtual void InvalidateWS()=0;
51
52                // Get object's transform (including object-offset)
53                // and also the WSM affect when appropriate )
54                // This is used inside object Display and HitTest routines
55                virtual Matrix3 GetObjectTM(TimeValue time, Interval* valid=NULL)=0;
56
57                // Get object's transform including object-offset but not WSM affect
58                virtual Matrix3 GetObjTMBeforeWSM(TimeValue time, Interval* valid=NULL)=0;
59
60                // Get object's transform including object-offset and WSM affect
61                virtual Matrix3 GetObjTMAfterWSM(TimeValue time, Interval* valid=NULL)=0;
62
63                // evaluate the State the object after offset and WSM's applied         
64                // if evalHidden is FALSE and the node is hidden the pipeline will not
65                // actually be evaluated (however the TM will).
66                virtual const ObjectState& EvalWorldState(TimeValue time,BOOL evalHidden=TRUE)=0;       
67
68                // Hierarchy manipulation
69                virtual INode*  GetParentNode()=0;
70                virtual void    AttachChild(INode* node, int keepPos=1)=0; // make node a child of this one
71                virtual void    Detach(TimeValue t, int keepPos=1)=0;     // detach node
72                virtual int     NumberOfChildren()=0;
73                virtual INode*  GetChildNode(int i)=0;
74
75                // display attributes
76                virtual void    Hide(BOOL onOff)=0;                     // set node's hide bit
77                virtual int             IsHidden(DWORD hflags=0)=0;     
78                virtual int             IsNodeHidden()=0;                       // is node hidden in *any* way.
79                virtual void    Freeze(BOOL onOff)= 0;          // stop node from being pickable
80                virtual int             IsFrozen()=0;
81                virtual void    BoxMode(BOOL onOff)=0;          // display node with a bounding box
82                virtual int             GetBoxMode()=0;
83                virtual void    AllEdges(BOOL onOff)=0;         // display all edges, including "hidden" ones
84                virtual int             GetAllEdges()=0;
85                virtual void    BackCull(BOOL onOff)=0;         // backcull display toggle
86                virtual int             GetBackCull()=0;
87                virtual void    SetCastShadows(BOOL onOff)=0;
88                virtual int             CastShadows()=0;
89                virtual void    SetRcvShadows(BOOL onOff)=0;
90                virtual int             RcvShadows()=0;
91                virtual void    SetMotBlur(BOOL onOff)=0;
92                virtual int             MotBlur()=0;
93
94                // bone display attributes.
95                virtual void    ShowBone(int boneVis)=0;        // 0: off, 1: show bone, 2: show bone only
96                virtual void    BoneAsLine(int onOff)=0;        // display bone as simple line
97                virtual BOOL    IsBoneShowing()=0;
98
99                // Access node's wire-frame color
100                virtual DWORD   GetWireColor()=0;
101                virtual void    SetWireColor(DWORD newcol)=0;
102
103                // Test various flags
104                virtual int     IsRootNode()=0;
105                virtual int     Selected()=0;
106                virtual int     Dependent()=0;
107                virtual int     IsTarget()=0;
108
109                // Node transform locks
110                virtual BOOL GetTransformLock(int type, int axis)=0;
111                virtual void SetTransformLock(int type, int axis, BOOL onOff)=0;
112
113                // Get target node if any.
114                virtual INode*  GetTarget()=0;  // returns NULL if node has no target.
115                virtual INode*  GetLookatNode()=0; // if this is a target, this finds the node that looks at it.
116
117                // This is just GetParent+GetNodeTM
118                virtual Matrix3 GetParentTM(TimeValue t)=0;
119
120                // This is just GetTarget+GetNodeTM
121                virtual int     GetTargetTM(TimeValue t, Matrix3& m)=0;
122
123                // Object reference
124                virtual Object* GetObjectRef()=0;
125                virtual void    SetObjectRef(Object *)=0;
126
127                // TM Controller
128                virtual Control* GetTMController()=0;
129                virtual void    SetTMController(Control *m3cont)=0;
130
131                // Visibility controller
132                virtual Control *GetVisController()=0;
133                virtual void    SetVisController(Control *cont)=0;
134                virtual float   GetVisibility(TimeValue t,Interval *valid=NULL)=0;
135                virtual void    SetVisibility(TimeValue t,float vis)=0;
136
137                // Renderer Materials
138                virtual Mtl *GetMtl()=0;
139                virtual void SetMtl(Mtl* matl)=0;
140
141                // GraphicsWindow Materials
142                virtual Material* Mtls()=0;   // Array  of GraphicsWindow Materials
143                virtual int     NumMtls()=0;  // number of entries in Mtls
144
145                // Object offset from node:
146                virtual void    SetObjOffsetPos(Point3 p)=0;
147                virtual Point3  GetObjOffsetPos()=0;
148                virtual void    SetObjOffsetRot(Quat q)=0;
149                virtual Quat    GetObjOffsetRot()=0;
150                virtual void    SetObjOffsetScale(ScaleValue sv)=0;
151                virtual ScaleValue GetObjOffsetScale()=0;
152               
153                // Misc.
154                virtual void    FlagForeground(TimeValue t,BOOL notify=TRUE)=0;
155                virtual int     IsActiveGrid()=0;
156
157                // A place to hang temp data. Don't expect the data to stay around after you return control
158                virtual void SetNodeLong(LONG l)=0;
159                virtual LONG GetNodeLong()=0;
160
161//              virtual void GetMaterial(Material &mtl)=0;  // Why do we need this?
162
163                // Access render data
164                virtual RenderData *GetRenderData()=0;
165                virtual void SetRenderData(RenderData *rd)=0;
166
167                //
168                // Access user defined property text
169                //
170                // The first two functions access the entire buffer
171                virtual void GetUserPropBuffer(TSTR &buf)=0;
172                virtual void SetUserPropBuffer(const TSTR &buf)=0;
173
174                // These get individual properties - return FALSE if the key is not found
175                virtual BOOL GetUserPropString(const TSTR &key,TSTR &string)=0;
176                virtual BOOL GetUserPropInt(const TSTR &key,int &val)=0;
177                virtual BOOL GetUserPropFloat(const TSTR &key,float &val)=0;
178                virtual BOOL GetUserPropBool(const TSTR &key,BOOL &b)=0;
179               
180                // These set individual properties - create the key if it doesn't exist
181                virtual void SetUserPropString(const TSTR &key,const TSTR &string)=0;
182                virtual void SetUserPropInt(const TSTR &key,int val)=0;
183                virtual void SetUserPropFloat(const TSTR &key,float val)=0;
184                virtual void SetUserPropBool(const TSTR &key,BOOL b)=0;
185               
186                // Just checks to see if a key exists
187                virtual BOOL UserPropExists(const TSTR &key)=0;
188
189                // G-Buffer ID's
190                virtual ULONG GetGBufID()=0;
191                virtual void SetGBufID(ULONG id)=0;
192
193                // Transform the node about a specified axis system.
194                // Either the pivot point or the object or both can be transformed.
195                // Also, the children can be counter transformed so they don't move.
196                virtual void Move(TimeValue t, const Matrix3& tmAxis, const Point3& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE)=0;
197                virtual void Rotate(TimeValue t, const Matrix3& tmAxis, const AngAxis& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE)=0;
198                virtual void Rotate(TimeValue t, const Matrix3& tmAxis, const Quat& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE)=0;
199                virtual void Scale(TimeValue t, const Matrix3& tmAxis, const Point3& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE)=0;
200
201                virtual BOOL IsGroupMember()=0;
202                virtual BOOL IsGroupHead()=0;
203                };             
204
205
206// Transform lock types
207#define INODE_LOCKPOS           0
208#define INODE_LOCKROT           1
209#define INODE_LOCKSCL           2
210
211// Transform lock axis
212#define INODE_LOCK_X            0
213#define INODE_LOCK_Y            1
214#define INODE_LOCK_Z            2
215
216// Derive a class from this class, implementing the callback.
217class ITreeEnumProc {
218        public:
219                virtual int callback( INode *node )=0;
220        };
221
222// Return values for the TreeEnum callback:
223#define TREE_CONTINUE                   0       // Continue enumerating
224#define TREE_IGNORECHILDREN             1       // Don't enumerate children, but continue
225#define TREE_ABORT                              2       // Stop enumerating
226
227// Node properties:
228#define PROPID_PINNODE          PROPID_USER+1   // Returns a pointer to the node this node is pinned to
229#define PROPID_PRECEDENCE       PROPID_USER+2   // Returns an integer representing this node's precedence
230#define PROPID_RELPOS           PROPID_USER+3   // Returns a pointer to the relative vector between the node and its pin
231#define PROPID_RELROT           PROPID_USER+4   // Returns a pointer to the relative quaternion between the node and its pin
232
233
234
235class INodeTransformed;
236
237// INodeTransformed can be allocated on the stack, but if you need
238// to create one dynamically, use these methods.
239CoreExport void DeleteINodeTransformed(INodeTransformed *n);
240CoreExport INodeTransformed *CreateINodeTransformed(INode *n,Matrix3 tm,BOOL dm=TRUE);
241
242// This class provides a layer that will add in a transformation to the
243// node's objectTM.
244//
245// Most methods pass through to the inode, except for the objectTM methods
246// which pre-multiply in the given matrix.
247//
248class INodeTransformed : public INode {
249        public:
250                INode *node;
251                Matrix3 tm;
252                BOOL deleteMe;
253
254                INodeTransformed(INode *n,Matrix3 tm,BOOL dm=TRUE) {node = n;this->tm = tm;deleteMe = dm;}
255               
256                void DisposeTemporary() {node->DisposeTemporary(); if (deleteMe) DeleteINodeTransformed(this);}
257                INode *GetActualINode() {return node->GetActualINode();}
258               
259                TCHAR*  GetName() {return node->GetName();}
260                void    SetName(TCHAR *s) {node->SetName(s);}
261                Matrix3 GetNodeTM(TimeValue t, Interval* valid=NULL) {return node->GetNodeTM(t,valid);}
262                void    SetNodeTM(TimeValue t, Matrix3& tm) {node->SetNodeTM(t,tm);}
263                void InvalidateTreeTM() {node->InvalidateTreeTM();}
264                void InvalidateTM() {node->InvalidateTM();}
265                void InvalidateWS() {node->InvalidateWS();}
266                Matrix3 GetObjectTM(TimeValue time, Interval* valid=NULL) {return tm*node->GetObjectTM(time,valid);}
267                Matrix3 GetObjTMBeforeWSM(TimeValue time, Interval* valid=NULL) {return tm*node->GetObjTMBeforeWSM(time,valid);}
268                Matrix3 GetObjTMAfterWSM(TimeValue time, Interval* valid=NULL) {return tm*node->GetObjTMAfterWSM(time,valid);}
269                const ObjectState& EvalWorldState(TimeValue time,BOOL evalHidden=TRUE) {return node->EvalWorldState(time,evalHidden);}
270                INode*  GetParentNode() {return node->GetParentNode();}
271                void    AttachChild(INode* node, int keepPos=1) {node->AttachChild(node,keepPos);}
272                void    Detach(TimeValue t, int keepPos=1) {node->Detach(t,keepPos);}
273                int     NumberOfChildren() {return node->NumberOfChildren();}
274                INode*  GetChildNode(int i) {return node->GetChildNode(i);}
275                void    Hide(BOOL onOff) {node->Hide(onOff);}
276                int             IsHidden(DWORD hflags=0) {return node->IsHidden(hflags);}
277                int             IsNodeHidden() { return node->IsNodeHidden(); }
278                void    Freeze(BOOL onOff) {node->Freeze(onOff);}
279                int             IsFrozen() {return node->IsFrozen();}
280                void    BoxMode(BOOL onOff) {node->BoxMode(onOff);}
281                int             GetBoxMode() {return node->GetBoxMode();}
282                void    AllEdges(BOOL onOff) {node->AllEdges(onOff);}
283                int             GetAllEdges() {return node->GetAllEdges();}
284                void    BackCull(BOOL onOff) {node->BackCull(onOff);}
285                int             GetBackCull() {return node->GetBackCull();}
286                void    SetCastShadows(BOOL onOff) { node->SetCastShadows(onOff); }
287                int             CastShadows() { return node->CastShadows(); }
288                void    SetRcvShadows(BOOL onOff) { node->SetRcvShadows(onOff); }
289                int             RcvShadows() { return node->RcvShadows(); }
290                void    SetMotBlur(BOOL onOff) { node->SetMotBlur(onOff); }
291                int             MotBlur() { return node->MotBlur(); }
292                void    ShowBone(int boneVis) {node->ShowBone(boneVis);}
293                void    BoneAsLine(int onOff) {node->BoneAsLine(onOff);}
294                BOOL    IsBoneShowing() {return node->IsBoneShowing();}
295                DWORD   GetWireColor() {return node->GetWireColor();}
296                void    SetWireColor(DWORD newcol) {node->SetWireColor(newcol);}
297                int     IsRootNode() {return node->IsRootNode();}
298                int     Selected() {return node->Selected();}
299                int     Dependent() {return node->Dependent();}
300                int     IsTarget() {return node->IsTarget();}
301                BOOL    GetTransformLock(int type, int axis) {return node->GetTransformLock(type,axis);}
302                void    SetTransformLock(int type, int axis, BOOL onOff) {node->SetTransformLock(type,axis,onOff);}
303                INode*  GetTarget() {return node->GetTarget();}
304                INode*  GetLookatNode() {return node->GetLookatNode();}
305                Matrix3 GetParentTM(TimeValue t) {return node->GetParentTM(t);}
306                int     GetTargetTM(TimeValue t, Matrix3& m) {return node->GetTargetTM(t,m);}
307                Object* GetObjectRef() {return node->GetObjectRef();}
308                void    SetObjectRef(Object *o) {node->SetObjectRef(o);}
309                Control* GetTMController() {return node->GetTMController();}
310                void    SetTMController(Control *m3cont) {node->SetTMController(m3cont);}               
311                Control *GetVisController() {return node->GetVisController();}
312                void    SetVisController(Control *cont) {node->SetVisController(cont);}
313                float   GetVisibility(TimeValue t,Interval *valid=NULL) {return node->GetVisibility(t,valid);}
314                void    SetVisibility(TimeValue t,float vis) {node->SetVisibility(t,vis);}
315               
316                Mtl *GetMtl() { return node->GetMtl(); }
317                void SetMtl(Mtl* matl) { node->SetMtl(matl); }
318
319                Material* Mtls() { return node->Mtls(); }   
320                int     NumMtls() { return node->NumMtls(); }
321
322                RenderData *GetRenderData() {return node->GetRenderData();}
323                void SetRenderData(RenderData *rd) {node->SetRenderData(rd);}
324
325                void    SetObjOffsetPos(Point3 p) {node->SetObjOffsetPos(p);}
326                Point3  GetObjOffsetPos() {return node->GetObjOffsetPos();}
327                void    SetObjOffsetRot(Quat q) {node->SetObjOffsetRot(q);}
328                Quat    GetObjOffsetRot() {return node->GetObjOffsetRot();}             
329                void    FlagForeground(TimeValue t,BOOL notify=TRUE) {node->FlagForeground(t,notify);}
330                int     IsActiveGrid() {return node->IsActiveGrid();}
331                void SetNodeLong(LONG l) {node->SetNodeLong(l);}
332                LONG GetNodeLong() {return node->GetNodeLong();}
333
334                void GetUserPropBuffer(TSTR &buf) {node->GetUserPropBuffer(buf);}
335                void SetUserPropBuffer(const TSTR &buf) {node->SetUserPropBuffer(buf);}
336                BOOL GetUserPropString(const TSTR &key,TSTR &string) {return node->GetUserPropString(key,string);}
337                BOOL GetUserPropInt(const TSTR &key,int &val) {return node->GetUserPropInt(key,val);}
338                BOOL GetUserPropFloat(const TSTR &key,float &val) {return node->GetUserPropFloat(key,val);}
339                BOOL GetUserPropBool(const TSTR &key,BOOL &b) {return node->GetUserPropBool(key,b);}
340                void SetUserPropString(const TSTR &key,const TSTR &string) {node->SetUserPropString(key,string);}
341                void SetUserPropInt(const TSTR &key,int val) {node->SetUserPropInt(key,val);}
342                void SetUserPropFloat(const TSTR &key,float val) {node->SetUserPropFloat(key,val);}
343                void SetUserPropBool(const TSTR &key,BOOL b) {node->SetUserPropBool(key,b);}
344                BOOL UserPropExists(const TSTR &key) {return node->UserPropExists(key);}
345                ULONG GetGBufID() { return node->GetGBufID(); }
346                void SetGBufID(ULONG id) { node->SetGBufID(id); }
347
348                CoreExport void         SetObjOffsetScale(ScaleValue sv);
349                CoreExport ScaleValue GetObjOffsetScale();
350
351                void Move(TimeValue t, const Matrix3& tmAxis, const Point3& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE) {node->Move(t,tmAxis,val,localOrigin,pivMode,ignoreLocks);}
352                void Rotate(TimeValue t, const Matrix3& tmAxis, const AngAxis& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE) {node->Rotate(t,tmAxis,val,localOrigin,pivMode,ignoreLocks);}
353                void Rotate(TimeValue t, const Matrix3& tmAxis, const Quat& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE) {node->Rotate(t,tmAxis,val,localOrigin,pivMode,ignoreLocks);}
354                void Scale(TimeValue t, const Matrix3& tmAxis, const Point3& val, BOOL localOrigin=FALSE, BOOL affectKids=TRUE, int pivMode=PIV_NONE, BOOL ignoreLocks=FALSE) {node->Scale(t,tmAxis,val,localOrigin,pivMode,ignoreLocks);}
355
356                BOOL IsGroupMember() {return node->IsGroupMember();}
357                BOOL IsGroupHead() {return node->IsGroupHead();}
358
359                RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget,
360                 PartID& partID,  RefMessage message) {return REF_SUCCEED;}
361        };
362
363
364#endif //__INODE__H
Note: See TracBrowser for help on using the repository browser.