GR_InstanceManager.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_InstanceManager (C++)
 *
 * COMMENTS:
 *   Global instance cache and global draw pass management
 * 
 */
#ifndef GR_InstanceManager_h
#define GR_InstanceManager_h


#include "GR_API.h"

#include <GT/GT_Primitive.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Map.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_VectorTypes.h>
#include <SYS/SYS_AtomicInt.h>

#include "GR_Defines.h"
#include "GR_CommonDispOption.h"
#include "GR_DrawParms.h"

class RE_Render;

class GR_API GR_InstanceManager : public UT_NonCopyable
{
public:
    static GR_InstanceManager &get() { return *theInstance; }

    // ------------------------------------------------------------------
    // Deferred Instance logging
    //
    // This allows you to register what you will be drawing, have everything
    // be globally processed to ensure a max poly count is respected, and get
    // the results of that
    // The bouding box, matrices, and arrays must not be deleted until the
    // request has been processed and you call getDrawRequestResult().

    bool isActive() const { return myIsActive; }

    bool canQueueRequests() const
                        { return myIsActive && myInteractiveMode; }

    void allowBBoxReplacement(bool allow) { myAllowBBoxes = allow; }

    /// For primitives that cannot be culled, this at least notifies the
    /// manager of the GL primitive count so it can be taken into account.
    void queueUncullableDraw(int num_gl_prims);

    /// Request a new draw ID used to queue requests. Return it when done.
    int  newDrawRequestID();
    void returnDrawRequestID(int draw_id);
    
    // Submit a draw request of a single object with 'nprims' GL primitives
    // within bounding box 'box' and having a full world transform of
    // 'world_mat'. Returns an ID which is used to fetch the results.
    void queueDrawRequest(const RE_Render *r,
                          int draw_id,
                          int num_gl_prims,
                          const UT_BoundingBox &box,
                          const UT_Matrix4D &world_mat,
                          GR_RenderMode  rmode,
                          GR_RenderFlags rflags,
                          const GR_DrawParms   &dp,
                          bool wireframe,
                          int32 prim_id,
                          bool selected,
                          UT_Vector3F *color = nullptr);

    // queue a list of instances to draw with different transforms.
    // If only some of the draws should be performed, 'result_visible_indices'
    // will indicte which ones.
    void queueInstanceDrawRequest(const RE_Render *r,
                                  int draw_id,
                                  int num_gl_prims,
                                  const UT_BoundingBox &box,
                                  const UT_Matrix4D &obj_transform,
                                  const UT_Matrix4DArray &instances,
                                  UT_IntArray &result_visible_indices,
                                  UT_Vector2i &result_visible_range,
                                  GR_RenderMode  rmode,
                                  GR_RenderFlags rflags,
                                  const GR_DrawParms   &dp,
                                  bool wireframe,
                                  const GT_DataArrayHandle &prim_ids,
                                  const UT_Array<uint8> *selected,
                                  const UT_Vector3FArray *colors,
                                  bool all_selected = false);
    void queueNestedInstanceDrawRequest(const RE_Render *r,
                                        int draw_id,
                                        int num_gl_prims,
                                        const UT_BoundingBox &box,
                                        const UT_Matrix4D &obj_transform,
                                        const UT_Matrix4DArray &instances,
                                        const UT_IntArray &nest_level_counts,
                                        UT_IntArray &result_visible_indices,
                                        UT_Vector2i &result_visible_range,
                                        GR_RenderMode  rmode,
                                        GR_RenderFlags rflags,
                                        const GR_DrawParms   &dp,
                                        bool wireframe,
                                        const GT_DataArrayHandle &prim_ids,
                                        const UT_Array<uint8> *selected,
                                        const UT_Vector3FArray *colors,
                                        bool all_selected = false);

    // queue a partial list of instances to draw from a full list.
    // 'visible_indices' must refer to entries in the 'instances' array.
    // If only some of the draws should be performed, 'result_visible_indices'
    // will indicte which ones. draw_index will be assigned the index to query
    // later on getDrawRequestResult().
    void queuePartialInstanceDrawRequest(const RE_Render *r,
                                         int draw_id,
                                         int num_gl_prims,
                                         const UT_BoundingBox &box,
                                         const UT_Matrix4D &obj_transform,
                                         const UT_Matrix4DArray &instances,
                                         const UT_IntArray &visible_indices,
                                         UT_IntArray &result_visible_indices,
                                         UT_Vector2i &result_visible_range,
                                         GR_RenderMode  rmode,
                                         GR_RenderFlags rflags,
                                         const GR_DrawParms   &dp,
                                         bool wireframe,
                                         const GT_DataArrayHandle &prim_ids,
                                         const UT_Array<uint8> *selected,
                                         const UT_Vector3FArray *colors,
                                         bool all_selected = false);

