polyshp.h

Go to the documentation of this file.

//
// Copyright 2010 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.  
//

#pragma once

#include "maxheap.h"
#include "shphier.h"
#include "captypes.h"
#include "shpsels.h"    // Shape selection classes
#include "templt.h"
#include "maxtypes.h"
#include "channels.h" // for ChannelMask typedef
#include "TabTypes.h" // cannot forward declare IntTab
#include "GraphicsConstants.h"

// forward declarations
class GraphicsWindow;
class Material;
class HitRegion;
struct SnapInfo;
class IPoint2;



#define PSHAPE_SNAP_IGNORELAST  (1<<0)
#define PSHAPE_SNAP_NOEDGES     (1<<1)



// (Must match interpolation types in object.h)
#define POLYSHP_INTERP_SIMPLE 0     //!< Parameter space based on segments
#define POLYSHP_INTERP_NORMALIZED 1 //!< Parameter space normalized to curve length


// Flags for sub object hit test

class Spline3D;

//--------------------------------------------------------------
// Capping classes, etc.


#define CAPVERT_VISEDGE (1<<0)


class CapVert: public MaxHeapOperators {
    public:
        int vert;
        DWORD flags;
        float ang;
        CapVert *prev,*next;
        CapVert *smaller,*bigger;
        CapVert() { vert=0; flags = 0; ang = 0.0f; prev=next=smaller=bigger = NULL; }
    };


#define POLYPT_KNOT         (1<<8)  

#define POLYPT_INTERPOLATED (1<<9)  

#define POLYPT_SMOOTH       (1<<10) 

#define POLYPT_SEG_SELECTED (1<<11) 

#define POLYPT_BRIDGE       (1<<16) //!< \internal Span between two polygons. Used internally by capping code.
#define POLYPT_SPLICE       (1<<17) //!< \internal Point is endpoint of a bridge. Used internally by capping code.
#define POLYPT_VISEDGE      (1<<18) //!< \internal Segment should be visible on mesh. Used internally by capping code.
#define POLYPT_NO_SPLICE    (1<<19) //!< \internal Don't allow a bridge at this point. Used internally by capping code.
#define POLYPT_INVIS_EDGE   (1<<20) //!< \internal Force segment to be invisible on capping. Used internally by capping code
#define POLYPT_NO_SNAP      (1<<21) //!< \internal Suppress snapping when set. Used internally by capping code.


#define POLYPT_MATID_SHIFT  16      
#define POLYPT_MATID_MASK   0xFFFF  



class PolyPt: public MaxHeapOperators {
    public:
        Point3 p;       
        DWORD flags;    
        DWORD flags2;   
        int aux;        
        
        PolyPt() { p = Point3(0,0,0); flags = 0; flags2 = 0; aux = 0; }

        PolyPt(Point3 ip, DWORD f=0, int a=0, DWORD f2=0) { p = ip; flags = f; aux = a; flags2 = f2;}
        
        inline  MtlID   GetMatID() {return (int)((flags2>>POLYPT_MATID_SHIFT)&POLYPT_MATID_MASK);}
        
        inline  void    SetMatID(MtlID id) {flags2 &= 0xFFFF; flags2 |= (DWORD)(id<<POLYPT_MATID_SHIFT);}
    };



#define CAP3DS_OPT_CLOSEST_BRIDGE (1<<0)    //!< Bridge polys at closest point





#define POLYLINE_CLOSED         (1<<0)       

#define POLYLINE_NO_SELF_INT    (1<<1)       


class PolyLine: public MaxHeapOperators {
    public:
        int numPts;         
        PolyPt *pts;        
        DWORD flags;        
        Box3 bdgBox;        
        float cachedLength; 
        float *lengths;     
        float *percents;    
        BOOL cacheValid;    

        CoreExport PolyLine();
        
        CoreExport PolyLine(PolyLine& from);

        CoreExport ~PolyLine();
        
        CoreExport void Init();

        void Close() { flags |= POLYLINE_CLOSED; }

        CoreExport BOOL IsClosed();

        void Open() { flags &= ~POLYLINE_CLOSED; }

        CoreExport BOOL IsOpen();

        void SetNoSelfInt() { flags |= POLYLINE_NO_SELF_INT; }
    
        BOOL IsNoSelfInt() { return (flags & POLYLINE_NO_SELF_INT) ? TRUE : FALSE; }

        int Verts() { return numPts; }

        CoreExport int Segments();

        CoreExport BOOL SetNumPts(int count, BOOL keep = TRUE);

        CoreExport void Append(PolyPt& p);

        CoreExport void Insert(int where, PolyPt& p);

        CoreExport void Delete(int where);

        CoreExport void Reverse(BOOL keepZero=FALSE);
    
        CoreExport PolyLine& operator=(PolyLine& from);
        CoreExport PolyLine& operator=(Spline3D& from);
        CoreExport PolyPt& operator[](int index) { return pts[index]; }

        CoreExport void BuildBoundingBox(void);

        CoreExport void InvalidateGeomCache();

        CoreExport Box3 GetBoundingBox(Matrix3 *tm=NULL); 

        CoreExport void Render(GraphicsWindow* gw, Material* ma, RECT *rp, int compFlags, int numMat);

        CoreExport void Render(GraphicsWindow* gw, Material* ma, int numMat, BOOL colorSegs, BitArray &segsel, BOOL useStartSegments = TRUE);
        
        CoreExport BOOL Select(GraphicsWindow* gw, Material* ma, HitRegion* hr, int abortOnHit = FALSE);
        
