GR_Uniforms.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_Uniforms.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Uniform parameters for rendering GR_GeoRenders
 */
#ifndef GR_Uniforms_h
#define GR_Uniforms_h

#include "GR_API.h"

#include "GR_Defines.h"
#include "GR_DisplayOption.h"
#include "GR_TextureRef.h"

#include <GU/GU_SelectType.h>
#include <GT/GT_RefineParms.h>
#include <GU/GU_DetailHandle.h>

#include <RE/RE_Render.h>
#include <RE/RE_RenderContext.h>
#include <RE/RE_Material.h>
#include <RE/RE_CachedObject.h>
#include <RE/RE_OGLFramebuffer.h>

#include <UT/UT_Matrix4.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Map.h>

class GR_MaterialGroups;

class OP_Node;

class RE_Render;

class RV_Instance;
class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderProgramBase;
class RV_ShaderVariableSet;
class RV_VKBuffer;
class RV_VKImage;

// helper macro: check value before setting var, which also sets dirty flag
#define SET_GLOBAL(name, v) \
    if (((const GR_Uniforms*)this)->globals().name != (v)) \
        { globals().name = (v); } \
// end SET_GLOBAL

/// set of parameters sent to GR_Primitive::update()
class GR_API GR_Uniforms
{
public:
    GR_Uniforms(RE_Render* r);
    GR_Uniforms();
    ~GR_Uniforms();

    void copyUniforms(const GR_Uniforms* other)
    {
        UT_ASSERT(other);
        objects() = other->objects();
        globals() = other->globals();
    }
    exint pushObjectUniforms();
    void popObjectUniforms(exint l=-1);

    // ~~~~~~~~~~~~~~~~
    // RE Helpers 

    // Init by copying values from RE_
    // TODO: assign to rational defaults, or taken from DisplaySettings
    //       like in DM_VPortAgent::setupViewUniforms
    void init(RE_RenderContext rc);

    // Helpers for pushing our CPU options int RE_
    void pushToRE(RE_Render* r);
    void popFromRE(RE_Render* r);
    void assignRE(RE_Render* r);

    // ~~~~~~~~~~~~~~~~~
    // RV Helpers 
    void assignRVBlock(
            RV_Render *r,
            RV_ShaderBlock *block,
            const RV_ShaderProgram *opt_shr) const;
    
    void assignRVBindings(
        RV_Render* r,
        RV_ShaderVariableSet* set,
        const RV_ShaderProgram* opt_shr) const;

    void assignRVGlobalBlock(RV_Render *r, RV_ShaderBlock *block) const;
    bool bindRVGlobalBlock(RV_Render *r, const RV_ShaderProgramBase *shader);

    // ~~~~~~~~~~~~~~~~~~~
    // Object Vars 

    // Values that are expected to change for each object rendered
    // Can be pushed/popped

    // Object Matrix
    void setObjModelMatrix(const UT_Matrix4D &v, const UT_Matrix4D *inv = nullptr)
    {
        objects().myModel = v;

        // setup dependent matrices
        if (inv)
        {
            objects().myInvModel = *inv;
        }
        else
        {
            objects().myInvModel = objects().myModel;
            objects().myInvModel.invert();
        }

        // ensure it's const, so it doesn't trigger update
        const GlobalUniforms& global_var = ((const GR_Uniforms*)this)->globals(); 

        objects().myModelView = objects().myModel * global_var.myView;

        objects().myModelF = objects().myModel;
        objects().myInvModelF = objects().myInvModel;
        objects().myModelViewF = objects().myModelView;
    }
    const UT_Matrix4D &getObjModelMatrix() const { return objects().myModel; }
    const UT_Matrix4D &getObjInvModelMatrix() const { return objects().myModel; }
    const UT_Matrix3D &getObjNormalMatrix() const { return globals().myNormalMat; }
    const UT_Matrix4D &getObjModelViewMatrix() const { return objects().myModelView; }

    void setViewMatrix(const UT_Matrix4D &v)
    {
        globals().myView = v;

        // setup dependent matrices
        globals().myInvView = globals().myView;
        globals().myInvView.invert();

        globals().myNormalMat = globals().myView;
        globals().myNormalMat.invert();
        globals().myNormalMat.transpose();

        globals().myViewF = globals().myView;
        globals().myInvViewF = globals().myInvView;
        globals().myNormalMatF = globals().myNormalMat;
        globals().myNormalMatFr1 = globals().myNormalMat[0];
        globals().myNormalMatFr2 = globals().myNormalMat[1];
        globals().myNormalMatFr3 = globals().myNormalMat[2];
        
        objects().myModelView = globals().myView * objects().myModel;
        objects().myModelViewF = objects().myModelView;
    }
    const UT_Matrix4D &getViewMatrix() const { return globals().myView; } 
    const UT_Matrix4D &getInvViewMatrix() const { return globals().myInvView; } 
    const UT_Matrix3D &getNormalMatrix() const { return globals().myNormalMat; } 

    // correct controls whether to apply OpenGL to Vulkan correction, to
    // account for different coordinate spaces
    void setProjectMatrix(const UT_Matrix4D &v, bool correct = true, bool is_ortho = false)
    {
        globals().myProjection = v;

        // setup dependent matrices
        globals().myInvProjection = globals().myProjection;
        globals().myInvProjection.invert();

        // NOTE: NDC space in Vulkan has a z-range of [0, 1] instead of [-1, 1] 
        //       and a downward-facing y-direction. appending transform after
        //       projection matrix to correct for these
        if(correct)
        {
            UT_Matrix4F correction(1.0f,  0.0f, 0.0f, 0.0f,
                                   0.0f,  1.0f, 0.0f, 0.0f,
                                   0.0f,  0.0f, 0.5f, 0.0f,
                                   0.0f,  0.0f, 0.5f, 1.0f);
            globals().myProjectionF =
                UT_Matrix4F(globals().myProjection) * correction;
        }
        else
            globals().myProjectionF = UT_Matrix4F(globals().myProjection);
        globals().myInvProjectionF = globals().myProjectionF;
        globals().myInvProjectionF.invert();
        globals().myIsOrtho = is_ortho;
    }
    void  useVulkanProjection(bool use_vk) { myUseVulkanProjection=use_vk; }
    bool  getUseVulkanProjection() const { return myUseVulkanProjection; }
    const UT_Matrix4D &getProjectionMatrix() const { return globals().myProjection; } 
    const UT_Matrix4F &getVKProjectionMatrix() const { return globals().myProjectionF; } 
    const UT_Matrix4D &getInvProjectionMatrix() const { return globals().myInvProjection; }
    bool  getIsOrtho() const { return globals().myIsOrtho; }

    void setDepthRange(const UT_Vector2F &r) { SET_GLOBAL(myDepthRange, r); }
    void setDepthProject(const UT_Vector2F &p) { SET_GLOBAL(myDepthProject, p); }
    const UT_Vector2F &getDepthProject() const { return globals().myDepthProject; }

    void    setShadowmapIndex(const int32 index) { SET_GLOBAL(myShadowmapIndex, index); }
    int32   getShadowmapIndex() const { return globals().myShadowmapIndex; }

        // These are technically Vector3s, but GLSL expects Vector3s to be 4-byte
        // aligned, so we add one more float for the C++ alignment to match the
        // GLSL alignment.
    typedef UT_FixedArray<UT_Vector4, 4> CSMRegionInvExts;
    void    setCSMRegionInvExts(const CSMRegionInvExts &e) { SET_GLOBAL(myCSMRegionInvExts, e); }
    const CSMRegionInvExts &getCSMRegionInvExts() const { return globals().myCSMRegionInvExts; }

    typedef UT_FixedArray<UT_Vector4, 4> CSMRegionOffsets;
    void    setCSMRegionOffsets(const CSMRegionInvExts &e) { SET_GLOBAL(myCSMRegionOffsets, e); }
    const CSMRegionInvExts &getCSMRegionOffsets() const { return globals().myCSMRegionOffsets; }

