GR_Utils.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_Utils.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Utility functions for GR.
 */
#ifndef GR_Utils_h
#define GR_Utils_h

#include "GR_API.h"
#include "GR_Defines.h"

#include <GT/GT_Primitive.h>
#include <GT/GT_Types.h>
#include <GU/GU_SelectType.h>
#include <GA/GA_Types.h>
#include <RE/RE_CachedObject.h>
#include <RE/RE_RenderContext.h>
#include <RE/RE_Types.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_VectorTypes.h>

#include <utility>

class RE_Render;
class RE_VertexArray;
class RE_VertexArrayRef;
class RE_Geometry;
class RE_Shader;
class GR_DisplayOption;
class GR_GeoRender;
class UT_WorkBuffer;
class GR_UpdateParms;

/// Utility GR methods common to all renderers
namespace GR_Utils
{
/// Returns the selection type in p.geometry
GR_API extern GR_AttribMask hasSelection(const GR_UpdateParms &p);
 
/// Returns true if prim_id is in the selection list for p.geometry
/// If geo is given it must be the unlocked p.geometry from a ReadLock
GR_API extern bool inPrimitiveSelection(const GR_UpdateParms &p,
                                        GA_Offset prim_id,
                                        const GU_Detail *geo = nullptr);
    
/// Returns true if point_id is in the selection list for p.geometry
GR_API extern bool inPointSelection(const GR_UpdateParms &p,
                                    GA_Offset point_id,
                                    const GU_Detail *geo = nullptr);

/// Returns true if vert_id is in the selection list for p.geometry
GR_API extern bool inVertexSelection(const GR_UpdateParms &p,
                                     GA_Offset vert_id,
                                     const GU_Detail *geo = nullptr);

/// @brief Checks if passed prim offsets are in p.geometry's selection.
/// Returns GR_SELECT_PRIM_PARTIAL/FULL if some or all of the prim offsets
/// are in the cook or temp selections, as indicated by the parms in p,
/// otherwise GR_SELECT_NONE is returned. The individual selection results 
/// are returned in 'selected'
GR_API extern GR_SelectMode inPrimitiveSelection(const GR_UpdateParms &p,
                                                 const UT_Array<GA_Offset>&pids,
                                                 UT_BitArray &selected);
    
/// @brief Checks if passed point offsets are in p.geometry's selection.
/// Returns GR_SELECT_POINT_PARTIAL/FULL if some or all of the point offsets
/// are in the cook or temp selections, as indicated by the parms in p,
/// otherwise GR_SELECT_NONE is returned. The individual selection results
/// are returned in 'selected'
GR_API extern GR_SelectMode inPointSelection(const GR_UpdateParms &p,
                                             const UT_Array<GA_Offset> &pids,
                                             UT_BitArray &selected);

/// @brief Checks if passed vertex offsets are in p.geometry's selection.
GR_API extern GR_SelectMode inVertexSelection(const GR_UpdateParms &p,
                                              const UT_Array<GA_Offset> &vids,
                                              UT_BitArray &selected);

/// Return the cache version for attribute 'ph'
GR_API extern RE_CacheVersion getAttribVersion(const GT_DataArrayHandle &ph,
                                               RE_CacheVersion geo_version);
    
/// Return the cache version for the topology of primitive 'prim'
GR_API extern RE_CacheVersion getTopologyVersion(const GT_Primitive *prim,
                                                 RE_CacheVersion geo_version);

/// Return true if the geometry has a per-prim transform or per-prim visibility 
GR_API extern bool hasPrimTransform(const RE_Geometry *geo);

// Call setupGhosting() to set up wire-ghosting (or other sample-based
// ghosting effects). opaque_data[] is just used to clean up correctly.
// transparency (1.0 - opacity) is rounded up to the nearest multiple of
// 1/s where s is the number of samples (at least 4 for ghosting to work).
GR_API extern void      setupGhosting  (RE_RenderContext r, int opaque_data[3],
                                        fpreal transparency = 0.25f);
GR_API extern void      cleanupGhosting(RE_RenderContext r, int opaque_data[3]);

/// Convenience method to return an RE type from a GT storage type.
inline RE_GPUType getREType(GT_Storage s)
{
    switch(s)
    {
    case GT_STORE_UINT8:        return RE_GPU_UINT8;
    case GT_STORE_INT32:        return RE_GPU_INT32;
    case GT_STORE_INT64:        return RE_GPU_INT32; // no such 64b type
    case GT_STORE_REAL16:       return RE_GPU_FLOAT16;
    case GT_STORE_REAL32:       return RE_GPU_FLOAT32;
    case GT_STORE_REAL64:       return RE_GPU_FLOAT64;
    case GT_STORE_STRING:       return RE_GPU_INT32; // string indices
    default:
        UT_ASSERT(!"No available RE type");
        return RE_GPU_UINT1;
        break;
    }
}

/// Returns the GPU type and vector size of the attribute based on the
/// data array, display option settings
GR_API extern RE_GPUType      getAttributeType(const char *attrib_name,
                                               int &vsize,
                                               const GT_DataArrayHandle &pa,
                                               const GR_DisplayOption &opts,
                                               RE_ArrayType array_type);

GR_API extern void *          fillAttribData(const char *attrib_name,
                                             const GT_DataArrayHandle   &pa,
                                             const GR_DisplayOption     &opts,
                                             RE_ArrayType                array,
                                             bool build_string_tables = true);


GR_API extern RE_Shader *getWireShader(RE_Render *r);
GR_API extern RE_Shader *getRibbonShader(RE_Render *r);
GR_API extern RE_Shader *getRibbonUVShader(RE_Render *r);
GR_API extern RE_Shader *getConstPointShader(RE_Render *r);
GR_API extern RE_Shader *getColorShader(RE_Render *r);
GR_API extern RE_Shader *getMatteShader(RE_Render *r);
GR_API extern RE_Shader *getMatteDisplaceShader(RE_Render *r);
GR_API extern RE_Shader *getDepthShader(RE_Render *r);
GR_API extern RE_Shader *getDepthPrimTransformShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCubeShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCubeLineShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCubePointShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCubeDisplaceShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCubePrimTransformShader(RE_Render *r);
GR_API extern RE_Shader *getDepthLinearShader(RE_Render *r);
GR_API extern RE_Shader *getDepthLinearDisplaceShader(RE_Render *r);
GR_API extern RE_Shader *getDepthLinearPrimTransformShader(RE_Render *r);
GR_API extern RE_Shader *getDepthWireShader(RE_Render *r);
GR_API extern RE_Shader *getDepthWirePrimTransformShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCascadeShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCascadeLineShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCascadePointShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCascadeDisplaceShader(RE_Render *r);
GR_API extern RE_Shader *getDepthCascadePrimTransformShader(RE_Render *r);

// Creates a center-point GeoRender where the transforms
// are used as individual points
GR_API extern void buildCenterPoints(RE_RenderContext r,
                                     const GT_PrimitiveHandle &handle,
                                     const GR_UpdateParms &p,
                                     const UT_Matrix4DArray &primxforms,
                                     const GT_DataArrayHandle &prim_ids,
                                     const GT_DataArrayHandle &pnt_ids,
                                     const GT_DataArrayHandle &vtx_ids,
                                     GR_GeoRender *gr,
                                     const char *cache_name,
                                     GT_PrimitiveHandle *pt_handle = nullptr,
                                     GR_SelectMode *pnt_sel_mode = NULL,
                                     bool is_offsets = true,
                                     bool build_selection = true);
// Creates a center-point GeoRender where the transforms
// are used as instance transforms
GR_API extern void buildInstancedCenterPoints(RE_RenderContext r,
                                     const GT_PrimitiveHandle &handle,
                                     const GR_UpdateParms &p,
                                     const UT_Matrix4DArray &primxforms,
                                     const GT_DataArrayHandle &prim_ids,
                                     const GT_DataArrayHandle &pnt_ids,
                                     const GT_DataArrayHandle &vtx_ids,
                                     const UT_Vector3F &point,
                                     RE_CacheVersion point_version,
                                     GR_GeoRender *gr,
                                     const char *cache_name,
                                     GT_PrimitiveHandle *pt_handle = nullptr,
                                     GR_SelectMode *pnt_sel_mode = NULL,
                                     bool is_offsets = true);
    
GR_API extern GR_SelectMode buildSelection(UT_Array<uint8> &selected,
                                            const GR_UpdateParms &p,
                                            GT_DataArrayHandle prim_id,
                                            GT_DataArrayHandle pnt_id,
                                            GT_DataArrayHandle vert_id,
                                            bool is_offset,
                                            int repeat_count);

GR_API extern int getMaxTextureSize(RE_RenderContext rc);

GR_API extern int getMaxTexture3DSize(RE_RenderContext rc);

GR_API extern bool inViewFrustum(const UT_BoundingBoxD &bbox,
                                 const UT_Matrix4D &objviewproj,
                                 const UT_Vector4D *frustum_area = NULL);

GR_API extern bool inViewFrustum(const UT_BoundingBoxF &bbox,
                                 const UT_Matrix4F &objviewproj);

GR_API extern bool inViewFrustumWithLOD(const UT_BoundingBoxF &bbox,
                                        const UT_Matrix4F &objviewproj,
                                        bool        &has_bounds,
                                        UT_Vector2F &bounds_2d);

GR_API extern bool isRasterized(const UT_Matrix4F &objviewproj,
                                const UT_Vector2F &min_proj_size,
                                const UT_BoundingBoxF &bbox);

GR_API extern GU_Connectivity getConnectivityFromString(const char *str);

class gr_MatBucket
{
public:
    gr_MatBucket() : next(NULL) {}
    UT_IntArray   prims;
    gr_MatBucket *next;
};
GR_API extern UT_Array<std::pair<gr_MatBucket*,int> > *
bucketMaterials(const GT_DataArrayHandle &mat_id);
GR_API extern void cleanupBuckets(
                        UT_Array<std::pair<gr_MatBucket *, int>> *&buckets);

GR_API extern void printUpdateReason(GR_UpdateReason r,
                                     std::ostream *os = NULL);
GR_API extern void updateReasonString(GR_UpdateReason r,
                                      UT_WorkBuffer &buf);
GR_API extern void printDrawMode(GR_RenderMode mode,
                                  std::ostream *os = NULL);
GR_API extern void printDrawFlags(GR_RenderFlags flags,
                                  std::ostream *os = NULL);
GR_API extern void drawFlagsString(GR_RenderFlags flags,
                                   UT_WorkBuffer &buf);
GR_API extern void drawModeString(GR_RenderMode mode,
                                  UT_WorkBuffer &buf);

} // End namespace GR_Utils

GR_API size_t
UTformatBuffer(char *buf, size_t bufsize, const GR_UpdateReason &r);
GR_API size_t
UTformatBuffer(char *buf, size_t bufsize, const GR_RenderFlags &r);
GR_API size_t
UTformatBuffer(char *buf, size_t bufsize, const GR_RenderMode &r);
GR_API size_t
UTformatBuffer(char *buf, size_t bufsize, const GR_AlphaPass &r);

#endif