RV_Type.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_Type.h ( RV Library, C++)
 *
 * COMMENTS:
 *      shared types for RV library
 */

#ifndef RV_Type_h
#define RV_Type_h

#include "RV_API.h"

#include <RE/RE_Types.h>
#include <RE/RE_TextureTypes.h>

#include <UT/UT_ComputeGPU.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_StringArray.h>

// indices for specific Descriptor Sets
// must match shaders
enum RV_SetType 
{
    RV_SET_GLOBAL        = 0,
    RV_SET_OBJECT        = 1,
    RV_SET_GEOMETRY      = 2,
    RV_SET_MATERIAL      = 3,
    RV_SET_SHADER        = 4,
    RV_SET_NUM           = 8
};


enum RV_GPUType
{
    RV_GPU_UINT1 = RE_GPU_UINT1,
    RV_GPU_UINT4 = RE_GPU_UINT4,

    RV_GPU_UINT8  = RE_GPU_UINT8,
    RV_GPU_UINT16 = RE_GPU_UINT16,
    RV_GPU_UINT32 = RE_GPU_UINT32,

    RV_GPU_INT8   = RE_GPU_INT8,
    RV_GPU_INT16  = RE_GPU_INT16,
    RV_GPU_INT32  = RE_GPU_INT32,

    RV_GPU_FLOAT16 = RE_GPU_FLOAT16,
    RV_GPU_FLOAT24 = RE_GPU_FLOAT24,
    RV_GPU_FLOAT32 = RE_GPU_FLOAT32,
    RV_GPU_FLOAT64 = RE_GPU_FLOAT64,

    // These can only be used in the context of a GLSL shader.
    RV_GPU_MATRIX2 = RE_GPU_MATRIX2,
    RV_GPU_MATRIX3 = RE_GPU_MATRIX3,
    RV_GPU_MATRIX4 = RE_GPU_MATRIX4,
    
    RV_GPU_UNKNOWN
    
};

inline RE_GPUType RVgetREType(RV_GPUType t)
{
    // Currently this is a pretty trivial transform.
    return RE_GPUType(t);
}

enum RV_GraphicsDevice
{
    RV_DEVICE_UNKNOWN       = 0x0,
    
    RV_DEVICE_ATI           = 0x1,
    RV_DEVICE_NVIDIA        = 0x2,
    RV_DEVICE_INTEL_GMA     = 0x4,      // Intel GMA (not supported)
    RV_DEVICE_INTEL_HD      = 0x8,      // Intel HD graphics
    RV_DEVICE_GDI           = 0x10,     // Software OGL on Windows
    RV_DEVICE_MESA          = 0x20,
    
    RV_DEVICE_PRO           = 0x100,    // Professional series
    RV_DEVICE_MAC           = 0x200,    // Mac versions of drivers
    RV_DEVICE_MAC_SILICON   = 0x600,    // ARM-based Macs
    
    RV_DEVICE_ATI_PRO       = (RV_DEVICE_PRO|RV_DEVICE_ATI),    // FireGL/Pro
    RV_DEVICE_NVIDIA_PRO    = (RV_DEVICE_PRO|RV_DEVICE_NVIDIA), // Quadro
    RV_DEVICE_INTEL_PRO     = (RV_DEVICE_PRO|RV_DEVICE_INTEL_HD)// n/a?
};

enum RV_AttributeType
{
    RV_ATTRIBUTE_POINT = 0,
    RV_ATTRIBUTE_VERTEX,
    RV_ATTRIBUTE_PRIMITIVE,
    // RV_ATTRIBUTE_INSTANCE,
    RV_ATTRIBUTE_CONSTANT,
    RV_ATTRIBUTE_RANDOM, // randomly sampled NOTE: also used for INSTANCE-level
    RV_ATTRIBUTE_NULL,
};


enum RV_MemType
{
   RV_MEM_AUTO = 0,
   RV_MEM_MAPPABLE_UPLOAD,
   RV_MEM_MAPPABLE_UPLOAD_DEVICE_LOCAL,
   RV_MEM_MAPPABLE_HOST_CACHED,
   RV_MEM_OPENGL_EXPORTABLE,
};

enum RV_ImageDim
{
    RV_IMAGE_UNKNOWN = 0,
    RV_IMAGE_1D,
    RV_IMAGE_2D,
    RV_IMAGE_3D,
    RV_IMAGE_CUBE,
    RV_IMAGE_2D_RECTANGLE,
    RV_IMAGE_1D_ARRAY,
    RV_IMAGE_2D_ARRAY,
    RV_IMAGE_CUBE_ARRAY,
    RV_IMAGE_BUFFER,

    RV_IMAGE_MAX_TYPE
};

enum RV_TextureFilter
{
    RV_FILTER_NEAREST,  // no filtering
    RV_FILTER_LINEAR,   // bi-linear filtering
    RV_FILTER_CUBIC,    // bi-cubic filtering NOTE: requires extension
};

enum RV_TextureMipMode
{
    RV_MIPMAP_DISABLED,    // No Mip filtering
    RV_MIPMAP_NEAREST,     // nearest mip level
    RV_MIPMAP_LINEAR       // linear blending
};

enum RV_TextureWrap
{
    RV_TEX_WRAP_REPEAT,  // texture repeats, tiling
    RV_TEX_WRAP_CLAMP,   // edge pixel is stretched
    RV_TEX_WRAP_BORDER,  // outside pixels are a const colour
    RV_TEX_WRAP_MIRROR   // texture repeats, mirrored tiling
};

class RV_TextureParms
{
public:
    UT_StringHolder Layer;      // Layer name within a deep raster file. C if ""
    UT_StringHolder ColorSpace; // OCIO colorspace of the source, auto if ""
    fpreal ImageScale      = 1.0; // Scale to apply to loaded images
    exint  MaxWidth        = 0;  // 0 = no limit
    exint  MaxHeight       = 0;
    exint  MaxDepth        = 0;
    bool   MipMap          = false;
    fpreal MinLOD          =  0.0;
    fpreal MaxLOD          = -1.0; // Default no limit to mip levels
    bool   LinearInterp    = true;  // Use bilinear or trilinear interpolation
    bool   IntTexture      = false; // If INT/UINT 8/16 is normalized or as-is
    bool   SampleTexels    = false; // if UV is [0,1] (false) or [0,res) (true).
    bool   CheckAlpha      = false; // check for detailed info about alpha
    int    Anisotropy      = 4;
    RV_TextureWrap WrapU   = RV_TEX_WRAP_REPEAT; // behaviour outside (0,1) uv
    RV_TextureWrap WrapV   = RV_TEX_WRAP_REPEAT;
    RV_TextureWrap WrapW   = RV_TEX_WRAP_REPEAT;
    fpreal32       BorderColor[4] = { 0.0, 0.0, 0.0, 0.0 };
    bool   IsData          = false;
};


/// Opaque reference to a texture stored in the RV_TextureCache
class RV_TextureRef
{
public:
    /// Reference to a valid texture
    bool isValid() const
        { return myTexID != -1 && !myIsMissingTex; }

    /// Texture is missing; a default color used instead
    bool isPlaceholder() const
        { return myIsPlaceholder; }
    /// Texture couldn't be found or resolved
    bool isMissingTex() const
        { return myIsMissingTex; }
    /// Texture is currently loading in the background
    bool isLoading() const
        { return myIsLoading; }
    /// Texture has been changed since last check
    bool isDirty() const
        { return myIsDirty; }

    /// Reset the reference to a null handle.
    void reset()
        {
            myTexID = -1;
            myIsMissingTex = false;
            myIsPlaceholder = false;
            myIsDirty = true;
            myIsLoading = false;
            myCacheVersion = 0;
            myCacheRefresh = 0;
        }

