GR_PolyRibbonVK.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_PolyRibbonVK (GR Library, C++)
 *
 * COMMENTS:
 *      Ribbon (curve with per-point thickness) renderer.
 */
#ifndef GR_PolyRibbonVK_h
#define GR_PolyRibbonVK_h

#include "GR_API.h"
#include "GR_GeoRenderVK.h"

#include <GT/GT_DANumeric.h>
#include <RV/RV_ShaderBlock.h>
#include <UT/UT_Map.h>

class GT_PrimCurveMesh;

class GR_API GR_PolyRibbonVK : public GR_GeoRenderVK {
public:
    static bool         initShaders(RV_Instance* inst);
    static void         cleanupShaders();

                        GR_PolyRibbonVK(GR_Primitive *prim);
                       ~GR_PolyRibbonVK() override;

    const char         *className() const override { return "GR_PolyRibbonVK"; }

    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;

    void                getPickConnectGroup(unsigned int pick_mode,
                                            GR_PickGeometry pick_geo,
                                            int &out_connect_start,
                                            int &out_connect_num) override;
    
    void                getVkDecorGeometry(GR_DecorationRender::
                                    PrimitiveType prim_type,
                                    RV_PrimType render_prim,
                                    RV_Geometry &geo,
                                    int &out_connect_start,
                                    int &out_connect_num) override;

    exint               getNumGLPrimitives() const override;
    
    // handle transparently internally, not part of the transparency pass
    bool                hasTransparency() const override
                            { return false; }

    void                setSubdivisionCurve(bool is_subdiv);

    struct CachedAuxFeatherBarbAttr {
        UT_UniquePtr<RV_ShaderBlock> myBlock;
        int64 myDataId = -1;
    };
    struct FeatherBlockSet {
        // these buffers exist iff the corresponding attributes exist
        UT_UniquePtr<RV_ShaderVariableSet> mySet;
        UT_UniquePtr<RV_ShaderBlock>       myInfoBlock;
        CachedAuxFeatherBarbAttr myPos, myUV, myColour, myWidth;
    };
    struct FeatherBlockSets {
        FeatherBlockSet left, right;
    };
private:
    typedef UT_Map<uint32, UT_Int32Array> ConnectsMap;
    // with only vertex attribs
    GT_PrimitiveHandle                 myModifiedMesh;
    UT_Int32Array                      myConnectGroupMats;
    // combine these into 1 struct so that in the case where this object does
    // *not* represent a collection of feathers, only 1 pointer is wasted.
    UT_UniquePtr<FeatherBlockSets>     myFeatherBlocks;
    bool                               myIsSubdivisionCurve : 1;
    unsigned                           myBarbMode : 2;
    bool                               myHasWidth;
    bool                               myObjectSelected;
    bool                               myForceWireframe = false;
    bool               setupFeatherShaderBlock(
                           UT_UniquePtr<RV_ShaderBlock> &block,
                           const char *const binding_name,
                           const exint element_count,
                           RV_Render &r);
    bool               updateBarbVectorBlock(UT_UniquePtr<RV_ShaderBlock> &block,
                                             RV_Render &r,
                                             GT_DataArrayHandle barb_attr,
                                             const char *binding_name);
    bool               updateBarbUVBlock(UT_UniquePtr<RV_ShaderBlock> &block,
                                         RV_Render &r,
                                         GT_DataArrayHandle barb_attr);
    void               buildSimpleConnectivity(const GT_PrimCurveMesh &mesh,
                                               UT_Int32Array &out_connect);
    void               buildConnectivity(const GT_PrimCurveMesh &mesh,
                                         ConnectsMap &connects_map,
                                         UT_Int32Array &out_curve_order,
                                         GT_DataArrayHandle attr_mat_id);
    void               drawBarbsOnOneSide(RV_Render &r,
                                          RV_ShaderProgram &feather_shader,
                                          FeatherBlockSet &block_set,
                                          GR_DrawParms dp,
                                          uint32_t connect_i);
    void updateBarbBlocks(RV_Render &r,
                          const GT_PrimitiveHandle &primh,
                          const UT_String &pos_attrib_name,
                          const UT_String &uv_attrib_name,
                          const UT_String &colour_attrib_name,
                          const UT_String &width_attrib_name,
                          FeatherBlockSet FeatherBlockSets::*blocks_ptr,
                          bool has_barb_orient);
    GT_DataArrayHandle genUAttr(const GT_PrimCurveMesh &mesh);
};
#endif