    // queue a partial list of nested instances to draw from a full list.
    // This is the same as the above method, but `nest_level_counts` determines
    // the number of instances in each level (index 0 is the #leaf instance).
    void queuePartialNestedInstanceRequest(const RE_Render *r,
                                           int draw_id,
                                           int num_gl_prims,
                                           const UT_BoundingBox &box,
                                           const UT_Matrix4D &obj_transform,
                                           const UT_Matrix4DArray &instances,
                                           const UT_IntArray &visible_indices,
                                           const UT_IntArray &nest_level_counts,
                                           UT_IntArray &result_visible_indices,
                                           UT_Vector2i &result_visible_range,
                                           GR_RenderMode  rmode,
                                           GR_RenderFlags rflags,
                                           const GR_DrawParms   &dp,
                                           bool wireframe,
                                           const GT_DataArrayHandle &prim_ids,
                                           const UT_Array<uint8> *selected,
                                           const UT_Vector3FArray *colors,
                                           bool all_selected = false);

    /// Request a new draw ID used to queue requests. Return it when done.
    int  newBBoxRequestID();
    void returnBBoxRequestID(int bbox_id);
    
    // Queue a single bounding box to be drawn.
    void queueBBoxDraw(const RE_Render *r,
                       int bbox_id,
                       const UT_BoundingBox &box, 
                       const UT_Matrix4D &obj_transform,
                       bool wireframe,
                       int32 prim_id,
                       bool selected,
                       UT_Vector3F *color = nullptr);
    
    // Queue a list of bounding boxes to be drawn (one bounding box transormed)
    void queueBBoxDraw(const RE_Render *r,
                       int bbox_id,
                       const UT_BoundingBox &box, 
                       const UT_Matrix4D &obj_transform,
                       const UT_Matrix4DArray &instances,
                       bool wireframe,
                       const GT_DataArrayHandle &prim_ids, //size of 'instances'
                       const UT_Array<uint8> *selected,  //size of 'instances'
                       const UT_Vector3FArray *colors,   //size of 'instances'
                       bool all_selected = false); // everything selected

    // Queue a partial list of bounding boxes to be drawn (one bbox transformed
    // by some of the transforms, indexed by visible_instances).
    void queuePartialBBoxDraw(
                       const RE_Render *r,
                       int bbox_id,
                       const UT_BoundingBox &box, 
                       const UT_Matrix4D &obj_transform,
                       const UT_Matrix4DArray &instances,
                       const UT_IntArray &visible_indices,
                       bool wireframe,
                       const GT_DataArrayHandle &prim_ids, //size of 'instances'
                       const UT_Array<uint8> *selected, //size of 'instances'
                       const UT_Vector3FArray *colors, // size of ^^
                       bool all_selected = false); // everything selected

    enum gr_DrawRequestResult
    {
        NO_DRAW,                // no instances to draw
        PARTIAL_DRAW,           // some instances, flagged ones drawn
        POINTS_ONLY_DRAW,       // draw all as points only
        FULL_DRAW,              // draw all instances as full geometry

        ERROR_NO_SUCH_ID,       // the draw_id passed is invalid.
        ERROR_NOT_PROCESSED     // called too early, before all requests were
    };                          // processed.

    // Get the result of the global processing. 'visible instances' from the
    // queued draw requests will only be set if the result is PARTIAL_DRAW.
    // If it is somehow visible, the render mode, flags and draw parms will be
    // set.
    gr_DrawRequestResult getDrawRequestResult(int draw_id,
                                              GR_RenderMode  &mode,
                                              GR_RenderFlags &flags,
                                              GR_DrawParms   &parms) const;
                                         
private:
    void        beginPass(const GR_CommonDispOption &opts);
    void        processDrawRequests(RE_Render *r,
                                    const GR_CommonDispOption &opts);
    void        processQueuedBBoxes(RE_Render *r,
                                    const GR_CommonDispOption &opts);
    void        endPass(RE_Render *r, const GR_CommonDispOption &opts);
    void        updateBBoxes(RE_Render *r);
    void        drawBBoxes(RE_Render *r, const GR_CommonDispOption &opts);
    void        generatePickID(const RE_Render *r, UT_Vector4i &pick_id);
    bool        determineBBoxMode(bool wire_req) const;
        
    
    static void initialize();

                GR_InstanceManager();
    virtual    ~GR_InstanceManager();
    
    class gr_Instance
    {
    public:
        GT_PrimitiveHandle myInstance;
        UT_BoundingBoxF    myBBox;
        int64              myLRU;
        int64              myVersion;
        int64              mySize;
        int                myUsage;
    };

    UT_StringMap<gr_Instance> myCache;
    int64                     myLRU;

public:
    class gr_DrawRequest
    {
    public:
        gr_DrawRequest(int np,
                       const UT_Matrix4D *si,
                       const UT_Matrix4DArray *insts,
                       const UT_BoundingBox   &bb,
                       const UT_IntArray      *vi,
                       UT_IntArray            *vr,
                       GR_RenderMode           rm,
                       GR_RenderFlags          rf,
                       GR_DrawParms            dp,
                       int                     passid)
            : num_prims(np), single_inst(si), instances(insts), bbox(&bb),
              visible_instances(vi), visible_result(vr), selected(false),
              result(ERROR_NOT_PROCESSED), rmode(rm), rflags(rf), dparms(dp),
              pass_id(passid), colors(nullptr), color(nullptr),
              nest_counts(nullptr), selected_prims(nullptr), wireframe(false),
              visible_range(nullptr) {}
        gr_DrawRequest()
            : dparms(nullptr, nullptr, nullptr, -1, -1, false, 0, 0,0,0),
              pass_id(-1), num_prims(0), single_inst(nullptr),
              instances(nullptr), bbox(nullptr), nest_counts(nullptr),
              visible_instances(nullptr), visible_result(nullptr),
              selected_prims(nullptr), color(nullptr), visible_range(nullptr) {}

