RV_Geometry.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:        RV_Geometry.h ( RV Library, C++)
 *
 * COMMENTS:
 *    High level class for wrapping geometry for drawing
 */

#ifndef RV_Geometry_h
#define RV_Geometry_h

#include "RV_API.h"

#include <RE/RE_CachedObject.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_Assert.h>
#include <UT/UT_ComputeGPU.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_WorkBuffer.h>

#include <VE/VE_VK.h>

#include "RV_Type.h"
#include "RV_TypePtrs.h"
#include "RV_VKBuffer.h"

class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderProgramBase;
class RV_ShaderVariableSet;
class RV_VKDescriptorSetInfo;
class RV_VKAccelerationStructure;
struct RV_VKPipelineInputInfo;

typedef RV_VKBuffer RV_Buffer;

enum RV_GenericAttribID
{
    RV_GENATTRIB_UNDEF = -2
};

enum RV_ConnectionType
{
    RV_CONNECTION_UNDEFINED = 0,
    RV_CONNECTION_POINTS,
    RV_CONNECTION_INDEXED,
};

inline VkPrimitiveTopology RVgetVkPrimType(RV_PrimType t)
{
   switch (t)
   {
        case RV_PRIM_POINTS              : return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
        case RV_PRIM_LINES               : return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
        case RV_PRIM_LINE_STRIP          : return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
        case RV_PRIM_TRIANGLES           : return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
        case RV_PRIM_TRIANGLE_STRIP      : return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
        case RV_PRIM_TRIANGLE_FAN        : return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
        case RV_PRIM_LINES_ADJACENT      : return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
        case RV_PRIM_LINE_STRIP_ADJACENT : return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
        case RV_PRIM_TRIANGLES_ADJACENT  : return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
        case RV_PRIM_TRIANGLE_STRIP_ADJACENT : return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
        case RV_PRIM_PATCHES             : return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
        default : break;
   }

   UT_ASSERT_MSG(false, "RVgetVkPrimType Invalid RV_PrimType");
   return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
}

inline UT_GPUType RVconvertToUTGPUType(RV_GPUType t)
{
    switch (t)
    {
        case RV_GPU_UINT1: return UT_GPU_UINT1;
        case RV_GPU_UINT4: return UT_GPU_UINT4;
        case RV_GPU_UINT8: return UT_GPU_UINT8;
        case RV_GPU_UINT16: return UT_GPU_UINT16;
        case RV_GPU_UINT32: return UT_GPU_UINT32;

        case RV_GPU_INT8: return UT_GPU_INT8;
        case RV_GPU_INT16: return UT_GPU_INT16;
        case RV_GPU_INT32: return UT_GPU_INT32;

        case RV_GPU_FLOAT16: return UT_GPU_FLOAT16;
        case RV_GPU_FLOAT24: return UT_GPU_FLOAT24;
        case RV_GPU_FLOAT32: return UT_GPU_FLOAT32;
        case RV_GPU_FLOAT64: return UT_GPU_FLOAT64;

        case RV_GPU_MATRIX2: return UT_GPU_MATRIX2;
        case RV_GPU_MATRIX3: return UT_GPU_MATRIX3;
        case RV_GPU_MATRIX4: return UT_GPU_MATRIX4;
        default : break;
    }

    UT_ASSERT(!"Unknown RV_GPUType.");
    return UT_GPU_UINT8;
}

