simpspl.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 1998-2006 Autodesk, Inc.
// All rights reserved.
// 
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc., and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//**************************************************************************/
// FILE:        simpspl.h
// DESCRIPTION: Defines a simple spline object class to make spline
//              primitives easier to create
// AUTHOR:      Tom Hudson
// HISTORY:     created 3 October 1995
//**************************************************************************/
#pragma once

#include "iparamm.h"
#include "object.h"
#include "GraphicsConstants.h"

// Special dialog handling
class SimpleSpline;

class SimpleSplineDlgProc : public ParamMapUserDlgProc {
    private:
        SimpleSpline *spl;
    public:
        SimpleSplineDlgProc(SimpleSpline *s) { spl = s; }
        CoreExport INT_PTR DlgProc(TimeValue t,IParamMap *map,HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam);
        CoreExport void DeleteThis();
    };

#pragma warning(push)
#pragma warning(disable:4239)

class SimpleSpline: public ShapeObject {               
    private:
    public:
        IParamBlock *ipblock;   // Interpolation parameter block (handled by SimpleSpline)
        IParamBlock *pblock;    // User's parameter block

        static IParamMap *ipmapParam;
        static int dlgSteps;
        static BOOL dlgOptimize;
        static BOOL dlgAdaptive;

        // Spline cache
        BezierShape shape;
        Interval ivalid;

        // Flag to suspend snapping -- Used during creation
        BOOL suspendSnap;

        CoreExport void UpdateShape(TimeValue t);

        static SimpleSpline *editOb;

        CoreExport SimpleSpline();
        CoreExport ~SimpleSpline();

        void ShapeInvalid() { ivalid.SetEmpty(); }

        //  inherited virtual methods:

        // From BaseObject
        CoreExport int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt);
        CoreExport void Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt);
        CoreExport int Display(TimeValue t, INode* inode, ViewExp *vpt, int flags);
        CoreExport virtual void BeginEditParams( IObjParam *ip, ULONG flags,Animatable *prev);
        CoreExport virtual void EndEditParams( IObjParam *ip, ULONG flags,Animatable *next);
        IParamArray* GetParamBlock() {return (IParamArray*)pblock;}
        CoreExport int GetParamBlockIndex(int id);

        // From Object
        CoreExport ObjectState Eval(TimeValue time);
        CoreExport Interval ObjectValidity(TimeValue t);
        CoreExport int CanConvertToType(Class_ID obtype);
        CoreExport Object* ConvertToType(TimeValue t, Class_ID obtype);
        CoreExport void GetCollapseTypes(Tab<Class_ID> &clist,Tab<MSTR*> &nlist);

        CoreExport void BuildMesh(TimeValue t, Mesh &mesh);
        
        // From ShapeObject
        CoreExport ObjectHandle CreateTriObjRep(TimeValue t);  // for rendering, also for deformation       
        CoreExport void GetWorldBoundBox(TimeValue t, INode* inode, ViewExp* vpt, Box3& box );
        CoreExport void GetLocalBoundBox(TimeValue t, INode* inode, ViewExp* vxt, Box3& box );
        CoreExport void GetDeformBBox(TimeValue t, Box3& box, Matrix3 *tm, BOOL useSel );
        CoreExport int NumberOfVertices(TimeValue t, int curve);
        CoreExport int NumberOfCurves();
        CoreExport BOOL CurveClosed(TimeValue t, int curve);
        CoreExport Point3 InterpCurve3D(TimeValue t, int curve, float param, int ptype=PARAM_SIMPLE);
        CoreExport Point3 TangentCurve3D(TimeValue t, int curve, float param, int ptype=PARAM_SIMPLE);
        CoreExport float LengthOfCurve(TimeValue t, int curve);
        CoreExport int NumberOfPieces(TimeValue t, int curve);
        CoreExport Point3 InterpPiece3D(TimeValue t, int curve, int piece, float param, int ptype=PARAM_SIMPLE);
        CoreExport Point3 TangentPiece3D(TimeValue t, int curve, int piece, float param, int ptype=PARAM_SIMPLE);
        CoreExport MtlID GetMatID(TimeValue t, int curve, int piece);
        BOOL CanMakeBezier() { return TRUE; }           // Return TRUE if can turn into a bezier representation
        CoreExport void MakeBezier(TimeValue t, BezierShape &shape);    // Create the bezier representation
        CoreExport ShapeHierarchy &OrganizeCurves(TimeValue t, ShapeHierarchy *hier=NULL);  // Ready for lofting, extrusion, etc.
        CoreExport void MakePolyShape(TimeValue t, PolyShape &shape, int steps = PSHAPE_BUILTIN_STEPS, BOOL optimize = FALSE);
        CoreExport int MakeCap(TimeValue t, MeshCapInfo &capInfo, int capType); // Makes a cap out of the shape
        CoreExport int MakeCap(TimeValue t, PatchCapInfo &capInfo);

        int NumRefs() { return 2 + ShapeObject::NumRefs();}
        CoreExport RefTargetHandle GetReference(int i);
protected:
        CoreExport virtual void SetReference(int i, RefTargetHandle rtarg);     
public:
        CoreExport RefResult NotifyRefChanged(Interval changeInt,RefTargetHandle hTarget, 
           PartID& partID, RefMessage message);

        CoreExport void ReadyInterpParameterBlock();
        void UnReadyInterpParameterBlock() { ipblock = NULL; }

        // When clients are cloning themselves, they should call this 
        // method on the clone to copy SimpleSpline's data.
        // NOTE: DEPRECATED! Use SimpleSplineClone(SimpleSpline *ssplSource, RemapDir& remap )
        CoreExport void SimpleSplineClone( SimpleSpline *ssplSource );

        // When clients are cloning themselves, they should call this 
        // method on the clone to copy SimpleSpline's data.
        CoreExport void SimpleSplineClone( SimpleSpline *ssplSource, RemapDir& remap );

        int NumSubs() { return 2 + ShapeObject::NumSubs(); }  
        CoreExport Animatable* SubAnim(int i);
        CoreExport MSTR SubAnimName(int i);     

        // Animatable methods
        CoreExport void DeleteThis();
        CoreExport void FreeCaches(); 

        // IO
        CoreExport IOResult Save(ISave *isave);
        CoreExport IOResult Load(ILoad *iload);
    #pragma warning(push)
    #pragma warning(disable:4100)
        LRESULT CALLBACK TrackViewWinProc( HWND hwnd,  UINT message, 
                WPARAM wParam,   LPARAM lParam ){return(0);}

        void GetClassName(MSTR& s) {s = GetObjectName();}
        void InitNodeName(MSTR& s) {s = GetObjectName();}

        // Clients of SimpleSpline need to implement these methods:
    
        virtual Class_ID ClassID() = 0;
        virtual void BuildShape(TimeValue t,BezierShape& ashape) = 0;
        virtual RefTargetHandle Clone(RemapDir& remap) = 0;
        
        virtual CreateMouseCallBack* GetCreateMouseCallBack() = 0;
        virtual BOOL ValidForDisplay(TimeValue t) = 0;
        virtual void InvalidateUI() {}
        virtual ParamDimension *GetParameterDim(int pbIndex) {return defaultDim;}
        virtual MSTR GetParameterName(int pbIndex) {return MSTR(_M("Parameter"));}
        #pragma warning(pop)

        virtual BOOL DisplayVertTicksDuringCreation() { return TRUE; }
    };              
#pragma warning(pop)