    /// Returns true if the reference is to a series of UDIM texture files
    bool isUDIM() const { return myUDIMW > 0; }
    /// Returns the UDIM range of the texture files (eg. (0,0) -> (3,2))
    void getUDIMParms(int &x, int &y, int &w, int &h) const
        {
            x = myUDIMX;
            y = myUDIMY;
            w = myUDIMW;
            h = myUDIMH;
        }
    
private:
    exint myTexID         = -1;
    exint myCacheVersion  = 0;
    exint myCacheRefresh  = 0;
    bool  myIsMissingTex  = false;
    bool  myIsPlaceholder = false;
    bool  myIsLoading     = false;
    bool  myIsDirty       = false;

    int8  myUDIMX = 0;
    int8  myUDIMY = 0;
    int8  myUDIMW = 0;
    int8  myUDIMH = 0;
 
    RV_ImageDim myTexType;
    
    friend class RV_TextureCache;
};

enum RV_UniformVarType
{
    RV_UNIFORM_MEMBER = 0,
    RV_UNIFORM_PUSH_CONSTANT,
    RV_UNIFORM_SAMPLER,
    RV_UNIFORM_SAMPLER_MULTISAMPLE,
    RV_UNIFORM_SAMPLER_SHADOW,
    RV_UNIFORM_IMAGE,
    //RV_UNIFORM_IMAGE_UNTYPED, // for `shaderStorageImageReadWithoutFormat`
    RV_UNIFORM_SAMPLED_IMAGE,
    RV_UNIFORM_SEPARATE_SAMPLER,
    RV_UNIFORM_INPUT_ATTACHMENT,
};

// Testing using a struct type instead of giant enum 
// -- worried the helper functions for the giant enum 
//    will be fragile when we want to add new types
struct RV_UniformType2
{
    unsigned int        vecsize     : 2;
    RV_GPUType          data_type   : 4;
    RV_UniformVarType   var_type    : 4;
    RV_ImageDim         image_dim   : 4;
};

