GR_SpriteVK.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_SpriteVK (GR Library, C++)
 *
 * COMMENTS:
 *      Sprite (view-aligned textured quads) rendering for Vulkan.
 */

#include "GR_GeoRenderVK.h"
#include "GR_UtilsVK.h"
#include <GT/GT_PrimPointMesh.h>

#define GPU_SORT

class GR_API GR_SpriteVK : public GR_GeoRenderVK {
public:
    GR_SpriteVK(GR_Primitive *prim);
    ~GR_SpriteVK() override;
    const char *className() const override { return "GR_SpriteVK"; }

    void        update(RE_RenderContext rc,
                       const GT_PrimitiveHandle &primh,
                       const GR_UpdateParms     &parms,
                       const char               *cache_name) override;

    void        draw(RE_RenderContext rc,
                     GR_RenderMode mode,
                     GR_RenderFlags flags,
                     GR_DrawParms dp) override;

    bool        hasTransparency() const override;

    exint       getNumGLPrimitives() const override;

    bool        hasLitSpheres() const { return myIsLitSpheres; }

    void        getPickConnectGroup(unsigned int pick_mode,
                                    GR_PickGeometry,
                                    int &out_connect_start,
                                    int &out_connect_num) override;

    void                getVkDecorConnectGroup(RV_PrimType render_prim,
                                    bool is_uv_view,
                                    int &out_connect_start,
                                    int &out_connect_num) override;

    static bool initShaders(RV_Instance* inst);
    static void cleanupShaders();

private:
    // maps material id -> connect group index
    typedef UT_Map<uint32, uint32> ConnectsMap;
    void        uploadIndexBuffer(RV_Render&, const uint32 connect_idx);
    RV_ShaderProgram *getShader(exint shader_bits, const char *for_what);
    void        fillGeoAlphaBlock(RV_Render&,
                                  bool geo_use_blend,
                                  const GT_DataArrayHandle sprite_cutoff_attr);
    // returns whether successful
    void        groupByMaterial(const GT_PrimPointMesh&,
                                const GR_MaterialAtlas&,
                                UT_Int32Array *opaque_mat_group_idxs);
    void        drawMaterialGroup(RE_RenderContext, RV_Render&, GR_RenderMode,
                                  GR_RenderFlags, const GR_DrawParms&,
                                  uint32 connect_idx);
    void        drawAsPoints(RE_RenderContext rc,
                             const GR_RenderMode mode,
                             const GR_RenderFlags flags,
                             const GR_DrawParms &dp,
                             const uint32 connect_idx);

    struct TexturedData
    {
        UT_String tex_files; // all file names concatenated into one string
        UT_UniquePtr<RV_ShaderBlock> geo_alpha_cutoff_uniform;
        UT_UniquePtr<RV_ShaderVariableSet> shader_var_set;
        OP_Node *parent_node;
    };

    // myConnectGroupMats maps
    // connect_idx -> pair{mat_id, is_idx_buffer_uploaded}. It is necessary to
    // keep track of whether the current index buffer is uploaded because we
    // might not know until a call to `draw` whether a connect group is
    // translucent, because that depends on the AlphaMode material property. In
    // this case, the index buffer won't have been uploaded in the call to
    // `update`, so it needs to be uploaded in `draw`, despite the index buffer
    // not needing to be sorted.
    UT_Int32Array              myConnectGroupMats;
    UT_Array<UT_Int32Array>    mySortedIndexArrays;
    GT_DataArrayHandle         myPoints;
    struct ViewDistance {
        fpreal32 view_distance;
        int32 index;
    };
    UT_Array<ViewDistance>     myViewDistances;
    UT_UniquePtr<TexturedData> myTexturedData;
    signed   myTranslucentPassId;
    bool     myHasAlpha : 1;
    bool     myHasNormal : 1;
    bool     myHasRotation : 1;
    bool     myHasSpriteScale : 1;
    bool     myIsLitSpheres : 1;
    bool     myNeedsBlending : 1;

#ifdef GPU_SORT
    UT_UniquePtr<GR_Utils::RadixSortGPU> myRadixSort;
    UT_UniquePtr<RV_VKBuffer> myDistanceBuffer;
    UT_UniquePtr<RV_VKBuffer> myIndicesBuffer;
#endif
};