GT_PrimVolume.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.
 *
 * NAME:        GT_PrimVolume.h ( GT Library, C++)
 *
 * COMMENTS:
 */
#ifndef GT_PrimVolume_h
#define GT_PrimVolume_h

#include "GT_API.h"
#include "GT_Primitive.h"
#include "GT_GEOPrimCollect.h"
#include "GT_AttributeList.h"
#include <GEO/GEO_PrimVolume.h>
#include <GU/GU_DetailHandle.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_VoxelArray.h>


class GEO_Primitive;
class GU_PrimVolumeCache;
class GU_PrimVolumeCacheParms;

enum GT_PrimVolumeRampMode
{
    RAMP_TYPE_NORAMP,
    RAMP_TYPE_CLAMPED,
    RAMP_TYPE_PERIODIC
};

/// Viewport visualization info for a volume.
struct GT_PrimVolumeVisualization
{
    const GEO_Primitive*        densityPrim;
    float                       densityScale;
    float                       shadowScale;
    float                       extinctionRatio;
    int                         scatteringIterations;
    float                       densityRange[2];
    UT_Ramp                     densityRamp;
    GT_PrimVolumeRampMode       densityRampType;

    float                       ambientShadows;
    float                       ambientMapSize;
    float                       ambientStepRate;
    UT_Vector3                  ambientExposed;
    UT_Vector3                  ambientOccluded;
    UT_Vector3                  shadowColor;

    const GEO_Primitive*        diffusePrim[3];
    float                       diffuseRange[2];
    UT_Ramp                     diffuseRamp;
    GT_PrimVolumeRampMode       diffuseRampType;
    UT_Vector3                  diffuseTint;

    const GEO_Primitive*        emissionPrim;
    float                       emissionScale;
    float                       emissionRange[2];
    UT_Ramp                     emissionRamp;
    GT_PrimVolumeRampMode       emissionRampType;

    const GEO_Primitive*        emissionColorPrim[3];
    float                       emissionColorRange[2];
    UT_Ramp                     emissionColorRamp;
    GT_PrimVolumeRampMode       emissionColorRampType;

    int                         maxVisResolution;
};

class GT_API GT_PrimVolume : public GT_Primitive
{
public:
    GT_PrimVolume(const GU_ConstDetailHandle &gdh,
                  const GEO_Primitive *prim,
                  const GT_DataArrayHandle &mat_id);
    GT_PrimVolume(const GT_PrimVolume &src);
    ~GT_PrimVolume() override;

    void getVisData(GT_PrimVolumeVisualization& v) const;
    int getTileCoords(UT_Vector3FArray& coords, UT_Int16Array& masks) const;

    /// Returns true if the geometry primitive's parent detail has the "gl_wireframe"
    /// attribute set.
    bool drawWireframe() const;

    /// Returns true if the motion vectors are to be drawn for this volume set.
    bool drawMotionVectors() const;
    bool drawNormals() const;

    int                 getPrimitiveType() const override
                            { return GT_PRIM_VOXEL_VOLUME; }

    const char         *className() const override { return "GT_PrimVolume"; }
    
    void                enlargeBounds(UT_BoundingBox boxes[],
                                      int nsegments) const override;
    int                 getMotionSegments() const override { return 1; }
    int64               getMemoryUsage() const override;
    GT_PrimitiveHandle  doSoftCopy() const override
                                    { return new GT_PrimVolume(*this); }

    bool                refine(GT_Refine &refiner,
                               const GT_RefineParms *parms) const override;
    bool                refineHeightField(GT_Refine &refiner,
                               const GT_RefineParms *parms) const;

    // Isosurface
    bool                isIsosurface() const;
    GT_PrimitiveHandle  buildIsosurface(const GT_RefineParms &p,
                                        bool as_points) const;
    GU_ConstDetailHandle        getIsosurfaceDetail() const;
    UT_Vector3          getIsoCd() const;

    // Height fields
    bool                isHeightField() const;
    GT_PrimitiveHandle  buildHeightField(const GT_RefineParms &p) const;
    
    class CacheMeshData
    {
    public:
        CacheMeshData() : myMeshSize(0,0),
                          myMeshP0(0,0,0), myMeshP1(0,0,0),
                          myMeshP2(0,0,0), myMeshP3(0,0,0), 
                          myMeshN0(0,0,0), myMeshN1(0,0,0),
                          myMeshN2(0,0,0), myMeshN3(0,0,0)
            {}
        UT_Vector2i                     myMeshSize;
        UT_Vector3F                     myMeshP0;
        UT_Vector3F                     myMeshP1;
        UT_Vector3F                     myMeshP2;
        UT_Vector3F                     myMeshP3;
        UT_Vector3F                     myMeshN0;
        UT_Vector3F                     myMeshN1;
        UT_Vector3F                     myMeshN2;
        UT_Vector3F                     myMeshN3;
    };
    void                buildHeightMesh(const GT_RefineParms &p,
                                        GT_PrimitiveHandle &mesh,
                                        CacheMeshData &cdata,
                                        UT_Vector2i &map_res,
                                        bool use_quads) const;
    enum gt_BlendMask
    {
        BlendNone,
        BlendMissingMask,
        BlendMask,
    };
    gt_BlendMask        blendMaskState(int index) const;