inline RV_GPUType RVconvertFromGPUType(UT_GPUType t)
{
    switch (t)
    {
        case UT_GPU_UINT1: return RV_GPU_UINT1;
        case UT_GPU_UINT4: return RV_GPU_UINT4;
        case UT_GPU_UINT8: return RV_GPU_UINT8;
        case UT_GPU_UINT16: return RV_GPU_UINT16;
        case UT_GPU_UINT32: return RV_GPU_UINT32;

        case UT_GPU_INT8: return RV_GPU_INT8;
        case UT_GPU_INT16: return RV_GPU_INT16;
        case UT_GPU_INT32: return RV_GPU_INT32;

        case UT_GPU_FLOAT16: return RV_GPU_FLOAT16;
        case UT_GPU_FLOAT24: return RV_GPU_FLOAT24;
        case UT_GPU_FLOAT32: return RV_GPU_FLOAT32;
        case UT_GPU_FLOAT64: return RV_GPU_FLOAT64;

        case UT_GPU_MATRIX2: return RV_GPU_MATRIX2;
        case UT_GPU_MATRIX3: return RV_GPU_MATRIX3;
        case UT_GPU_MATRIX4: return RV_GPU_MATRIX4;
        default : break;
    }

    UT_ASSERT(!"Unknown UT_GPUType.");
    return RV_GPU_UNKNOWN;
}

struct rv_DrawSetInfo;
struct rv_DrawInputInfo;
struct rv_Attribute;
struct rv_Connectivity;
struct rv_InstanceGroup;

// TODO: use cache for multiple Drawing-Sets
//typedef UT_Map<RV_VKDescriptorSetInfo, rv_DrawSetInfo> rv_DrawSetCache;

typedef UT_UniquePtr<rv_InstanceGroup>  rv_InstanceGroupPtr;
typedef UT_UniquePtr<RV_Buffer>         RV_BufferPtr;

/// @brief Object that represents drawable geometry.
/// This object holds vertex, instancing and index buffers for drawing.
/// The normal workflow is to:
///    - Set the number of points in the geometry with `setNumPoints()`
///    - Create all needed attribute definitions (P, N, uv, etc).
///    - Create all needed index buffer definitions or connect groups
///    - Call populateBuffers()
///    - Fetch each attribute with getAttribute() and fill it with
///      `RV_Buffer::uploadData()`
///    - Fetch each index buffer with getIndexBuffer() and fill it with
///      `RV_Buffer::uploadData()`
///    - Draw connect groups with any of the draw...() methods.
/// Draws must be done inside a begin/endRendering() block; all others must be
/// done outside. 
class RV_API RV_Geometry
{
public:
     RV_Geometry();
    ~RV_Geometry();

    // Setup and cleanup

    /// clear & free resources
    void reset();
    /// remove from VRAM; move to back in RAM (not implemented yet)
    void unload();

    /// Memory use of all buffers for this geometry (in bytes) including RT
    /// acceleration structures.
    exint gpuMemoryUsage() const;

    /// Set name used for debugging
    void setName(const UT_StringHolder &name) { myName = name; }
    /// Get name used for debugging
    const UT_StringHolder &getName() const { return myName; }

    /// Set number of points in geometry for vertex shader inputs
    bool  setNumPoints(exint num_points); 
    /// Number of points in geometry for vertex shader inputs
    exint getNumPoints() const;

    /// Set number of per-vertex elements, accessed in fragment shader/
    /// Must match the number of primitives drawn.
    void  setVertexBufferSize(exint vert_buffer_elements);
    /// Number of per-primitive elements, accessed in fragment shader
    exint getVertexBufferSize() const;

    /// Set number of per-primitive elements, accessed in fragment shader/
    /// Must match the number of primitives drawn.
    void  setPrimitiveBufferSize(exint prim_buffer_elements);
    /// Number of per-primitive elements, accessed in fragment shader
    exint getPrimitiveBufferSize() const;

    // ---------------------------------------------------------------
    // Methods for configuring the structure of the geometry

    /// @brief Create an attribute definition
    /// Create an attribute definition for a vertex shader input
    /// Capacity - optional buffer capacity in elements, in case of resizes
    bool createAttribute(const UT_StringHolder &name,
                         RV_GPUType data_format, int vector_size,
                         exint capacity = -1, bool normalized = true,
                         bool allow_gpu_write = false);

    /// Creates a single value for a vertex shader input.
    bool createConstant(const UT_StringHolder &name,
                        RV_GPUType data_format, int vector_size,
                        bool normalized = true);

