GR_UtilsVK.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_UtilsVK.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Utility functions for Vulkan GR_GeoRenders.
 */

#ifndef GR_UtilsVK_h
#define GR_UtilsVK_h

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

#include <UT/UT_Map.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_VectorTypes.h>
#include <GT/GT_Primitive.h>
#include <GT/GT_Types.h>

#include <RV/RV_Type.h>

class GR_DisplayOption;
class GR_GeoRender;
class GR_UpdateParms;

class GT_PrimCurveMesh;

class RV_Instance;
class RV_Geometry;
class RV_Render;
class RV_ShaderAtlas;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderProgramBase;
class RV_ShaderVariableSet;
class RV_VKBuffer;


class RE_CacheVersion;

namespace GR_Utils
{
inline RV_GPUType getRVType(GT_Storage s)
{
    switch(s)
    {
    case GT_STORE_UINT8:       return RV_GPU_UINT8;
    case GT_STORE_INT8:        return RV_GPU_INT8;
    case GT_STORE_INT32:       return RV_GPU_INT32;
    case GT_STORE_INT64:       return RV_GPU_INT32; // no such 64b type
    case GT_STORE_REAL16:      return RV_GPU_FLOAT16;
    case GT_STORE_REAL32:      return RV_GPU_FLOAT32;
    case GT_STORE_REAL64:      return RV_GPU_FLOAT64;
    case GT_STORE_STRING:      return RV_GPU_INT32; // string indices
    default:
        UT_ASSERT(!"No available RV type");
        return RV_GPU_UINT1;
        break;
    }
}


/// Returns the GPU type and vector size of the attribute based on the
/// data array, display option settings and supported Vulkan capabilities.
GR_API extern RV_GPUType      getAttributeType(RV_Render *r,
                                               const char *attrib_name,
                                               const GT_DataArrayHandle &pa,
                                               const GR_DisplayOption &opts,
                                               RV_AttributeType array_type,
                                               int &out_vsize,
                                               bool &out_isnormalized);

// Allocate a CPU buffer, convert the data from the GT_Data into the correct
// format for upload, and place it in the new buffer
GR_API extern void *          fillAttribData(RV_Render *r,
                                             const char        *attrib_name,
                                             const GT_DataArrayHandle   &pa,
                                             const GR_DisplayOption     &opts,
                                             RV_AttributeType            array,
                                             bool build_string_tables = true);


GR_API GR_SelectMode    buildInstSelectInfo(RV_Render *r,
                                             RV_Geometry *geo,
                                             const GR_UpdateParms &p,
                                             RE_CacheVersion top_ver,
                                             GT_DataArrayHandle prim_id,
                                             GT_DataArrayHandle pnt_id,
                                             GT_DataArrayHandle vert_id,
                                             bool is_offset = true,
                                             int inst_per_prim = 1,
                                             UT_Array<uint8> *selected = nullptr);

GR_API extern bool createOrReuseSet(RV_Render* r,
                                    UT_UniquePtr<RV_ShaderVariableSet> &set,
                                    int set_num,
                                    const RV_ShaderProgramBase* shader,
                                    bool* created = nullptr,
                                    const char* name = nullptr);
GR_API extern bool initBuiltinBlock(RV_Render* r,
                                    UT_UniquePtr<RV_ShaderBlock> &block, 
                                    const char* name,
                                    RV_ShaderVariableSet* set,
                                    const RV_ShaderProgramBase* shader);
GR_API extern void loadAtlas(RV_Instance *inst,
                             RV_ShaderAtlas &atlas,
                             UT_Map<exint,RV_ShaderProgram*> &programmap);


GR_API extern void buildCurvePrimInfo(const GT_PrimCurveMesh *cmesh,
                                      const GR_UpdateParms &p,
                                      RV_Geometry* geo,
                                      GR_GeoRender* gr,
                                      RE_CacheVersion geo_version,
                                      UT_Vector4iArray &data,
                                      UT_Int32Array* opt_curve_oder = nullptr);

}

class GR_InstanceBuffer
{
public:
    GR_InstanceBuffer(const char *name,
                      RV_GPUType type,
                      int vsize,
                      int ninstances,
                      int step = 1,
                      bool normalized = true)
        : AttribName(name),
          Type(type),
          VectorSize(vsize),
          NumInstances(ninstances),
          InstanceStep(step),
          NormalizedFormat(normalized)
        {}

    void init(RV_Render *r, int entries);
    void initCPUMapped(RV_Render *r, int entries, bool cpu_mapped = true);
                      
    UT_UniquePtr<RV_VKBuffer> Buffer;
    UT_StringHolder AttribName;
    RV_GPUType   Type = RV_GPU_FLOAT32;
    int          VectorSize = 4;
    int          NumInstances = 1;
    int          InstanceStep = 1;
    bool         NormalizedFormat = true;

    UT_NON_COPYABLE(GR_InstanceBuffer);
};

#endif