RE_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:        RE_Utils.h ( RE Library, C++)
 *
 * COMMENTS:
 *      Utility functions for RE and RV.
 */
#ifndef RE_Utils_h
#define RE_Utils_h

#include "RE_API.h"
#include "RE_Types.h"
#include <UT/UT_Array.h>
#include <UT/UT_Rect.h>
#include <UT/UT_VectorTypes.h>

class UT_StringHolder;
class UT_StringArray;
class PXL_Raster;
class IMG_File;
class RE_Render;
class RE_OGLTexture;

typedef void (*RE_TextureHDAResolverCB)(const char *optable_optype,
                                        const char *pattern,
                                        UT_StringArray &files);



namespace RE_Utils
{
// Returns true if <UDIM> or %(UDIM)d is in the filename.
extern RE_API bool isUDIMTexture(const UT_StringHolder &map_name);

// Given a filepath with <UDIM> or %(UDIM)d in it, determine the UDIM extent,
// the filenames and their coordinate
extern RE_API bool determineUDIMBounds(
    const UT_StringHolder  &filepath,
    UT_DimRect             &udim_area,
    int                    &max_tile,
    UT_Array<std::pair<UT_StringHolder,UT_Vector2i>> &tiles,
    int                     tile_stride,
    RE_TextureHDAResolverCB hda_resolver);

/// Given an oppath + a channel name (op:/path/to/node/parmname) to a ramp parm,
/// generate a ramp in ramp_data. Presize the array to the precision you require.
/// parm_path can also be op:parmname if rel_path is the path to the node.
extern RE_API bool createRampFromParm(const UT_StringHolder &parm_path,
                                      const UT_StringHolder &rel_path,
                                      UT_Vector4FArray &ramp_data,
                                      int &op_id, int &op_version,
                                      bool &is_rgb);
// Given a polar map, create a 6-face map in 'output_pixels', which must be
// large enough to hold 6 images of cube_size X cube_size with the bit depth of
// 'data_type' and the tuple size of the polar_image.
// order: +X, -X, +Y, -Y, +Z, -Z
extern RE_API bool createSphereMap(const PXL_Raster *polar_image,
                                   int cube_size,
                                   void *output_pixels,
                                   RE_GPUType dest_type);
// Scale a polar raster to a lower mip, 1/2 size. Must be FP32.
extern RE_API void scalePolarFromRaster(PXL_Raster *dest,
                                        const PXL_Raster *src,
                                        bool wrap_y);
// Load a six-plane cubemap file (with planes Right, Left, Top,Bottom,Front,Back
// into a block of memory big enough for 6 x W x H x depth(type) x vsize
extern RE_API bool loadCubeMap(IMG_File *fp, int w, int h,
                               RE_GPUType type, int vsize, void *output_pixels);

// Given an oppath (op:/path/to/node/parmname) to a cubemap (with planes
// Right, Left, Top, Bottom, Front, Back) loads it into a block of memory
// big enough for 6 x W x H x depth(type) x vsize, and also returns the
// size, format, and op id of the pixel through output parameters.
// If ptr to data is null, still sets the output parameters
extern RE_API bool resolveCopCubeMap(const UT_StringHolder &op_path,
                                     int &op_id,
                                     int &w, int &h, 
                                     RE_GPUType &datatype, int &vsize,
                                     void *output_pixels, exint output_size);

extern RE_API UT_Matrix4D getPerspectiveProjection(fpreal l, fpreal r,
                                                   fpreal b, fpreal t,
                                                   fpreal n, fpreal f,
                                                   bool reverse_depth = false);
extern RE_API UT_Matrix4D getOrthoProjection(fpreal l, fpreal r,
                                             fpreal b, fpreal t,
                                             fpreal n, fpreal f);
extern RE_API UT_Matrix4D getLookatTransform(const UT_Vector3D &eye,
                                             const UT_Vector3D &target,
                                             const UT_Vector3D &up);

extern RE_API void copyDepth(RE_Render *r,
                            RE_OGLTexture *dst,
                            RE_OGLTexture *src);

extern RE_API void copyDepthRaw2DSrc(RE_Render *r,
                                     RE_OGLTexture *dst,
                                     exint src_id);
}

#endif