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_ScopeExit.h>
#include <UT/UT_VectorTypes.h>
#include <GT/GT_Primitive.h>
#include <GT/GT_Types.h>

#include <RV/RV_Type.h>
#include <RV/RV_Render.h>

#include "GR_Uniforms.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,
                                             const UT_Span<uint8> &out_data = UT_Span<uint8>());

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,
                                    uint32_t array_size = 0);
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);

template <typename Range, typename Body>
void renderParallelFor(RE_RenderContext main_rc, const Range &range, const Body &body,
                       int subscribe_ratio = 2,
                       int min_grain_size = 1)
{
    exint size = UTestimatedNumItems(range);
    UT_ASSERT(main_rc.isVulkan() || size == 0);
    if (size == 0)
        return;

    if (!main_rc.isVulkan())
    {
        body(main_rc, range);
        return;
    }

#ifdef USE_VULKAN
    // Vulkan Pre-amble: quite out if task is too small or MT is disabled
    int nthreads = SYSmin(
            main_rc.vkRender()->getNumRenderThreads(),
            UT_Thread::getNumProcessors());

    // grain size to make tasks 1-to-1 with threads
    exint grain = SYSmax(1, (size/nthreads + ((size%nthreads) ? 1 : 0)));

    bool do_parallel = (nthreads > 1) && (grain >= min_grain_size);
    if (!do_parallel)
    {
        body(main_rc, range);
        return;
    }

    RV_Render* main_r = main_rc.vkRender();
    bool initial_split = main_r->isMainRender();
    UT_ASSERT(!(main_r->isMainRender() && main_r->isThreading()));
    UT_ASSERT(!(main_r->isMainRender() && !UT_Thread::isMainThread()));

    if (initial_split)
    {
        main_r->enableThreadedRender();
        GR_Uniforms::prepareThreadedUniforms(nthreads);
    }
    UT_AT_SCOPE_EXIT({
        if (initial_split)
        {
            GR_Uniforms::returnThreadedUniforms();
            main_r->endThreadedRender();
        }
    });

    // Copy state for thread -- don't want to grab directly from thread
    // in case we're called from a worker thread, and it's being modified
    GR_Uniforms* main_u = main_rc.uniforms();
    GR_Uniforms::ObjectUniforms objects = main_u->objects();
    GR_Uniforms::GlobalUniforms globals = main_u->globals();

    RV_Render::RenderState render_state = main_r->getRenderState();

    auto parallel_body = [&](const UT_BlockedRange<exint> &range)
    {
        int u_count = 0;
        int r_count = 0;
        int r_idx = -1;
        RV_Render* r = main_r->getThreadedRender(r_count, r_idx);
        GR_Uniforms* u = GR_Uniforms::getForThread(&u_count, r_idx);
        RE_RenderContext rc(nullptr, r, u);

        // setup Render
        exint vk_frame = r->beginFrame();
        UT_ASSERT( vk_frame >= 2); // should have already been called by `enableThreadedRender()`
        r->copyRenderState(&render_state);

        // cleanup Render
        UT_ScopeExit scope_name([&](){
            if (vk_frame <= 2)
            {
#ifdef WIP_VULKAN_DEFER_DRAW
                //// If deferring draws them run them all within current CB
                if (r->myIsDeferring)
                {
                    r->runDraws();
                    r->clearDraws(); 
                }
#endif // WIP_VULKAN_DEFER_DRAW
            }
            r->endFrame(vk_frame);
            r->returnThreadedRender(r_count);
        });
    
        // setup uniform
        u->init(rc);
        exint l = u->pushObjectUniforms();
        u->objects() = objects;
        if ( memcmp(&((const GR_Uniforms*)u)->globals(), &globals, sizeof(globals)))
            u->globals() = globals;

        // cleanup uniform
        UT_AT_SCOPE_EXIT({
            u->popObjectUniforms(l);
            GR_Uniforms::returnForThread(&u_count);
        });

        body(rc, range);
    };

#define USE_ARENA

#ifdef USE_ARENA
    // with arena limit, can oversubscribe tasks
    // NOTE: still need to specifiy grain size manually, since the 
    //       grain calculation in `UTparallelFor` is based on total
    //       processor count, not limited by arena
    if (subscribe_ratio > 1)
        grain = SYSmax(min_grain_size, grain / subscribe_ratio);

    main_r->getTaskArena().execute([&](){
        UTparallelFor(range, parallel_body, 0, grain);
    });

    // need to restore state, most state is pushed/popped in
    //  `parallel_body()`, but some can't be yet, so reset here
    main_r->copyRenderState(&render_state);
    if ( memcmp(&((const GR_Uniforms*)main_u)->globals(), &globals, sizeof(globals)))
        main_u->globals() = globals;
#else
    // use caclulated grain to force grain size
    // will limit the number of threads used
    // -- can't call nested though, if it is called
    // while threading, just run the body directrly
    if (initial_split)
    {
        UTparallelFor(range, parallel_body, 0, grain);
    }
    else
    {
        body(main_rc, range);
    }
#endif
#endif // USE_VULKAN
}

}

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