GR_PrimInstance.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_PrimInstance.h (GR Library, C++)
 *
 * COMMENTS:
 */
#ifndef __GR_PrimInstance__
#define __GR_PrimInstance__

#include "GR_PrimPacked.h"
#include <GT/GT_PrimInstance.h>

class GR_API GR_PrimInstance : public GR_PrimPacked
{
public:
             GR_PrimInstance(const GR_RenderInfo *info,
                             const char *cache_name,
                             const GT_PrimitiveHandle &instance_prim,
                             const GT_PrimitiveHandle &instancer,
                             const UT_Matrix4DArray &instance_transforms,
                             const GU_ConstDetailHandle &instance_gdp,
                             int nest_level,
                             int prim_index = -1,
                             const UT_BoundingBox *bbox = nullptr);
            ~GR_PrimInstance() override;

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

    GR_BasePrimType     getBasePrimType() const override
                        { return GR_BASE_PRIM_INSTANCE; }

    void                setTransforms(const UT_Matrix4DArray &inst_transforms);

    void                setNestLevel(int nest_level)
                            {
                                myNestLevel = nest_level;
                                if(nest_level == 0)
                                    myTopLevelTransforms.entries(0);
                            }
    
    // when nested, the top-level transforms are needed to position the point
    // and primitive decorations.
    void                setTopTransforms(const UT_Matrix4DArray &top_xforms)
                        { myTopLevelTransforms = top_xforms; }
    void                setBounds(const UT_BoundingBox &bbox);
    bool                updateOnViewChange(
                                const GR_DisplayOption &dopts) const override
    { return ((getNumInstances() > 1) ||
              (myInstance?myInstance->updateOnViewChange(dopts):false)); }
    
    void                viewUpdate(RE_RenderContext r,
                                   const GR_ViewUpdateParms &parms) override;
    
    void                checkForDeferredDraw(RE_RenderContext r,
                                             GR_RenderMode mode,
                                             GR_RenderFlags flags,
                                             const GR_DrawParms &dp,
                                             const UT_Matrix4D &proj_view,
                                             const UT_Matrix4D &object,
                                             const UT_Vector2F &min_proj_size,
                                             bool &visible,
                                             bool &defer) override;

     void               update(RE_RenderContext           r,
                               const GT_PrimitiveHandle  &primh,
                               const GR_UpdateParms      &p) override;

    void                render(RE_RenderContext        r,
                               GR_RenderMode           render_mode,
                               GR_RenderFlags          flags,
                               GR_DrawParms            dp) override;

    bool                inViewFrustum(
                                const UT_Matrix4D &objviewprojj,
                                const UT_BoundingBoxD *bbox = nullptr) override;
    
    exint               getNumGLPrimitives(const GR_DisplayOption *) override;
 
    bool                getSingleTransform(UT_Matrix4D &mat) const override
                            {
                                if(getNumInstances() == 1)
                                {
                                    mat = myInstancedTransforms(0);
                                    return true;
                                }
                                return false;
                            }

    int                 getNumTopTransforms() const
                        {
                            if(myTopLevelTransforms.entries())
                                return myTopLevelTransforms.entries();
                            return myInstancedTransforms.entries();
                        }
    int                 getNumTransforms() const
                        {
                            return myInstancedTransforms.entries();
                        }

    void                setInstancer(const GT_PrimitiveHandle &ph);

    typedef GT_PrimInstance::ExtractTransformEntry ExtractTransformEntry;
    typedef GT_PrimInstance::ExtractTransformCache ExtractTransformCache;
    ExtractTransformCache &getExtractTransformCache()
                        { return myExtractTransfomCache; }

    UT_Matrix4DArray &getInstancedTransforms()
                        { return myInstancedTransforms; }

private:
    int                 getNumInstances() const override;
    UT_Matrix4D         getTransform(int instance_index) const override
                            { return myInstancedTransforms(instance_index); }
    