enum RV_UniformType
{
    RV_UNIFORM_INVALID = -1,
    RV_UNIFORM_FLOAT = 0,
    RV_UNIFORM_FLOAT_VEC2,
    RV_UNIFORM_FLOAT_VEC3,
    RV_UNIFORM_FLOAT_VEC4,
    RV_UNIFORM_DOUBLE,
    RV_UNIFORM_DOUBLE_VEC2,
    RV_UNIFORM_DOUBLE_VEC3,
    RV_UNIFORM_DOUBLE_VEC4,
    RV_UNIFORM_INT,
    RV_UNIFORM_INT_VEC2,
    RV_UNIFORM_INT_VEC3,
    RV_UNIFORM_INT_VEC4,
    RV_UNIFORM_UNSIGNED_INT,
    RV_UNIFORM_UNSIGNED_INT_VEC2,
    RV_UNIFORM_UNSIGNED_INT_VEC3,
    RV_UNIFORM_UNSIGNED_INT_VEC4,
    RV_UNIFORM_UNSIGNED_INT64,
    RV_UNIFORM_BOOL,
    RV_UNIFORM_BOOL_VEC2,
    RV_UNIFORM_BOOL_VEC3,
    RV_UNIFORM_BOOL_VEC4,
    RV_UNIFORM_FLOAT_MAT2,
    RV_UNIFORM_FLOAT_MAT3,
    RV_UNIFORM_FLOAT_MAT4,
    RV_UNIFORM_FLOAT_MAT3X4,
    RV_UNIFORM_DOUBLE_MAT2,
    RV_UNIFORM_DOUBLE_MAT3,
    RV_UNIFORM_DOUBLE_MAT4,
    RV_UNIFORM_DOUBLE_MAT3X4,
    RV_UNIFORM_SAMPLER_1D,
    RV_UNIFORM_SAMPLER_2D,
    RV_UNIFORM_SAMPLER_3D,
    RV_UNIFORM_SAMPLER_CUBE,
    RV_UNIFORM_SAMPLER_RECTANGLE,
    RV_UNIFORM_SAMPLER_1D_ARRAY,
    RV_UNIFORM_SAMPLER_2D_ARRAY,
    RV_UNIFORM_SAMPLER_CUBE_ARRAY,
    RV_UNIFORM_SAMPLER_2D_MULTISAMPLE,
    RV_UNIFORM_SAMPLER_2D_SHADOW,
    RV_UNIFORM_SAMPLER_BUFFER,
    RV_UNIFORM_INT_SAMPLER_BUFFER,
    RV_UNIFORM_UNSIGNED_INT_SAMPLER_BUFFER,
    RV_UNIFORM_IMAGE_1D,
    RV_UNIFORM_IMAGE_2D,
    RV_UNIFORM_IMAGE_3D,
    RV_UNIFORM_IMAGE_CUBE,
    RV_UNIFORM_IMAGE_RECTANGLE,
    RV_UNIFORM_IMAGE_BUFFER,
    RV_UNIFORM_IMAGE_1D_ARRAY,
    RV_UNIFORM_IMAGE_2D_ARRAY,
    RV_UNIFORM_IMAGE_CUBE_MAP_ARRAY,
    RV_UNIFORM_IMAGE_2D_MULTISAMPLE,
    RV_UNIFORM_IMAGE_2D_MULTISAMPLE_ARRAY,
    RV_UNIFORM_IMAGE_INT_1D,
    RV_UNIFORM_IMAGE_INT_2D,
    RV_UNIFORM_IMAGE_INT_3D,
    RV_UNIFORM_IMAGE_INT_RECTANGLE,
    RV_UNIFORM_IMAGE_INT_CUBE,
    RV_UNIFORM_IMAGE_INT_BUFFER,
    RV_UNIFORM_IMAGE_INT_1D_ARRAY,
    RV_UNIFORM_IMAGE_INT_2D_ARRAY,
    RV_UNIFORM_IMAGE_INT_CUBE_MAP_ARRAY,
    RV_UNIFORM_IMAGE_INT_2D_MULTISAMPLE,
    RV_UNIFORM_IMAGE_INT_2D_MULTISAMPLE_ARRAY,
    RV_UNIFORM_IMAGE_UINT_1D,
    RV_UNIFORM_IMAGE_UINT_2D,
    RV_UNIFORM_IMAGE_UINT_3D,
    RV_UNIFORM_IMAGE_UINT_RECTANGLE,
    RV_UNIFORM_IMAGE_UINT_CUBE,
    RV_UNIFORM_IMAGE_UINT_BUFFER,
    RV_UNIFORM_IMAGE_UINT_1D_ARRAY,
    RV_UNIFORM_IMAGE_UINT_2D_ARRAY,
    RV_UNIFORM_IMAGE_UINT_CUBE_MAP_ARRAY,
    RV_UNIFORM_IMAGE_UINT_2D_MULTISAMPLE,
    RV_UNIFORM_IMAGE_UINT_2D_MULTISAMPLE_ARRAY,
    RV_UNIFORM_STRUCT,

    RV_UNIFORM_TYPE__count
};

enum RV_PrimType
{
    RV_PRIM_NONE,
    RV_PRIM_AS_IS = RV_PRIM_NONE,

    RV_PRIM_POINTS,

    RV_PRIM_LINES,
    RV_PRIM_LINE_STRIP,
    RV_PRIM_LINE_LOOPS, // NOTE: no direct Vk analogue

    RV_PRIM_TRIANGLES,
    RV_PRIM_TRIANGLE_STRIP,
    RV_PRIM_TRIANGLE_FAN,

    RV_PRIM_LINES_ADJACENT,      // for geometry shaders; includes
    RV_PRIM_LINE_STRIP_ADJACENT, // extra vertices outside the primitive
    RV_PRIM_TRIANGLES_ADJACENT,  // for curvature
    RV_PRIM_TRIANGLE_STRIP_ADJACENT,

    RV_PRIM_POLYGONS, // NOTE: no direct Vk analogue

    RV_PRIM_PATCHES, // Patches sent to tessellation shaders

    RV_NUM_PRIM_TYPES
};

