GR_VolumeRender.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_VolumeRender.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Global Volume slice renderer. Slices are acculated then sorted and drawn.
 */
#ifndef GR_VolumeRender_h
#define GR_VolumeRender_h

#include <UT/UT_Array.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_UniquePtr.h>

#include "GR_API.h"
#include "GR_Defines.h"
#include "GR_TextureRef.h"

class GR_CommonDispOption;
class GR_VolumeSlice;
class GR_Uniforms;
class RV_Geometry;
class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderVariableSet;

class GR_API GR_VolumeRender
{
public:
    static GR_VolumeRender *get(int idx = 0);

    static int getMaxVolumeSlices();

    // Normal volumes
    void   addSlices(const UT_Array<GR_VolumeSlice*> &new_slices);

    // volumetric fog
    void   addFogSlice(fpreal depth, fpreal slice);
    void   setFogTexture(GR_TextureRef fog, fpreal opacity)
           {
               myFogVolume = fog;
               myFogOpacity = opacity;
           }
    void   setFogShader(RV_ShaderProgram* sh)
           {
               myFogShader = sh;
           }
    void   setFogRange(const UT_Vector2D &range) { myFogRange = range; }

    bool   hasSlices() const { return mySlices.entries() > 0; }

    void   clearSlices();

    // Draw all elements and reset
    void   draw(RV_Render *r,
                GR_Uniforms* u,
                const GR_CommonDispOption *opt,
                bool hq_lighting,
                bool has_fog,
                bool show_selection);
    
    void destroyResources();
private:
     GR_VolumeRender();
    ~GR_VolumeRender();

    UT_Array<GR_VolumeSlice *> mySlices;
    UT_Array<GR_VolumeSlice *> myFogSlices;
    UT_Array<GR_VolumeSlice *> myFreeFogSlices;

    // Temporary per draw but cached to avoid reallocs
    UT_Array<GR_VolumeSlice *> myReducedSlices;
    UT_Vector3FArray myPosData;
    UT_Vector3FArray myTexData;
    UT_IntArray myDrawMode;
    UT_Array<GR_TextureRef> myTextures;
    UT_IntArray myDrawCount;
    UT_FloatArray myZInc;
    UT_FloatArray myDepth;
    UT_ValArray<UT_SharedPtr<UT_Matrix3D>> myObjectMatrices;
    GR_TextureRef myFogVolume;
    fpreal myFogOpacity;
    UT_Vector2D myFogRange;

    // Vulkan resource ptrs
    UT_UniquePtr<RV_Geometry>           myGeoVK;
    UT_UniquePtr<RV_Geometry>           myFullscreenGeoVK;
    UT_Array<UT_UniquePtr<RV_ShaderVariableSet>>  myVolumeSet;
    
    UT_UniquePtr<RV_ShaderVariableSet>  myObjSet;
    UT_UniquePtr<RV_ShaderBlock>        myObjUniforms;

    UT_UniquePtr<RV_ShaderVariableSet>  myFogSet;
    UT_UniquePtr<RV_ShaderVariableSet>  myFogObjSet;
    RV_ShaderProgram*                   myFogShader = nullptr;
};

class GR_VolumeSlice : public UT_NonCopyable
{
public:
    // True volume
    GR_VolumeSlice(const UT_Vector3Array &points,
                   const UT_Vector3Array &texcoords,
                   GR_TextureRef volume,
                   bool selected,
                   bool motion,
                   bool normal,
                   fpreal32 zinc)
    : myPoints(points), myTexcoords(texcoords), mySelectValue(selected?1:0),
      myVolume(volume), myZInc(zinc), myIsFog(false),
      myDepth(0.0), myMotionFlag(motion), myNormalFlag(normal)
        { }
    // Fog
    GR_VolumeSlice(fpreal depth, fpreal slice)
        : myVolume(nullptr), myZInc(slice), myIsFog(true), myDepth(depth)
        { }
 
    void setDepth(const UT_Matrix4D &proj);
    void setMesh(const UT_Vector3Array &points,
                 const UT_Vector3Array &texcoords);
    void setVolume(GR_TextureRef vol_tex) { myVolume = vol_tex; }
    void setInc(fpreal32 i) { myZInc = i; }
    void setFlags(int select, bool motion, bool normal)
        {
            mySelectValue = select;
            myMotionFlag = motion;
            myNormalFlag = normal;
        }

    void setObjectXform(const UT_SharedPtr<UT_Matrix3D>& object)
    {
        myObjectMatrix = object;
    }

    void     setFog(fpreal depth, fpreal slice)
        {
            myDepth = depth;
            myZInc = slice;
        }
    fpreal32 depth() const { return myDepth; }
    int      triCount() const { return myPoints.entries()/3; }
    
    void createSlice(UT_Vector3FArray &pos,
                     UT_Vector3FArray &texcoord,
                     UT_IntArray      &draw_mode,
                     UT_Array<GR_TextureRef> &tex,
                     UT_IntArray      &draw_count,
                     UT_FloatArray    &zincs,
                     UT_FloatArray    &depth,
                     bool show_selection,
                     UT_ValArray<UT_SharedPtr<UT_Matrix3D>> *obj_mats = nullptr)
        const;

private:

    GR_TextureRef    myVolume;
    UT_Vector3FArray myPoints;
    UT_Vector3FArray myTexcoords;
    int              mySelectValue;
    fpreal32         myZInc;
    fpreal32         myDepth;
    unsigned         myIsFog:1,
                     myNormalFlag:1,
                     myMotionFlag:1;

    UT_SharedPtr<UT_Matrix3D>       myObjectMatrix;
};

#endif