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 <RE/RE_ShaderHandle.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 RE_OGLTexture;
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_VolumeBase* base);
            ~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;
    
    static bool         initShaders(RV_Instance* inst);
    static void         initResources(RV_Render* r);
    static void         cleanupShaders();
    static void         cleanupResources();

    // 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);

    static RV_VKImage*  get3DNoise(RV_Render* r);         
    static RV_VKImage*  get2DNoise(RV_Render* r);
    static RV_VKImage*  getBSplineWeights(RV_Render* r);
private:

    /// 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 RV_ShaderProgram* theVolumeSliceShader;
    static RV_ShaderProgram* theVolumeSliceShaderMaterial;
    static RV_ShaderProgram* theVolumeSliceNormalShader;
    static RV_ShaderProgram* theVolumeSliceMVShader;

    GR_VolumeBase*  myVolume;

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

    friend struct gr_SliceDrawTask;
    friend class  GR_VolumeRender;
};

#endif