GR_ImageVK.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_ImageVK ( GR Library, C++)
 *
 * COMMENTS:
 *      Simple renderer class for a 2D image
 */
#ifndef GR_ImageVK_h
#define GR_ImageVK_h

#include "GR_GeoRenderVK.h"

#include <GA/GA_Names.h>
#include <RV/RV_Type.h>

#include <UT/UT_Vector4.h>
#include <UT/UT_UniquePtr.h>

class RV_Geometry;
class GEO_PrimVolume;
class GT_PrimVolume;

class RV_Render;
class RV_ShaderBlock;
class RV_ShaderVariableSet;
class RV_VKImage;

class GR_API GR_ImageVK : public GR_GeoRenderVK
{
public:
             GR_ImageVK(GR_Primitive *prim);
            ~GR_ImageVK() override;

    const char         *className() const override { return "GR_ImageVK"; }
    
    RV_Geometry        *getVkPickGeometry(unsigned int pick_mode) override;
    
    // Rebuilds the geometry bounds and UV coordinates for the image quad.
    // remove_padding determines whether or not to inset by half a voxel in
    // each dimension to avoid having to extrapolate when using bilinear
    // interpolation.
    void                updateUVsAndBounds(RV_Render *r,
                                           GT_PrimVolume *volume,
                                           bool remove_padding);

    void                update(RE_RenderContext rc,
                               const GT_PrimitiveHandle &primh,
                               const GR_UpdateParms     &parms,
                               const char               *cache_name) override;
    
    void                draw(RE_RenderContext rc,
                             GR_RenderMode mode,
                             GR_RenderFlags flags,
                             GR_DrawParms dp) override;
    
    exint               getNumGLPrimitives() const override { return 1; }
    bool                hasTransparency() const override { return myHasAlpha; }
    
    static bool         initShaders(RV_Instance* inst);
    static void         cleanupShaders();

private:
    void                fillImageFromImage(RV_Render *r,
                                           const GEO_PrimVolume *vol);
    void                fillImageFromVolume(RV_Render *r,
                                            const GT_PrimVolume *vol,
                                            const GR_UpdateParms &p);
    /// Allocate a new image if necessary.
    void                allocateImage(RV_Render *r, VkFormat format,
                                      RV_TextureWrap wrap,
                                      int w, int h,
                                      RV_TextureSwizzle* swizzle = nullptr,
                                      bool is_int = false);
    UT_UniquePtr<RV_Geometry> myDisplayWinVk;
    UT_UniquePtr<RV_VKImage> myColorImage;
    //UT_UniquePtr<RV_VKImage *> myDepthImage; // TODO: for COPs
    UT_UniquePtr<RV_ShaderVariableSet>  myImageSet;
    UT_UniquePtr<RV_ShaderVariableSet>  myDisplayHullSet;
    UT_UniquePtr<RV_ShaderBlock>        myDisplayHullBlock;
    bool            myHasAlpha = false;
    bool            myHasImage = false;
    bool            myHasDisplayWin = false;
    int             myChannels = 4;
    int             myTypeInfo = 0;
    bool            myDrawHullOnly = false;
    UT_Vector4      myDisplayWinColor = {0.1f, 0.1f, 1.0f, 1.0f};
    int             myPostPassID = -1;
    bool            myInterpolateLayers = 0;
    GT_PrimVolume  *myVolume = nullptr;
};

#endif