GEO/GEO_Delta.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jonathan McGee
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GEO library (C++)
 *
 * COMMENTS:    GEO_Delta is an abstract class for recording changes to
 *              point positions, as well as point, primitive, or vertex
 *              attributes.
 *
 *              This class is a simple interface to the GDT library classes,
 *              specifically GDT_Detail, which inherits from GEO_Delta.
 *
 *              Existing geometry-modifying functions which are called
 *              from the Edit SOP must be modified to take a GEO_Delta
 *              pointer as a parameter, and must record all changes
 *              to the geometry through this interface.
 *              
 *              Example of a point position change:
 *                      void geo_foo(... , GEO_Delta *geodelta, ...)
 *                      {
 *                              .
 *                              .
 *                              .
 *                              GEO_Point *pt = points()(i);
 *                              
 *                              geodelta->beginPointPositionChange(pt);
 *                              pt->getPos().multiply3(xform);
 *                              geodelta->endChange();
 *                              .
 *                              .
 *                              .
 *                      }
 *                      
 *              IMPORTANT IMPLEMENTATION NOTES:
 *                      The functions in this class are designed to
 *                      be as fast as possible, while maintaining some
 *                      degree of flexibility.  The following rules are
 *                      in place to ensure very fast operation:
 *
 *              1.      Every begin*Change() call must be accompanied by
 *                      a following endChange() call.
 *                      
 *              2.      If a call to beginPointPositionChange() (for example)
 *                      is made, then ONLY the position of the given point
 *                      must change before the call to endChange.  Any other
 *                      changes will NOT be recorded.  This applies to any
 *                      begin*Change() call.
 *
 *              3.      The attribute dictionary MUST be specifed with a
 *                      call to set*AttribDict.  Deltas will only be computed
 *                      for the attributes found in this dictionary.
 *                      A call to set*AttribDict should be found in the
 *                      Edit SOP, and in any place where the dictionary is
 *                      modified (which is why the set*AttribDict functions
 *                      are included in this interface, just in case.
 *                      Caution - this introduces a lot of additional cases
 *                      to consider).
 *
 *              4.      It is important that the given attribute dictionary
 *                      stays constant for future begin/end calls, since the
 *                      computation of deltas depends on its structure.
 */

#ifndef __GEO_Delta_h__
#define __GEO_Delta_h__

#include "GEO_API.h"
class GEO_Detail;
class GEO_Point;
class GEO_PointList;
class GEO_Primitive;
class GEO_PointAttribDict;
class GEO_PrimAttribDict;
class GEO_VertexAttribDict;


class GEO_API GEO_Delta
{
public:
                GEO_Delta() {}
    virtual    ~GEO_Delta() {}

    // Applies the delta to a point.
    // For orthoganality, additional methods should be created as needed.
    virtual void        applyScaledPointDelta(GEO_Detail &gdp, GEO_Point &pt,
                                        float scale) const = 0;
    virtual void        applyScaledVertexDelta(GEO_Detail &gdp, 
                                        GEO_Primitive &prim, int vtxidx,
                                        float scale) const = 0;
    
    // Begin changes to a point's position
    virtual void        beginPointPositionChange(
                                        const GEO_Point &pt) = 0;
    
    // Begin changes to a point's attributes
    virtual void        beginPointAttributeChange(
                                        const GEO_Point &pt) = 0;
    
    // Begin changes to a point list's attributes
    // NOTES:
    //  - This function will use MUCH more memory than
    //    beginPointAttributeChange.
    //  - It should only be used when you KNOW that ALL the point
    //    attributes on the gdp will change.  beginPointAttributeChange is
    //    much faster when only some point attributes will change, since
    //    you can ignore the point attributes that don't matter.
    virtual void        beginPointListAttributeChange(
                                        const GEO_PointList &ptlist) = 0;

    // Begin changes to a primitive's transform
    virtual void        beginPrimitiveTransformChange(
                                        const GEO_Primitive &prim) = 0;

    // Begin changes to a primitive's attributes
    virtual void        beginPrimitiveAttributeChange(
                                        const GEO_Primitive &prim) = 0;

    // Begin changes to a vertex attribute;
    // linear_index is the index which would be passed
    // to GEO_Primitive::getVertex(unsigned idx) to retrieve
    // the desired vertex.
    virtual void        beginVertexAttributeChange(
                                        const GEO_Primitive &prim,
                                        unsigned int linear_index_in_prim) = 0;

    // interface for changing point capture weights
    virtual void        initCaptureWeightChange( const GEO_Detail &gdp ) = 0;
    virtual void        beginCaptureWeightChange( const GEO_Point &pt ) = 0;

    // End any of the above changes
    virtual void        endChange() = 0;

    // Specify the attribute dictionary of the points to be modified
    // in between subsequent calls to beginPointAttributeChange
    // and endChange.
    virtual void        setPointAttribDict(
                                        const GEO_PointAttribDict &dict) = 0;

    // Specify the attribute dictionary of the primitives to be modified
    // in between subsequent calls to beginPointAttributeChange
    // and endChange.
    virtual void        setPrimAttribDict(
                                        const GEO_PrimAttribDict &dict) = 0;
    
    // Specify the attribute dictionary of the vertices to be modified
    // in between subsequent calls to beginPointAttributeChange
    // and endChange.
    virtual void        setVertexAttribDict(
                                        const GEO_VertexAttribDict &dict) = 0;

    // Refresh attributes added from GDT_Detail::set.*AttribDict() functions.
    // These functions assume that your geometry has not changed but your
    // attribute offsets might have changed because of re-cooking.
    // If a geometry function changes the attribute dictionary, then it should
    // call these.
    virtual void        refreshPointAttribDict(
                                        const GEO_PointAttribDict &dict) = 0;
    virtual void        refreshPrimAttribDict(
                                        const GEO_PrimAttribDict &dict) = 0;
    virtual void        refreshVertexAttribDict(
                                        const GEO_VertexAttribDict &dict) = 0;

};

#endif

---