    /// Create a vertex buffer for fragment shader indexing via vertex ID
    bool createVertexBuffer(const UT_StringHolder &name,
                         RV_GPUType data_format, int vector_size,
                         exint capacity = -1, bool normalized = true,
                         bool allow_gpu_write = false);

    /// Create a buffer view for fragment shader indexing via gl_PrimitiveID
    bool createPrimitiveBuffer(const UT_StringHolder &name,
                               RV_GPUType data_format, int vector_size,
                               bool normalized = true);

    /// Create a random-access attribute for instancing and other random access
    /// Uses a buffer view.
    bool createBufferAttribute(const UT_StringHolder &name,
                               RV_GPUType data_format, int vector_size,
                               exint buffer_size, bool normalized = true);
    
    /// Create an attribute that is allocated immediately
    /// separate from those allocated during 'populateBuffers'
    RV_Buffer* createAllocatedAttribute(RV_Render* r,
                                        const UT_StringHolder &name,
                                        RV_GPUType data_format, int vector_size,
                                        RV_AttributeType usage,
                                        exint capacity = -1,
                                        bool normalized = true);

    /// @brief Fetch a buffer for an attribute.
    /// Return the RV buffer for attribute `name`. Will not exist until
    /// `populateBuffers()` is called.
    RV_Buffer*        getAttribute(const UT_StringHolder &name) const;
    /// Tag the attribute with version information.
    void              setAttributeVersion(const UT_StringHolder &name,
                                          const RE_CacheVersion &ver);
    /// Set the attribute type (point, primitive, constant, random).
    void              setAttributeUsage(const UT_StringHolder &name,
                                        RV_AttributeType ver);

    /// Set the attribute's original format, used for display
    void              setAttributeDisplayFormat(const UT_StringHolder &name, 
                                        RV_GPUType out_type, 
                                        int out_vec_size) const;

    /// Record a vertex shader input's constant scalar value.
    void              setAttributeConstValue(const UT_StringHolder &name,
                                            fpreal64 val);
    /// Record a vertex shader input's constant vector value.
    void              setAttributeConstVecValue(const UT_StringHolder &name,
                                            const UT_Vector4F &val);
    
    /// Disables all attributes that are marked as stashable, and clears
    /// attributes that were previously stashed. Attributes can be marked
    /// as stashable and kept active by calling `unstashAttribute()` after
    /// calling `stashAttributes()`
    /// Should only be called by `GR_GeoRenderVK::fillGeoAttribs()`
    void              stashAttributes();

    /// Marks an attribute as active and stashable
    bool              unstashAttribute(const UT_StringHolder &name);
    bool              unstashInstanceAttrib(int group_index,
                                            const UT_StringHolder &name);
    /// Remove attribute and free its resource
    bool              freeAttribute(RV_Render* r, const UT_StringHolder &name);

    /// @brief Get an attribute's usage
    /// Get the type of an attribute (point, prim, const, random, null). May be
    /// null if the attribute was freed.
    bool              getAttributeType(const UT_StringHolder &name, 
                                        RV_AttributeType& out_type) const;
    
    /// Get the format of an attribute (return false if it does not exist).
    bool              getAttributeFormat(const UT_StringHolder &name, 
                                        RV_GPUType& out_type, 
                                        int& out_vec_size) const;

    /// @brief Get the length of an attribute
    /// Get the length, in elements (not bytes) of an attribute
    /// (return false if it does not exist).
    bool              getAttributeLength(const UT_StringHolder &name, 
                                        exint& out_len) const;
    /// Get the version of an attribute (return false if it does not exist).
    bool              getAttributeVersion(const UT_StringHolder &name, 
                                        RE_CacheVersion& out_ver) const;

    /// @brief Get an attribute's usage
    /// Get the version of an attribute (return false if it does not exist).
    /// Will always return the usage it was defined with, even if freed.
    bool              getAttributeUsage(const UT_StringHolder &name, 
                                        RV_AttributeType& out_ver) const;

