GR_VolumeGL3.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:        GR_VolumeGL3.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Volume rendering in GL3.
 */
#ifndef GR_VolumeGL3_h
#define GR_VolumeGL3_h

class UT_Color;
class RE_OGLTexture;
class GU_PrimVolume;
struct gr_VolumeAngleVector;
class GR_VolumeSlice;

#include "GR_GeoRenderGL.h"

#include <RE/RE_Geometry.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Lock.h>
#include <UT/UT_Array.h>
#include <UT/UT_Vector3.h>
#include <GU/GU_Detail.h>
#include <GEO/GEO_PrimVolume.h>

#include "GR_TextureRef.h" // for GR_TextureRef

// Base class for volume slice rendering
// Creates a set of slices with individual properties
// and assigned texture, based on the volume bounds
class GR_VolumeBase
{
public:
             GR_VolumeBase();
            ~GR_VolumeBase();


    void                setTexture(GR_TextureRef tex);

    void                updateTexture(GR_TextureRef tex);
    void                clearTexture();
    const GR_TextureRef &getTexture() const { return myVolumeTexture; }

    UT_Array<GR_VolumeSlice *> &slices() { return myGLVolumeSlices; }

    static void         cleanupSlices();
    
    void                setDrawMotionVectors(bool v) { myDrawMotionVectors = v; }
    bool                getDrawMotionVectors() const 
                                { return myDrawMotionVectors; }

    void                setDrawNormals(bool v) { myDrawNormals = v; } 
    bool                getDrawNormals() const { return myDrawNormals; }

    void                setIsSelected(bool v) { myIsSelected = v; } 
    bool                getIsSelected() const { return myIsSelected; }


    static float        getCutoff(int x, int y, int z);
    static void         fillBSplineData(const UT_Span<fpreal32> &out_values);
    static bool         useBSplineInterpolation(const GR_CommonDispOption& opt);

    bool                update( const GT_PrimitiveHandle &primh,
                                const GR_UpdateParms     &p);
    void                setInstanceTransforms(const UT_Matrix4DArray& inst);
    bool                updateViewAligned(UT_Matrix4D &proj,
                                          UT_Matrix4D &view,
                                          UT_Matrix4D &object,
                                          const GR_DisplayOption &drawOpt);

    const UT_Matrix4DArray& getInstanceTransforms() const { return myInstanceTransforms; }

private:

    static void         sliceCube(void *data, int idx, int num, UT_Lock &lock);
    static void barycenterTriangulateConvexPoly(const UT_Vector3Array &points,
                                                float tolerance2,
                                                UT_Vector3Array *out_points,
                                                int total_depth=1, int d=0);
    static void         sortPolygonCCW(gr_VolumeAngleVector *points, int n);
    static UT_Vector3   pointAverage(const UT_Vector3Array &points);
    static void         triangulate(const UT_Vector3Array &points,
                                    float tolerance2,
                                    UT_Vector3Array *out_points,
                                    int total_depth=-1, int d=0);

    static constexpr int getMaxVolumeSilces();

    bool                instanceSlices(UT_Matrix4D &proj,
                                       UT_Matrix4D &view, UT_Matrix4D &object,
                                       fpreal zinc);

    void                clearSlices(bool free);

    GU_Detail           myBox;
    GEO_PrimVolumeXform myVolumeSpace;
    UT_Vector3I         myVolumeRes;
    UT_BoundingBox      myVolumeBounds;
    GR_TextureRef       myVolumeTexture;
    UT_Matrix4DArray    myInstanceTransforms;
    bool                myDrawMotionVectors;
    bool                myDrawNormals;
    bool                myIsSelected;
    
    static int          theVolumePassID;
    
    UT_Array<GR_VolumeSlice *> myGLVolumeSlices;
    UT_Array<GR_VolumeSlice *> myCachedSlices;
 };


// Class for rendering volume slices in GL3, using slices generated by GR_VolumeBase
class GR_VolumeGL3 : public GR_GeoRenderGL
{
public:
             GR_VolumeGL3(GR_Primitive *prim, GR_VolumeBase* base);
            ~GR_VolumeGL3() override;

    const char         *className() const override { return "GR_VolumeGL3"; }
    
    void                update(RE_RenderContext r,
                               const GT_PrimitiveHandle &primh,
                               const GR_UpdateParms     &p,
                               const char               *cache_name) override;

    void                viewUpdate(RE_RenderContext r,
                                   const GR_DisplayOption &opts,
                                   const char *cache_name,
                                   RE_CacheVersion geo_version,
                                   RE_CacheVersion select_version) override;
    void                draw(RE_RenderContext r,
                             GR_RenderMode mode,
                             GR_RenderFlags flags,
                             GR_DrawParms dp) override;

    exint               getNumGLPrimitives() const override;

    static RE_Texture  *getBSplineWeights(RE_Render *r);

private:
    void                drawSlices(RE_Render *r,
                                   UT_Array<GR_VolumeSlice *> *slices,
                                   bool draw_normals,
                                   GR_RenderMode render_mode,
                                   const GR_DisplayOption *opt);

    GR_VolumeBase*  myVolume;
};

#endif