        int                     pass_id;
        int                     num_prims;
        const UT_Matrix4D      *single_inst;
        const UT_Matrix4DArray *instances;
        const UT_BoundingBox   *bbox;
        const UT_IntArray      *visible_instances;
        const UT_IntArray      *nest_counts;
        UT_IntArray            *visible_result;
        gr_DrawRequestResult    result;
        GR_RenderMode           rmode;
        GR_RenderFlags          rflags;
        GR_DrawParms            dparms;
        const UT_Array<uint8>  *selected_prims;
        const UT_Vector3FArray *colors;
        GT_DataArrayHandle      prim_ids;
        UT_Vector4i             pick_id;
        UT_Vector3F            *color;
        UT_Vector2i            *visible_range;
        bool                    selected;
        bool                    wireframe;
    };

    class gr_BBoxRequest
    {
    public:
        gr_BBoxRequest(const UT_Matrix4D      *si,
                       const UT_Matrix4DArray *insts,
                       const UT_IntArray      *nesting,
                       const UT_BoundingBox   &bb,
                       const UT_IntArray      *vi,
                       int passid)
            : single_inst(si),instances(insts),bbox(&bb),visible_instances(vi),
              offset(0), bucket(0), pass_id(passid), selected_prims(nullptr),
              colors(nullptr), selected(false), wireframe(false),
              color(nullptr), nest_counts(nesting)             
            {}
        gr_BBoxRequest()
            : single_inst(nullptr),instances(nullptr),bbox(nullptr),
              visible_instances(nullptr), offset(0), bucket(0), pass_id(-1),
              selected_prims(nullptr),colors(nullptr), selected(false),
              wireframe(false), color(nullptr), nest_counts(nullptr)
            {}
        const UT_Matrix4D      *single_inst;
        const UT_Matrix4DArray *instances;
        const UT_IntArray      *visible_instances;
        const UT_IntArray      *nest_counts;
        GT_DataArrayHandle      prim_ids;
        const UT_Array<uint8>  *selected_prims;
        const UT_Vector3FArray *colors;
        const UT_BoundingBox   *bbox;
        UT_Vector4i             pick_id;
        UT_Vector3F            *color;
        bool                    selected;
        bool                    wireframe;

        // the list to write to.
        int                     offset;
        int                     bucket;
        int                     pass_id;
    };
    class gr_DrawEntry
    {
    public:
        gr_DrawEntry() : z(0.0), draw_id(0), draw_index(0) {} 
        gr_DrawEntry(fpreal32 _z, int did, int didx)
            : z(_z), draw_id(did), draw_index(didx) {}
        fpreal32 z;
        int          draw_id;
        int      draw_index;
    };
    

    enum
    {
        BBOX_COLOR_SHADED=0,
        BBOX_COLOR_WIRE=1,
        BBOX_SHADED =2,
        BBOX_WIRE =3,

        NUM_BBOX_SHADING_MODES = 4,
        NUM_BBOX_COLOR_MODES = 2
    };
    
private:
    UT_Array<gr_DrawRequest> myDrawRequests;
    UT_Array<gr_BBoxRequest> myBBoxRequests;
    UT_Array<UT_Array<gr_DrawEntry> > myBucketIndex;
    UT_Matrix4FArray         myBBoxTransforms;
    UT_Array<int8>           myBBoxCategories;
    UT_Array<const UT_Vector3F *>  myBBoxColors;
    SYS_AtomicInt64          myGLPrimCount;
    SYS_AtomicInt64          myNumBBoxRequests;
    fpreal                   myLastZ;
    fpreal                   myLastMinZ;
    bool                     myReducedDraws;
    bool                     myIsActive;
    bool                     myInteractiveMode;
    bool                     myAllowBBoxes;
    UT_Vector3F              mySelectionColor;
    GR_CommonDispOption::gr_BBoxMode myBBoxMode;
    int                      myPassID;
    UT_IntArray              myFreeDrawIDs;
    UT_IntArray              myFreeBBoxIDs;
    UT_Vector3FArray         mySplitBBoxColors[NUM_BBOX_COLOR_MODES];
    UT_Matrix4FArray         mySplitBBoxTransforms[NUM_BBOX_SHADING_MODES];
    
    static GR_InstanceManager *theInstance;

    // These two are friends for the pass management and initialization.
    friend class GUI_SceneFeel;
    friend class DM_VPortAgent;
};

#endif