subtextureIdentifier.h

//
// Copyright 2020 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HD_ST_SUBTEXTURE_IDENTIFIER_H
#define PXR_IMAGING_HD_ST_SUBTEXTURE_IDENTIFIER_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hdSt/api.h"
 
#include "pxr/base/tf/token.h"
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class HdStDynamicUvTextureImplementation;
 
class HdStSubtextureIdentifier
{
public:
    using ID = size_t;
 
    HDST_API
    virtual std::unique_ptr<HdStSubtextureIdentifier> Clone() const = 0;
 
    HDST_API
    virtual ~HdStSubtextureIdentifier();
 
protected:
    HDST_API
    friend size_t hash_value(const HdStSubtextureIdentifier &subId);
 
    virtual ID _Hash() const = 0;
};
 
HDST_API
size_t hash_value(const HdStSubtextureIdentifier &subId);
 
class HdStFieldBaseSubtextureIdentifier : public HdStSubtextureIdentifier
{
public:
    HDST_API
    TfToken const &GetFieldName() const { return _fieldName; }
 
    HDST_API
    int GetFieldIndex() const { return _fieldIndex; }
 
    HDST_API
    ~HdStFieldBaseSubtextureIdentifier() override = 0;
    
protected:
    HDST_API
    HdStFieldBaseSubtextureIdentifier(TfToken const &fieldName, int fieldIndex);
 
    HDST_API
    ID _Hash() const override;
 
private:
    TfToken _fieldName;
    int _fieldIndex;
};
 
class HdStAssetUvSubtextureIdentifier final
                                : public HdStSubtextureIdentifier
{
public:
    HDST_API
    explicit HdStAssetUvSubtextureIdentifier(bool flipVertically, 
                                             bool premultiplyAlpha,
                                                                 const TfToken& sourceColorSpace);
 
    HDST_API
    std::unique_ptr<HdStSubtextureIdentifier> Clone() const override;
 
    HDST_API
    bool GetFlipVertically() const { return _flipVertically; }
 
    HDST_API
    bool GetPremultiplyAlpha() const { return _premultiplyAlpha; }
    
    HDST_API
    TfToken GetSourceColorSpace() const { return _sourceColorSpace; }
    
    HDST_API
    ~HdStAssetUvSubtextureIdentifier() override;
 
protected:
    HDST_API
    ID _Hash() const override;
 
private:
    bool _flipVertically;
    bool _premultiplyAlpha;
    TfToken _sourceColorSpace;
};
 
class HdStDynamicUvSubtextureIdentifier : public HdStSubtextureIdentifier
{
public:
    HDST_API
    HdStDynamicUvSubtextureIdentifier();
 
    HDST_API
    ~HdStDynamicUvSubtextureIdentifier() override;
    
    HDST_API
    std::unique_ptr<HdStSubtextureIdentifier> Clone() const override;
 
    HDST_API
    virtual HdStDynamicUvTextureImplementation *GetTextureImplementation() const;
 
protected:
    HDST_API
    ID _Hash() const override;
};
 
class HdStPtexSubtextureIdentifier final
                                : public HdStSubtextureIdentifier
{
public:
    HDST_API
    explicit HdStPtexSubtextureIdentifier(bool premultiplyAlpha);
 
    HDST_API
    std::unique_ptr<HdStSubtextureIdentifier> Clone() const override;
 
    HDST_API
    bool GetPremultiplyAlpha() const { return _premultiplyAlpha; }
    
    HDST_API
    ~HdStPtexSubtextureIdentifier() override;
 
protected:
    HDST_API
    ID _Hash() const override;
 
private:
    bool _premultiplyAlpha;
};
 
class HdStUdimSubtextureIdentifier final
                                : public HdStSubtextureIdentifier
{
public:
    HDST_API
    explicit HdStUdimSubtextureIdentifier(bool premultiplyAlpha,
                                          const TfToken& sourceColorSpace);
 
    HDST_API
    std::unique_ptr<HdStSubtextureIdentifier> Clone() const override;
 
    HDST_API
    bool GetPremultiplyAlpha() const { return _premultiplyAlpha; }
 
    HDST_API
    TfToken GetSourceColorSpace() const { return _sourceColorSpace; }
    
    HDST_API
    ~HdStUdimSubtextureIdentifier() override;
 
protected:
    HDST_API
    ID _Hash() const override;
 
private:
    bool _premultiplyAlpha;
    TfToken _sourceColorSpace;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif