GU/GU_CurveCache.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:
 *      Cristin Barghiel
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Geometry library (C++)
 *
 * COMMENTS:    Display cache for spline curves.
 *
 */

#ifndef __GU_CurveCache_H__
#define __GU_CurveCache_H__

#include "GU_API.h"
#include <UT/UT_Vector4.h>
#include <UT/UT_Vector4Array.h>
#include <GB/GB_Attribute.h>
#include "GU_AttribCache.h"
#include "GU_DisplayCache.h"

class GEO_Curve;
class GU_CurveCacheParms;


class GU_API GU_CurveCache : public GU_DisplayCache
{
public:
                 GU_CurveCache(void);
    virtual     ~GU_CurveCache(void);

    // Record the domain interval within which the curve needs to be recomputed
    void         touchDomain(int ustart_idx, int ustop_idx);

    // Build the cache.
    int          refresh(GU_CurveCacheParms &parms);

    int          colorOffset  (void) const      { return theCdOffset;  }
    int          textureOffset(void) const      { return theTxtOffset; }
    int          tangentOffset(void) const      { return theTangentOffset; }

    int          hasAttributes(void) const      { return theCdOffset  >= 0 ||
                                                         theTxtOffset >= 0 ||
                                                 theTangentOffset >= 0; }

    // Get the tesselation commands, if any:
    const unsigned short        *commands() const       { return theCommands; }

    // Find out how the cache was built: wire or shaded.
    GU_CacheMode builtAs(void) const { return theMode; }

    UT_Vector3  *normal(void) const     { return theNormal; }

    const UT_Vector4Array                &points() const { return thePoints;  }
    const GU_AttribCache                 &colors() const 
                                         { return theAttribs; }
    const UT_Vector4Array                &tangents() const
                                         { return theTangents;  }

protected:
    // Clear the cache data and other related info:
    virtual void initializeData(void);

    // If pushXform is set, the cache data has not been updated with the
    // latest xform matrix. This method makes sure the data _is_ updated,
    // and turns off the flag.
    virtual void assimilateXform(void);

private:
    UT_Vector4Array                      thePoints;
    GU_AttribCache                       theAttribs;
    UT_Vector4Array                      theTangents;
    GU_CacheMode                         theMode;

    UT_Vector3  *theNormal;
    UT_Vector3  *theSavedNormal;
    int          theUMin, theUMax;              // knot indices
    int          theBreakIdx;                   // cached start breakpoint
    int          theCdOffset, theTxtOffset;     // pt color & texture offsets
    int          theTangentOffset;              // tangent offsets
    int          theAttribSize;
    int          theAttribDict;
    int          theHasTangents;

    unsigned short      *theCommands;
    int                  theCommandSize;

    // Resize the attribute data and the attribute list (if necessary):
    void         resizeAttributes(GEO_Detail *gdp);

    // Rebuild the tesselation assuming the curve is closed and we're shaded:
    void         refreshTessellation(int maxsides);

    // Rebuild our cache of tangents:
    void         refreshTangents(const GEO_Curve *curve, int poffset);
};

class GU_API GU_CurveCacheParms : public GU_CacheParms
{
public:
                 GU_CurveCacheParms(void) {}
    virtual     ~GU_CurveCacheParms(void);

    void         curve(GEO_Curve *curve)        { theCurve = curve;    }
    GEO_Curve   *curve(void) const              { return theCurve;     }
    void         maxSides(int sides)            { theMaxSides = sides; }
    int          maxSides(void) const           { return theMaxSides;  }

    void         needTangents(bool val)         { theNeedTangents = val; }
    bool         needTangents() const           { return theNeedTangents; }

private:
    GEO_Curve   *theCurve;
    int          theMaxSides;
    bool         theNeedTangents;

};

#endif

---