    void    setObjWireColor(const UT_Vector4 &v) { objects().myWireColor = v; }
    const UT_Vector4 &getObjWireColor() const { return objects().myWireColor; }

    void    setObjWireframeColor(const UT_Vector4 &v) { objects().myWireframeColor = v; }
    const UT_Vector4 &getObjWireframeColor() const { return objects().myWireframeColor; }

    void    setObjWireThickness(const float &v) { objects().myWireThickness = v; }
    float   getObjWireThickness() const { return objects().myWireThickness; }

    void    setObjConstColor(const UT_Vector4 &v) { objects().myConstColor = v; }
    const UT_Vector4 &getObjConstColor() const { return objects().myConstColor; }

    void    setObjConstColorMap(GR_TextureRef v)
                {
                    objects().myConstColorMap = v;
                    objects().myConstColorEnableVK = v.isVulkan();
                    objects().myConstColorEnableGL = v.isGL();
                }

    void    setObjEmission(const UT_Vector4F &c)
                {
                    objects().myEmitColor = c;
                }
    void    setObjGhosting(const UT_Vector4 &v, float gfact=0.5) 
    { 
        objects().myGhostColor = v;
        objects().myGhostFactor = gfact;
        objects().myHasGhosting = true;
    }
    const UT_Vector4 &getObjGhostColor() const { return objects().myGhostColor; }
    float   getObjGhostFactor() const { return objects().myGhostFactor; }

    void    setObjBackfaceTint(const UT_Vector3 &v, float gfact=0.5) 
    { 
        objects().myBackfaceColor = UT_Vector4(v, gfact);
        objects().myHasBackfaceTint = true;
    }
    const UT_Vector4 &getObjBackfaceColor() const { return objects().myBackfaceColor; }
    float   getObjBackfaceFactor() const { return objects().myBackfaceColor[3]; }

    void    setObjSelectColor(const UT_Vector4 &v) { objects().mySelectColor = v; }
    const UT_Vector4 &getObjSelectColor() const { return objects().mySelectColor; }

    void    setObjSelectSecondaryColor(const UT_Vector4 &v) { objects().mySelectSecondaryColor = v; }
    const UT_Vector4 &getObjSelectSecondaryColor() const { return objects().mySelectSecondaryColor; }

    void    setObjSelectMode(int v) { objects().mySelectMode = v; }
    int     getObjSelectMode() const { return objects().mySelectMode; }

    void    setObjSelectType(int v) { objects().mySelectType = v; }
    int     getObjSelectType() const { return objects().mySelectType; }

    void    setObjSelectInstance(int v) { objects().mySelectInstance = v; }
    int     getObjSelectInstance() const { return objects().mySelectInstance; }

    void    setObjFillSelection(int v) { objects().myFillSelection = v; }
    int     getObjFillSelection() const { return objects().myFillSelection; }

    void    setObjPrimConstandID(int v) { objects().myPrimConstantID = v; }
    int     getObjPrimConstandID() const { return objects().myPrimConstantID; }

    void    setObjDecorationScale(float v) { objects().myDecorationScale = v; }
    float   getObjDecorationScale() const { return objects().myDecorationScale; }

    void        setObjPickBaseID(const UT_Vector3i &v)
                { objects().myPickBaseID = v; }
    UT_Vector3i getObjPickBaseID() const
                { return objects().myPickBaseID; }
    
    void        setObjPickComponentID(const UT_Vector3i &v)
                { objects().myPickComponentID = v; }
    UT_Vector3i getObjPickComponentID() const
                { return objects().myPickComponentID; }

    void        setObjColorRamp(GR_TextureRef v, UT_Vector2F range = UT_Vector2F())
                {
                    objects().myColorRamp = v;
                    objects().myColorRampEnableVK = v.isVulkan();
                    objects().myColorRampEnableGL = v.isGL();

                    objects().myColorRange = range;
                }