    /// Get the display format of an attribute (return false if it does not exist).
    /// May be different from the actual Vulkan Buffer's data format, if an
    /// implicit reformatting occured on the data before upload
    bool              getAttributeDisplayFormat(const UT_StringHolder &name, 
                                        RV_GPUType& out_type, 
                                        int& out_vec_size) const;

    /// Get the constant value for the vertex input 'name', after set as scalar
    fpreal64          getAttributeConstValue(const UT_StringHolder &name) const;
    
    /// Get the constant value for the vertex input 'name', after set as vector
    const UT_Vector4F&getAttributeConstVecValue(const UT_StringHolder &name) const;

    /// True if the attribute exists in the geometry.
    bool              hasAttribute(const UT_StringHolder &name,
                                        int instance_group = -1) const;

    // Instancing support ----------------------------------------------

    // subsets of instances (for materials)

    /// Create a instance group for instanced drawing
    bool createInstanceGroup(int group_index);
    /// Remove an instance group
    void removeInstanceGroup(int group_index);
    /// Return true if the instance group exists
    bool hasInstanceGroup(int group_index) const;
    /// Return the maximum index of all instance groups.
    int  getMaxInstanceGroup() const;

    /// Set the numbers of instances drawn in a group
    void    setInstanceGroupCount(int instance_group, int count);
    /// Fetch the numbers of instances drawn in a group
    int     getInstanceGroupCount(int instance_group) const;
    /// Fetch the numbers of instanced transforms in a group, ignoring index lists
    int     getInstanceGroupTransformCount(int instance_group) const;

    /// Set the group to draw all transforms, ignoring existing index list
    void    setInstanceGroupForceFullDraw(int instance_group, bool enable);
    /// Fetch whether group was set to force full draws
    bool    getInstanceGroupForceFullDraw(int instance_group) const;

    /// Select a subset of instance indices for an instance group (eg, culling)
    void    setInstanceGroupIndexList(int group_index,
                                      const UT_IntArray &indices,
                                      int max_capacity = -1);
    /// Draw one instance with a specific index
    void     setInstanceGroupConstIndex(int instance_group,
                                        int instance_to_draw);
    /// Draw all instances
    void     setInstanceGroupDrawEverything(int instance_group);
    /// Draw none of the instances
    void     setInstanceGroupDrawNothing(int instance_group);

    // Transforms for instances

    /// Single transform for all instances (or additional transform if
    /// remove_instanced_xform is false)
    void setConstInstanceGroupTransform(int instance_group,
                                        const UT_Matrix4F &xform,
                                        bool remove_instanced_xform);

    /// set instance group to use the same const transform as another
    void copyConstInstanceGroupTransform(int instance_group, int src_group);

    /// @brief Create an per-instance attribute
    /// Reserve an buffer for per-instance data (call populateBuffers() to
    /// create the RV_Buffer for it).
    bool setInstanceGroupAttrib(int instance_group,
                                const UT_StringHolder &name,
                                RV_GPUType data_type,
                                int vector_size,
                                int instance_step,
                                int num_instances,
                                exint capacity = -1,
                                bool normalized = true);

    /// Create per-instance attribute that can be shared by multiple RV_Geometrys
    bool createSharedInstanceGroupAttrib(int instance_group,
                                         const UT_StringHolder &name,
                                         RV_GPUType data_type,
                                         int vector_size,
                                         int instance_step,
                                         int num_instances,
                                         exint capacity = -1,
                                         bool normalized = true);
    
    /// Assign a buffer for the per-instance shared attribute
    bool assignSharedInstanceGroupAttrib(int instance_group,
                                         const UT_StringHolder &name,
                                         RV_VKBuffer* buffer);

    /// Remove per-instance attribute and free its resource
    bool freeInstanceGroupAttrib(int instance_group,
                                 const UT_StringHolder &name);

