GR_GeoRender.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_GeoRender.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Base class for all drawing methods that Houdini is natively capable of
 *      rendering.
 */
#ifndef GR_GeoRender_H
#define GR_GeoRender_H

class OP_Node;
class GU_Detail;
class GR_DisplayOption;
class GR_RenderInfo;
class UT_StringArray;
class GT_CountArray;
class GA_BreakpointGroup;
class GR_Primitive;
class RE_Geometry;
class RV_Geometry;

#include <RE/RE_RenderContext.h>
#include <UT/UT_Array.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Vector4.h>
#include <GT/GT_DataArray.h>
#include <GT/GT_Primitive.h>
#include <GA/GA_ElementGroup.h>
#include <GA/GA_EdgeGroup.h>

#include "GR_DrawParms.h"
#include "GR_MaterialGroups.h"
#include "GR_PickRecord.h"
#include "GR_UpdateParms.h"
#include "GR_ErrorManager.h"

class GR_API GR_GeoRender
{
public:
    enum RenderType { OPENGL, VULKAN };

             GR_GeoRender(GR_Primitive *parent_prim, RenderType type);
    virtual ~GR_GeoRender();

    virtual const char *className() const = 0;

    bool isGL() const { return myRenderer == OPENGL; }
    bool isVulkan() const { return myRenderer == VULKAN; }

    /// Update the geometry of this render object using the GT primitive. No
    /// rendering commands should be issued.
    virtual void        update(RE_RenderContext          r,
                               const GT_PrimitiveHandle &primh,
                               const GR_UpdateParms     &p,
                               const char               *cache_name) = 0;

    /// Called when the view changes, if the parent primitive requested view
    /// changes
    virtual void        viewUpdate(RE_RenderContext r,
                                   const GR_DisplayOption &opts,
                                   const char *cache_name,
                                   RE_CacheVersion geo_version,
                                   RE_CacheVersion select_version)
                        {}

    /// Normal drawing method. Only issue rendering commands.
    virtual void        draw(RE_RenderContext r,
                             GR_RenderMode mode,
                             GR_RenderFlags flags,
                             GR_DrawParms draw_parms) = 0;

    /// By default, no instanced drawing support.
    virtual bool        supportsInstances() const { return false; }

    virtual bool         isConvexed() const    { return myConvexFlag; }

    /// Called if another entity makes changes to the RE_Geometry after update()
    /// is called (usually the entity is a GR_Primitive object).
    virtual void                 geometryUpdated(RE_RenderContext )     {}

    virtual void                 retireGeometry() {}

    /// returns true if this drawable renders some transparent elements
    virtual bool                 hasTransparency() const { return false; }


    /// return the number of GL primitives that this renderer produces. May be
    /// roughly estimated.
    virtual exint                getNumGLPrimitives() const = 0;

    virtual RE_Geometry         *getGeometry() { return nullptr; }

    virtual RV_Geometry         *getVkGeometry() { return nullptr; }

    virtual void                 getPickConnectGroup(unsigned int pick_mode,
                                                     GR_PickGeometry pick_geo,
                                                     int &out_connect_start,
                                                     int &out_connect_num) {} // = 0;

    // Get connect group and num, then use them to get connect group end, used by
    // some functions
    void                         getPickConnectGroup(unsigned int pick_mode,
                                                     GR_PickGeometry pick_geo,
                                                     int &out_connect_start,
                                                     int &out_connect_num,
                                                     int &out_connect_end)
                            {
                                getPickConnectGroup(pick_mode, pick_geo,
                                                    out_connect_start,
                                                    out_connect_num);
                                if (out_connect_num > 0 && 
                                    out_connect_num < 0x40000000)
                                { 
                                    out_connect_end = out_connect_start 
                                                    + out_connect_num - 1;
                                }
                                else
                                    out_connect_end = -1;
                            };

    /// check if there is a specifc geometry and connect group that should be
    /// used for pick rendering
    virtual RV_Geometry         *getVkPickGeometry(unsigned int pick_mode)
                                                {
                                                    return getVkGeometry();
                                                }

    // Accessors to various high-level data
    bool                         showSelections() const;
    GR_RenderVersion             getRenderVersion() const;

    void                         allowGeoOverride(bool allow_overrides);

    virtual bool                 canFrustumCull() { return true; }
    bool                         inViewFrustum(const UT_Matrix4D &objviewproj,
                                               const UT_BoundingBoxD *bbox);
    bool                         isRasterizedInView(
                                       const UT_Matrix4F &objviewproj,
                                       const UT_Vector2F &min_proj_size,
                                       const UT_BoundingBoxF *bbox=nullptr);
                            
    GR_BasePrimType              getParentType() const;

    RenderType                   getRenderType() const { return myRenderer; }
    
    GR_Primitive*                getParent() { return myParentPrim; }

    void                         buildInformation(bool prim_id,
                                                  bool point_id)
                                    {
                                        myBuildPrimInfo = prim_id;
                                        myBuildPointInfo = point_id;
                                    }
    bool                         shouldBuildPrimID() const
                                    { return myBuildPrimInfo; }
    bool                         shouldBuildPointID() const
                                    { return myBuildPointInfo; }
    
    void                         setSelectionMask(GR_AttribMask selection_mask)
                                    { mySelectionMask = selection_mask; }
    GR_AttribMask                getSelectionMask() const
                                    { return mySelectionMask; }

    void                         setSelectionDisplayMode(GR_SelectMode m)
                                    { myCurrentSelection = m; }
    GR_SelectMode                getSelectionDisplayMode() const
                                    { return myCurrentSelection; }

    void                         setSelectionInstance(int i)
                                    { myCurrentPointSelectInstance = i; }
    int                          getSelectionInstance() const
                                    { return myCurrentPointSelectInstance; }

    void                         setMaterialOverride(int mat_index)
                                    { myMaterialOverride = mat_index; }
    void                         clearMaterialOverride()
                                    { myMaterialOverride = -1; }

    bool                         getDetailPrimID(int &id) const
                                    {
                                        if(myHasDetailPrimID)
                                        {
                                            id = myDetailPrimID;
                                            return true;
                                        }
                                        id = 0;
                                        return false;
                                    }
    virtual void gpuMemoryUsage(exint &used_bytes,
                                exint &unused_bytes,
                                exint &pinned_bytes) {}

    // Message and error reporting
    void        addUpdateMessage(GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());
    void        addUpdateWarning(GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());
    void        addUpdateError  (GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());
    void        addUpdateFatal  (GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());   
    void        addRedrawMessage(GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());
    void        addRedrawWarning(GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());
    void        addRedrawError  (GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());
    void        addRedrawFatal  (GR_ErrorManager::Source err_source,
                                 GR_ErrorCode    gr_code,
                                 UT_StringHolder extra_text=UT_StringHolder(),
                                 UT_StringHolder src_name=UT_StringHolder());

protected:
    GR_AttribMask hasAttribute(const GT_Primitive *prim,
                               const char *name,
                               GT_DataArrayHandle &h) const;


    GT_PrimitiveHandle  getCachedGTPrimitive();
    void                cacheGTPrimitive(GT_PrimitiveHandle &primh);

    int                  getCurrentLayer() const
                         { return myCurrentLayer; }

    // for the materials in matlist, map them to the shop_*path in 'prim'.
    // returns 'matmap' array which indicates what the index in shop_*path is
    // for the materials it matlist.
#ifdef USE_MATERIAL_MAP
    bool buildMaterialMap(const GT_Primitive    *prim,
                          const RE_MaterialAtlas &mats,
                          UT_IntArray           &matmap);
#endif


    // Helpers for selection

    // implemented for: T = uint8, T = int32
    template <typename T>
    GR_SelectMode       addToPointSelection(const UT_Span<T>      &out_select,
                                            const GU_Detail     &geo, 
                                            const GT_DataArrayHandle &vh,
                                            const GT_DataArrayHandle &vl,
                                            const GA_PointGroup *pntsel,
                                            bool use_vertex_for_point_select,
                                            bool &init);
    
    GR_SelectMode       addToVertexSelection(const UT_Span<uint8>     &out_select,
                                             const GU_Detail    &geo, 
                                             const GT_DataArrayHandle &vh,
                                             const GA_VertexGroup *vertsel,
                                             bool               &init);
    
    // implemented for: T = uint8, T = int32
    template <typename T>
    GR_SelectMode       addToEdgeSelection(const UT_Span<T>      &out_select,
                                           const GU_Detail      &geo, 
                                           const GT_DataArrayHandle &vt,
                                           const GT_DataArrayHandle &vert_list,
                                           const GA_EdgeGroup   *edgesel,
                                           bool                 &init);
    
    GR_SelectMode       addToPrimSelection(const UT_Span<uint8>     &out_select,
                                           const GT_DataArrayHandle &vh,
                                           const GA_PrimitiveGroup  *primsel,
                                           bool                     &init);

public:
    // For derived class's parallel helpers
    GT_DataArrayHandle    buildPointIDData(const GT_Primitive &prim,
                                           const GU_ConstDetailHandle &geo,
                                           int npoints);
    GT_DataArrayHandle    buildPrimitiveIDData(const GT_Primitive &prim,
                                               const GU_ConstDetailHandle &geo);

    static bool           createTanAttrib(UT_Vector4F *tan_data,
                                          const GT_DataArray *nml,
                                          const GT_DataArray *tanu,
                                          const GT_DataArray *tanv,
                                          const GT_DataArray *vlist);
    
    void          setGeoBounds(const UT_BoundingBox &b) { myBounds = b; }
    const UT_BoundingBoxD &getGeoBounds() const { return myBounds; }

protected:
    RenderType           myRenderer;
    const GR_RenderInfo *myInfo;
    GR_MaterialGroups    myMatGroups;
    UT_BoundingBoxD      myBounds;
    unsigned             myBuildPointInfo : 1,
                         myBuildPrimInfo : 1,
                         myHasDetailPrimID : 1,
                         myHasInstancedTransform : 1,
                         myHasIdentityTransform : 1,
                         myUseBoneDeform : 1,
                         myNumBoneDeform : 2,
                         myAllowGeoOverride : 1;

    UT_Matrix4D          myPrimitiveTransform;
    GR_AttribMask        mySelectionMask;
    GR_SelectMode        myCurrentSelection;
    int                  myCurrentPointSelectInstance;
    int                  myMaterialOverride;
    int                  myConvexFlag;
    int                  myDetailPrimID;

    GR_Primitive        *myParentPrim;
    int                  myCurrentLayer;
};

#endif