    void        setObjColorIgnoreGeo(bool v)
                { 
                    objects().myColorIgnoreGeo = v;
                }
    bool        getObjColorIgnoreGeo() const
                { 
                    return objects().myColorIgnoreGeo;
                }

                // Use -1 flag to force use of geo color, ignoring
                // any per-material geo color disable
    void        setObjColorForceUseGeo()
                { 
                    objects().myColorIgnoreGeo = -1;
                }

    void        setObjColorTransform(int32 mode, UT_Vector3F ref = UT_Vector3F())
                {
                    objects().myColorTransformMode = mode;
                    objects().myColorTransformRef = ref;
                }

    void        setObjUseInstancePrimId(int32 v)
                {
                    objects().myUseInstancePrimId = v;
                }

    void        setObjMaxLocatedID(exint v)
                { objects().myMaxLocatedId = v; }

    exint       getObjMaxLocatedID() const
                { return objects().myMaxLocatedId; }

    void        setObjMinLocatedID(exint v)
                { objects().myMinLocatedId = v; }

    exint       getObjMinLocatedID() const
                { return objects().myMinLocatedId; }


    void        setObjLocatedBuffer(RV_VKBuffer* buf)
                {
                    objects().myLocatedBufVK = buf;
                    objects().myUseLocatedBufVK = buf ? 1 : 0;
                }

    void        setObjLocatedBuffer(RE_Texture* buf)
                {
                    UT_ASSERT(!buf || buf->getTextureType() == RE_TEXTURE_BUFFER);
                    objects().myLocatedBufGL = buf;
                    objects().myUseLocatedBufGL = buf ? 1 : 0;
                }

    void        setObjLightingEnabled(int v)
                { objects().myLightingEnabled = v; }

    int         getObjLightingEnabled() const
                { return objects().myLightingEnabled; }

    void        setObjTexturesEnabled(int v)
                { objects().myTexturesEnabled = v; }

    int         getObjTexturesEnabled() const
                { return objects().myTexturesEnabled; }

    // Values which may be changed per-object
    struct ObjectUniforms
    {
        
        #define VK_BLOCK_START (offsetof(ObjectUniforms, myModelF))
        // begin VK block
        UT_Matrix4F myModelF;
        UT_Matrix4F myModelViewF;
        
        UT_Vector4F myGhostColor;
        UT_Vector4F myBackfaceColor = UT_Vector4F(0,0,0,0);
        UT_Vector4F mySelectColor;
        UT_Vector4F myWireColor;
        UT_Vector4F myConstColor;
        UT_Vector4F myEmitColor = UT_Vector4F(0,0,0,0);

        int mySelectMode = 0;
        int mySelectType = 0;
        int mySelectInstance = 0;
        int myFillSelection = 0;

        int myPrimConstantID = 0;
        int myPrimInstanceBase = 0;

        float myWireThickness;
        float myDecorationScale;

        UT_Vector2F   myColorRange;
        int32         myColorRampEnableVK = 0;
        int32         myColorIgnoreGeo = 0;
        
        UT_Vector3F   myColorTransformRef;
        int32         myColorTransformMode = 0;

        // NOTE: only used in locate highlight rendering
        int32         myUseInstancePrimId = 0;
        int32         myMaxLocatedId = 0;
        int32         myMinLocatedId = 0;
        int32         myUseLocatedBufVK = 0;

        // NOTE: only used in pick buffer rendering
        UT_Vector3i   myPickBaseID;
        int32         myPickDepthPass = 0;
        UT_Vector3i   myPickComponentID;

        int32         myConstColorEnableVK = 0;
        int32         myLightMask = 0xFFFFFFFF;
        int32         myLightingEnabled = 1;
        int32         myTexturesEnabled = 1;

        // end VK block
        #define VK_BLOCK_END (offsetof(ObjectUniforms, myTexturesEnabled )\
                              + sizeof(ObjectUniforms::myTexturesEnabled))

        // Ghosting
        float      myGhostFactor;
        bool       myHasGhosting;

        bool       myHasPrimLightMask = false;

        // Backface Tinting
        bool       myHasBackfaceTint = false;

        // Selection
        UT_Vector4 mySelectSecondaryColor;

        // Wire color
        UT_Vector4 myWireframeColor;

        // color mapping
        int32         myConstColorEnableGL = 0;
        GR_TextureRef myConstColorMap;

        // Color Transform
        int32         myColorRampEnableGL = 0;
        GR_TextureRef myColorRamp;
    
        UT_Vector3 myReflectOrigin;

        UT_Matrix4D myModel;
        UT_Matrix4D myInvModel;
        UT_Matrix4D myModelView;

        UT_Matrix4F myInvModelF;

        RV_VKBuffer*  myLocatedBufVK = nullptr;
        RE_Texture*   myLocatedBufGL = nullptr;
        int32         myUseLocatedMap = 0; // redundant
        int32         myUseLocatedBufGL = 0;
    };
    static constexpr int32 VkBlockSize = VK_BLOCK_END - VK_BLOCK_START;

    // ~~~~~~~~~~~~~
    // Global Vars 
    //
    // Values static across the whole render
    // typically may be changed between passes of different types
    // Can be set, but not push/popped

    void    setEmission(float v) { SET_GLOBAL(myEmissionFactor, v); }
    float   getEmission() const { return globals().myEmissionFactor; }

    void    setSpecular(float v) { SET_GLOBAL(mySpeculaFactor, v); }
    float   getSpecular() const { return globals().mySpeculaFactor; }

    void    setDiffuse(float v) { SET_GLOBAL(myDiffuseFactor, v); }
    float   getDiffuse() const { return globals().myDiffuseFactor; }

    void    setAmbient(float v) { SET_GLOBAL(myAmbientFactor, v); }
    float   getAmbient() const { return globals().myAmbientFactor; }

    void    setAlphaPass(int v) { SET_GLOBAL(myAlphaPass, v); }
    int     getAlphaPass() const { return globals().myAlphaPass; }

    void     setLightMask(unsigned mask) { objects().myLightMask = mask; }
    unsigned getLightMask() const        { return objects().myLightMask; }

    void     setUseHeadlight(bool use_headlight)
                { SET_GLOBAL(myUseHeadlight, (int32)use_headlight); }
    bool     useHeadlight() const { return globals().myUseHeadlight; } 
    void     setHeadlightParms(UT_Vector3F dir,
                               UT_Vector3F color,
                               float       ambient,
                               float       soft,
                               bool        use_spec,
                               bool use_world_space)
                {
                    SET_GLOBAL(myHeadlightDir, dir);
                    SET_GLOBAL(myHeadlightColor, color);
                    SET_GLOBAL(myHeadlightSpec, (int32)(use_spec?1:0));
                    SET_GLOBAL(myHeadlightWorldSpace, (int32)use_world_space);
                    SET_GLOBAL(myHeadlightAmbient, ambient);
                    SET_GLOBAL(myHeadlightSoft, soft);
                }
    UT_Vector3F headlightDir() { return globals().myHeadlightDir; } 
    UT_Vector3F headlightColor() { return globals().myHeadlightColor; } 
    void     setUseFilllight(bool use_fill)
                { SET_GLOBAL(myUseFilllight, (int32)use_fill); }
    void     setFilllightParms(UT_Vector3F dir, UT_Vector3F color)
                {
                    SET_GLOBAL(myFilllightDir, dir);
                    SET_GLOBAL(myFilllightColor, color);
                }
    UT_Vector3F filllightDir() { return globals().myFilllightDir; } 
    UT_Vector3F filllightColor() { return globals().myFilllightColor; } 
    void     setUseBacklight(bool use_back)
                { SET_GLOBAL(myUseBacklight, (int32)use_back); }
    void     setBacklightParms(UT_Vector3F dir, UT_Vector3F color)
                {
                    SET_GLOBAL(myBacklightDir, dir);
                    SET_GLOBAL(myBacklightColor, color);
                }
    UT_Vector3F backlightDir() { return globals().myBacklightDir; } 
    UT_Vector3F backlightColor() { return globals().myBacklightColor; } 
    

    void     setEnvlightMapRotate(const UT_Vector3F &rot);
    void     setEnvlightMapTint(const UT_Vector3F &tint)
              { SET_GLOBAL(myEnvlightTint, UT_Vector4F(tint, 1.0)); }
    void     setUseEnvlight(bool use_env)
              { SET_GLOBAL(myUseEnvlight, (int32)use_env); }
    bool     useEnvlight() const { return globals().myUseEnvlight; } 
    UT_Matrix4F getEnvlightRotate() const { return globals().myEnvlightRotate; }
    UT_Vector3F getEnvlightMapTint() const
              { return UT_Vector3F(globals().myEnvlightTint); }
#ifdef USE_VULKAN
    RV_TextureRef &envlightMap() { return globals().myEnvlightMapRef; }
    RV_TextureRef &bgenvMap() { return globals().myBGEnvMapRef; }
#endif
    
    void     setHasPrimLightMask(bool m) { objects().myHasPrimLightMask = m; }
    bool     hasPrimLightMask() const { return objects().myHasPrimLightMask; }

    enum RenderPass
    {
        RENDER_MATERIAL = 0,
        RENDER_CONST    = 1,
        RENDER_OTHER  = 2,
    };
    void       setRenderPass(RenderPass v)
                   { SET_GLOBAL(myRenderPass, v); }
    RenderPass getRenderPass() const
                   { return RenderPass(globals().myRenderPass); }

    void    setAlphaCutoff(float v) { SET_GLOBAL(myAlphaCutoff, v); }
    float   getAlphaCutoff() const { return globals().myAlphaCutoff; }

    void  setCamView(const UT_Matrix4D& v) { globals().myCamView = v;}
    const UT_Matrix4D &getCamView() const { return globals().myCamView;}

    void  setCamProject(const UT_Matrix4D& v) { globals().myCamProject = v;}
    const UT_Matrix4D &getCamProject() const { return globals().myCamProject;}

    void  setScreenSize(const UT_Vector2& v) { SET_GLOBAL(myScreenSize, v); }
    const UT_Vector2& getScreenSize() const { return globals().myScreenSize; }

    void  setNumSamples(int v) { SET_GLOBAL(myNumSamples, v); }
    int   getNumSamples() const { return globals().myNumSamples; }

    void  setLODParms(const UT_Vector2& v) { SET_GLOBAL(myLODParms, v); }
    const UT_Vector2& getLODParms() const { return globals().myLODParms; }

    void setPickArea(const UT_Vector4F& v) { SET_GLOBAL(myPickArea, v); }
    const UT_Vector4F& getPickArea() const { return globals().myPickArea; }

    void setPickMap(GR_TextureRef v, bool use = true) 
                { 
                  SET_GLOBAL(myPickMap, v);
                  SET_GLOBAL(myPickHasMapVK, (use && globals().myPickMap.isVulkan()));
                  SET_GLOBAL(myPickHasMapGL, (use && globals().myPickMap.isGL()));
                }

    void setDepthMap(GR_TextureRef v, bool use = true, RE_ZFunction func = RE_ZALWAYS)
                {
                  SET_GLOBAL(myDepthMap, v);
                  int vk_val = 0;
                  if (use && globals().myDepthMap.isVulkan())
                  {
                    if (func == RE_ZLESS || func == RE_ZLEQUAL)
                        vk_val = -1;
                    else if (func == RE_ZGREATER || func == RE_ZGEQUAL)
                        vk_val = -2;
                    else
                        vk_val = 1;
                  }
                  SET_GLOBAL(myHasDepthMapVK, vk_val);
                  SET_GLOBAL(myHasDepthMapGL, (use && globals().myDepthMap.isGL()));
                }

    void  setSnapDistances(const UT_Vector3i &v) { SET_GLOBAL(mySnapDistances, v);}
    const UT_Vector3i &getSnapDistances() const { return globals().mySnapDistances;}

    void  setSnapParms(int32 v) { SET_GLOBAL(mySnapParams, v);}
    int32 getSnapParms() const { return globals().mySnapParams;}

    void  setDecorationLocate(const UT_Vector4F& v) { SET_GLOBAL(myDecorLocate, v); }
    const UT_Vector4F& getDecorationLocate() const { return globals().myDecorLocate; }


    void print(); 

    // TODO: use these maybe ?
    bool myIsGlobalUniformLocked = false;
    void lockGlobalUniforms()
    {
        myIsGlobalUniformLocked = true;
    }
    void unlockGlobalUniforms()
    {
        myIsGlobalUniformLocked = false;
    }
    bool myGlobalUniformDirty = true;

    #define UT_Vector2F_UBO alignas(8)  UT_Vector2F
    #define UT_Vector3F_UBO alignas(16) UT_Vector3F
    #define UT_Vector4F_UBO alignas(16) UT_Vector4F
    #define UT_Vector2i_UBO alignas(8)  UT_Vector2i
    #define UT_Vector3i_UBO alignas(16) UT_Vector3i
    #define UT_Vector4i_UBO alignas(16) UT_Vector4i
    #define UT_Matrix4F_UBO alignas(16) UT_Matrix4F

    struct GlobalUniforms
    {
        #define VK_GLOBAL_BLOCK_START (offsetof(GlobalUniforms, myProjectionF))
        // float versions for VK
        UT_Matrix4F_UBO myProjectionF;
        UT_Matrix4F_UBO myViewF;
        UT_Vector3F_UBO myNormalMatFr1; // store `mat3` as 3 `vec3`s to match UBO spacing
        UT_Vector3F_UBO myNormalMatFr2;
        UT_Vector3F_UBO myNormalMatFr3;
        UT_Matrix4F_UBO myInvProjectionF;
        UT_Matrix4F_UBO myInvViewF;
        UT_Matrix4F_UBO myCamViewF;
        UT_Matrix4F_UBO myCamProjectF;

        // Inverses (reciprocals) of the extents of the cascading shadowmap regions.
        CSMRegionInvExts  myCSMRegionInvExts;
        CSMRegionOffsets  myCSMRegionOffsets;

        // TODO: make this a push constant
        int32             myShadowmapIndex;

        // Screen/Framebuffer info
        UT_Vector2F_UBO myScreenSize;
        UT_Vector2F_UBO myLODParms;

        UT_Vector2F_UBO myDepthRange;
        UT_Vector2F_UBO myDepthProject;
        int32           myHasDepthMapVK = 0;

        // Enum code indicating whether or not inside a
        // transparency rendering pass, or what kind of pass 
        int32 myRenderPass = RENDER_MATERIAL;
        int32 myAlphaPass = 0;

        int32 myMaterialLayer = 0;
        int32 myOnionSkinGroup = 0;

        fpreal32 SceneIOR = 1.0;

        // Multipliers for different aspects of lighting,
        // typically 0.0 or 1.0
        fpreal32 myEmissionFactor = 1.0;
        fpreal32 myDiffuseFactor = 1.0;
        fpreal32 myAmbientFactor = 1.0;
        fpreal32 mySpeculaFactor = 1.0;

        UT_Vector3i_UBO myCoverageMask;

        fpreal32        myAlphaCutoff = 1e-3;

        int32           myNumSamples = 4;

        int32           myIsOrtho = 0;
        UT_Vector2F_UBO myDepthOffset;

        // NOTE: only used in pick rendering
        UT_Vector4F_UBO myPickArea;
        int32           myPickHasMapVK = 0;

        // NOTE: only used in snap rendering
        UT_Vector3i_UBO mySnapDistances;
        int32           mySnapParams = 0;

        // NOTE: only used in decoration rendering
        UT_Vector4F_UBO myDecorLocate;
        float           myDecorOcclusionFade = 1.0;

        int32           myHeadlightWorldSpace = 0;
        fpreal32        myHeadlightAmbient = 0.02;

        UT_Vector3F_UBO myHeadlightDir;
        int32           myHeadlightSpec = 1;
        UT_Vector3F_UBO myHeadlightColor;
        int32           myUseHeadlight = 0;
        fpreal32        myHeadlightSoft = 0.0;

        UT_Vector3F_UBO myFilllightDir;
        int32           myUseFilllight = 0;
        UT_Vector3F_UBO myFilllightColor;

        UT_Vector3F_UBO myBacklightDir;
        int32           myUseBacklight = 0;
        UT_Vector3F_UBO myBacklightColor;

        UT_Matrix4F_UBO myEnvlightRotate;
        UT_Vector4F_UBO myEnvlightTint;
        int32           myUseEnvlight = 0;
        
        #define VK_GLOBAL_BLOCK_END (offsetof(GlobalUniforms, myUseEnvlight ) \
                                     + sizeof(GlobalUniforms::myUseEnvlight))

        UT_Matrix3F myNormalMatF;
        
        UT_Matrix4D myProjection;
        UT_Matrix4D myInvProjection;
        UT_Matrix4D myView;
        UT_Matrix4D myInvView;
        UT_Matrix3D myNormalMat;
        UT_Matrix4D myCamView;
        UT_Matrix4D myCamProject;

        // NOTE: only used in pick rendering
        GR_TextureRef   myPickMap;
        int32           myPickHasMapGL = 0;

        // NOTE: only used in shadow map rendering 
        GR_TextureRef myDepthMap;
        int32         myHasDepthMapGL = 0;
        fpreal32      myDepthBufferFar = 1.0;

#ifdef USE_VULKAN
        RV_TextureRef myEnvlightMapRef;
        RV_TextureRef myBGEnvMapRef;
#endif
    };
    static constexpr int32 VkGlobalBlockSize = VK_GLOBAL_BLOCK_END
                                               - VK_GLOBAL_BLOCK_START;

#ifdef USE_VULKAN
    static void initStaticResources(RV_Instance* inst);
    static void cleanupStaticResources();

    static void prepareThreadedUniforms(exint num_threads);
    static void returnThreadedUniforms();

    static GR_Uniforms* getForThread(int* level, int idx);
    static void returnForThread(int* level);
#endif

    ObjectUniforms& objects()
        {
            return myObjectUniforms.last();
        }
    const ObjectUniforms& objects() const
        {
            return myObjectUniforms.last();
        }

    GlobalUniforms& globals()
        {
            UT_ASSERT(!myIsGlobalUniformLocked);
            myGlobalUniformDirty = true;
            return myGlobalUniforms;
        }
    const GlobalUniforms& globals() const
        {
            return myGlobalUniforms;
        }

private:
    UT_ValArray<ObjectUniforms> myObjectUniforms;
    GlobalUniforms myGlobalUniforms;

    // ~~~~~~~~~~~~~~~
    // RE Private Helpers 

    // RE_Render stack helpers
    bool myIsREPushed = false;

    // Ghosting setup taken form GUI_GeoRender::setupGhosting
    struct RECachedState
    {
        bool    useSampleMask;
        int     sampleMask;
        bool    multisample;
    } myCachedREState;

    // Special handlers for ghosting state -- changes some Render state as well
    // as pushing uniforms
    void pushGhosting(RE_Render* r);
    void assignGhosting(RE_Render* r);
    void popGhosting(RE_Render* r);

private:
    bool myUseVulkanProjection = false;
#ifdef USE_VULKAN
    struct gr_SetCache
    {
        // Array doing linear lookup, fine if number of sets small
        // TODO: could do a hashmap
        UT_Array<UT_UniquePtr<RV_ShaderVariableSet>> mySets;
        UT_Array<bool>                               myDirtyFlags;

        RV_ShaderVariableSet *createOrReuseSet(
                RV_Render *r,
                int set_num,
                const RV_ShaderProgramBase *shader,
                bool* out_is_new_or_dirty);
    };
    gr_SetCache                     myGlobalSet;
    UT_UniquePtr<RV_ShaderBlock>    myPassInfoBlock;
#endif
};


#endif