RV_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:        RV_Utils.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Utility functions for RV.
 */
#ifndef RV_Utils_h
#define RV_Utils_h

#include "RV_API.h"

#include "RV_Type.h"
#include "RV_TypePtrs.h"

#include <UT/UT_Rect.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_UniquePtr.h>
#include <SYS/SYS_Types.h>

class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderVariableSet;
class RV_VKImage;
class PXL_Lookup;
class PXL_Raster;
class UI_Icon;

typedef UT_UniquePtr<RV_VKImage> RV_VKImagePtr;

namespace RV_Utils
{
/// Returns an 8b RGBA 64x64 texture with 0-1 random values in all comps.
extern RV_API RV_VKImagePtr getRandomTexture(RV_Render* r, 
                                             unsigned int seed,
                                             bool interp,
                                             int size = 64);
/// Returns an 8b RGBA size^3 3D texture with 0-1 random values
extern RV_API RV_VKImagePtr getRandomTexture3D(RV_Render* r, 
                                             unsigned int seed,
                                             bool interp,
                                             int size = 32);
/// Returns an 8b RGBA size^2 2D texture array of size 'num_layers'
extern RV_API RV_VKImagePtr getRandomTextureArray(RV_Render* r, 
                                             unsigned int seed,
                                             bool interp,
                                             int num_layers,
                                             int size = 64 );
/// Create a new 2D image from a 2D multisample image by increasing the
/// resolution of the 2D image to show all samples.
extern RV_API UT_UniquePtr<RV_VKImage> resolveMSTexture(RV_Render *r,
                                                        RV_VKImage *ms_image);

/// Create resources for color correction in HOUcolorCorrect(). 
extern RV_API bool setupColorCorrection(RV_Render *r,
                                        RV_ShaderProgram *sh,
                                        int set_number,
                                        const PXL_Lookup *lut,
                                        fpreal brightness,
                                        fpreal bright_shift,
                                        fpreal gamma,
                                        fpreal alpha_scale,
                                        exint &lut_version,
                                        UT_UniquePtr<RV_ShaderVariableSet> &set,
                                        UT_UniquePtr<RV_ShaderBlock> &block,
                                        UT_UniquePtr<RV_VKImage> &main_lut_image,
                                        UT_UniquePtr<RV_VKImage> &pre_lut_image);

extern RV_API bool matchesRaster(const RV_VKImage &img,
                                 const PXL_Raster &raster);

extern RV_API void setupRaster(RV_VKImage &img,
                               PXL_Raster &raster,
                               bool alloc = true);

extern RV_API RV_VKImagePtr
imageFromRaster(RV_Render *r, const PXL_Raster *raster);

extern RV_API void
createLUTTexture(RV_Render *r,
                 const PXL_Lookup *lut,
                 UT_UniquePtr<RV_VKImage> &main_lut,
                 UT_UniquePtr<RV_VKImage> &pre); // optionally generated prelut

extern RV_API UT_Matrix4D getOrthoProjection(fpreal l, fpreal r,
                                             fpreal b, fpreal t,
                                             fpreal n, fpreal f);
/// Pixel-space ortho projection for a viewport rect
extern RV_API UT_Matrix4D getOrthoProjection(const UT_DimRect &rect,
                                             bool reverse_depth);
/// Remap a GL-style projection's clip depth from [-1,1] to Vulkan's [0,1].
extern RV_API UT_Matrix4F convertProjectionToVK(const UT_Matrix4D &proj);

/// Create lower mipmaps for a cubemap texture. image must be a latlong map
extern RV_API void
generateCubeMips(RV_Render *r, UT_UniquePtr<PXL_Raster> &latlong_image,
                 RV_VKImage *tex, RV_GPUType format_type, int vsize);

/// Copy a 2D image sphere map into a cubemap
extern RV_API void
copySphereMap(RV_Render *r, RV_VKImage *dst_cubemap, RV_VKImage *src_image);

/// Copy depth value from src into dst. src and dst may be depth textures
/// or single component color textures and must be single-sample
extern RV_API void copyDepth(RV_Render *r, RV_VKImage *dst, RV_VKImage *src);

extern RV_API void drawRaster(
        RV_Render *r,
        PXL_Raster *rst,
        const UT_DimRect &area,
        const UT_Vector2F &uv_min,
        const UT_Vector2F &uv_max,
        const UT_DimRect &screen_area,
        fpreal32 alpha);

extern RV_API bool initShaders(RV_Instance* inst);
extern RV_API void cleanupShaders();
};

#endif