    /// Helper to allocate a shared per-instance buffer 
    static RV_VKBufferPtr allocateSharedInstanceBuffer(
                                 RV_Render* r,
                                 RV_GPUType data_type,
                                 int vector_size,
                                 exint length,
                                 bool normalized = true,
                                 const char* name = nullptr);

    static RV_VKBufferPtr allocateSharedCPUMappedInstanceBuffer(
                                 RV_Render* r,
                                 RV_GPUType data_type,
                                 int vector_size,
                                 exint length,
                                 bool normalized = true,
                                 bool cpu_mapped = true,
                                 const char* name = nullptr);

    /// Fetch the buffer backing an per-instance attribute, usually to fill it
    RV_Buffer *     getInstanceGroupAttrib(int instance_group,
                                        const UT_StringHolder &name) const;
    /// @brief Get the length of an attribute
    /// Get the length, in elements (not bytes) of an attribute
    /// (return false if it does not exist).
    bool            getInstanceAttribLength(int instance_group,
                                        const UT_StringHolder &name, 
                                        exint& out_len) const;

    /// Fetch the per-instance attribute version (to avoid refilling)
    bool            getInstanceAttribVersion(int instance_group,
                                        const UT_StringHolder &name,
                                        RE_CacheVersion& out_ver) const;
    /// Set the per-instance attribute version (to avoid refilling)
    void            setInstanceAttribVersion(int instance_group,
                                        const UT_StringHolder& name,
                                        const RE_CacheVersion& ver);

    // ----------------------------------------------------------------------
    // Connectivity

    /// Connect all points to form prims of `prim` type
    void        connectAllPrims(int connect_index,
                                RV_PrimType prim,
                                int patch_size = 0);
    /// Connect a range of points to form prims of `prim` type
    void        connectSomePrims(int connect_index,
                                 RV_PrimType prim,
                                 int start,
                                 int length,
                                 unsigned int stride = 0,
                                 int patch_size = 0);
    /// Connect points form prims `prim` type from a list of `num_elements`
    /// point indices. The index buffer must be populated after a
    /// `populateBuffers()` call with `getIndexBuffer()->uploadData()`.
    void         connectIndexedPrims(int connect_index,
                                     RV_PrimType prim,
                                     int num_elements,
                                     bool need_prim_info = false,
                                     int patch_size = 0);
    /// Connect a range of vertices to form prims of `prim` type
    void        connectSomeVerts(int connect_index,
                                 RV_PrimType prim,
                                 int start,
                                 int length,
                                 unsigned int stride = 0,
                                 int patch_size = 0);

    void        connectIndexedVerts(int connect_index,
                                     RV_PrimType prim,
                                     int num_elements,
                                     bool need_prim_info = false,
                                     int patch_size = 0);

    /// Set the primitive to GPU primitive ratio for acessing primitive
    /// attributes. For example, if all polygons are quads, the divisor would be
    /// 2 as the GPU creates 2 triangles for each quad.
    void        setConnectDivisor(int connect_index, int divisor,
                                  int base_prim=0);
    /// Generate a primitive info buffer for accessing primtive attribute data
    /// if the polygon vertex counts vary (use getPrimVertexBuffer() after
    // calling populateBuffers() to fill it).
    void        setConnectUsePrimInfo(int connect_index, int base_prim= 0);

    // Override the parameters used for the draw call in the connect group,
    // without modifying the connect group
    void setDrawModeOverride(int connect_index,
                             RV_PrimType prim_type,
                             exint vert_count);
    
    // disables any active draw mode overrides for the given connect group
    void resetDrawModeOverride(int connect_index);

    /// Set a PrimInfo buffer to be shared across connect groups with same
    /// primitive type. Attribute must already exist in geometry.
    void        setPrimitiveInfoAttrib(RV_TopologyClass prim_type,
                                       const UT_StringHolder &name);
    /// return the number of primitives that are rendered for a connect group
    int         getNumRenderPrims(int connect_index) const;

    /// return the type of primitives that are rendered for a connect group
    RV_PrimType getRenderPrimType(int connect_index) const;

    /// return the number of vertices that are rendered for a connect group
    int         getLength(int connect_index) const;

    /// Fetch the index buffer to fill (after populateBuffers())
    RV_Buffer *getIndexBuffer(int connect_index) const;
    /// Fetch the primitive buffer to fill (after populateBuffers())
    RV_Buffer *getPrimBuffer(int connect_index) const;
    /// Fetch the primitive/vertex buffer to fill (after populateBuffers())
    RV_Buffer *getPrimVertexBuffer(int connect_index) const;

    // True if the vertex shader is run at vertex frequency (False if at point)
    bool       isVertexFrequency(int connect_index) const;

    /// Return true if the connect group exists
    bool    hasConnectGroup(int connect_index) const;
    /// Return true if the connect group isn't empty
    bool    hasNonEmptyConnectGroup(int connect_index) const;
    /// Return the maximum connect group index
    int     getMaxConnectGroup() const;

    /// Remove a connect group
    bool    removeConnectedPrims(int connect_index);
    /// Remove all connect groups.
    void    resetConnectedPrims(); // remove all

    // -------------------------------------------------------------
    /// Populates all RV_Buffers declared above which haven't been populated yet.
    bool populateBuffers(RV_Render *r);

    // --------------------------------------------------------------
    // Drawing

    /// Setup Uniform buffers and Descriptor Set to be used by current shader
    void prepareForDraw(RV_Render *r,
                        int connect_index,
                        const RV_OverrideList *overrides = nullptr);
    /// Setup Uniform buffers and Descriptor Set to be used by current shader,
    /// when drawing with instances
    void prepareForDrawInstance( RV_Render* r,
                        int connect_index,
                        int instance_group,
                        const RV_OverrideList *overrides = nullptr);

    /// draw a single connection group
    /// draw_offset and draw_size can specifiy a vertex range in the connect
    void draw(
            RV_Render *r,
            int connect_index,
            const RV_OverrideList *overrides = nullptr,
            exint draw_offset = -1, exint draw_size = -1);

    /// draw a single connection group using with instancing, using the indices
    /// in instance_group
    /// draw_offset and draw_size can specifiy a vertex range in the connect
    void drawInstanceGroup(
            RV_Render *r,
            int connect_index,
            int instance_group,
            const RV_OverrideList *overrides = nullptr,
            exint draw_offset = -1, exint draw_size = -1);

    /// draw multiple connection groups (really just a loop over draw()).
    void drawRange(
            RV_Render *r,
            int connect_index_start,
            int num_connect_indexs,
            const RV_OverrideList *overrides = nullptr);

    /// draw instanced over multiple connection groups.
    void drawInstanceGroupRange(
            RV_Render *r,
            int connect_start,
            int num_connect,
            int instance_group,
            const RV_OverrideList *overrides = nullptr);

    /// draw indirectly from a buffer
    void drawIndirect(
            RV_Render *r,
            int connect_index,
            RV_Buffer &indirect_buffer);

    /// dispatch a compute shader for a single connect group
    void dispatch(RV_Render *r,
                  int connect_index,
                  int instance_group,
                  const RV_OverrideList *overrides = nullptr);

    /// dispatch compute shader for multiple connect groups
    void dispatchRange(RV_Render *r,
                  int connect_index,
                  int num_connect,
                  int instance_group,
                  const RV_OverrideList *overrides = nullptr);

    static void initResources(RV_Instance* inst);
    static void cleanupResources();

    // --------------------------------------------------------------
    // Ray tracing
    void updateAccelerationStructure(
            RV_Render *r,
            int tag,
            int light_id,
            int surface_connect_index,
            const UT_Matrix4F &obj_mat);

    RV_VKAccelerationStructure* getAccelerationStructure();

