Texture.h

Go to the documentation of this file.

/*
 *  Copyright 2019-2021 Diligent Graphics LLC
 *  Copyright 2015-2019 Egor Yusov
 *  
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */
 
#pragma once
 
// clang-format off
 
 
#include "GraphicsTypes.h"
#include "DeviceObject.h"
#include "TextureView.h"
 
DILIGENT_BEGIN_NAMESPACE(Diligent)
 
 
// {A64B0E60-1B5E-4CFD-B880-663A1ADCBE98}
static const INTERFACE_ID IID_Texture =
    {0xa64b0e60, 0x1b5e, 0x4cfd,{0xb8, 0x80, 0x66, 0x3a, 0x1a, 0xdc, 0xbe, 0x98}};
 
struct TextureDesc DILIGENT_DERIVE(DeviceObjectAttribs)
 
    RESOURCE_DIMENSION Type DEFAULT_INITIALIZER(RESOURCE_DIM_UNDEFINED);
 
    Uint32 Width            DEFAULT_INITIALIZER(0);
 
    Uint32 Height           DEFAULT_INITIALIZER(0);
 
    union
    {
        Uint32 ArraySize    DEFAULT_INITIALIZER(1);
 
        Uint32 Depth;
    };
 
    TEXTURE_FORMAT Format       DEFAULT_INITIALIZER(TEX_FORMAT_UNKNOWN);
 
    Uint32          MipLevels   DEFAULT_INITIALIZER(1);
 
    Uint32          SampleCount DEFAULT_INITIALIZER(1);
 
    USAGE           Usage       DEFAULT_INITIALIZER(USAGE_DEFAULT);
 
    BIND_FLAGS      BindFlags   DEFAULT_INITIALIZER(BIND_NONE);
 
    CPU_ACCESS_FLAGS CPUAccessFlags     DEFAULT_INITIALIZER(CPU_ACCESS_NONE);
    
    MISC_TEXTURE_FLAGS MiscFlags        DEFAULT_INITIALIZER(MISC_TEXTURE_FLAG_NONE);
    
    OptimizedClearValue ClearValue;
 
    Uint64 CommandQueueMask              DEFAULT_INITIALIZER(1);
 
 
#if DILIGENT_CPP_INTERFACE
    TextureDesc()noexcept{}
 
    TextureDesc(RESOURCE_DIMENSION  _Type, 
                Uint32              _Width,
                Uint32              _Height,
                Uint32              _ArraySizeOrDepth,
                TEXTURE_FORMAT      _Format,
                Uint32              _MipLevels        = TextureDesc{}.MipLevels,
                Uint32              _SampleCount      = TextureDesc{}.SampleCount,
                USAGE               _Usage            = TextureDesc{}.Usage,
                BIND_FLAGS          _BindFlags        = TextureDesc{}.BindFlags,
                CPU_ACCESS_FLAGS    _CPUAccessFlags   = TextureDesc{}.CPUAccessFlags,
                MISC_TEXTURE_FLAGS  _MiscFlags        = TextureDesc{}.MiscFlags,
                OptimizedClearValue _ClearValue       = TextureDesc{}.ClearValue,
                Uint64              _CommandQueueMask = TextureDesc{}.CommandQueueMask) : 
        Type             {_Type            }, 
        Width            {_Width           },
        Height           {_Height          },
        ArraySize        {_ArraySizeOrDepth},
        Format           {_Format          },
        MipLevels        {_MipLevels       },
        SampleCount      {_SampleCount     },
        Usage            {_Usage           },
        BindFlags        {_BindFlags       },
        CPUAccessFlags   {_CPUAccessFlags  },
        MiscFlags        {_MiscFlags       },
        ClearValue       {_ClearValue      },
        CommandQueueMask {_CommandQueueMask}
    {}
 
 
    bool operator ==(const TextureDesc& RHS)const
    {
                // Name is primarily used for debug purposes and does not affect the state.
                // It is ignored in comparison operation.
        return  // strcmp(Name, RHS.Name) == 0          &&
                Type             == RHS.Type           &&
                Width            == RHS.Width          &&
                Height           == RHS.Height         &&
                ArraySize        == RHS.ArraySize      &&
                Format           == RHS.Format         &&
                MipLevels        == RHS.MipLevels      &&
                SampleCount      == RHS.SampleCount    &&
                Usage            == RHS.Usage          &&
                BindFlags        == RHS.BindFlags      &&
                CPUAccessFlags   == RHS.CPUAccessFlags &&
                MiscFlags        == RHS.MiscFlags      &&
                ClearValue       == RHS.ClearValue     &&
                CommandQueueMask == RHS.CommandQueueMask;
    }
#endif
};
typedef struct TextureDesc TextureDesc;
 
