GraphicsAccessories.hpp

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
 
 
#include "../../GraphicsEngine/interface/GraphicsTypes.h"
#include "../../GraphicsEngine/interface/Shader.h"
#include "../../GraphicsEngine/interface/Texture.h"
#include "../../GraphicsEngine/interface/Buffer.h"
#include "../../GraphicsEngine/interface/RenderDevice.h"
#include "../../../Platforms/Basic/interface/DebugUtilities.hpp"
#include "../../../Platforms/interface/PlatformMisc.hpp"
 
namespace Diligent
{
 
template <VALUE_TYPE ValType>
struct VALUE_TYPE2CType
{};
 
 
template <> struct VALUE_TYPE2CType<VT_INT8>
{
    typedef Int8 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_INT16>
{
    typedef Int16 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_INT32>
{
    typedef Int32 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_UINT8>
{
    typedef Uint8 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_UINT16>
{
    typedef Uint16 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_UINT32>
{
    typedef Uint32 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_FLOAT16>
{
    typedef Uint16 CType;
};
 
 
template <> struct VALUE_TYPE2CType<VT_FLOAT32>
{
    typedef Float32 CType;
};
 
 
static const Uint32 ValueTypeToSizeMap[] =
    // clang-format off
{
    0,
    sizeof(VALUE_TYPE2CType<VT_INT8>    :: CType),
    sizeof(VALUE_TYPE2CType<VT_INT16>   :: CType),
    sizeof(VALUE_TYPE2CType<VT_INT32>   :: CType),
    sizeof(VALUE_TYPE2CType<VT_UINT8>   :: CType),
    sizeof(VALUE_TYPE2CType<VT_UINT16>  :: CType),
    sizeof(VALUE_TYPE2CType<VT_UINT32>  :: CType),
    sizeof(VALUE_TYPE2CType<VT_FLOAT16> :: CType),
    sizeof(VALUE_TYPE2CType<VT_FLOAT32> :: CType)
};
// clang-format on
static_assert(VT_NUM_TYPES == VT_FLOAT32 + 1, "Not all value type sizes initialized.");
 
inline Uint32 GetValueSize(VALUE_TYPE Val)
{
    VERIFY_EXPR(Val < _countof(ValueTypeToSizeMap));
    return ValueTypeToSizeMap[Val];
}
 
const Char* GetValueTypeString(VALUE_TYPE Val);
 
 
const TextureFormatAttribs& GetTextureFormatAttribs(TEXTURE_FORMAT Format);
 
 
TEXTURE_FORMAT GetDefaultTextureViewFormat(TEXTURE_FORMAT TextureFormat, TEXTURE_VIEW_TYPE ViewType, Uint32 BindFlags);
 
 
inline TEXTURE_FORMAT GetDefaultTextureViewFormat(const TextureDesc& TexDesc, TEXTURE_VIEW_TYPE ViewType)
{
    return GetDefaultTextureViewFormat(TexDesc.Format, ViewType, TexDesc.BindFlags);
}
 
 
const Char* GetTexViewTypeLiteralName(TEXTURE_VIEW_TYPE ViewType);
 
 
const Char* GetBufferViewTypeLiteralName(BUFFER_VIEW_TYPE ViewType);
 
 
const Char* GetShaderTypeLiteralName(SHADER_TYPE ShaderType);
 
String GetShaderStagesString(SHADER_TYPE ShaderStages);
 
 
const Char* GetShaderVariableTypeLiteralName(SHADER_RESOURCE_VARIABLE_TYPE VarType, bool bGetFullName = false);
 
 
const Char* GetShaderResourceTypeLiteralName(SHADER_RESOURCE_TYPE ResourceType, bool bGetFullName = false);
 
inline const Char* GetViewTypeLiteralName(TEXTURE_VIEW_TYPE TexViewType)
{
    return GetTexViewTypeLiteralName(TexViewType);
}
 
inline const Char* GetViewTypeLiteralName(BUFFER_VIEW_TYPE BuffViewType)
{
    return GetBufferViewTypeLiteralName(BuffViewType);
}
 
 
const Char* GetFilterTypeLiteralName(FILTER_TYPE FilterType, bool bGetFullName);
 
 
 
const Char* GetTextureAddressModeLiteralName(TEXTURE_ADDRESS_MODE AddressMode, bool bGetFullName);
 
 
 
const Char* GetComparisonFunctionLiteralName(COMPARISON_FUNCTION ComparisonFunc, bool bGetFullName);
 
 
 
const Char* GetStencilOpLiteralName(STENCIL_OP StencilOp);
 
 
 
const Char* GetBlendFactorLiteralName(BLEND_FACTOR BlendFactor);
 
 
 
const Char* GetBlendOperationLiteralName(BLEND_OPERATION BlendOp);
 
 
 
const Char* GetFillModeLiteralName(FILL_MODE FillMode);
 
 
const Char* GetCullModeLiteralName(CULL_MODE CullMode);
 
const Char* GetMapTypeString(MAP_TYPE MapType);
 
const Char* GetUsageString(USAGE Usage);
 
const Char* GetResourceDimString(RESOURCE_DIMENSION TexType);
 
const Char* GetBindFlagString(Uint32 BindFlag);
 
String GetBindFlagsString(Uint32 BindFlags, const char* Delimeter = "|");
 
String GetCPUAccessFlagsString(Uint32 CpuAccessFlags);
 
String GetTextureDescString(const TextureDesc& Desc);
 
String GetBufferFormatString(const BufferFormat& Fmt);
 
const Char* GetBufferModeString(BUFFER_MODE Mode);
 
String GetBufferDescString(const BufferDesc& Desc);
 
const Char* GetResourceStateFlagString(RESOURCE_STATE State);
String      GetResourceStateString(RESOURCE_STATE State);
 
template <typename TObjectDescType>
String GetObjectDescString(const TObjectDescType&)
{
    return "";
}
 
template <>
inline String GetObjectDescString(const TextureDesc& TexDesc)
{
    String Str{"Tex desc: "};
    Str += GetTextureDescString(TexDesc);
    return Str;
}
 
template <>
inline String GetObjectDescString(const BufferDesc& BuffDesc)
{
    String Str{"Buff desc: "};
    Str += GetBufferDescString(BuffDesc);
    return Str;
}
 
const char* GetQueryTypeString(QUERY_TYPE QueryType);
 
const char* GetSurfaceTransformString(SURFACE_TRANSFORM SrfTransform);
 
const char* GetPipelineTypeString(PIPELINE_TYPE PipelineType);
 
const char* GetShaderCompilerTypeString(SHADER_COMPILER Compiler);
 
String GetPipelineResourceFlagsString(PIPELINE_RESOURCE_FLAGS Flags, bool GetFullName = false, const char* DelimeterString = "|");
 
PIPELINE_RESOURCE_FLAGS GetValidPipelineResourceFlags(SHADER_RESOURCE_TYPE ResourceType);
 
Uint32 ComputeMipLevelsCount(Uint32 Width);
Uint32 ComputeMipLevelsCount(Uint32 Width, Uint32 Height);
Uint32 ComputeMipLevelsCount(Uint32 Width, Uint32 Height, Uint32 Depth);
 
inline bool IsComparisonFilter(FILTER_TYPE FilterType)
{
    return FilterType == FILTER_TYPE_COMPARISON_POINT ||
        FilterType == FILTER_TYPE_COMPARISON_LINEAR ||
        FilterType == FILTER_TYPE_COMPARISON_ANISOTROPIC;
}
 
inline bool IsAnisotropicFilter(FILTER_TYPE FilterType)
{
    return FilterType == FILTER_TYPE_ANISOTROPIC ||
        FilterType == FILTER_TYPE_COMPARISON_ANISOTROPIC ||
        FilterType == FILTER_TYPE_MINIMUM_ANISOTROPIC ||
        FilterType == FILTER_TYPE_MAXIMUM_ANISOTROPIC;
}
 
bool VerifyResourceStates(RESOURCE_STATE State, bool IsTexture);
 
struct MipLevelProperties
{
    Uint32 LogicalWidth   = 0;
    Uint32 LogicalHeight  = 0;
    Uint32 StorageWidth   = 0;
    Uint32 StorageHeight  = 0;
    Uint32 Depth          = 1;
    Uint32 RowSize        = 0;
    Uint32 DepthSliceSize = 0;
    Uint32 MipSize        = 0;
};
 
MipLevelProperties GetMipLevelProperties(const TextureDesc& TexDesc, Uint32 MipLevel);
 
ADAPTER_VENDOR VendorIdToAdapterVendor(Uint32 VendorId);
 
 
inline Int32 GetShaderTypeIndex(SHADER_TYPE Type)
{
    if (Type == SHADER_TYPE_UNKNOWN)
        return -1;
 
    VERIFY(Type > SHADER_TYPE_UNKNOWN && Type <= SHADER_TYPE_LAST, "Value ", Uint32{Type}, " is not a valid SHADER_TYPE enum value");
    VERIFY(((Uint32{Type} & (Uint32{Type} - 1)) == 0), "Only single shader stage should be provided");
 
    return PlatformMisc::GetLSB(Type);
}
 
inline Int32 GetFirstShaderStageIndex(SHADER_TYPE Stages)
{
    if (Stages == SHADER_TYPE_UNKNOWN)
        return -1;
 
    VERIFY(Stages > SHADER_TYPE_UNKNOWN && Stages < SHADER_TYPE_LAST * 2, "Value ", Uint32{Stages}, " is not a valid SHADER_TYPE enum value");
 
    return PlatformMisc::GetLSB(Stages);
}
 
inline Int32 ExtractFirstShaderStageIndex(SHADER_TYPE& Stages)
{
    if (Stages == SHADER_TYPE_UNKNOWN)
        return -1;
 
    VERIFY(Stages > SHADER_TYPE_UNKNOWN && Stages < SHADER_TYPE_LAST * 2, "Value ", Uint32{Stages}, " is not a valid SHADER_TYPE enum value");
 
    const auto StageIndex = PlatformMisc::GetLSB(Stages);
    Stages &= ~static_cast<SHADER_TYPE>(1u << StageIndex);
    return StageIndex;
}
 
 
static_assert(SHADER_TYPE_LAST == 0x2000, "Please add the new shader type index below");
 
static constexpr Int32 VSInd   = 0;
static constexpr Int32 PSInd   = 1;
static constexpr Int32 GSInd   = 2;
static constexpr Int32 HSInd   = 3;
static constexpr Int32 DSInd   = 4;
static constexpr Int32 CSInd   = 5;
static constexpr Int32 ASInd   = 6;
static constexpr Int32 MSInd   = 7;
static constexpr Int32 RGSInd  = 8;
static constexpr Int32 RMSInd  = 9;
static constexpr Int32 RCHSInd = 10;
static constexpr Int32 RAHSInd = 11;
static constexpr Int32 RISInd  = 12;
static constexpr Int32 RCSInd  = 13;
 
static constexpr Int32 LastShaderInd = RCSInd;
 
// clang-format off
static_assert(SHADER_TYPE_VERTEX           == (1 << VSInd),   "VSInd is not consistent with SHADER_TYPE_VERTEX");
static_assert(SHADER_TYPE_PIXEL            == (1 << PSInd),   "PSInd is not consistent with SHADER_TYPE_PIXEL");
static_assert(SHADER_TYPE_GEOMETRY         == (1 << GSInd),   "GSInd is not consistent with SHADER_TYPE_GEOMETRY");
static_assert(SHADER_TYPE_HULL             == (1 << HSInd),   "HSInd is not consistent with SHADER_TYPE_HULL");
static_assert(SHADER_TYPE_DOMAIN           == (1 << DSInd),   "DSInd is not consistent with SHADER_TYPE_DOMAIN");
static_assert(SHADER_TYPE_COMPUTE          == (1 << CSInd),   "CSInd is not consistent with SHADER_TYPE_COMPUTE");
static_assert(SHADER_TYPE_AMPLIFICATION    == (1 << ASInd),   "ASInd is not consistent with SHADER_TYPE_AMPLIFICATION");
static_assert(SHADER_TYPE_MESH             == (1 << MSInd),   "MSInd is not consistent with SHADER_TYPE_MESH");
static_assert(SHADER_TYPE_RAY_GEN          == (1 << RGSInd),  "RGSInd is not consistent with SHADER_TYPE_RAY_GEN");
static_assert(SHADER_TYPE_RAY_MISS         == (1 << RMSInd),  "RMSInd is not consistent with SHADER_TYPE_RAY_MISS");
static_assert(SHADER_TYPE_RAY_CLOSEST_HIT  == (1 << RCHSInd), "RCHSInd is not consistent with SHADER_TYPE_RAY_CLOSEST_HIT");
static_assert(SHADER_TYPE_RAY_ANY_HIT      == (1 << RAHSInd), "RAHSInd is not consistent with SHADER_TYPE_RAY_ANY_HIT");
static_assert(SHADER_TYPE_RAY_INTERSECTION == (1 << RISInd),  "RISInd is not consistent with SHADER_TYPE_RAY_INTERSECTION");
static_assert(SHADER_TYPE_CALLABLE         == (1 << RCSInd),  "RCSInd is not consistent with SHADER_TYPE_CALLABLE");
 
static_assert(SHADER_TYPE_LAST == (1 << LastShaderInd), "LastShaderInd is not consistent with SHADER_TYPE_LAST");
// clang-format on
 
inline SHADER_TYPE GetShaderTypeFromIndex(Int32 Index)
{
    VERIFY(Index >= 0 && Index <= LastShaderInd, "Shader type index is out of range");
    return static_cast<SHADER_TYPE>(1 << Index);
}
 
 
bool          IsConsistentShaderType(SHADER_TYPE ShaderType, PIPELINE_TYPE PipelineType);
Int32         GetShaderTypePipelineIndex(SHADER_TYPE ShaderType, PIPELINE_TYPE PipelineType);
SHADER_TYPE   GetShaderTypeFromPipelineIndex(Int32 Index, PIPELINE_TYPE PipelineType);
PIPELINE_TYPE PipelineTypeFromShaderStages(SHADER_TYPE ShaderStages);
 
Uint32 GetStagingTextureLocationOffset(const TextureDesc& TexDesc,
                                       Uint32             ArraySlice,
                                       Uint32             MipLevel,
                                       Uint32             Alignment,
                                       Uint32             LocationX,
                                       Uint32             LocationY,
                                       Uint32             LocationZ);
 
inline Uint32 GetStagingTextureSubresourceOffset(const TextureDesc& TexDesc,
                                                 Uint32             ArraySlice,
                                                 Uint32             MipLevel,
                                                 Uint32             Alignment)
{
    return GetStagingTextureLocationOffset(TexDesc, ArraySlice, MipLevel, Alignment, 0, 0, 0);
}
 
 
struct BufferToTextureCopyInfo
{
    Uint32 RowSize = 0;
 
    Uint32 RowStride = 0;
 
    Uint32 RowStrideInTexels = 0;
 
    Uint32 RowCount = 0;
 
    Uint32 DepthStride = 0;
 
    Uint32 MemorySize = 0;
 
    Box Region;
};
BufferToTextureCopyInfo GetBufferToTextureCopyInfo(const TextureDesc& TexDesc,
                                                   Uint32             MipLevel,
                                                   const Box&         Region,
                                                   Uint32             RowStrideAlignment);
 
 
 
void CopyTextureSubresource(const TextureSubResData& SrcSubres,
                            Uint32                   NumRows,
                            Uint32                   NumDepthSlices,
                            Uint32                   RowSize,
                            void*                    pDstData,
                            Uint32                   DstRowStride,
                            Uint32                   DstDepthStride);
 
 
inline String GetShaderResourcePrintName(const char* Name, Uint32 ArraySize, Uint32 ArrayIndex)
{
    VERIFY(ArrayIndex < ArraySize, "Array index is out of range");
    String PrintName = Name;
    if (ArraySize > 1)
    {
        PrintName.push_back('[');
        PrintName.append(std::to_string(ArrayIndex));
        PrintName.push_back(']');
    }
    return PrintName;
}
 
template <typename DescType>
String GetShaderResourcePrintName(const DescType& ResDesc, Uint32 ArrayIndex = 0)
{
    return GetShaderResourcePrintName(ResDesc.Name, ResDesc.ArraySize, ArrayIndex);
}
 
} // namespace Diligent