    // manually force acceleration structure rebuild
    void dirtyAccelerationStructure() { myIsAccelStructDirty = true; }

    // -------------------------------------------------------------------
    // DEBUG

    /// @brief Debug output
    /// Debug methd to print information about all attributes, connect groups,
    /// and instance groups
    void    print() const;
    // TODO: setDebugDraw() to print shader state during draw

private:

    // ------------------------------------------------------------------
    // CONNECTIVITY
    rv_Connectivity* getConnect(int group_idx, bool do_create);

    // ------------------------------------------------------------------
    // INSTANCE
    static void      getInstanceAttribName(UT_WorkBuffer &out_name,
                                           const char *base_name,
                                           int instance_group);

    int getTransformAttribCount(const rv_Attribute* attr) const;

    // ------------------------------------------------------------------
    // ATTRIBUTES
    const rv_Attribute*  findAttribute(const UT_StringRef& name,
                                 const RV_OverrideList *overrides,
                                 int instance_group,
                                 int* out_idx = nullptr) const;

    bool privCreateAttribute( const UT_StringHolder& name,
                              RV_GPUType data_format,
                              int vector_size,
                              bool normalize,
                              RV_AttributeType usage,
                              exint capacity = -1,
                              int inst_group = -1,
                              bool attr_owned = false,
                              bool allow_gpu_write = false);
    bool privFreeAttrib(RV_Render* r, rv_Attribute &attr);

    // ------------------------------------------------------------------
    // BUFFERS
    RV_Buffer *allocateAttributeBuffer(
                    RV_Render *r,
                    rv_Attribute &attr,
                    UT_Array<RV_BufferPtr> *opt_old_buffers = nullptr);
    bool       allocateConnectBuffers(RV_Render* r, rv_Connectivity& c,
                        UT_Array<RV_BufferPtr>* opt_old_buffers);
    bool       allocateInstIndexBuffer(RV_Render* r, rv_InstanceGroup& g,
                        UT_Array<RV_BufferPtr>* opt_old_buffers);

    RV_BufferPtr allocOrReuseBuffer( RV_Render *r, rv_Attribute &attr,
                        exint length, VkBufferUsageFlags vk_usage,
                        UT_Array<RV_BufferPtr> *old_buffers);

    void       resetAttribBuffers(RV_Render* r);
    void       resetConnectBuffers(RV_Render* r);
    void       resetCachedSets(RV_Render* r);

    bool privPrepareDraw(
            RV_Render* r,
            const rv_Connectivity *connect,
            int instance_group_idx,
            const RV_OverrideList* overrides
    );

    void privDraw(
            RV_Render *r,
            const rv_Connectivity *connect,
            int instance_group_idx,
            const RV_OverrideList *overrides,
            RV_Buffer* indirect_buf,
            exint draw_offset = -1,
            exint draw_length = -1
    );

    void privDispatch(
        RV_Render *r,
        const rv_Connectivity *connect,
        int instance_group_idx,
        const RV_OverrideList *overrides,
        RV_Buffer *indirect_buf
    );

    void fillInstanceInfoBlock(RV_Render *r, int instance_group_idx, RV_ShaderBlock* block);
    void fillGeometryInfoBlock(RV_Render *r, const rv_Connectivity* connect, RV_ShaderBlock* geo);

    // ------------------------------------------------------------------
    // DATA
    RV_Render* myR = nullptr;
    UT_StringHolder myName;

    uint32_t myNumPoints = 0;
    uint32_t myVertBufferSize = 0;
    uint32_t myPrimBufferSize = 0;
    
    bool myAttributesValid = false;

    // TODO: Make sure nothing name-to-idx mapping is stable
    //       (i.e. attrib names can't be removed)
    UT_StringMap<int>      myAttributeTable;
    UT_Array<int>          myDefaultAttribTable;
    UT_Array<int>          myPrimInfoAttribTable;
    UT_Array<rv_Attribute> myAttributeList;