    // 2D/3D volume
    bool                isSmokeVolume() const;
    bool                is3DVolume() const;
    bool                isImage() const;
    GEO_PrimVolumeXform getVolumeSpace() const;

    GEO_VolumeBorder    getBorder() const;
    fpreal              getVisTiles() const;

    /// Returns true if this volume stores integer data.
    bool                getStoresIntegers() const;
    /// Returns the number of components in a native Houdini volume. Returns -1
    /// for VDBs.
    int                 getTupleSize() const;
    UT_Vector3I         getRes() const;

    /// If remove_padding is true, half a voxel is deleted from each side of the
    /// bound.
    void                get2DBounds(UT_Vector3F &p0, UT_Vector3F &p1,
                                    UT_Vector3F &p2, UT_Vector3F &p3,
                                    bool remove_padding = false) const;
    void                get2DNormals(UT_Vector3F &n0, UT_Vector3F &n1,
                                    UT_Vector3F &n2, UT_Vector3F &n3) const;
                                    
    const UT_VoxelArray<UT_Vector4> *getVoxels(const GU_PrimVolumeCacheParms &p,
                                               int64 version[2]) const;

    GEO_PrimVolumeXform getVolumeTransform() const;
    GEO_PrimVolumeXform getVolumeIndexTransform() const;
    GT_PrimitiveHandle  getPointPrimitive();
    const GEO_Primitive *getGeoPrimitive() const
                            { return getPrimitive(); }
    const GU_ConstDetailHandle &getDetail() const { return myDetail; }

    exint                getNumVolumeAttributes() const
                                { return myVolumeAttributes.entries(); }
    const GEO_Primitive *getVolumeAttribute(exint i) const
                                { return myVolumeAttributes(i); }
    void                 appendVolumeAttribute(const GEO_Primitive *prim)
                                { myVolumeAttributes.append(prim); }

    /// Set the list of uniform attributes.
    void setUniformAttributes(const GT_AttributeListHandle &uniform)
    {
        myUniformList = uniform;
    }

    const GT_AttributeListHandle        &getUniformAttributes() const override
                                            { return myUniformList; }
    bool                updateGeoPrim(const GU_ConstDetailHandle &dtl,
                                      const GT_RefineParms &refine) override;

    bool                getFlip() const { return myFlip; }
    bool                isVolumeReduced() const { return myVolumeReduced; }
    void        flagVolumeReduced() const { myVolumeReduced = true; }

private:
    const GEO_Primitive *getPrimitive() const;
    
    GU_PrimVolumeCache          *myCache;
    GT_AttributeListHandle       myUniformList;

    // Is either VDB or Volume.
    GU_ConstDetailHandle                myDetail;
    GA_Offset                           myPrimOffset;
    int                     myCollationIndex;
    UT_Array<const GEO_Primitive *>     myVolumeAttributes;
    mutable int64                       myCacheVersion[2];
    mutable bool                        myIsosurfaceFlag = false;
    mutable bool                        mySmokeVolumeFlag = false;
    mutable bool                        myHeightFieldFlag = false;
    mutable bool                        myIs3DVolume = true;
    mutable bool                        myIsImageVolume = false;
    mutable bool                        myFlip = false;
    mutable UT_Array<gt_BlendMask>      myBlendMaskState;
    mutable bool                        myVolumeReduced = false;
    static  int64                       theMeshDataID;
    static  int64                       theMeshTopID;
};
 
/// Trivial collector class for Volume - 1 GT_PrimVolume per Volume primitive
/// with the visualization set to 'volume'.
class GT_API GT_GEOPrimCollectVolume: public GT_GEOPrimCollect
{
public:
                    GT_GEOPrimCollectVolume() {}
                   ~GT_GEOPrimCollectVolume() override {}

    GT_GEOPrimCollectData *
                beginCollecting(const GT_GEODetailListHandle &geometry,
                                const GT_RefineParms *parms) const override;

    GT_PrimitiveHandle         collect(const GT_GEODetailListHandle &,
                                       const GEO_Primitive *const* prim_list,
                                       int,
                                       GT_GEOPrimCollectData *) const override;

    GT_PrimitiveHandle
                endCollecting(const GT_GEODetailListHandle &geometry,
                                GT_GEOPrimCollectData *data) const override;
};

#endif