        CoreExport void Snap(GraphicsWindow* gw, SnapInfo* snap, IPoint2* p, Matrix3 &tm, DWORD flags);
        
        CoreExport void Transform(Matrix3 &tm);

        CoreExport void Dump(MCHAR *title = NULL);

        CoreExport void SpliceLine(int where, PolyLine &source, int splicePoint);

        CoreExport BOOL HitsSegment(Point2 p1, Point2 p2, BOOL findAll = FALSE, IntersectionCallback3D *cb = NULL);

        CoreExport int Cap3DS(CapVert *capverts, MeshCapInfo &capInfo, DWORD options = 0);

        CoreExport BOOL HitsPolyLine(PolyLine &line, BOOL findAll = FALSE, IntersectionCallback3D *cb = NULL);

        CoreExport BOOL SurroundsPoint(Point2 &point);

        CoreExport Point3 InterpPiece3D(int segment, float t);

        CoreExport Point3 InterpCurve3D(float u, int ptype=POLYSHP_INTERP_SIMPLE);

        CoreExport Point3 TangentPiece3D(int segment, float t);

        CoreExport Point3 TangentCurve3D(float u, int ptype=POLYSHP_INTERP_SIMPLE);

        CoreExport MtlID GetMatID(int segment);
        CoreExport float CurveLength();

        CoreExport BOOL IsClockWise();
        
        CoreExport BOOL SelfIntersects(BOOL findAll = FALSE, IntersectionCallback3D *cb = NULL);        // 2D!

        CoreExport void GetSmoothingMap(IntTab& map);
        // IO
        CoreExport IOResult Save(ISave* isave);
        CoreExport IOResult Load(ILoad* iload);

        CoreExport void Swap(PolyLine& line);
    };

#define CAPFACE_AB  (1<<0)
#define CAPFACE_BC  (1<<1)
#define CAPFACE_CA  (1<<2)

class ShapeObject;

class PolyShape: public MaxHeapOperators {
    public:
        int numLines;               
        PolyLine *lines;            
        DWORD flags;                
        Box3 bdgBox;                


        ShapeVSel   vertSel;        
        ShapeSSel   segSel;         
        ShapePSel   polySel;        


        DWORD       selLevel;       

        DWORD       dispFlags;      


        MeshCapInfo morphCap;           
        BOOL morphCapCacheValid;        
        MeshCapInfo gridCap;            
        BOOL gridCapCacheValid;         
        PatchCapInfo patchCap;          
        BOOL patchCapCacheValid;        
        ShapeHierarchy cachedHier;      
        BOOL hierCacheValid;            


        CoreExport PolyShape();

        CoreExport PolyShape(PolyShape& from);

        CoreExport ~PolyShape();

        CoreExport void Init(); 

        CoreExport void NewShape(); 

        CoreExport BOOL SetNumLines(int count, BOOL keep = TRUE);

        CoreExport PolyLine* NewLine();

        CoreExport void Append(PolyLine &l);

        CoreExport void Insert(int where, PolyLine& l);

        CoreExport void Delete(int where);

        CoreExport PolyShape& operator=(PolyShape& from);

        CoreExport PolyShape& operator=(BezierShape& from);

        CoreExport void BuildBoundingBox(void);

        CoreExport void InvalidateGeomCache(BOOL unused);

        CoreExport void InvalidateCapCache();

        CoreExport Box3 GetBoundingBox(Matrix3 *tm=NULL);

        CoreExport void GetDeformBBox(TimeValue t, Box3& box, Matrix3 *tm, BOOL useSel );

        CoreExport void Render(GraphicsWindow* gw, Material* ma, RECT *rp, int compFlags, int numMat);

        CoreExport BOOL Select(GraphicsWindow* gw, Material* ma, HitRegion* hr, int abortOnHit = FALSE);

        CoreExport void Snap(GraphicsWindow* gw, SnapInfo* snap, IPoint2* p, Matrix3 &tm);

        CoreExport void Snap(GraphicsWindow* gw, SnapInfo* snap, IPoint2* p, Matrix3 &tm, DWORD flags);

        CoreExport void Transform(Matrix3 &tm);

        CoreExport int MakeCap(TimeValue t, MeshCapInfo &capInfo, int capType);

        CoreExport int MakeCap(TimeValue t, PatchCapInfo &capInfo);

        CoreExport int Make3DSCap(MeshCapInfo &capInfo, DWORD options = 0);

        CoreExport int MakeGridCap(MeshCapInfo &capInfo);

        CoreExport void Dump(MCHAR *title = NULL);

        CoreExport void UpdateCachedHierarchy();

        CoreExport ShapeHierarchy &OrganizeCurves(TimeValue t, ShapeHierarchy *hier = NULL);

        CoreExport void UpdateSels();

        CoreExport void Reverse(int poly, BOOL keepZero=FALSE);
        
        CoreExport void Reverse(BitArray &reverse, BOOL keepZero=FALSE);

        CoreExport MtlID GetMatID(int poly, int piece);
        CoreExport BitArray VertexTempSel(int poly);

        CoreExport void ShallowCopy(PolyShape* ashape, ChannelMask channels);

        CoreExport void DeepCopy(PolyShape* ashape, ChannelMask channels);

        CoreExport void NewAndCopyChannels(ChannelMask channels);

        CoreExport void FreeChannels(ChannelMask channels, int zeroOthers=1);
        
        
        CoreExport IOResult Save(ISave *isave);

        CoreExport IOResult Load(ILoad *iload);
        
        CoreExport bool Delete(const unsigned int* indices, unsigned int n);

        CoreExport void Append(PolyLine* lines, unsigned int n, bool useSwap = false);
    };