source: golgotha/src/maxtool/sdk_inc/patchobj.h @ 80

Last change on this file since 80 was 80, checked in by Sam Hocevar, 12 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: 5.2 KB
Line 
1/**********************************************************************
2 *<
3        FILE: patchobj.h
4
5        DESCRIPTION:  Defines Patch Mesh Object
6
7        CREATED BY: Tom Hudson
8
9        HISTORY: created 21 June 1995
10
11 *>     Copyright (c) 1995, All Rights Reserved.
12 **********************************************************************/
13
14#ifndef __PATCHOBJ__
15
16#define __PATCHOBJ__
17
18#include "meshlib.h"
19#include "patchlib.h"
20#include "snap.h"
21
22extern CoreExport Class_ID patchObjectClassID;
23
24class PatchObject: public GeomObject {
25                Interval geomValid;
26                Interval topoValid;
27                Interval texmapValid;
28                Interval selectValid;
29                DWORD validBits; // for the remaining constant channels
30                void CopyValidity(PatchObject *fromOb, ChannelMask channels);
31               
32        protected:
33                //  inherited virtual methods for Reference-management
34                RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message );
35        public:
36                PatchMesh patch;
37
38                // Mesh cache
39                Mesh mesh;
40                int cacheSteps;         // meshSteps used for the cache
41                BOOL cacheAdaptive;     // adaptive switch used for cache
42                BOOL meshValid;
43                BOOL showMesh;
44                BOOL showLattice;
45
46                CoreExport PatchObject();
47                CoreExport ~PatchObject();
48
49                //  inherited virtual methods:
50
51                // From BaseObject
52                CoreExport int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt);
53                CoreExport int Display(TimeValue t, INode* inode, ViewExp *vpt, int flags);
54                CoreExport void Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt);
55                CoreExport CreateMouseCallBack* GetCreateMouseCallBack();
56                CoreExport RefTargetHandle Clone(RemapDir& remap = NoRemap());
57
58                // From Object                   
59                CoreExport ObjectState Eval(TimeValue time);
60                CoreExport Interval ObjectValidity(TimeValue t);
61
62                // get and set the validity interval for the nth channel
63                CoreExport Interval ChannelValidity(TimeValue t, int nchan);
64                CoreExport void SetChannelValidity(int i, Interval v);
65                CoreExport void InvalidateChannels(ChannelMask channels);
66
67                // Convert-to-type validity
68                CoreExport Interval ConvertValidity(TimeValue t);
69
70                // Deformable object procs     
71                int IsDeformable() { return 1; } 
72                CoreExport int NumPoints();
73                CoreExport Point3 GetPoint(int i);
74                CoreExport void SetPoint(int i, const Point3& p);
75               
76                CoreExport void PointsWereChanged();
77                CoreExport void GetDeformBBox(TimeValue t, Box3& box, Matrix3 *tm=NULL,BOOL useSel=FALSE );
78                CoreExport void Deform(Deformer *defProc, int useSel);
79
80                // Mappable object procs
81                int IsMappable() { return 1; }
82                void ApplyUVWMap(int type, float utile, float vtile, float wtile,
83                        int uflip, int vflip, int wflip, int cap,const Matrix3 &tm) {
84                                patch.ApplyUVWMap(type,utile,vtile,wtile,uflip,vflip,wflip,cap,tm); }
85
86                CoreExport int CanConvertToType(Class_ID obtype);
87                CoreExport Object* ConvertToType(TimeValue t, Class_ID obtype);
88                CoreExport void FreeChannels(ChannelMask chan);
89                CoreExport Object *MakeShallowCopy(ChannelMask channels);
90                CoreExport void ShallowCopy(Object* fromOb, ChannelMask channels);
91                CoreExport void NewAndCopyChannels(ChannelMask channels);
92
93                CoreExport DWORD GetSubselState();
94
95                // From GeomObject
96                CoreExport int IntersectRay(TimeValue t, Ray& r, float& at);
97                CoreExport void GetWorldBoundBox(TimeValue t, INode *inode, ViewExp* vpt, Box3& box );
98                CoreExport void GetLocalBoundBox(TimeValue t, INode *inode, ViewExp* vpt, Box3& box );
99                CoreExport int IsInstanceDependent();   // Not view-dependent (yet)
100                CoreExport Mesh* GetRenderMesh(TimeValue t, INode *inode, View& view, BOOL& needDelete);
101
102                PatchMesh& GetPatchMesh() { return patch; }
103                Mesh& GetMesh() { PrepareMesh(); return mesh; }
104
105                // Animatable methods
106
107                void DeleteThis() { delete this; }
108                void FreeCaches() {patch.InvalidateGeomCache(); }
109                Class_ID ClassID() { return Class_ID(PATCHOBJ_CLASS_ID,0); }
110                void GetClassName(TSTR& s) { s = TSTR(_T("PatchObject")); }
111                void NotifyMe(Animatable *subAnim, int message) {}
112                int IsKeyable() { return 0;}
113                int Update(TimeValue t) { return 0; }
114                BOOL BypassTreeView() { return TRUE; }
115                // This is the name that will appear in the history browser.
116                TCHAR *GetObjectName() { return _T("Patch"); }
117
118                // IO
119                CoreExport IOResult Save(ISave *isave);
120                CoreExport IOResult Load(ILoad *iload);
121
122                // PatchObject-specific methods
123                CoreExport void PrepareMesh();
124                CoreExport BOOL ShowLattice() { return patch.GetDispFlag(DISP_LATTICE) ? TRUE : FALSE; }
125                CoreExport BOOL ShowVerts() { return patch.GetDispFlag(DISP_VERTS) ? TRUE : FALSE; }
126                CoreExport void SetShowLattice(BOOL sw) { if(sw) patch.SetDispFlag(DISP_LATTICE); else patch.ClearDispFlag(DISP_LATTICE); }
127                CoreExport void SetShowVerts(BOOL sw) { if(sw) patch.SetDispFlag(DISP_VERTS); else patch.ClearDispFlag(DISP_VERTS); }
128                CoreExport void SetMeshSteps(int steps);
129                CoreExport int GetMeshSteps();
130                CoreExport void SetAdaptive(BOOL sw);
131                CoreExport BOOL GetAdaptive();
132                CoreExport void InvalidateMesh();
133        };
134
135CoreExport ClassDesc* GetPatchObjDescriptor();
136
137#endif // __PATCHOBJ__
Note: See TracBrowser for help on using the repository browser.