struct TextureSubResData
{
    const void* pData           DEFAULT_INITIALIZER(nullptr);
 
    struct IBuffer* pSrcBuffer   DEFAULT_INITIALIZER(nullptr);
 
    Uint32 SrcOffset            DEFAULT_INITIALIZER(0);
 
    Uint32 Stride               DEFAULT_INITIALIZER(0);
 
    Uint32 DepthStride          DEFAULT_INITIALIZER(0);
 
 
#if DILIGENT_CPP_INTERFACE
 
    TextureSubResData()noexcept{}
    
    TextureSubResData(const void* _pData, Uint32 _Stride, Uint32 _DepthStride = 0)noexcept :
        pData       (_pData),
        pSrcBuffer  (nullptr),
        SrcOffset   (0),
        Stride      (_Stride),
        DepthStride (_DepthStride)
    {}
 
    TextureSubResData(IBuffer* _pBuffer, Uint32 _SrcOffset, Uint32 _Stride, Uint32 _DepthStride = 0)noexcept :
        pData       {nullptr     },
        pSrcBuffer  {_pBuffer    },
        SrcOffset   {_SrcOffset  },
        Stride      {_Stride     },
        DepthStride {_DepthStride}
    {}
#endif
};
typedef struct TextureSubResData TextureSubResData;
 
struct TextureData
{
    TextureSubResData* pSubResources    DEFAULT_INITIALIZER(nullptr);
 
    Uint32             NumSubresources  DEFAULT_INITIALIZER(0);
 
#if DILIGENT_CPP_INTERFACE
    TextureData() noexcept {}
 
    TextureData(TextureSubResData* _pSubResources,
                Uint32             _NumSubresources) noexcept :
        pSubResources   {_pSubResources  },
        NumSubresources {_NumSubresources}
    {}
#endif
};
typedef struct TextureData TextureData;
 
struct MappedTextureSubresource
{
    PVoid  pData       DEFAULT_INITIALIZER(nullptr);
    Uint32 Stride      DEFAULT_INITIALIZER(0);
    Uint32 DepthStride DEFAULT_INITIALIZER(0);
 
#if DILIGENT_CPP_INTERFACE
    MappedTextureSubresource() noexcept {}
 
    MappedTextureSubresource(PVoid  _pData,
                             Uint32 _Stride,
                             Uint32 _DepthStride = 0) noexcept :
        pData       {_pData      },
        Stride      {_Stride     },
        DepthStride {_DepthStride}
    {}
#endif
};
typedef struct MappedTextureSubresource MappedTextureSubresource;
 
#define DILIGENT_INTERFACE_NAME ITexture
#include "../../../Primitives/interface/DefineInterfaceHelperMacros.h"
 
#define ITextureInclusiveMethods   \
    IDeviceObjectInclusiveMethods; \
    ITextureMethods Texture
 
DILIGENT_BEGIN_INTERFACE(ITexture, IDeviceObject)
{
#if DILIGENT_CPP_INTERFACE
    virtual const TextureDesc& METHOD(GetDesc)()const override = 0;
#endif
 
 
    VIRTUAL void METHOD(CreateView)(THIS_
                                    const TextureViewDesc REF ViewDesc,
                                    ITextureView**            ppView) PURE;
 
    
    VIRTUAL ITextureView* METHOD(GetDefaultView)(THIS_
                                                 TEXTURE_VIEW_TYPE ViewType) PURE;
 
 
 
    VIRTUAL void* METHOD(GetNativeHandle)(THIS) PURE;
 
 
    VIRTUAL void METHOD(SetState)(THIS_
                                  RESOURCE_STATE State) PURE;
 
    VIRTUAL RESOURCE_STATE METHOD(GetState)(THIS) CONST PURE;
};
DILIGENT_END_INTERFACE
 
#include "../../../Primitives/interface/UndefInterfaceHelperMacros.h"
 
#if DILIGENT_C_INTERFACE
 
// clang-format off
 
#    define ITexture_GetDesc(This) (const struct TextureDesc*)IDeviceObject_GetDesc(This)
 
#    define ITexture_CreateView(This, ...)     CALL_IFACE_METHOD(Texture, CreateView,      This, __VA_ARGS__)
#    define ITexture_GetDefaultView(This, ...) CALL_IFACE_METHOD(Texture, GetDefaultView,  This, __VA_ARGS__)
#    define ITexture_GetNativeHandle(This)     CALL_IFACE_METHOD(Texture, GetNativeHandle, This)
#    define ITexture_SetState(This, ...)       CALL_IFACE_METHOD(Texture, SetState,        This, __VA_ARGS__)
#    define ITexture_GetState(This)            CALL_IFACE_METHOD(Texture, GetState,        This)
 
// clang-format on
 
#endif
 
DILIGENT_END_NAMESPACE // namespace Diligent