enum RV_TopologyClass
{
    RV_TOPOLOGY_UNKNOWN = -1,
    RV_TOPOLOGY_POINT = 0,
    RV_TOPOLOGY_LINE,
    RV_TOPOLOGY_TRIANGLE,
    RV_TOPOLOGY_PATCH,
    RV_NUM_TOPO_TYPES
};

enum RV_AttachmentType
{
    RV_COLOR_BUFFER,
    RV_DEPTH_BUFFER,
    RV_DEPTH_STENCIL_BUFFER,
    // RV_RESOLVE_BUFFER, // for now uneeded; we handle resolve in shader
};

enum RV_ImageOp
{
    RV_IMAGE_LOAD,
    RV_IMAGE_CLEAR,
    RV_IMAGE_DONT_CARE,
};

enum RV_RenderPassType
{
    RV_PASS_WHOLE,
    RV_PASS_INITIAL,
    RV_PASS_MIDDLE,
    RV_PASS_FINAL,
};

enum RV_ShaderType
{
    RV_SHADER_UNKNOWN = 0,
    RV_SHADER_GRAPHICS,
    RV_SHADER_COMPUTE,
    RV_SHADER_RAY_TRACE,
};

enum RV_PolygonMode
{
    RV_POLYGON_FILL,
    RV_POLYGON_LINE,
    RV_POLYGON_POINT
};

enum RV_LogicOp
{
    RV_LOGIC_NO_OP = 0,
    RV_LOGIC_AND,
    RV_LOGIC_OR,
    RV_LOGIC_XOR,
    RV_LOGIC_INVERT,
};

enum RV_StageGroup
{
    RV_STAGE_NONE = -1,
    RV_STAGE_ANY = 0, // ALWAYS need to be execute
    RV_STAGE_TRANSFER,
    RV_STAGE_GRAPHICS,
    RV_STAGE_COMPUTE,
    RV_STAGE_RAY,
    RV_STAGE_ANY_SHADER, // will be run for UBOs/SSBOs which can be consumed by compute or graphics pipelines
    RV_STAGE_NUM,
};

typedef UT_StringArray RV_OverrideList;

RV_API bool RVgetUniformFormat(
        RV_UniformType t,
        RV_GPUType &out_type,
        int &out_vecsize);
RV_API RV_ImageDim RVgetUniformTypeImageDim(RV_UniformType t);

inline bool RVisUIntGPUType(RV_GPUType gpu_type)
{
    return gpu_type >= RV_GPU_UINT8 && gpu_type <= RV_GPU_UINT32;
}

inline bool RVisIntGPUType(RV_GPUType gpu_type)
{
    return gpu_type >= RV_GPU_INT8 && gpu_type <= RV_GPU_INT32;
}

inline bool RVisFloatGPUType(RV_GPUType gpu_type)
{
    return gpu_type >= RV_GPU_FLOAT16 && gpu_type <= RV_GPU_FLOAT64;
}

inline bool RVisMatrixGPUType(RV_GPUType gpu_type)
{
    return gpu_type >= RV_GPU_MATRIX2 && gpu_type <= RV_GPU_MATRIX4;
}

inline uint32_t RVsizeOfGPUType(RV_GPUType gpu_type)
{
    int bpp = 32;

    switch (gpu_type)
    {
        // NOTE: that int-1 and int-4 don't correspond to
        //       actual Vulkan types
        case RV_GPU_UINT1:   
            bpp = 1; break;
        case RV_GPU_UINT4:   
            bpp = 4; break;

        case RV_GPU_INT8:
        case RV_GPU_UINT8:
          bpp = 8; break;

        case RV_GPU_INT16:
        case RV_GPU_UINT16:
        case RV_GPU_FLOAT16:
            bpp = 16; break;

        case RV_GPU_INT32:
        case RV_GPU_UINT32:
        case RV_GPU_FLOAT32:
        case RV_GPU_FLOAT24:
            bpp = 32; break;

        case RV_GPU_FLOAT64: 
            bpp = 64; break;

        case RV_GPU_MATRIX2: 
            bpp = 32 * 4; break;
        case RV_GPU_MATRIX3:
            bpp = 32 * 9; break;
        case RV_GPU_MATRIX4:
            bpp = 32 * 16; break;
        default:
            bpp = 32;
            UT_ASSERT_MSG(0, "RVsizeOfGPUType(): Unrecognized RV_GPUType");
    }

    return bpp;
}