    void                buildInstancedSelection(RE_RenderContext r,
                                                const GR_UpdateParms &p);
    void                buildInstancedColor(RE_RenderContext r,
                                            const GR_UpdateParms &p);
    
    void                buildPoints(RE_RenderContext r,
                                    const GR_UpdateParms &p,
                                    bool check_lod_centroid);

    void                buildVisibilityInfo(RE_RenderContext r,
                                            const GR_DisplayOption &opts,
                                            const GR_FrustumList &frustums);
    void                buildInstanceIndexArrays(RE_RenderContext r,
                                                 bool has_partial_vis,
                                                 bool has_culled_instances,
                                                 const UT_IntArray &vis_insts);

    void                renderInstances(RE_RenderContext r, 
                                        GR_RenderMode    render_mode,
                                        GR_RenderFlags   render_flags,
                                        GR_DrawParms     dp);
    void                renderCentroidsOrBoxes(RE_RenderContext    r,
                                               GR_RenderMode       render_mode,
                                               GR_RenderFlags      render_flags,
                                               GR_DrawParms        dp);

    GR_SelectMode       buildSelectionFromAttrib(const GT_DataArrayHandle &sel);

    GR_SelectMode       buildSelectionFromAttrib(RE_RenderContext r,
                                                 RE_Geometry *geo,
                                                 const GR_UpdateParms &p,
                                                 const GT_DataArrayHandle &sel);

    GR_SelectMode       buildSelectionFromAttrib(RE_RenderContext r,
                                                 RV_Geometry *geo,
                                                 const GR_UpdateParms &p,
                                                 const GT_DataArrayHandle &sel);

    void                buildLODInfo();
    void                buildNestedInstancing();
    void                buildNestedVisibility(RE_RenderContext r,
                                              const GR_DisplayOption &opts,
                                              const UT_Matrix4FArray &frustums,
                                              const UT_BoundingBoxD &bbox);

    void                determineNestedVisibility(int offset,
                                                  int level,
                                                  int index,
                                                  int mult,
                                                  const UT_Matrix4F &pxform,
                                                  const UT_Array<UT_BoundingBoxF> &bboxes,
                                                  const UT_Matrix4FArray &frustums);
    
    // transforms from the GT prim itself. If nested, there will be more
    // instanced transforms than the top-level transforms (it'll be a multiple)
    UT_Matrix4DArray  myInstancedTransforms;

    // Decoration transforms, if nested (otherwise used instanced transforms)
    UT_Matrix4DArray  myTopLevelTransforms;

    // GT transforms convolved with object-level instancing
    UT_Matrix4DArray  myObjectInstancedTransforms;

    ExtractTransformCache myExtractTransfomCache;

    int                myNestLevel;
    int                myInstancesPerPrim;
    bool               myHasObjectInstancing;
    bool               myHasCentroidLOD;
    bool               myHasBBoxLOD;
    bool               myHasPointsLOD;
    bool               myHasFullLOD;
    bool               myIsInstanceFile;
    bool               myQueuedPointIDValid;
    bool               myRenderFullLOD;

    bool               myHasPartialVisibility;
    bool               myHasPartialBBoxVisibility;
    bool               myVisArraysDirty;
    UT_IntArray        myVisibleInstanceIndex;
    UT_Array<uint8>    myVisibleInstances;
    UT_Array<uint8>    myVisibleBBoxes;
    UT_IntArray        myDeferInstances;
    UT_IntArray        myDeferPointInstances;
    UT_Vector2i        myDeferInstanceRange;
    UT_Vector2i        myDeferPointInstanceRange;
    UT_IntArray        myFullInstances;
    UT_IntArray        myBBoxVisibleInstances;
    UT_Array<uint8>    mySelected;
    UT_Vector3FArray   myInstanceColors;
    
    int64              myNameDataId;
    int64              myInstanceId;

    UT_IntArray        myMaterials;
    UT_IntArray        myMaterialGroupsVisible;
    UT_IntArray        myNestedInstanceLevels;
    UT_BoundingBox     myPrimBBox;
};

#endif