GR_VolumeVK.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_VolumeVK.h ( GR Library, C++)
 *
 * COMMENTS:
  *     Volume rendering in VK.
 */
#ifndef GR_VolumeVK_h
#define GR_VolumeVK_h

#include "GR_API.h"
#include "GR_GeoRenderVK.h"
#include "GR_VolumeRender.h"

#include <RV/RV_Geometry.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Lock.h>
#include <UT/UT_Array.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Vector3.h>
#include <GU/GU_Detail.h>
#include <GEO/GEO_PrimVolume.h>

struct gr_VolumeAngleVector;

class GR_VolumeSlice;
class GR_VolumeBase;
class GU_PrimVolume;
class RV_Geometry;
class RV_Render;
class RV_ShaderVariableSet;
class RV_ShaderBlock;
class UT_Color;

class GR_API GR_VolumeVK : public GR_GeoRenderVK
{
public:
             GR_VolumeVK(GR_Primitive *prim);
            ~GR_VolumeVK() override;

    const char         *className() const override { return "GR_VolumeVK"; }
    
    void                update(RE_RenderContext rc,
                               const GT_PrimitiveHandle &primh,
                               const GR_UpdateParms     &parms,
                               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 rc,
                             GR_RenderMode mode,
                             GR_RenderFlags flags,
                             GR_DrawParms dp) override;
    
    exint               getNumGLPrimitives() const override;

    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; }
    const UT_Array<GR_VolumeSlice *> &slices() const { return myGLVolumeSlices; }

    static RV_VKImage*  get3DNoise(RV_Render* r);         
    static RV_VKImage*  get2DNoise(RV_Render* r);
    static RV_VKImage*  getBSplineWeights(RV_Render* r);
    
    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; }

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

    static void         cleanupSlices();
    static bool         initShaders(RV_Instance* inst);
    static void         initResources(RV_Render* r);
    static void         cleanupShaders();
    static void         cleanupResources();
    
    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);


    // Expose Shaders so `GR_VolumeRender` can use them
    static RV_ShaderProgram* getVolumeSliceShader(RV_Render *r, bool bspline);
    static RV_ShaderProgram* getVolumeSliceShaderHQ(RV_Render *r, bool bspline);
    static RV_ShaderProgram* getVolumeMaterialShader(RV_Render *r, bool bspline);
    static RV_ShaderProgram* getVolumeNormalShader(RV_Render *r, bool bspline);
    static RV_ShaderProgram* getVolumeMotionShader(RV_Render *r, bool bspline);
private:
    bool                updateVolume( 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);


    /// draw setup down outside Render Pass
    void                drawSlices(RV_Render *r,
                                   GR_Uniforms* uniforms,
                                   UT_Array<GR_VolumeSlice *> *slices,
                                   bool draw_normals,
                                   GR_RenderMode render_mode,
                                   const GR_DisplayOption *opt);

    // draw commands executed inside a Render Pass
    void                renderSlices(RV_Render *r,
                                   UT_Array<GR_VolumeSlice *> *slices,
                                   const UT_IntArray &selected,
                                   const UT_Array<GR_TextureRef> &textures,
                                   const UT_IntArray &draw_count,
                                   const UT_FloatArray &zincs,
                                   const UT_FloatArray &depth,
                                   float astep,
                                   bool show_selection,
                                   bool use_transparent,
                                   bool draw_normals);

    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 = false;
    bool                myDrawNormals = false;
    bool                myIsSelected = false;
    
    static int          theVolumePassID;
    
    UT_Array<GR_VolumeSlice *> myGLVolumeSlices;
    UT_Array<GR_VolumeSlice *> myCachedSlices;
    static RV_ShaderProgram* theVolumeSliceShader;
    static RV_ShaderProgram* theVolumeSliceShaderMaterial;
    static RV_ShaderProgram* theVolumeSliceNormalShader;
    static RV_ShaderProgram* theVolumeSliceMVShader;

    UT_UniquePtr<RV_ShaderBlock>        myVolumeUniforms;
    UT_UniquePtr<RV_ShaderVariableSet>  myVolumeSet;

    friend struct gr_SliceDrawTask;
    friend class  GR_VolumeRender;
};

#endif