inline RV_TextureWrap RVconvertToTextureWrap(RE_TexClampType type)
{
    switch(type)
    {
    case RE_CLAMP_REPEAT : return RV_TEX_WRAP_REPEAT;
    case RE_CLAMP_BORDER : return RV_TEX_WRAP_BORDER;
    case RE_CLAMP_EDGE   : return RV_TEX_WRAP_CLAMP;
    case RE_CLAMP_MIRROR : return RV_TEX_WRAP_MIRROR;
    }
    return RV_TEX_WRAP_REPEAT;
}

inline RV_TopologyClass RVgetTopologyClass(RV_PrimType t)
{
    switch (t) 
    {
        case RV_PRIM_POINTS :
            return RV_TOPOLOGY_POINT;
        case RV_PRIM_LINES:
        case RV_PRIM_LINE_STRIP:
        case RV_PRIM_LINES_ADJACENT:
        case RV_PRIM_LINE_STRIP_ADJACENT: 
            return RV_TOPOLOGY_LINE;
        case RV_PRIM_TRIANGLES:
        case RV_PRIM_TRIANGLE_STRIP:
        case RV_PRIM_TRIANGLE_FAN:
        case RV_PRIM_TRIANGLES_ADJACENT:
        case RV_PRIM_TRIANGLE_STRIP_ADJACENT:
            return RV_TOPOLOGY_TRIANGLE;
        case RV_PRIM_PATCHES:
            return RV_TOPOLOGY_PATCH;
        default: break;
    }
    UT_ASSERT(false && "Unrecognized Topology Type used for Pipeline");
    return RV_TOPOLOGY_UNKNOWN;
}

inline RV_PrimType RVconvertToRVPrim(RE_PrimType type)
{
    switch(type)
    {
    case RE_PRIM_POINTS                 : return RV_PRIM_POINTS;
    case RE_PRIM_LINES                  : return RV_PRIM_LINES;
    case RE_PRIM_LINE_STRIP             : return RV_PRIM_LINE_STRIP;
    case RE_PRIM_TRIANGLES              : return RV_PRIM_TRIANGLES;
    case RE_PRIM_TRIANGLE_STRIP         : return RV_PRIM_TRIANGLE_STRIP;
    case RE_PRIM_TRIANGLE_FAN           : return RV_PRIM_TRIANGLE_FAN;
    case RE_PRIM_LINES_ADJACENT         : return RV_PRIM_LINES_ADJACENT;
    case RE_PRIM_LINE_STRIP_ADJACENT    : return RV_PRIM_LINE_STRIP_ADJACENT;
    case RE_PRIM_TRIANGLES_ADJACENT     : return RV_PRIM_TRIANGLES_ADJACENT;
    case RE_PRIM_TRIANGLE_STRIP_ADJACENT: return RV_PRIM_TRIANGLE_STRIP_ADJACENT;
    case RE_PRIM_POLYGONS               : return RV_PRIM_POLYGONS;
    case RE_PRIM_PATCHES                : return RV_PRIM_PATCHES;
    case RE_PRIM_NONE       :
    case RE_NUM_PRIM_TYPES  :
    case RE_PRIM_LINE_LOOP  :
    default : break;
    }
    return RV_PRIM_NONE;
}

const char *RVgetTypeName(RV_GPUType t);

const char *RVgetPrimName(RV_PrimType p);

const char *RVgetUniformTypeName(RV_UniformType t);

int RVgetPointsPerPrim(RV_PrimType p);

int RVgetNumberOfPrim(RV_PrimType p, int num_verts);

#endif