RV_TextureRef.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_TextureRef.h ( RV Library, C++)
 *
 * COMMENTS:
 */
#ifndef RV_TextureRef_h
#define RV_TextureRef_h

#include "RV_Type.h"
#include "RV_VKImage.h"

#include <UT/UT_UniquePtr.h>

class RV_TextureCache;

/// Opaque reference to a texture stored in the RV_TextureCache
class RV_TextureRef
{
public:
    RV_TextureRef() = default;
    RV_TextureRef(const RV_TextureRef& other) { *this = other; }
    ~RV_TextureRef() { if(myRef) myRef->refCount.add(-1); }
    
    /// Reference to a valid texture
    bool isValid() const
        { return myTexID != -1 && !myIsMissingTex; }

    /// Texture is missing; a default color used instead
    bool isPlaceholder() const
        { return myIsPlaceholder; }
    /// Texture couldn't be found or resolved
    bool isMissingTex() const
        { return myIsMissingTex; }
    /// Texture is currently loading in the background
    bool isLoading() const
        { return myIsLoading; }
    /// Texture has been changed since last check
    bool isDirty() const
        { return myIsDirty; }

    /// Reset the reference to a null handle.
    void reset()
        {
            myTexID = -1;
            myIsMissingTex = false;
            myIsPlaceholder = false;
            myIsDirty = true;
            myIsLoading = false;
            myCacheVersion = 0;
            myCacheRefresh = 0;
            mySampler.reset();
        }

    /// Returns true if the reference is to a series of UDIM texture files
    bool isUDIM() const { return myUDIMW > 0; }
    /// Returns the UDIM range of the texture files (eg. (0,0) -> (3,2))
    void getUDIMParms(int &x, int &y, int &w, int &h) const
        {
            x = myUDIMX;
            y = myUDIMY;
            w = myUDIMW;
            h = myUDIMH;
        }

    void getRes(int *w, int *h = nullptr, int *d = nullptr) const
        {
            if(w)
                *w = myWidth;
            if(h)
                *h = myHeight;
            if(d)
                *d = myDepth;
        }
    
    /// Returns texture dimension
    RV_ImageDim getImageDim() const { return myTexType; }
    fpreal      getImageAspectRatio() const { return myAspectRatio; }
    
    exint id() const { return myTexID; }

    RV_TextureRef& operator=(const RV_TextureRef& other)
    {
        if (this == &other)
            return *this;

        myTexID = other.myTexID;
        myCacheVersion = other.myCacheVersion;
        myCacheRefresh = other.myCacheRefresh;
        myIsMissingTex = other.myIsMissingTex;
        myIsPlaceholder = other.myIsPlaceholder;
        myIsLoading = other.myIsLoading;
        myIsDirty = other.myIsDirty;

        if (myRef)
            myRef->refCount.add(-1);
        myRef = other.myRef;
        if (myRef)
            myRef->refCount.add(1);
        
        myUDIMX = other.myUDIMX;
        myUDIMY = other.myUDIMY;
        myUDIMW = other.myUDIMW;
        myUDIMH = other.myUDIMH;
        myWidth = other.myWidth;
        myHeight = other.myHeight;
        myDepth = other.myDepth;
        myAspectRatio = other.myAspectRatio;
        myChannels = other.myChannels;
        myTypeInfo = other.myTypeInfo;

        myTexType = other.myTexType;

        mySampler.reset();

        return *this;
    }

    struct CacheData
    {
        CacheData() : refCount(0), isValid(false) {}
        
        SYS_AtomicInt32 refCount;
        bool            isValid;
    };

    int getChannels() const { return myChannels; }
    int getTypeInfo() const { return myTypeInfo; }

private:
    exint myTexID         = -1;
    exint myCacheVersion  = 0;
    exint myCacheRefresh  = 0;
    bool  myIsMissingTex  = false;
    bool  myIsPlaceholder = false;
    bool  myIsLoading     = false;
    bool  myIsDirty       = false;

    UT_SharedPtr<CacheData> myRef;

    int8  myUDIMX = 0;
    int8  myUDIMY = 0;
    int8  myUDIMW = 0;
    int8  myUDIMH = 0;
    int   myWidth  = 1;
    int   myHeight = 1;
    int   myDepth  = 1;
    fpreal myAspectRatio = 1.0;
    int myChannels = 4;
    int myTypeInfo = 0;
 
    RV_ImageDim myTexType = RV_IMAGE_UNKNOWN;

    /// Sampler for when we need to use something different from the image's
    /// built-in one.
    UT_UniquePtr<RV_VKSampler> mySampler;
    
    friend class RV_TextureCache;
};

#endif