GU/GU_TPSurfCache.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 surfaces.
 *
 */

#ifndef __GU_TPSurfCache_H__
#define __GU_TPSurfCache_H__

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

class GEO_TPSurf;
class GU_Detail;
class GEO_Detail;
class GEO_Point;
class GU_TPSurfCacheParms;
class GD_TrimLoop;
class GU_TrimBaseTesselator;
class GU_TrimTesselator;
class GU_TrimPatch;

class GU_API GU_TPTrimSurfCache
{
public:
     GU_TPTrimSurfCache();
    ~GU_TPTrimSurfCache();

    void         resizeAttributes(GEO_Detail *gdp, int ptattrib = 1);

    // Uncut loops
    GD_TrimLoop                         *myLoops;
    GU_TrimTesselator                   *myTesselator;
    GU_TrimPatch                        *myPatch;
    int                                  myTrimmedState;
    int                                  myAttribSize;
    int                                  myAttribDict;
    UT_Vector4Array                      myPoints;
    UT_Vector3Array                      myNormals;
    UT_RefArray<GB_AttributeData>        myAttribs;
};


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

    // Record the domain interval in which the surface needs to be recomputed:
    void         touchDomain(int ustart_idx, int ustop_idx,
                             int vstart_idx, int vstop_idx);

    // Get tesselation of patch.
    // Will tesselate if not already done...
    GU_TrimTesselator   *getTesselation();

    // Gets the tesselated trimmed patch:
    GU_TrimPatch        *getPatch() { return (myPatches)?myPatches->myPatch:0;}

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

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

    // Get the curve and point counts given the internal lod, the build type,
    // and the mesh's "wrap" characteristics.
    void         getCounts(int uwrapped, int vwrapped, 
                           int &nucurves, int &nupoints,
                           int &nvcurves, int &nvpoints) const;
    void         getCounts(int uwrapped, int vwrapped, 
                           int &nupoints, int &nvpoints) const;

    int          colorOffset  (void) const      { return theCdOffset;     }
    int          alphaOffset  (void) const      { return theAlphaOffset;  }
    int          textureOffset(void) const      { return theTxtOffset;    }

    // we only worry about alpha if there is color as well
    int          hasAttributes(GU_CacheMode mode) const
                 {
                     return (theCdOffset < 0 && mode != GU_CACHESHADED)
                         ? 0
                         : theCdOffset    >= 0 || theTxtOffset>= 0 ||
                           theAlphaOffset >= 0;
                 }

    // 0 if trimmed out, 1 if all present, -1 if trim curve matters.
    int          getTrimmedState(void) const    { return !myPatches ? 1 : 
                                    myPatches->myTrimmedState; }
    // Allocates new trim index.
    int          getNewTrimIndex();
    // Evaluates trim point described by index:
    void         evaluateTrimIndex(GEO_TPSurf *surf, int index, 
                                    float u, float v);
    // Create point if req'd.
    GEO_Point   *getPointAtIndex(GU_Detail *gdp, int index);

    const UT_Vector4Array                &points () const { return thePoints; }
    const UT_Vector3Array                &normals() const { return theNormals;}
    const GU_AttribCache                 &attribs() const 
                                                { return theAttribs;}
    const UT_Vector4Array                &trimPoints () const 
                                                { return myPatches->myPoints; }
    const UT_Vector3Array                &trimNormals () const 
                                                { return myPatches->myNormals;}
    const UT_RefArray<GB_AttributeData>  &trimAttribs() const 
                                                { return myPatches->myAttribs;}

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;
    UT_Vector4Array                      theTrimPoints;
    UT_Vector3Array                      theNormals;
    GU_AttribCache                       theAttribs;
    GU_CacheMode                         theMode;
    GU_TPTrimSurfCache                  *myPatches;

    int          theUMin, theUMax;              // U knot indices
    int          theVMin, theVMax;              // U knot indices
    int          theUSpans, theVSpans;          // U and V spans (bkpoints-1)
    int          theUBreakIdx, theVBreakIdx;    // cached start breakpoints
    int          theCdOffset, theTxtOffset;     // pt color & textture offsets
    int          theAlphaOffset;                // alpha offset
    int          theAttribSize;
    int          theAttribDict;

    // Resize the attribute data and the attribute list (if necessary):
    void         resizeAttributes(GEO_Detail *gdp, int ptattrib = 1);

    // Fill the array of float offsets based on what attributes are set.
    void         buildFloatOffsets(void);

    // Evaluate the surface because we know it's dirty. Return 0 if OK.
    int          evaluateSurface(GEO_TPSurf *surf);

    // Evaluate the normals of the whole evaluated surface.
    void         evaluateNormals(GEO_TPSurf *surf);
};

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

    void         surface(GEO_TPSurf *surf)      { theTPSurf = surf; }
    GEO_TPSurf  *surface(void) const            { return theTPSurf; }

private:
    GEO_TPSurf  *theTPSurf;
};

#endif

---