texture.h

//
// Copyright 2019 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HGI_TEXTURE_H
#define PXR_IMAGING_HGI_TEXTURE_H
 
#include "pxr/pxr.h"
#include "pxr/base/gf/vec3i.h"
#include "pxr/imaging/hgi/api.h"
#include "pxr/imaging/hgi/enums.h"
#include "pxr/imaging/hgi/handle.h"
#include "pxr/imaging/hgi/types.h"
 
#include <string>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct HgiComponentMapping
{
    HgiComponentSwizzle r;
    HgiComponentSwizzle g;
    HgiComponentSwizzle b;
    HgiComponentSwizzle a;
};
 
HGI_API
bool operator==(
    const HgiComponentMapping& lhs,
    const HgiComponentMapping& rhs);
 
HGI_API
bool operator!=(
    const HgiComponentMapping& lhs,
    const HgiComponentMapping& rhs);
 
struct HgiTextureDesc
{
    HgiTextureDesc()
    : usage(0)
    , format(HgiFormatInvalid)
    , componentMapping{
        HgiComponentSwizzleR,
        HgiComponentSwizzleG,
        HgiComponentSwizzleB,
        HgiComponentSwizzleA}
    , type(HgiTextureType2D)
    , dimensions(0)
    , layerCount(1)
    , mipLevels(1)
    , sampleCount(HgiSampleCount1)
    , pixelsByteSize(0)
    , initialData(nullptr)
    {}
 
    std::string debugName;
    HgiTextureUsage usage;
    HgiFormat format;
    HgiComponentMapping componentMapping;
    HgiTextureType type;
    GfVec3i dimensions;
    uint16_t layerCount;
    uint16_t mipLevels;
    HgiSampleCount sampleCount;
    size_t pixelsByteSize;
    void const* initialData;
};
 
HGI_API
bool operator==(
    const HgiTextureDesc& lhs,
    const HgiTextureDesc& rhs);
 
HGI_API
bool operator!=(
    const HgiTextureDesc& lhs,
    const HgiTextureDesc& rhs);
 
 
class HgiTexture
{
public:
    HGI_API
    virtual ~HgiTexture();
 
    HGI_API
    HgiTextureDesc const& GetDescriptor() const;
 
    HGI_API
    virtual size_t GetByteSizeOfResource() const = 0;
 
    HGI_API
    virtual uint64_t GetRawResource() const = 0;
 
    HGI_API
    virtual void SubmitLayoutChange(HgiTextureUsage newLayout) = 0;
 
protected:
    HGI_API
    static
    size_t _GetByteSizeOfResource(const HgiTextureDesc &descriptor);
 
    HGI_API
    HgiTexture(HgiTextureDesc const& desc);
 
    HgiTextureDesc _descriptor;
 
private:
    HgiTexture() = delete;
    HgiTexture & operator=(const HgiTexture&) = delete;
    HgiTexture(const HgiTexture&) = delete;
};
 
 
using HgiTextureHandle = HgiHandle<class HgiTexture>;
using HgiTextureHandleVector = std::vector<HgiTextureHandle>;
 
 
struct HgiTextureViewDesc
{
    HgiTextureViewDesc()
    : format(HgiFormatInvalid)
    , layerCount(1)
    , mipLevels(1)
    , sourceTexture()
    , sourceFirstLayer(0)
    , sourceFirstMip(0)
    {}
 
    std::string debugName;
    HgiFormat format;
    uint16_t layerCount;
    uint16_t mipLevels;
    HgiTextureHandle sourceTexture;
    uint16_t sourceFirstLayer;
    uint16_t sourceFirstMip;
};
 
HGI_API
bool operator==(
    const HgiTextureViewDesc& lhs,
    const HgiTextureViewDesc& rhs);
 
HGI_API
bool operator!=(
    const HgiTextureViewDesc& lhs,
    const HgiTextureViewDesc& rhs);
 
class HgiTextureView
{
public:
    HGI_API
    HgiTextureView(HgiTextureViewDesc const& desc);
 
    HGI_API
    virtual ~HgiTextureView();
 
    HGI_API
    void SetViewTexture(HgiTextureHandle const& handle);
 
    HGI_API
    HgiTextureHandle const& GetViewTexture() const;
 
protected:
    HgiTextureHandle _viewTexture;
 
private:
    HgiTextureView() = delete;
    HgiTextureView & operator=(const HgiTextureView&) = delete;
    HgiTextureView(const HgiTextureView&) = delete;
};
 
using HgiTextureViewHandle = HgiHandle<class HgiTextureView>;
using HgiTextureViewHandleVector = std::vector<HgiTextureViewHandle>;
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif