source: golgotha/src/maxtool/sdk_inc/spline3d.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: 7.9 KB
Line 
1/**********************************************************************
2 *<
3        FILE: spline3d.cpp
4
5        DESCRIPTION: General-purpose 3D spline class
6
7        CREATED BY: Tom Hudson & Dan Silva
8
9        HISTORY: created 2/23/95
10
11 *>     Copyright (c) 1995, All Rights Reserved.
12 **********************************************************************/
13
14#ifndef __SPLINE3D_H__
15
16#define __SPLINE3D_H__
17
18#include "polyshp.h"    // Need this for PolyLine class
19
20// Point flags for PolyShape representation
21#define BEZ_SHAPE_KNOT                  (1<<0)  // It's a knot point
22#define BEZ_SHAPE_INTERPOLATED  (1<<1)  // It's an interpolated point between two knots
23
24// Line types:
25#define LTYPE_CURVE 0
26#define LTYPE_LINE 1
27
28// Compound line types
29#define CURVE_CURVE (LTYPE_CURVE | (LTYPE_CURVE<<2))
30#define LINE_CURVE (LTYPE_LINE | (LTYPE_CURVE<<2))
31#define CURVE_LINE (LTYPE_CURVE | (LTYPE_LINE<<2))
32#define LINE_LINE (LTYPE_LINE | (LTYPE_LINE<<2))
33
34// Knot types
35#define KTYPE_AUTO 0
36#define KTYPE_CORNER 1
37#define KTYPE_BEZIER 2
38#define KTYPE_BEZIER_CORNER (KTYPE_BEZIER | KTYPE_CORNER)
39
40// Parameter types
41#define PARM_UNIFORM            0
42#define PARM_ARCLENGTH          1
43#define PARM_CENTRIPETAL        2
44#define PARM_CUSTOM                     3
45
46class Spline3D;
47
48class SplineKnot {
49        int ktype;
50        int ltype;
51        Point3 point;
52        Point3 inVec;
53        Point3 outVec;
54public:
55        SplineKnot(int k, int l, Point3 p, Point3 in, Point3 out) { ktype=k; ltype=l; point=p; inVec=in; outVec=out; }
56        inline  int             Ktype() { return ktype; }
57        inline  int             Ltype() { return ltype; }
58        friend class Spline3D;
59        };
60
61typedef struct {
62        int ktype;                      // Knot type
63        int ltype;                      // Line type
64        float du;                       // Parameter value
65        int aux;                        // Used in capping
66        } Knot;
67
68// Private spline flags
69#define SPLINE_CLOSED   (1<<0)
70
71class Spline3D {
72private:
73        static  int                     splineCount;    // Number of splines in the system
74                        int                     parmType;               // Interpolation parameter type (needed?)
75                        int                     knotCount;              // Number of points in spline
76
77                        int                     flags;                  // Private flags
78//                      HMENU           hMenuPType;
79                        int                     iCur;                   // Current editing point
80                        int                     Interact(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3* mat ); // Handle mouse interaction
81                        float           cachedLength;
82                        BOOL            cacheValid;
83public:
84                        // Should consolidate all of these into one knot structure -- Was this way for simple Windows GDI version
85                        Knot *          knots;          // Knot attributes array
86                        Point3 *        bezp;           // Bezier point array
87
88                        int                     drawPhase;              // Drawing phase
89                        int                     editMode;               // 1 if editing, 0 otherwise
90
91                        // Creation settings
92                        int                     initialType;    // Knot type at initial click
93                        int                     dragType;               // Knot type at drag
94
95        CoreExport              Spline3D(int itype = KTYPE_CORNER,int dtype = KTYPE_BEZIER,int ptype = PARM_UNIFORM);           // Constructor 
96        CoreExport              ~Spline3D();    // Destructor
97        CoreExport              Spline3D&       operator=(Spline3D& fromSpline);
98        CoreExport              Spline3D&       operator=(PolyLine& fromLine);
99        CoreExport              void            NewSpline();
100        CoreExport              void            Allocate(int count);
101        inline                  int                     ParmType() { return parmType; };
102        inline                  int                     KnotCount() { return knotCount; }                                                       // Point (knot) count
103        inline                  int                     Flags() { return flags; }
104        inline                  int                     Segments() { return knotCount + Closed() - 1; }                         // Segment count
105        inline                  int                     Closed() { return (flags & SPLINE_CLOSED) ? 1:0; }              // Returns closed status
106        CoreExport              int                     ShiftKnot(int where,int direction);                                             // Shove array left or right 1,
107                                                                                                                                                                                // starting at given point
108        CoreExport              int                     AddKnot(SplineKnot &k,int where = -1);                                          // Add a knot to the spline
109        CoreExport              int                     DeleteKnot(int where);                                                                  // Delete the specified knot
110        CoreExport              int                     Create(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3* mat);    // Create the spline
111        CoreExport              int                     StartInsert(ViewExp *vpt,int msg, int point, int flags, IPoint2 theP, Matrix3* mat, int where );        // Start an insertion operation on the spline
112        CoreExport              void            ChordParams();                                                  // Compute chord length params
113        CoreExport              void            UniformParams();                                                // Compute uniform params
114        CoreExport              void            CentripetalParams();                                    // Compute centripetal params
115        CoreExport              int                     SetParam(int index,float param);                // Set custom param value
116        CoreExport              float           GetParam(int index);                                    // Get param value
117        inline                  int                     GetKnotType(int index) { return knots[index].ktype; }
118        CoreExport              int                     SetKnotType(int index,int type);                // Set the knot type
119        inline                  int                     GetLineType(int index) { return knots[index].ltype; }
120        CoreExport              int                     SetLineType(int index,int type);                // Set the line type
121        virtual                 void            CustomParams() { UniformParams(); }             // Replace this as needed
122        CoreExport              void            CompParams();                                                   // Compute param values
123        CoreExport              void            ComputeBezPoints();
124        CoreExport              void            LinearFwd(int i);
125        CoreExport              void            LinearBack(int i);
126        CoreExport              void            ContinFwd(int i);
127        CoreExport              void            ContinBack(int i);
128        CoreExport              void            HybridPoint(int i);
129        CoreExport              void            CompCornerBezPoints(int n);
130        CoreExport              void            CompAdjBesselBezPoints(int i);
131        CoreExport              void            BesselStart(int i);
132        CoreExport              void            BesselEnd(int i);
133        CoreExport              void            NaturalFwd(int i);
134        CoreExport              void            NaturalBack(int i);
135        CoreExport              Point2          InterpBezier(IPoint2 *bez, float t);
136        CoreExport              Point3          InterpBezier3D(int segment, float t);
137        CoreExport              Point3          InterpCurve3D(float u);
138        CoreExport              Point3          TangentBezier3D(int segment, float t);
139        CoreExport              Point3          TangentCurve3D(float u);
140        CoreExport              void            BoundingRect(RECT *r, IPoint2 *p, int npoints);
141        CoreExport              Point3          AverageTangent(int i);
142        CoreExport              void            MakeBezCont(int i);
143        CoreExport              void            RedistTangents(int i, Point3 d);
144        CoreExport              void            FixAdjBezTangents(int i);
145        CoreExport              void            DrawCurve(GraphicsWindow *gw, Material *mtl);
146        inline                  void            SetEditMode(int mode) { editMode = mode ? 1:0; }
147        CoreExport              int                     IsAuto(int i);
148        CoreExport              int                     IsBezierPt(int i);
149        CoreExport              int                     IsCorner(int i);
150        CoreExport              Point3          GetDragVector(ViewExp *vpt,IPoint2 p,int i,Matrix3* mat);
151        CoreExport              int                     InsertPoint(ViewExp *vpt,int where, IPoint2& p, float t);
152        CoreExport              int                     AppendPoint(ViewExp *vpt,const Point3& p, int where = -1);
153        CoreExport              void            ComputeAdjBezPts(int n);
154        CoreExport              int                     DrawPhase() { return drawPhase; }
155        CoreExport              int                     GetiCur() { return iCur; }
156        CoreExport              void            CheckMenu(HMENU hMenu, int idfirst, int idlast, int idcheck);
157        CoreExport              void            RedrawCurves();
158        CoreExport              void            GetBBox(TimeValue t,  Matrix3& tm, Box3& box);
159        CoreExport              IPoint2         ProjectPoint(ViewExp *vpt, Point3 fp, Matrix3 *mat);
160        CoreExport              Point3          UnProjectPoint(ViewExp *vpt, IPoint2 p, Matrix3 *mat);
161        CoreExport              void            Snap(GraphicsWindow *gw, SnapInfo *snap, IPoint2 *p, Matrix3 &tm);
162        CoreExport              IOResult        Save(ISave *isave);
163        CoreExport              IOResult        Load(ILoad *iload);
164        CoreExport              int                     SetClosed(int flag = 1);
165        CoreExport              int                     SetOpen();
166        CoreExport              void            Dump(int where);
167        inline                  Point3&         InVec(int i) { return bezp[i*3]; }
168        inline                  Point3&         KnotPoint(int i) { return bezp[i*3+1]; }
169        inline                  Point3&         OutVec(int i) { return bezp[i*3+2]; }
170        inline                  Point3&         GetVert(int i) { return bezp[i]; }
171        inline                  void            SetVert(int i, const Point3& p) { bezp[i] = p; }
172        inline                  int                     Verts() { return knotCount*3; }
173        CoreExport              float           SplineLength();
174        CoreExport              void            Transform(Matrix3 *tm);
175        CoreExport              void            Reverse();
176        CoreExport              void            Append(Spline3D *spline);
177        CoreExport              void            Prepend(Spline3D *spline);
178        CoreExport              BOOL            IsClockWise();                  // 2D!
179        CoreExport              BOOL            SelfIntersects();               // 2D!
180        CoreExport              BOOL            IntersectsSpline(Spline3D *spline);             // 2D!
181        CoreExport              BOOL            SurroundsPoint(Point2 p);       // 2D!
182        CoreExport              void            MakePolyLine(PolyLine &line, int steps = -1, BOOL optimize = FALSE);
183        CoreExport              void            InvalidateGeomCache();
184        };
185
186#endif // __SPLINE3D_H__
Note: See TracBrowser for help on using the repository browser.