    // own directly so helper structs can be passed around more easily
    UT_Array<RV_BufferPtr> myOwnedAttribBuffers;
    UT_Array<RV_BufferPtr> myOwnedConnectBuffers;
    UT_Array<RV_BufferPtr> myOwnedFallbackBuffers;
    UT_Array<UT_UniquePtr<RV_ShaderBlock>> myOwnedGeoBuffers;
    UT_Array<UT_UniquePtr<RV_ShaderBlock>> myOwnedInstBuffers;

    // TODO: allocate buffers from single block of memory
    //UT_UniquePtr<RV_VKMemory>         myMemBlock;

    UT_Array<rv_Connectivity> myConnectivityGroups;

    UT_Array<rv_InstanceGroupPtr> myInstanceGroups;

    struct rv_DrawSetInfo
    {
        // track the override list used
        RV_OverrideList     myOverrideList;
        int                 myConnectGroupIdx;
        int                 myInstanceGroupIdx;

        bool                myIsValid = false;

        UT_UniquePtr<RV_ShaderVariableSet> myDescriptorSet;
        UT_UniquePtr<RV_ShaderBlock>       myUniformBlock;

        // TODO: move into connect group
        UT_UniquePtr<RV_ShaderBlock>       myGeometryBlock;

        int                 myInstTransformUniformIdx = -1;
        int                 myInstNestLevelUniformIdx = -1;

        // TODO: keep a list of the [attrib ID, binding ID] pairs
        //       and check if they are up-to-date per-frame
        // TODO: requires RV_Geo and RV_ShaderVariableSet
        //      be setup to refer to attribs by consistent
        //      idx/binding num
        // currently invalidating any time the interface 
        // may have changed
    };

    // Set Used for drawing
    // cached by (connect group, instance group, set id)
    typedef UT_Map<std::tuple<int, int, int>, rv_DrawSetInfo> DrawSetCache;
    DrawSetCache myDrawSet;
    
    // Get the set that is compatible with the passed in shader
    // creating it if necessary
    rv_DrawSetInfo* getDrawSet(
        RV_Render* r,
        RV_ShaderProgramBase* sh,
        const rv_Connectivity *connect,
        int instance_group_idx,
        const RV_OverrideList* overrides);

    // Prepare a set, making sure all attributes are attached and 
    // up-to-date
    bool prepareDrawSet(
        RV_Render* r,
        rv_DrawSetInfo& set_info,
        const rv_Connectivity *connect,
        int instance_group_idx,
        const RV_OverrideList* overrides
    );

    bool bindInputAttribute(
            RV_Render* r,
            RV_VKPipelineInputInfo& pipe_input,
            const rv_Connectivity *connect,
            const rv_Attribute *attrib,
            bool instance,
            int location,
            RV_GPUType type,
            int vec_size);
    //rv_DrawSetCache                    myDrawSets;

    // Zero-valued constant buffers to fill attribs we don't have values for
    // TODO: use nullDescriptor bindings if VK_EXT_robustness2 is available
    void                        populateFallbackAttribs(RV_Render* r);
    void                        resetFallbackAttribs(RV_Render* r);
    rv_Attribute*               getFallbackVertAttrib(RV_GPUType type);
    rv_Attribute*               getFallbackTexBufAttrib(RV_UniformType type);
    UT_UniquePtr<rv_Attribute>     myDefaultVertexAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultIntVertexAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultUIntVertexAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultSamplerAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultIntSamplerAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultUIntSamplerAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultIndexSamplerAttrib;
    UT_UniquePtr<rv_Attribute>     myDefaultIndexVertexAttrib;

    // Ray tracing
    RV_VKAccelerationStructurePtr myAccelerationStructure;

    UT_Matrix4F myLastObjTransform = UT_Matrix4F::getIdentityMatrix();
    bool        myIsAccelStructDirty = true;
    bool        myIsAccelStructInstDirty = true;
};

#endif