SIM/SIM_Geometry.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:
 *      Side Effects Software Inc.
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 */

#ifndef __SIM_Geometry_h__
#define __SIM_Geometry_h__

#include "SIM_API.h"
#include <GU/GU_DetailHandle.h>
#include "SIM_OptionsUser.h"
#include "SIM_DataUtils.h"

class UT_DMatrix4;
class UT_IStream;

/// This is the definitions for the SIM_Geometry interface. It also
/// provides a default implementation that returns an empty geometry and
/// an identity transform. It also has the facility to hold its own
/// geometry and transform as internal data. If set, these are saved and
/// loaded automatically. But there is no way for anyone except subclasses
/// to set these internal data. Thus they are really just a convenience
/// when writing SIM_Geometry subcalsses.
class SIM_API SIM_Geometry : public SIM_Data,
                             public SIM_OptionsUser
{
public:
    /// Accesses the relative path to the position data associated with
    /// this geometry.
    GETSET_DATA_FUNCS_S(SIM_NAME_POSITIONPATH, PositionPath);

    /// Method for accessing the geometry. If we have some internal
    /// geometry data, we return that. Otherwise this function calls
    /// getGeometrySubclass().
    GU_ConstDetailHandle getGeometry() const;
    /// Get the geometry transform. If we have some internal transform
    /// data, we return that. Otherwise this function calls
    /// getTransformSubclass().
    void                 getTransform(UT_DMatrix4 &xform) const;

protected:
    explicit             SIM_Geometry(const SIM_DataFactory *factory);
    virtual             ~SIM_Geometry();

    /// Set initial values on all the geometry attributes.
    virtual void         initializeSubclass();
    /// Makes this geometry equal to some other SIM_Geometry.
    virtual void         makeEqualSubclass(const SIM_Data *source);
    /// Saves our attributes, and our internal data if it has been set.
    virtual void         saveSubclass(ostream &os) const;
    /// Loads our attributes and internal data if it was set when we saved.
    virtual bool         loadSubclass(UT_IStream &is);
    /// Creates a query object specifically for geometry data to access
    /// the transforms associated with geometry data.
    virtual SIM_Query   *createQueryObjectSubclass() const;
    /// Create an interpolation between two other SIM_Geometry subclasses.
    /// This is one place where the internal data gets used automatically.
    /// Since the source data may be of any subclass, the only way to
    /// safely and correctly interpolate between two SIM_Geometry subclasses
    /// is to copy one of the source geometry and transform to our internal
    /// data, and then do a blend towards the second source data.
    virtual void         interpolateSubclass(const SIM_Data *source1,
                                             const SIM_Data *source2,
                                             fpreal interp);
    virtual int64        getMemorySizeSubclass() const;

    /// This function is called by getGeometry() to return the actual
    /// geometry data. The default implementation returns an empty geometry.
    virtual GU_ConstDetailHandle getGeometrySubclass() const;
    /// This function is called by getTransform() to return the actual
    /// transform data. The default implementation returns an identity matrix.
    virtual void                 getTransformSubclass(UT_DMatrix4 &xform) const;

    /// Set our internal geometry data. If some internal data already exists,
    /// it is deleted. The pointer passed in becomes controlled by the
    /// SIM_Geometry so must not be deleted by external code. A null pointer
    /// can be passed in to clear our internal geometry data.
    void                 setOwnGeometry(GU_Detail *gdp);
    /// Set our internal geometry data from an existing GU_DetailHandle.
    /// If some internal data already exists, it is deleted.
    void                 setOwnGeometry(const GU_DetailHandle &gdh);
    /// Returns a const pointer to our internal geometry data, if it is set.
    GU_ConstDetailHandle getOwnGeometry() const;
    /// Returns a pointer to our internal geometry data, if it is set.
    GU_DetailHandle      getOwnGeometry();
    /// Set our internal transform data. If some internal data already exists,
    /// it is deleted. The pointer passed in becomes controlled by the
    /// SIM_Geometry so must not be deleted by external code. A null pointer
    /// can be passed in to clear our internal transform data.
    void                 setOwnTransform(UT_DMatrix4 *xform);
    /// Returns a const pointer to our internal transform data, if it is set.
    const UT_DMatrix4   *getOwnTransform() const;
    /// Returns a pointer to our internal transform data, if it is set.
    UT_DMatrix4         *getOwnTransform();

private:
    GU_DetailHandle      myOwnGeometry;
    UT_DMatrix4         *myOwnTransform;

    DECLARE_STANDARD_GETCASTTOTYPE();
    DECLARE_CLASSNAME(SIM_Geometry, SIM_Data);
};

#endif

---