birkeh
/
o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
development
monroegm-disable-blank-issue-2
main
2111.2
2111.1
2107.1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c2cbd430fe'
${ noResults }
o3de/Code/CryEngine/RenderDll/XRenderD3D9/DXMETAL/Implementation/GLResource.cpp

3194 lines
126 KiB
C++
Raw Blame History

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Implements the resource related functions
#include "RenderDll_precompiled.h"
#include "GLResource.hpp"
#include "METALContext.hpp"
#include "MetalDevice.hpp"
#include <DriverD3D.h>
namespace NCryMetal
{
enum
{
MIN_MAPPED_RESOURCE_ALIGNMENT = 64, // DX10+ mapped resources are 16-aligned but GL_ARB_map_buffer_alignment ensures 64-alignment for AVX
};
MemRingBufferStorage GetMemAllocModeBasedOnSize(const size_t size)
{
MemRingBufferStorage memAllocMode = MEM_SHARED_RINGBUFFER;
#if defined(AZ_PLATFORM_MAC)
if (size > FASTBUFFER_SIZE_THRESHHOLD)
{
memAllocMode = MEM_MANAGED_RINGBUFFER;
}
#endif
return memAllocMode;
}
id<MTLBuffer> GetMtlBufferBasedOnSize(const SBuffer* pBuffer)
{
if (!pBuffer)
{
return NULL;
}
id<MTLBuffer> buffer = pBuffer->m_BufferShared;
#if defined(AZ_PLATFORM_MAC)
if (pBuffer->m_BufferManaged && GetMemAllocModeBasedOnSize(pBuffer->m_uMapSize) == MEM_MANAGED_RINGBUFFER)
{
buffer = pBuffer->m_BufferManaged;
}
#endif
return buffer;
}
uint32 GetRowPitch(uint32 uWidth, uint32 uRowBytes, const SGIFormatInfo* pFormatInfo)
{
uint32 uNumElementsPerRow(uRowBytes * pFormatInfo->m_pTexture->m_uBlockWidth / pFormatInfo->m_pTexture->m_uNumBlockBytes);
return uNumElementsPerRow == uWidth ? 0 : uNumElementsPerRow;
}
uint32 GetImagePitch(uint32 uHeight, uint32 uImageBytes, uint32 uRowBytes)
{
uint32 uNumRowsPerImage(uImageBytes / uRowBytes);
return uNumRowsPerImage == uHeight ? 0 : uNumRowsPerImage;
}
struct STexBox
{
STexPos m_kOffset;
STexSize m_kSize;
};
struct SPackedLayout
{
uint32 m_uRowPitch;
uint32 m_uImagePitch;
uint32 m_uTextureSize;
};
static GLint GetMaxMipLevels(const D3D11_TEXTURE1D_DESC& kTexDesc)
{
return (GLint)IntegerLog2(kTexDesc.Width);
}
static GLint GetMaxMipLevels(const D3D11_TEXTURE2D_DESC& kTexDesc)
{
return (GLint)max(IntegerLog2(kTexDesc.Width), IntegerLog2(kTexDesc.Height));
}
static GLint GetMaxMipLevels(const D3D11_TEXTURE3D_DESC& kTexDesc)
{
return (GLint)max(max(IntegerLog2(kTexDesc.Width), IntegerLog2(kTexDesc.Height)), IntegerLog2(kTexDesc.Depth));
}
template <typename TextureDesc>
static GLint GetNumMipLevels(const TextureDesc& kTexDesc)
{
return kTexDesc.MipLevels != 0 ? kTexDesc.MipLevels : GetMaxMipLevels(kTexDesc);
}
static STexSize GetMipSize(STexture* pTexture, GLint iLevel, const SGIFormatInfo* pFormat, bool bClampToBlockSize)
{
STexSize kMinSize(1, 1, 1);
if (bClampToBlockSize && pFormat->m_pTexture->m_bCompressed)
{
kMinSize = STexSize(
pFormat->m_pTexture->m_uBlockWidth,
pFormat->m_pTexture->m_uBlockHeight,
pFormat->m_pTexture->m_uBlockDepth);
}
return STexSize(
max(kMinSize.x, pTexture->m_iWidth >> iLevel),
max(kMinSize.y, pTexture->m_iHeight >> iLevel),
max(kMinSize.z, pTexture->m_iDepth >> iLevel));
}
void GetTextureBox(STexBox& kTexBox, STexture* pTexture, GLint iLevel, const SGIFormatInfo* pFormat, bool bClampToBlockSize)
{
kTexBox.m_kOffset = STexPos(0, 0, 0);
kTexBox.m_kSize = GetMipSize(pTexture, iLevel, pFormat, bClampToBlockSize);
}
void GetTextureBox(STexBox& kTexBox, STexture* pTexture, GLint iLevel, const D3D11_BOX* pBox, const SGIFormatInfo* pFormat, bool bClampToBlockSize)
{
if (pBox != NULL)
{
kTexBox.m_kOffset = STexPos(pBox->left, pBox->top, pBox->front);
kTexBox.m_kSize = STexSize(pBox->right - pBox->left, pBox->bottom - pBox->top, pBox->back - pBox->front);
}
else
{
GetTextureBox(kTexBox, pTexture, iLevel, pFormat, bClampToBlockSize);
}
}
struct STex1DBase
{
static GLsizei GetBCImageSize(STexSize kSize, const STextureFormat* pTexFormat)
{
return pTexFormat->m_uNumBlockBytes *
((kSize.x + pTexFormat->m_uBlockWidth - 1) / pTexFormat->m_uBlockWidth);
}
};
struct STex2DBase
{
static GLsizei GetBCImageSize(STexSize kSize, const STextureFormat* pTexFormat)
{
return pTexFormat->m_uNumBlockBytes *
((kSize.x + pTexFormat->m_uBlockWidth - 1) / pTexFormat->m_uBlockWidth) *
((kSize.y + pTexFormat->m_uBlockHeight - 1) / pTexFormat->m_uBlockHeight);
}
};
struct STex3DBase
{
static GLsizei GetBCImageSize(STexSize kSize, const STextureFormat* pTexFormat)
{
return pTexFormat->m_uNumBlockBytes *
((kSize.x + pTexFormat->m_uBlockWidth - 1) / pTexFormat->m_uBlockWidth) *
((kSize.y + pTexFormat->m_uBlockHeight - 1) / pTexFormat->m_uBlockHeight) *
((kSize.z + pTexFormat->m_uBlockDepth - 1) / pTexFormat->m_uBlockDepth);
}
};
struct SDefaultTex1DBase
: STex1DBase
{
static void TexStorage(STexture* pTexture, STexSize kSize, GLsizei iLevels, const SGIFormatInfo* pFormat, id<MTLDevice> mtlDevice, const uint32 uBindFlags)
{
assert(pFormat->m_pTexture);
DXMETAL_NOT_IMPLEMENTED
}
};
struct SDefaultTex2DBase
: STex2DBase
{
typedef SDefaultTex1DBase TArrayElement;
static void TexStorage(STexture* pTexture, STexSize kSize, GLsizei iLevels, const SGIFormatInfo* pFormat, id<MTLDevice> mtlDevice, const uint32 uBindFlags)
{
const STextureFormat* pTexFormat = pFormat->m_pTexture;
assert(pTexFormat);
// Confetti BEGIN: Igor Lobanchikov
bool bHasStecnilAttachment = false;
MTLPixelFormat eMetalFormat = pTexFormat->m_eMetalFormat;
bool isDepthStencilBuffer = pFormat->m_eTypelessFormat == eGIF_R32G8X24_TYPELESS || pFormat->m_eDXGIFormat == DXGI_FORMAT_R32G8X24_TYPELESS || pFormat->m_eDXGIFormat == DXGI_FORMAT_R16_TYPELESS || pFormat->m_eDXGIFormat == DXGI_FORMAT_R32_TYPELESS ;
// Igor: Special handling for the texture which is actually 2 textures
if (isDepthStencilBuffer)
{
bHasStecnilAttachment = true;
#if defined(AZ_PLATFORM_MAC)
//The OSX_GPUFamily1_v1 feature set does not support separate depth and stencil render targets.
//If these render targets are needed, use the following newly introduced depth/stencil pixel formats
//to set the same texture as both the depth and stencil render target
eMetalFormat = MTLPixelFormatDepth32Float_Stencil8;
#else
eMetalFormat = MTLPixelFormatDepth32Float;
#endif
}
if (eMetalFormat != MTLPixelFormatInvalid)
{
MTLTextureDescriptor* Desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:eMetalFormat
width:kSize.x
height:kSize.y
mipmapped:(iLevels > 1)];
switch (pTexture->m_eTextureType)
{
case MTLTextureTypeCube:
assert(pTexture->m_uNumElements == 6);
Desc.textureType = MTLTextureTypeCube;
break;
case MTLTextureType2D:
assert(pTexture->m_uNumElements == 1);
break;
case MTLTextureType2DArray:
Desc.textureType = MTLTextureType2DArray;
Desc.arrayLength = pTexture->m_uNumElements;
break;
default:
DXGL_NOT_IMPLEMENTED;
}
Desc.mipmapLevelCount = iLevels;
if (uBindFlags & D3D11_BIND_RENDER_TARGET)
{
Desc.usage = MTLTextureUsageRenderTarget;
}
if (uBindFlags & D3D11_BIND_SHADER_RESOURCE)
{
Desc.usage |= MTLTextureUsageShaderRead;
}
if (isDepthStencilBuffer)
{
//MTLStorageModePrivate on OS X makes it so that this resource is stored
//in video memory for the GPU.
Desc.storageMode = MTLStorageModePrivate;
//Depth stencil buffer gets written into and sampled from.
Desc.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
#if defined(AZ_PLATFORM_MAC)
//On osx the depth/stencil texture is merged. You need to create a different
//texture view to access stencil data. Hence we need this flag.
Desc.usage |= MTLTextureUsagePixelFormatView;
#endif
}
else if(CTexture::IsDeviceFormatTypeless(pFormat->m_eDXGIFormat))
{
//Apple recommendation -> For sRGB variant views, you don't need the PFV flag when: - running on
//iOS/tvOS 12.0 or newer - running on macOS 10.15 or newer
//However, on older OSs (and in macOS case, older GPUs) you are still required to set the flag.
#if defined(AZ_COMPILER_CLANG) && AZ_COMPILER_CLANG >= 9 //@available was added in Xcode 9
if (@available(macOS 10.15, iOS 12.0, *))
{
//No need to do anything but if we want to add non sRGB view related flags it would go here.
}
else
{
Desc.usage |= MTLTextureUsagePixelFormatView;
}
#endif
}
pTexture->m_Texture = [mtlDevice newTextureWithDescriptor:Desc];
if (!pTexture->m_Texture)
{
LOG_METAL_SHADER_ERRORS(@ "Failed to create texture: %@", Desc);
}
else if (isDepthStencilBuffer)
{
#if defined(AZ_PLATFORM_MAC)
pTexture->m_StencilTexture = pTexture->m_Texture;
#else
Desc.pixelFormat = MTLPixelFormatStencil8;
pTexture->m_StencilTexture = [mtlDevice newTextureWithDescriptor: Desc];
if (!pTexture->m_StencilTexture)
{
LOG_METAL_SHADER_ERRORS(@ "Failed to create stencil attachment: %@", Desc);
}
#endif
}
}
// Confetti End: Igor Lobanchikov
}
template <typename T>
static void SetLayerComponent(STexVec<T>& kVec, T kLayer)
{
kVec.y = kLayer;
}
};
struct SDefaultTex3DBase
: STex3DBase
{
typedef SDefaultTex2DBase TArrayElement;
static void TexStorage(STexture* pTexture, STexSize kSize, GLsizei iLevels, const SGIFormatInfo* pFormat, id<MTLDevice> mtlDevice, const uint32 uBindFlags)
{
const STextureFormat* pTexFormat = pFormat->m_pTexture;
assert(pTexFormat);
// Confetti BEGIN: Igor Lobanchikov
MTLPixelFormat eMetalFormat = pTexFormat->m_eMetalFormat;
assert(pTexture->m_eTextureType == MTLTextureType3D || pTexture->m_eTextureType == MTLTextureType2DArray);
assert(pTexture->m_uNumElements == 1 || pTexture->m_eTextureType != MTLTextureType3D);
if (eMetalFormat != MTLPixelFormatInvalid)
{
MTLTextureDescriptor* Desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:eMetalFormat
width:kSize.x
height:kSize.y
mipmapped:(iLevels > 1)];
Desc.depth = kSize.z;
Desc.textureType = MTLTextureType3D;
Desc.mipmapLevelCount = iLevels;
pTexture->m_Texture = [mtlDevice newTextureWithDescriptor:Desc];
if (!pTexture->m_Texture)
{
LOG_METAL_SHADER_ERRORS(@ "Failed to create texture: %@", Desc);
}
}
// Confetti End: Igor Lobanchikov
}
template <typename T>
static void SetLayerComponent(STexVec<T>& kVec, T kLayer)
{
kVec.z = kLayer;
}
};
struct STexCompressed
{
static bool GetPackedRange(const STexBox& kPixels, STexBox* pPackedRange, const SGIFormatInfo* pFormat)
{
const STextureFormat* pTexFormat(pFormat->m_pTexture);
if ((kPixels.m_kOffset.x % pTexFormat->m_uBlockWidth) != 0 ||
(kPixels.m_kOffset.y % pTexFormat->m_uBlockHeight) != 0 ||
(kPixels.m_kOffset.z % pTexFormat->m_uBlockDepth) != 0 ||
(kPixels.m_kSize.x % pTexFormat->m_uBlockWidth) != 0 ||
(kPixels.m_kSize.y % pTexFormat->m_uBlockHeight) != 0 ||
(kPixels.m_kSize.z % pTexFormat->m_uBlockDepth) != 0)
{
return false;
}
pPackedRange->m_kOffset.x = pTexFormat->m_uNumBlockBytes * kPixels.m_kOffset.x / pTexFormat->m_uBlockWidth;
pPackedRange->m_kSize.x = pTexFormat->m_uNumBlockBytes * kPixels.m_kSize.x / pTexFormat->m_uBlockWidth;
pPackedRange->m_kOffset.y = kPixels.m_kOffset.y / pTexFormat->m_uBlockHeight;
pPackedRange->m_kSize.y = kPixels.m_kSize.y / pTexFormat->m_uBlockHeight;
pPackedRange->m_kOffset.z = kPixels.m_kOffset.z / pTexFormat->m_uBlockDepth;
pPackedRange->m_kSize.z = kPixels.m_kSize.z / pTexFormat->m_uBlockDepth;
return true;
}
};
struct STexUncompressed
{
static bool GetPackedRange(const STexBox& kPixels, STexBox* pPackedRange, const SGIFormatInfo* pFormat)
{
uint32 uPixelBytes(pFormat->m_pTexture->m_uNumBlockBytes);
pPackedRange->m_kOffset.x = kPixels.m_kOffset.x * uPixelBytes;
pPackedRange->m_kSize.x = kPixels.m_kSize.x * uPixelBytes;
pPackedRange->m_kOffset.y = kPixels.m_kOffset.y;
pPackedRange->m_kSize.y = kPixels.m_kSize.y;
pPackedRange->m_kOffset.z = kPixels.m_kOffset.z;
pPackedRange->m_kSize.z = kPixels.m_kSize.z;
return true;
}
};
struct STex1DUncompressed
: SDefaultTex1DBase
, STexUncompressed
{
// Confetti BEGIN: Igor Lobanchikov
static void TexSubImage(STexture* pTexture, uint32 slice, GLint iLevel, STexBox kBox, const STextureFormat* pTexFormat, const GLvoid* pData, uint32 uRowPitch, uint32 uImagePitch)
{
MTLRegion Region = MTLRegionMake3D(kBox.m_kOffset.x, 0, 0, kBox.m_kSize.x, 1, 1);
assert(kBox.m_kSize.y < 2);
[pTexture->m_Texture replaceRegion: Region mipmapLevel: iLevel slice: slice withBytes: pData bytesPerRow: uRowPitch bytesPerImage: uImagePitch];
}
// Confetti End: Igor Lobanchikov
static void GetPackedLayout(STexSize kRect, const SGIFormatInfo* pFormat, SPackedLayout* pLayout)
{
pLayout->m_uRowPitch = kRect.x * pFormat->m_pTexture->m_uNumBlockBytes;
pLayout->m_uImagePitch = pLayout->m_uRowPitch;
pLayout->m_uTextureSize = pLayout->m_uRowPitch;
}
};
struct STex2DUncompressed
: SDefaultTex2DBase
, STexUncompressed
{
// Confetti BEGIN: Igor Lobanchikov
static void TexSubImage(STexture* pTexture, uint32 slice, GLint iLevel, STexBox kBox, const STextureFormat* pTexFormat, const GLvoid* pData, uint32 uRowPitch, uint32 uImagePitch)
{
MTLRegion Region = MTLRegionMake3D(kBox.m_kOffset.x, kBox.m_kOffset.y, 0, kBox.m_kSize.x, kBox.m_kSize.y, 1);
assert(kBox.m_kSize.z < 2);
[pTexture->m_Texture replaceRegion: Region mipmapLevel: iLevel slice: slice withBytes: pData bytesPerRow: uRowPitch bytesPerImage: uImagePitch];
}
// Confetti End: Igor Lobanchikov
static void GetPackedLayout(STexSize kRect, const SGIFormatInfo* pFormat, SPackedLayout* pLayout)
{
pLayout->m_uRowPitch = kRect.x * pFormat->m_pTexture->m_uNumBlockBytes;
pLayout->m_uImagePitch = kRect.y * pLayout->m_uRowPitch;
pLayout->m_uTextureSize = pLayout->m_uImagePitch;
}
};
struct STex3DUncompressed
: SDefaultTex3DBase
, STexUncompressed
{
// Confetti BEGIN: Igor Lobanchikov
static void TexSubImage(STexture* pTexture, uint32 slice, GLint iLevel, STexBox kBox, const STextureFormat* pTexFormat, const GLvoid* pData, uint32 uRowPitch, uint32 uImagePitch)
{
MTLRegion Region = MTLRegionMake3D(kBox.m_kOffset.x, kBox.m_kOffset.y, kBox.m_kOffset.z, kBox.m_kSize.x, kBox.m_kSize.y, kBox.m_kSize.z);
assert(slice == 0);
[pTexture->m_Texture replaceRegion: Region mipmapLevel: iLevel slice: slice withBytes: pData bytesPerRow: uRowPitch bytesPerImage: uImagePitch];
}
// Confetti End: Igor Lobanchikov
static void GetPackedLayout(STexSize kRect, const SGIFormatInfo* pFormat, SPackedLayout* pLayout)
{
pLayout->m_uRowPitch = kRect.x * pFormat->m_pTexture->m_uNumBlockBytes;
pLayout->m_uImagePitch = kRect.y * pLayout->m_uRowPitch;
pLayout->m_uTextureSize = kRect.z * pLayout->m_uImagePitch;
}
};
struct STex1DCompressed
: SDefaultTex1DBase
, STexCompressed
{
// Confetti BEGIN: Igor Lobanchikov
static void TexSubImage(STexture* pTexture, uint32 slice, GLint iLevel, STexBox kBox, const STextureFormat* pTexFormat, const GLvoid* pData, uint32 uRowPitch, uint32 uImagePitch)
{
MTLRegion Region = MTLRegionMake3D(kBox.m_kOffset.x, 0, 0, kBox.m_kSize.x, 1, 1);
assert(kBox.m_kSize.y < 2);
//MTLPixelFormatPVRTC_RGB_2BPP/MTLPixelFormatPVRTC_RGBA_4BPP_sRGB not supported on OSX GPUs
#if !defined AZ_PLATFORM_MAC
// Igor: Metal requires these to be 0 for PVR formats
if (pTexFormat->m_eMetalFormat >= MTLPixelFormatPVRTC_RGB_2BPP && pTexFormat->m_eMetalFormat <= MTLPixelFormatPVRTC_RGBA_4BPP_sRGB)
{
uRowPitch = 0;
uImagePitch = 0;
}
#endif
[pTexture->m_Texture replaceRegion: Region mipmapLevel: iLevel slice: slice withBytes: pData bytesPerRow: uRowPitch bytesPerImage: uImagePitch];
}
// Confetti End: Igor Lobanchikov
static void GetPackedLayout(STexSize kRect, const SGIFormatInfo* pFormat, SPackedLayout* pLayout)
{
pLayout->m_uRowPitch = GetBCImageSize(kRect, pFormat->m_pTexture);
pLayout->m_uImagePitch = pLayout->m_uRowPitch;
pLayout->m_uTextureSize = pLayout->m_uRowPitch;
}
};
struct STex2DCompressed
: SDefaultTex2DBase
, STexCompressed
{
// Confetti BEGIN: Igor Lobanchikov
static void TexSubImage(STexture* pTexture, uint32 slice, GLint iLevel, STexBox kBox, const STextureFormat* pTexFormat, const GLvoid* pData, uint32 uRowPitch, uint32 uImagePitch)
{
MTLRegion Region = MTLRegionMake3D(kBox.m_kOffset.x, kBox.m_kOffset.y, 0, kBox.m_kSize.x, kBox.m_kSize.y, 1);
assert(kBox.m_kSize.z < 2);
//MTLPixelFormatPVRTC_RGB_2BPP/MTLPixelFormatPVRTC_RGBA_4BPP_sRGB not supported on OSX GPUs
#if !defined AZ_PLATFORM_MAC
// Igor: Metal requires these to be 0 for PVR formats
if (pTexFormat->m_eMetalFormat >= MTLPixelFormatPVRTC_RGB_2BPP && pTexFormat->m_eMetalFormat <= MTLPixelFormatPVRTC_RGBA_4BPP_sRGB)
{
uRowPitch = 0;
uImagePitch = 0;
}
#endif
[pTexture->m_Texture replaceRegion: Region mipmapLevel: iLevel slice: slice withBytes: pData bytesPerRow: uRowPitch bytesPerImage: uImagePitch];
}
// Confetti End: Igor Lobanchikov
static void GetPackedLayout(STexSize kRect, const SGIFormatInfo* pFormat, SPackedLayout* pLayout)
{
pLayout->m_uRowPitch = GetBCImageSize(STexSize(kRect.x, 1, 1), pFormat->m_pTexture);
pLayout->m_uImagePitch = GetBCImageSize(kRect, pFormat->m_pTexture);
pLayout->m_uTextureSize = pLayout->m_uImagePitch;
}
};
struct STex3DCompressed
: SDefaultTex3DBase
, STexCompressed
{
// Confetti BEGIN: Igor Lobanchikov
static void TexSubImage(STexture* pTexture, uint32 slice, GLint iLevel, STexBox kBox, const STextureFormat* pTexFormat, const GLvoid* pData, uint32 uRowPitch, uint32 uImagePitch)
{
MTLRegion Region = MTLRegionMake3D(kBox.m_kOffset.x, kBox.m_kOffset.y, kBox.m_kOffset.z, kBox.m_kSize.x, kBox.m_kSize.y, kBox.m_kSize.z);
assert(slice == 0);
//MTLPixelFormatPVRTC_RGB_2BPP/MTLPixelFormatPVRTC_RGBA_4BPP_sRGB not supported on OSX GPUs
#if !defined AZ_PLATFORM_MAC
// Igor: Metal requires these to be 0 for PVR formats
if (pTexFormat->m_eMetalFormat >= MTLPixelFormatPVRTC_RGB_2BPP && pTexFormat->m_eMetalFormat <= MTLPixelFormatPVRTC_RGBA_4BPP_sRGB)
{
uRowPitch = 0;
uImagePitch = 0;
}
#endif
[pTexture->m_Texture replaceRegion: Region mipmapLevel: iLevel slice: slice withBytes: pData bytesPerRow: uRowPitch bytesPerImage: uImagePitch];
}
// Confetti End: Igor Lobanchikov
static void GetPackedLayout(STexSize kRect, const SGIFormatInfo* pFormat, SPackedLayout* pLayout)
{
pLayout->m_uRowPitch = GetBCImageSize(STexSize(kRect.x, 1, 1), pFormat->m_pTexture);
pLayout->m_uImagePitch = GetBCImageSize(STexSize(kRect.x, kRect.y, 1), pFormat->m_pTexture);
pLayout->m_uTextureSize = GetBCImageSize(kRect, pFormat->m_pTexture);
}
};
template <typename Interface>
struct SSingleTexImpl
: Interface
{
static void InitializeStorage(STexture* pTexture, uint32, const SGIFormatInfo* pFormat, CDevice* pDevice, const uint32 uBindFlags)
{
Interface::TexStorage(pTexture, GetMipSize(pTexture, 0, pFormat, false), pTexture->m_uNumMipLevels, pFormat, pDevice->GetMetalDevice(), uBindFlags);
}
static void UploadImage(STexture* pTexture, STexSubresourceID kSubID, STexBox kBox, const void* pSrcData, uint32 uSrcRowPitch, uint32 uSrcDepthPitch, CContext* pContext, const SGIFormatInfo* pFormat)
{
assert((kSubID.m_uElement == 0) ||
(pTexture->m_eTextureType == MTLTextureTypeCube && kSubID.m_uElement < 6));
// Confetti BEGIN: Igor Lobanchikov
Interface::TexSubImage(pTexture, kSubID.m_uElement, kSubID.m_iMipLevel, kBox, pFormat->m_pTexture, pSrcData, uSrcRowPitch, uSrcDepthPitch);
// Confetti End: Igor Lobanchikov
}
static void DownloadImage(STexture* pTexture, STexSubresourceID kSubID, STexBox kBox, void* pDstData, uint32 uDstRowPitch, uint32 uDstDepthPitch, CContext* pContext, const SGIFormatInfo* pFormat)
{
DXMETAL_NOT_IMPLEMENTED
}
static void Map(STexture* pTexture, STexSubresourceID kSubID, bool bDownload, SMappedSubTexture& kMappedSubTex, CContext* pContext, const SGIFormatInfo* pFormat)
{
STexBox kBox;
GetTextureBox(kBox, pTexture, kSubID.m_iMipLevel, pFormat, true);
SPackedLayout kPackedLayout;
Interface::GetPackedLayout(kBox.m_kSize, pFormat, &kPackedLayout);
DXGL_TODO("Check if it's worth to keep an allocation pool");
kMappedSubTex.m_pBuffer = static_cast<uint8*>(Memalign(kPackedLayout.m_uTextureSize, MIN_MAPPED_RESOURCE_ALIGNMENT));
kMappedSubTex.m_uRowPitch = kPackedLayout.m_uRowPitch;
kMappedSubTex.m_uImagePitch = kPackedLayout.m_uImagePitch;
kMappedSubTex.m_uDataOffset = 0;
if (bDownload)
{
DownloadImage(pTexture, kSubID, kBox, kMappedSubTex.m_pBuffer, kPackedLayout.m_uRowPitch, kPackedLayout.m_uImagePitch, pContext, pFormat);
}
}
static void Unmap(STexture* pTexture, STexSubresourceID kSubID, const SMappedSubTexture& kMappedSubTex, CContext* pContext, const SGIFormatInfo* pFormat)
{
if (kMappedSubTex.m_bUpload)
{
STexBox kBox;
GetTextureBox(kBox, pTexture, kSubID.m_iMipLevel, pFormat, true);
UploadImage(pTexture, kSubID, kBox, kMappedSubTex.m_pBuffer, kMappedSubTex.m_uRowPitch, kMappedSubTex.m_uImagePitch, pContext, pFormat);
}
MemalignFree(kMappedSubTex.m_pBuffer);
}
};
template <typename Interface>
struct SArrayTexImpl
: Interface
{
static void InitializeStorage(STexture* pTexture, uint32, const SGIFormatInfo* pFormat, CDevice* pDevice, const uint32 uBindFlags)
{
STexSize kTexSize(GetMipSize(pTexture, 0, pFormat, false));
Interface::SetLayerComponent(kTexSize, (GLsizei)pTexture->m_uNumElements);
Interface::TexStorage(pTexture, kTexSize, pTexture->m_uNumMipLevels, pFormat, pDevice->GetMetalDevice(), uBindFlags);
}
static void UploadImage(STexture* pTexture, STexSubresourceID kSubID, STexBox kBox, const void* pSrcData, uint32 uSrcRowPitch, uint32 uSrcDepthPitch, CContext* pContext, const SGIFormatInfo* pFormat)
{
assert(pTexture->m_eTextureType != MTLTextureTypeCube);
Interface::SetLayerComponent(kBox.m_kOffset, (int)kSubID.m_uElement);
Interface::SetLayerComponent(kBox.m_kSize, 1);
// Confetti BEGIN: Igor Lobanchikov
Interface::TexSubImage(pTexture, kSubID.m_uElement, kSubID.m_iMipLevel, kBox, pFormat->m_pTexture, pSrcData, uSrcRowPitch, uSrcDepthPitch);
// Confetti End: Igor Lobanchikov
}
static void DownloadImage(STexture* pTexture, STexSubresourceID kSubID, STexBox kBox, void* pDstData, uint32 uDstRowPitch, uint32 uDstDepthPitch, CContext* pContext, const SGIFormatInfo* pFormat)
{
DXGL_NOT_IMPLEMENTED
}
static void Map(STexture* pTexture, STexSubresourceID kSubID, bool bDownload, SMappedSubTexture& kMappedSubTex, CContext* pContext, const SGIFormatInfo* pFormat)
{
DXMETAL_NOT_IMPLEMENTED
}
static void Unmap(STexture* pTexture, STexSubresourceID kSubID, const SMappedSubTexture& kMappedSubTex, CContext* pContext, const SGIFormatInfo* pFormat)
{
DXMETAL_NOT_IMPLEMENTED
}
};
template <typename Interface>
uint32 GetSystemMemoryTextureOffset(STexture* pTexture, const SGIFormatInfo* pFormat, STexSubresourceID kID)
{
uint32 uOffset(0);
uint32 uTotSize(0);
uint32 uLevel;
for (uLevel = 0; uLevel < pTexture->m_uNumMipLevels; ++uLevel)
{
STexSize kLevelSize(GetMipSize(pTexture, (GLint)uLevel, pFormat, true));
SPackedLayout kPackedLayout;
Interface::GetPackedLayout(kLevelSize, pFormat, &kPackedLayout);
uTotSize += kPackedLayout.m_uTextureSize;
// Keep every subresource aligned so that it can be directly mapped
uTotSize += MIN_MAPPED_RESOURCE_ALIGNMENT - 1;
uTotSize -= (uTotSize % MIN_MAPPED_RESOURCE_ALIGNMENT);
if (uLevel < kID.m_iMipLevel)
{
uOffset = uTotSize;
}
}
return uTotSize * kID.m_uElement + uOffset;
}
template <typename Interface>
struct SStagingTexImpl
: Interface
{
static void InitializeStorage(STexture* pTexture, uint32 uCPUAccess, const SGIFormatInfo* pFormat, CDevice* pDevice, const uint32 uBindFlags)
{
Interface::TexStorage(pTexture, GetMipSize(pTexture, 0, pFormat, false), pTexture->m_uNumMipLevels, pFormat, pDevice->GetMetalDevice(), uBindFlags);
{
STexSubresourceID kEndID = {aznumeric_cast<int32>(pTexture->m_uNumMipLevels),
static_cast<uint32>(pTexture->m_uNumElements)};
uint32 uMappedSize(GetSystemMemoryTextureOffset<Interface>(pTexture, pFormat, kEndID));
pTexture->m_pMapMemoryCopy = static_cast<uint8*>(Memalign(uMappedSize, MIN_MAPPED_RESOURCE_ALIGNMENT));
}
}
static void UploadImage(STexture* pTexture, STexSubresourceID kSubID, STexBox kBox, const void* pSrcData, uint32 uSrcRowPitch, uint32 uSrcDepthPitch, CContext* pContext, const SGIFormatInfo* pFormat)
{
DXMETAL_NOT_IMPLEMENTED
}
static void DownloadImage(STexture* pTexture, STexSubresourceID kSubID, STexBox kBox, const void* pDstData, uint32 uSrcRowPitch, uint32 uSrcDepthPitch, CContext* pContext, const SGIFormatInfo* pFormat)
{
DXGL_NOT_IMPLEMENTED
}
static void Map(STexture* pTexture, STexSubresourceID kSubID, bool bDownload, SMappedSubTexture& kMappedSubTex, CContext* pContext, const SGIFormatInfo* pFormat)
{
STexSize kSubSize(GetMipSize(pTexture, kSubID.m_iMipLevel, pFormat, true));
SPackedLayout kPackedLayout;
Interface::GetPackedLayout(kSubSize, pFormat, &kPackedLayout);
kMappedSubTex.m_pBuffer = pTexture->m_pMapMemoryCopy + GetSystemMemoryTextureOffset<Interface>(pTexture, pFormat, kSubID);
if (bDownload)
{
static ICVar* isScreenshot = gEnv->pConsole->GetCVar("e_ScreenShot");
static ICVar* isCaptureFrame = gEnv->pConsole->GetCVar("capture_frames");
if (isScreenshot->GetIVal() || isCaptureFrame->GetIVal())
{
//This will stall the GPU so be very careful when using it. Only use it when you absolutely need the
//work encoded by the current comman buffer.
pContext->FlushBlitEncoderAndWait();
}
MTLRegion region = {
{0, 0, 0}, {pTexture->m_Texture.width, pTexture->m_Texture.height, pTexture->m_Texture.depth}
};
[pTexture->m_Texture getBytes: kMappedSubTex.m_pBuffer
bytesPerRow: kPackedLayout.m_uRowPitch
bytesPerImage: kPackedLayout.m_uImagePitch
fromRegion: region
mipmapLevel: kSubID.m_iMipLevel
slice: kSubID.m_uElement];
}
kMappedSubTex.m_uRowPitch = kPackedLayout.m_uRowPitch;
kMappedSubTex.m_uImagePitch = kPackedLayout.m_uImagePitch;
kMappedSubTex.m_uDataOffset = 0;
}
static void Unmap(STexture* pTexture, STexSubresourceID kSubID, const SMappedSubTexture& kMappedSubTex, CContext*, const SGIFormatInfo*)
{
if (kMappedSubTex.m_bUpload)
{
MTLRegion region = {
{0, 0, 0}, {pTexture->m_Texture.width, pTexture->m_Texture.height, pTexture->m_Texture.depth}
};
[pTexture->m_Texture replaceRegion: region
mipmapLevel: kSubID.m_iMipLevel
slice: kSubID.m_uElement
withBytes: kMappedSubTex.m_pBuffer
bytesPerRow: kMappedSubTex.m_uRowPitch
bytesPerImage: kMappedSubTex.m_uImagePitch];
}
}
};
inline STexSubresourceID GetTexSubresourceID(STexture* pTexture, uint32 uSubresource)
{
STexSubresourceID kID;
kID.m_iMipLevel = uSubresource % pTexture->m_uNumMipLevels;
kID.m_uElement = uSubresource / pTexture->m_uNumMipLevels;
assert(kID.m_uElement < pTexture->m_uNumElements);
return kID;
}
template <typename Impl>
void UpdateTexSubresource(SResource* pResource, uint32 uSubresource, const D3D11_BOX* pDstBox, const void* pSrcData, uint32 uSrcRowPitch, uint32 uSrcDepthPitch, CContext* pContext)
{
DXGL_SCOPED_PROFILE("UpdateTexSubresource")
STexture * pTexture(static_cast<STexture*>(pResource));
const SGIFormatInfo* pFormatInfo(GetGIFormatInfo(pTexture->m_eFormat));
assert(pFormatInfo != NULL);
assert(pFormatInfo->m_pTexture != NULL);
STexSubresourceID kSubID(GetTexSubresourceID(pTexture, uSubresource));
STexBox kTexBox;
GetTextureBox(kTexBox, pTexture, kSubID.m_iMipLevel, pDstBox, pFormatInfo, false);
Impl::UploadImage(pTexture, kSubID, kTexBox, pSrcData, uSrcRowPitch, uSrcDepthPitch, pContext, pFormatInfo);
}
template <typename Impl>
bool MapTexSubresource(SResource* pResource, uint32 uSubresource, D3D11_MAP eMapType, uint32 uMapFlags, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("MapTexSubresource")
STexture * pTexture(static_cast<STexture*>(pResource));
const SGIFormatInfo* pFormatInfo(GetGIFormatInfo(pTexture->m_eFormat));
assert(pFormatInfo != NULL);
assert(pFormatInfo->m_pTexture != NULL);
if (uSubresource >= pTexture->m_kMappedSubTextures.size())
{
pTexture->m_kMappedSubTextures.resize(uSubresource + 1);
}
SMappedSubTexture& kMappedSubTexture(pTexture->m_kMappedSubTextures.at(uSubresource));
if (kMappedSubTexture.m_pBuffer != NULL)
{
DXGL_ERROR("Texture subresource is already mapped");
return false;
}
bool bDownload = (eMapType == D3D11_MAP_READ || eMapType == D3D11_MAP_READ_WRITE);
Impl::Map(pTexture, GetTexSubresourceID(pTexture, uSubresource), bDownload, kMappedSubTexture, pContext, pFormatInfo);
kMappedSubTexture.m_bUpload = (eMapType != D3D11_MAP_READ);
pMappedResource->pData = kMappedSubTexture.m_pBuffer + kMappedSubTexture.m_uDataOffset;
pMappedResource->RowPitch = kMappedSubTexture.m_uRowPitch;
pMappedResource->DepthPitch = kMappedSubTexture.m_uImagePitch;
return kMappedSubTexture.m_pBuffer != NULL;
}
template <typename Impl>
void UnmapTexSubresource(SResource* pResource, UINT uSubresource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("UnmapTexSubresource")
STexture * pTexture(static_cast<STexture*>(pResource));
const SGIFormatInfo* pFormatInfo(GetGIFormatInfo(pTexture->m_eFormat));
assert(pFormatInfo != NULL);
assert(pFormatInfo->m_pTexture != NULL);
if (uSubresource >= pTexture->m_kMappedSubTextures.size())
{
pTexture->m_kMappedSubTextures.resize(uSubresource + 1);
}
SMappedSubTexture& kMappedSubTexture(pTexture->m_kMappedSubTextures.at(uSubresource));
if (kMappedSubTexture.m_pBuffer == NULL)
{
DXGL_ERROR("Texture subresource is not mapped");
return;
}
Impl::Unmap(pTexture, GetTexSubresourceID(pTexture, uSubresource), kMappedSubTexture, pContext, pFormatInfo);
kMappedSubTexture.m_pBuffer = NULL;
}
template <typename Impl>
void UnpackTexData(STexture* pTexture, STexSubresourceID kSubID, STexPos kOffset, STexSize kSize, const SMappedSubTexture& kDataLocation, CContext* pContext)
{
DXGL_SCOPED_PROFILE("UnpackTexData")
STexBox kBox;
kBox.m_kOffset = kOffset;
kBox.m_kSize = kSize;
const SGIFormatInfo* pFormat(GetGIFormatInfo(pTexture->m_eFormat));
Impl::UploadImage(pTexture, kSubID, kBox, kDataLocation.m_pBuffer + kDataLocation.m_uDataOffset, kDataLocation.m_uRowPitch, kDataLocation.m_uImagePitch, pContext, pFormat);
}
template <typename Impl>
void PackTexData(STexture* pTexture, STexSubresourceID kSubID, STexPos kOffset, STexSize kSize, const SMappedSubTexture& kDataLocation, CContext* pContext)
{
DXGL_SCOPED_PROFILE("PackTexData")
STexBox kBox;
kBox.m_kOffset = kOffset;
kBox.m_kSize = kSize;
const SGIFormatInfo* pFormat(GetGIFormatInfo(pTexture->m_eFormat));
Impl::DownloadImage(pTexture, kSubID, kBox, kDataLocation.m_pBuffer + kDataLocation.m_uDataOffset, kDataLocation.m_uRowPitch, kDataLocation.m_uImagePitch, pContext, pFormat);
}
template <typename Impl>
void InitializeTexture(STexture* pTexture, const D3D11_SUBRESOURCE_DATA* pInitialData, uint32 uCPUAccess, CDevice* pDevice /*CContext* pContext*/, const SGIFormatInfo* pFormatInfo, const uint32 uBindFlags)
{
pTexture->m_pfUpdateSubresource = &UpdateTexSubresource<Impl>;
pTexture->m_pfMapSubresource = &MapTexSubresource<Impl>;
pTexture->m_pfUnmapSubresource = &UnmapTexSubresource<Impl>;
Impl::InitializeStorage(pTexture, uCPUAccess, pFormatInfo, pDevice, uBindFlags);
if (pInitialData)
{
STexBox kMipBox;
kMipBox.m_kOffset = STexPos(0, 0, 0);
STexSubresourceID kSubID;
for (kSubID.m_uElement = 0; kSubID.m_uElement < pTexture->m_uNumElements; ++kSubID.m_uElement)
{
for (kSubID.m_iMipLevel = 0; kSubID.m_iMipLevel < (GLint)pTexture->m_uNumMipLevels; ++kSubID.m_iMipLevel)
{
kMipBox.m_kSize = GetMipSize(pTexture, kSubID.m_iMipLevel, pFormatInfo, false);
Impl::UploadImage(pTexture, kSubID, kMipBox, pInitialData->pSysMem, pInitialData->SysMemPitch, pInitialData->SysMemSlicePitch, /*pContext*/ 0, pFormatInfo);
++pInitialData;
}
}
}
}
SResource::SResource()
: m_pfUpdateSubresource(NULL)
, m_pfMapSubresource(NULL)
, m_pfUnmapSubresource(NULL)
{
}
SResource::SResource(const SResource& kOther)
: m_pfUpdateSubresource(kOther.m_pfUpdateSubresource)
, m_pfMapSubresource(kOther.m_pfMapSubresource)
, m_pfUnmapSubresource(kOther.m_pfUnmapSubresource)
{
}
SResource::~SResource()
{
}
STexture::STexture(GLsizei iWidth, GLsizei iHeight, GLsizei iDepth, MTLTextureType eTextureType, EGIFormat eFormat, uint32 uNumMipLevels, uint32 uNumElements)
: m_eTextureType(eTextureType)
, m_eFormat(eFormat)
, m_uNumMipLevels(uNumMipLevels)
, m_uNumElements(uNumElements)
, m_iWidth(iWidth)
, m_iHeight(iHeight)
, m_iDepth(iDepth)
, m_pShaderViewsHead(NULL)
, m_pOutputMergerViewsHead(NULL)
, m_pBoundModifier(NULL)
// Confetti BEGIN: Igor Lobanchikov
, m_Texture(nil)
, m_StencilTexture(nil)
, m_bClearDepth(false)
, m_bClearStencil(false)
, m_bBackBuffer(false)
, m_pMapMemoryCopy(NULL)
// Confetti End: Igor Lobanchikov
{
#if DXGL_FULL_EMULATION
m_uNumElements = max(1u, m_uNumElements);
#endif //DXGL_FULL_EMULATION
ResetDontCareActionFlags();
}
STexture::~STexture()
{
// Confetti BEGIN: Igor Lobanchikov
if (m_pMapMemoryCopy)
{
MemalignFree(m_pMapMemoryCopy);
}
if (m_Texture)
{
[m_Texture release];
}
bool isDepthStencilTexSeparate = m_StencilTexture != m_Texture;
if (m_StencilTexture && isDepthStencilTexSeparate)
{
[m_StencilTexture release];
}
// Confetti End: Igor Lobanchikov
}
SShaderTextureViewPtr STexture::CreateShaderView(const SShaderTextureViewConfiguration& kConfiguration, CDevice* pDevice)
{
DXGL_TODO("This is not thread-safe, as multiple threads can create shader views for the same texture. Add synchronization primitive.");
SShaderTextureViewPtr spView(new SShaderTextureView(this, kConfiguration));
if (!spView->Init(pDevice))
{
return NULL;
}
return spView;
}
SShaderBufferViewPtr SBuffer::CreateShaderView(const SShaderBufferViewConfiguration& kConfiguration, CDevice* pDevice)
{
DXGL_TODO("This is not thread-safe, as multiple threads can create shader views for the same buffer. Add synchronization primitive.");
SShaderBufferViewPtr spView(new SShaderBufferView(this, kConfiguration));
if (!spView->Init(pDevice))
{
return NULL;
}
return spView;
}
SOutputMergerTextureViewPtr STexture::CreateOutputMergerView(const SOutputMergerTextureViewConfiguration& kConfiguration, CDevice* pDevice)
{
SOutputMergerTextureViewPtr spView(new SOutputMergerTextureView(this, kConfiguration));
if (!spView->Init(pDevice))
{
return NULL;
}
return spView;
}
SOutputMergerTextureViewPtr STexture::GetCompatibleOutputMergerView(const SOutputMergerTextureViewConfiguration& kConfiguration, CDevice* pDevice)
{
DXGL_TODO("This is not thread-safe, as multiple threads can create output merger views for the same texture. Add synchronization primitive.");
SOutputMergerTextureView* pExistingView(m_pOutputMergerViewsHead);
while (pExistingView != NULL)
{
if (pExistingView->m_kConfiguration == kConfiguration)
{
return pExistingView;
}
pExistingView = pExistingView->m_pNextView;
}
return CreateOutputMergerView(kConfiguration, pDevice);
}
void STexture::ResetDontCareActionFlags()
{
m_bColorLoadDontCare =
m_bDepthLoadDontCare =
m_bStencilLoadDontCare =
m_bColorStoreDontCare =
m_bDepthStoreDontCare =
m_bStencilStoreDontCare = false;
}
SShaderResourceView::SShaderResourceView(EGIFormat eFormat)
: m_eFormat(eFormat)
{
}
SShaderResourceView::~SShaderResourceView()
{
}
bool SShaderResourceView::GenerateMipmaps(CContext*)
{
DXGL_ERROR("Cannot create mipmaps from a generic shader resource view");
return false;
}
SShaderBufferView::SShaderBufferView(SBuffer* pBuffer, const SShaderBufferViewConfiguration& kConfiguration)
: SShaderResourceView(kConfiguration.m_eFormat)
, m_kConfiguration(kConfiguration)
, m_pBuffer(pBuffer)
, m_BufferView(0)
{
}
SShaderBufferView::~SShaderBufferView()
{
if (m_BufferView)
{
[m_BufferView release];
}
}
bool SShaderBufferView::Init(CDevice* pDevice)
{
if (!m_BufferView)
{
m_BufferView = GetMtlBufferBasedOnSize(m_pBuffer);
[m_BufferView retain];
}
return true;
}
id<MTLBuffer> SShaderBufferView::GetMetalBuffer()
{
id<MTLBuffer> mtlBuffer = GetMtlBufferBasedOnSize(m_pBuffer);
return m_BufferView ? m_BufferView : mtlBuffer;
}
bool SShaderBufferView::GenerateMipmaps(CContext* pContext)
{
DXGL_ERROR("Cannot create mipmaps from a buffer shader resource view");
return false;
}
SShaderTextureView::SShaderTextureView(STexture* pTexture, const SShaderTextureViewConfiguration& kConfiguration)
: SShaderResourceView(kConfiguration.m_eFormat)
, m_kConfiguration(kConfiguration)
, m_pTexture(pTexture)
// Confetti BEGIN: Igor Lobanchikov
, m_TextureView(0)
// Confetti End: Igor Lobanchikov
{
m_pNextView = pTexture->m_pShaderViewsHead;
pTexture->m_pShaderViewsHead = this;
}
SShaderTextureView::~SShaderTextureView()
{
// Confetti BEGIN: Igor Lobanchikov
if (m_TextureView)
{
[m_TextureView release];
}
// Confetti End: Igor Lobanchikov
SShaderTextureView** pLink = &m_pTexture->m_pShaderViewsHead;
while (*pLink != NULL)
{
if (*pLink == this)
{
*pLink = m_pNextView;
break;
}
pLink = &((*pLink)->m_pNextView);
}
}
bool SShaderTextureView::Init(CDevice* pDevice)
{
const SGIFormatInfo* pFormatInfo;
if (m_kConfiguration.m_eFormat == eGIF_NUM ||
(pFormatInfo = GetGIFormatInfo(m_kConfiguration.m_eFormat)) == NULL)
{
DXGL_ERROR("Invalid format for shader resource view");
return false;
}
if (m_kConfiguration.m_uMinMipLevel != 0
|| m_kConfiguration.m_uNumMipLevels != m_pTexture->m_uNumMipLevels)
{
DXGL_ERROR("Metal doesn't support SRV which map to a part of resource.");
}
bool bFormatRequiresUniqueView(false);
if (m_kConfiguration.m_eFormat != m_pTexture->m_eFormat)
{
if (pFormatInfo->m_eTypelessFormat != m_pTexture->m_eFormat)
{
DXGL_ERROR("Shader resource view format is not compatible with texture format");
return false;
}
switch (pFormatInfo->m_eTypelessConversion)
{
case eGIFC_DEPTH_TO_RED:
break;
case eGIFC_STENCIL_TO_RED:
#if defined AZ_PLATFORM_MAC
//Need a new texture view to access the stencil data. x32_stencil8 or x24_stencil8
bFormatRequiresUniqueView = true;
#else
m_TextureView = m_pTexture->m_StencilTexture;
[m_TextureView retain];
#endif
break;
case eGIFC_TEXTURE_VIEW:
bFormatRequiresUniqueView = true;
break;
case eGIFC_UNSUPPORTED:
DXGL_ERROR("Shader resource view conversion not supported for the requested format");
return false;
}
}
if (m_kConfiguration.m_eViewType != m_pTexture->m_eTextureType)
{
bFormatRequiresUniqueView = true;
}
if (bFormatRequiresUniqueView ||
m_kConfiguration.m_uMinLayer > 0 ||
m_kConfiguration.m_uNumLayers != m_pTexture->m_uNumElements)
{
// Confetti BEGIN: Igor Lobanchikov
assert(!m_TextureView);
assert(!m_pTexture->m_bBackBuffer);
if (m_pTexture->m_bBackBuffer)
{
DXGL_ERROR("Back buffer doesn't support views other than native format view");
return false;
}
// Confetti End: Igor Lobanchikov
if (!CreateUniqueView(pDevice))
{
return false;
}
}
// Confetti BEGIN: Igor Lobanchikov
if (!m_TextureView && !m_pTexture->m_bBackBuffer)
{
m_TextureView = m_pTexture->m_Texture;
[m_TextureView retain];
}
// Confetti End: Igor Lobanchikov
return true;
}
bool SShaderTextureView::CreateUniqueView(CDevice* pDevice)
{
const SGIFormatInfo* pFormatInfo(GetGIFormatInfo(m_kConfiguration.m_eFormat));
// Confetti BEGIN: Igor Lobanchikov
if (m_kConfiguration.m_uMinLayer > 0 ||
m_kConfiguration.m_uNumLayers != m_pTexture->m_uNumElements)
{
DXGL_ERROR("Not implemented. Metal doesn't support this functionality.");
}
if (pFormatInfo->m_eTypelessFormat != m_pTexture->m_eFormat)
{
DXGL_ERROR("Texture view format is not compatible with texture format");
return false;
}
m_TextureView = [m_pTexture->m_Texture newTextureViewWithPixelFormat:pFormatInfo->m_pTexture->m_eMetalFormat];
if (!m_TextureView)
{
DXGL_ERROR("Couldn't create output merger or depth-stencil view");
return false;
}
else
{
return true;
}
// Confetti End: Igor Lobanchikov
}
bool SShaderTextureView::GenerateMipmaps(CContext* pContext)
{
id<MTLBlitCommandEncoder> blitCommandEncoder = pContext->GetBlitCommandEncoder();
[blitCommandEncoder generateMipmapsForTexture: GetMetalTexture()];
return true;
}
SOutputMergerView::SOutputMergerView(EGIFormat eFormat)
: m_eFormat(eFormat)
{
}
SOutputMergerView::~SOutputMergerView()
{
}
const int32 SOutputMergerTextureView::INVALID_LAYER = -1;
SOutputMergerTextureView::SOutputMergerTextureView(STexture* pTexture, const SOutputMergerTextureViewConfiguration& kConfiguration)
: SOutputMergerView(kConfiguration.m_eFormat)
, m_kConfiguration(kConfiguration)
, m_pTexture(pTexture)
// Confetti BEGIN: Igor Lobanchikov
, m_RTView(0)
// Confetti End: Igor Lobanchikov
{
m_pNextView = pTexture->m_pOutputMergerViewsHead;
pTexture->m_pOutputMergerViewsHead = this;
}
SOutputMergerTextureView::~SOutputMergerTextureView()
{
SOutputMergerTextureView*& pLink = m_pTexture->m_pOutputMergerViewsHead;
while (pLink != NULL)
{
if (pLink == this)
{
pLink = m_pNextView;
}
else
{
pLink = pLink->m_pNextView;
}
}
// Confetti BEGIN: Igor Lobanchikov
if (m_RTView)
{
[m_RTView release];
}
// Confetti End: Igor Lobanchikov
}
// Confetti BEGIN: Igor Lobanchikov
bool IsMetalRenderable(MTLPixelFormat format)
{
switch (format)
{
#if !defined AZ_PLATFORM_MAC
case MTLPixelFormatB5G6R5Unorm:
case MTLPixelFormatR8Unorm_sRGB:
case MTLPixelFormatRG8Unorm_sRGB:
case MTLPixelFormatA1BGR5Unorm:
case MTLPixelFormatABGR4Unorm:
#endif
case MTLPixelFormatR8Unorm:
case MTLPixelFormatRG8Unorm:
case MTLPixelFormatRGBA8Unorm:
case MTLPixelFormatRG32Float:
case MTLPixelFormatRGBA32Float:
case MTLPixelFormatR32Float:
case MTLPixelFormatBGRA8Unorm:
case MTLPixelFormatRGBA8Unorm_sRGB:
case MTLPixelFormatBGRA8Unorm_sRGB:
case MTLPixelFormatR8Uint:
case MTLPixelFormatR8Sint:
case MTLPixelFormatRG8Uint:
case MTLPixelFormatRG8Sint:
case MTLPixelFormatRGBA8Uint:
case MTLPixelFormatRGBA8Sint:
case MTLPixelFormatR16Uint:
case MTLPixelFormatR16Sint:
case MTLPixelFormatRG16Uint:
case MTLPixelFormatRG16Sint:
case MTLPixelFormatRGBA16Uint:
case MTLPixelFormatRGBA16Sint:
case MTLPixelFormatR16Float:
case MTLPixelFormatRG16Float:
case MTLPixelFormatRGBA16Float:
case MTLPixelFormatR32Uint:
case MTLPixelFormatR32Sint:
case MTLPixelFormatRG32Uint:
case MTLPixelFormatRG32Sint:
case MTLPixelFormatRGBA32Uint:
case MTLPixelFormatRGBA32Sint:
case MTLPixelFormatRGB10A2Unorm:
case MTLPixelFormatRG11B10Float:
case MTLPixelFormatRGB9E5Float:
case MTLPixelFormatRGB10A2Uint:
case MTLPixelFormatRG8Snorm:
return true;
default:
return false;
}
}
bool IsMetalDepthRenderable(const SGIFormatInfo& formatInfo)
{
if (!formatInfo.m_pTexture)
{
return false;
}
bool isMetalDepthRenderable = formatInfo.m_pTexture->m_eMetalFormat == MTLPixelFormatDepth32Float ||
formatInfo.m_eTypelessFormat == eGIF_R32G8X24_TYPELESS || formatInfo.m_eTypelessFormat == eGIF_R16_TYPELESS ;
#if defined(AZ_PLATFORM_MAC)
isMetalDepthRenderable = isMetalDepthRenderable ||
formatInfo.m_pTexture->m_eMetalFormat == MTLPixelFormatDepth32Float_Stencil8 ||
formatInfo.m_pTexture->m_eMetalFormat == MTLPixelFormatDepth24Unorm_Stencil8;
#endif
return isMetalDepthRenderable;
}
// Confetti End: Igor Lobanchikov
bool SOutputMergerTextureView::Init(CDevice* pDevice)
{
m_iMipLevel = (GLint)m_kConfiguration.m_uMipLevel;
if (m_kConfiguration.m_uMinLayer == 0 && m_kConfiguration.m_uNumLayers == m_pTexture->m_uNumElements)
// Confetti BEGIN: Igor Lobanchikov
{
if (m_kConfiguration.m_uNumLayers != 1)
{
// Igor: for obvoiuse reasons iOS supports only 2D RT views, no arrays, no 3D RT, only a slice of it
DXGL_NOT_IMPLEMENTED;
}
else
{
m_iLayer = m_kConfiguration.m_uMinLayer;
}
}
// Confetti End: Igor Lobanchikov
else if (m_kConfiguration.m_uNumLayers == 1)
{
m_iLayer = m_kConfiguration.m_uMinLayer;
}
else
{
DXGL_NOT_IMPLEMENTED;
}
// Confetti BEGIN: Igor Lobanchikov
{
const SGIFormatInfo* pFormatInfo;
if (m_kConfiguration.m_eFormat == eGIF_NUM ||
(pFormatInfo = GetGIFormatInfo(m_kConfiguration.m_eFormat)) == NULL ||
pFormatInfo->m_pTexture == NULL ||
(!IsMetalRenderable(pFormatInfo->m_pTexture->m_eMetalFormat) && !IsMetalDepthRenderable(*pFormatInfo)))
{
DXGL_ERROR("Invalid format for output merger view");
return false;
}
assert(m_pTexture);
assert(m_pTexture->m_Texture);
if ((m_kConfiguration.m_eFormat != m_pTexture->m_eFormat) && !IsMetalDepthRenderable(*pFormatInfo))
{
assert(!m_pTexture->m_bBackBuffer);
if (m_pTexture->m_bBackBuffer)
{
DXGL_ERROR("Back buffer doesn't support views other than native format view");
return false;
}
return CreateUniqueView(pFormatInfo, pDevice);
}
else if (!m_pTexture->m_bBackBuffer)
{
m_RTView = m_pTexture->m_Texture;
[m_RTView retain];
}
return true;
}
// Confetti End: Igor Lobanchikov
if (m_kConfiguration.m_eFormat != m_pTexture->m_eFormat)
{
const SGIFormatInfo* pFormatInfo;
if (m_kConfiguration.m_eFormat == eGIF_NUM ||
(pFormatInfo = GetGIFormatInfo(m_kConfiguration.m_eFormat)) == NULL ||
pFormatInfo->m_pTexture == NULL)
{
DXGL_ERROR("Invalid format for output merger view");
return false;
}
if (pFormatInfo->m_pTexture->m_eMetalFormat == GetGIFormatInfo(m_pTexture->m_eFormat)->m_pTexture->m_eMetalFormat)
{
return true;
}
// Frame buffer attachment does not support any kind of in-place conversion - texture view is required unless no conversion is needed at all
return CreateUniqueView(pFormatInfo, pDevice);
}
return true;
}
bool SOutputMergerTextureView::CreateUniqueView(const SGIFormatInfo* pFormatInfo, CDevice* pDevice)
{
// Confetti BEGIN: Igor Lobanchikov
if (pFormatInfo->m_eTypelessFormat != m_pTexture->m_eFormat)
{
DXGL_ERROR("Output merger view format is not compatible with texture format");
return false;
}
m_RTView = [m_pTexture->m_Texture newTextureViewWithPixelFormat:pFormatInfo->m_pTexture->m_eMetalFormat];
if (!m_RTView)
{
DXGL_ERROR("Couldn't create output merger or depth-stencil view");
return false;
}
return true;
// Confetti End: Igor Lobanchikov
}
SBuffer::SBuffer()
: m_pSystemMemoryCopy(NULL)
, m_bMapped(false)
// Confetti BEGIN: Igor Lobanchikov
, m_BufferShared(0)
#if defined(AZ_PLATFORM_MAC)
, m_BufferManaged(0)
#endif
, m_pMappedData(0)
, m_uMapOffset(0)
, m_uMapSize(0)
, m_pfMapBufferRange(0)
// Confetti End: Igor Lobanchikov
{
}
SBuffer::~SBuffer()
{
if (m_pSystemMemoryCopy != NULL)
{
MemalignFree(m_pSystemMemoryCopy);
}
// Confetti BEGIN: Igor Lobanchikov
if (m_BufferShared)
{
[m_BufferShared release];
}
#if defined(AZ_PLATFORM_MAC)
if (m_BufferManaged)
{
[m_BufferManaged release];
}
#endif
// Confetti End: Igor Lobanchikov
}
bool SBuffer::GetBufferAndOffset(CContext& context, uint32 uInputBufferOffset, uint32 uBaseOffset, uint32 uBaseStride, id<MTLBuffer>& tmpBuffer, uint32& offset, bool const popTransientMappedDataQueue)
{
offset = uInputBufferOffset;
tmpBuffer = GetMtlBufferBasedOnSize(this);
void* tmpMappedData = m_pMappedData;
// Igor: for now vertex buffers always store data in Metal buffer
// Dynamic updates are expected to use direct CPU access
// Other updates are handled using GPU copies.
assert(tmpBuffer);
if (m_eUsage == eBU_MapInRingBufferTTLOnce)
{
assert(offset == uInputBufferOffset);
// We assume that tmpMappedData has already map offest applied. Don't want to do it twice.
offset = 0;
// David: set appropriate mapped data if the buffer was mapped multiple times
// Caller of this function is responsible to pop the m_pTransientMappedData list.
if (!m_pTransientMappedData.empty())
{
tmpMappedData = m_pTransientMappedData.front();
if (popTransientMappedDataQueue)
{
m_pTransientMappedData.pop_front();
}
}
}
// Igor: this is used to calculate offset correctly when ring buffer is used
if (tmpMappedData)
{
// Check if offset in this situation is always 0
assert(!offset);
offset += (uint8*)(tmpMappedData) - (uint8*)(tmpBuffer.contents);
}
{
offset += uBaseOffset * uBaseStride;
}
return true;
}
SQuery::~SQuery()
{
}
// Confetti BEGIN: Igor Lobanchikov
void SQuery::Begin(CContext* pContext)
{
}
void SQuery::End(CContext* pContext)
{
}
// Confetti End: Igor Lobanchikov
uint32 SQuery::GetDataSize()
{
return 0;
}
SPlainQuery::SPlainQuery()
{
}
SPlainQuery::~SPlainQuery()
{
}
// Confetti BEGIN: Igor Lobanchikov
void SPlainQuery::Begin(CContext* pContext)
{
DXMETAL_NOT_IMPLEMENTED
}
void SPlainQuery::End(CContext* pContext)
{
DXMETAL_NOT_IMPLEMENTED
}
SOcclusionQuery::SOcclusionQuery()
: m_pEventHelper(NULL)
, m_pQueryData(NULL)
{
}
void SOcclusionQuery::Begin(CContext* pContext)
{
assert(pContext);
m_pEventHelper = 0;
m_pQueryData = 0;
pContext->BeginOcclusionQuery(this);
}
void SOcclusionQuery::End(CContext* pContext)
{
pContext->EndOcclusionQuery(this);
}
bool SOcclusionQuery::GetData(void* pData, uint32 uDataSize, bool bFlush)
{
//TODO: m_pEventHelper is null sometimes
if (!m_pEventHelper)
{
return false;
}
//assert(m_pEventHelper != nullptr);
assert(m_pQueryData);
// Igor: If the command buffer is not submitted event will never be triggered.
// Flushing of the command buffer is expensive (resolve/restore all RTs bound)
// As the result we don't support flush operation.
// This will lead to stall, if the command buffer is not submitted and application loops until
// the event will be triggered which will never happen.
// Assert chacks for this situation. If you are here, it is a good idea to reconsider
// using the event the way you want to.
// note: when the application is just initialized frame throttle events will assert
// if there are no resources since command buffer has never been committed.
assert(!(bFlush) || (bFlush && m_pEventHelper->bCommandBufferSubmitted));
if (!(!(bFlush) || (bFlush && m_pEventHelper->bCommandBufferSubmitted)))
{
int i = 0;
++i;
AZ_TracePrintf("Metal", "Potential dead lock is possible! Event is not triggered. Continue to prevent a deadlock");
*reinterpret_cast<UINT64*>(pData) = 0;
return true;
}
DXMETAL_TODO("Consider returning something big for true instead of one for occlusion query.");
// Igor: Motivation: Cryengine uses threshold to determine visibility. 1 is usually below that threshold.
if (m_pEventHelper->bTriggered)
{
*reinterpret_cast<UINT64*>(pData) = *m_pQueryData;
return true;
}
else
{
return false;
}
}
// Confetti End: Igor Lobanchikov
uint32 SOcclusionQuery::GetDataSize()
{
return sizeof(UINT64);
}
// Confetti BEGIN: Igor Lobanchikov
SFenceSync::SFenceSync()
: m_pEventHelper(NULL)
{
}
SFenceSync::~SFenceSync()
{
}
void SFenceSync::End(CContext* pContext)
{
assert(pContext);
m_pEventHelper = pContext->GetCurrentEventHelper();
assert(m_pEventHelper);
}
bool SFenceSync::GetData(void* pData, uint32 uDataSize, bool bFlush)
{
assert(m_pEventHelper != NULL);
// Igor: If the command buffer is not submitted event will never be triggered.
// Flushing of the command buffer is expensive (resolve/restore all RTs bound)
// As the result we don't support flush operation.
// This will lead to stall, if the command buffer is not submitted and application loops until
// the event will be triggered which will never happen.
// Assert chacks for this situation. If you are here, it is a good idea to reconsider
// using the event the way you want to.
// note: when the application is just initialized frame throttle events will assert
// if there are no resources since command buffer has never been committed.
assert(!(bFlush) || (bFlush && m_pEventHelper->bCommandBufferSubmitted));
if (!(!(bFlush) || (bFlush && m_pEventHelper->bCommandBufferSubmitted)))
{
int i = 0;
++i;
AZ_TracePrintf("Metal", "Potential dead lock is possible! Event is not triggered. Continue to prevent a deadlock");
*reinterpret_cast<BOOL*>(pData) = TRUE;
return true;
}
if (m_pEventHelper->bTriggered)
{
*reinterpret_cast<BOOL*>(pData) = TRUE;
return true;
}
else
{
return false;
}
}
// Confetti End: Igor Lobanchikov
uint32 SFenceSync::GetDataSize()
{
return sizeof(BOOL);
}
struct SDefaultFrameBufferOutputMergerView
: SOutputMergerTextureView
{
SDefaultFrameBufferOutputMergerView(SDefaultFrameBufferTexture* pTexture, const SOutputMergerTextureViewConfiguration& kConfiguration)
: SOutputMergerTextureView(pTexture, kConfiguration)
{
}
virtual bool CreateUniqueView(const SGIFormatInfo* pFormatInfo, CDevice* pDevice)
{
return SOutputMergerTextureView::CreateUniqueView(pFormatInfo, 0);
}
};
struct SDefaultFrameBufferShaderView
: SShaderTextureView
{
SDefaultFrameBufferShaderView(SDefaultFrameBufferTexture* pTexture, const SShaderTextureViewConfiguration& kConfiguration)
: SShaderTextureView(pTexture, kConfiguration)
{
}
};
SDefaultFrameBufferTexture::SDefaultFrameBufferTexture(int32 iWidth, int32 iHeight, EGIFormat eFormat)
: STexture(iWidth, iHeight, 1, MTLTextureType2D, eFormat, 1, 1)
#if CRY_DXGL_FULL_EMULATION
, m_kCustomWindowContext(NULL)
#endif //DXGL_FULL_EMULATION
{
m_pfUpdateSubresource = &UpdateSubresource;
m_pfMapSubresource = &MapSubresource;
m_pfUnmapSubresource = &UnmapSubresource;
}
SShaderTextureViewPtr SDefaultFrameBufferTexture::CreateShaderView(const SShaderTextureViewConfiguration& kConfiguration, CDevice* pDevice)
{
SShaderTextureViewPtr spView(new SDefaultFrameBufferShaderView(this, kConfiguration));
if (!spView->Init(pDevice))
{
return NULL;
}
return spView;
}
SOutputMergerTextureViewPtr SDefaultFrameBufferTexture::CreateOutputMergerView(const SOutputMergerTextureViewConfiguration& kConfiguration, CDevice* pDevice)
{
SOutputMergerTextureViewPtr spView(new SDefaultFrameBufferOutputMergerView(this, kConfiguration));
if (!spView->Init(pDevice))
{
return NULL;
}
return spView;
}
#if DXGL_FULL_EMULATION
void SDefaultFrameBufferTexture::SetCustomWindowContext(const TWindowContext& kCustomWindowContext)
{
m_kCustomWindowContext = kCustomWindowContext;
}
#endif //DXGL_FULL_EMULATION
void SDefaultFrameBufferTexture::UpdateSubresource(SResource* pResource, uint32 uSubresource, const D3D11_BOX* pDstBox, const void* pSrcData, uint32 uSrcRowPitch, uint32 uSrcDepthPitch, CContext* pContext)
{
if (uSubresource > 0)
{
DXGL_ERROR("The only valid subresource index for the default frame buffer is 0 - cannot update subresource");
return;
}
SDefaultFrameBufferTexture* pDefaultFramebufferTexture(static_cast<SDefaultFrameBufferTexture*>(pResource));
UpdateTexSubresource<SSingleTexImpl<STex2DUncompressed> >(pDefaultFramebufferTexture, uSubresource, pDstBox, pSrcData, uSrcRowPitch, uSrcDepthPitch, pContext);
}
bool SDefaultFrameBufferTexture::MapSubresource(SResource* pResource, uint32 uSubresource, D3D11_MAP MapType, UINT MapFlags, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext* pContext)
{
if (uSubresource > 0)
{
DXGL_ERROR("The only valid subresource index for the default frame buffer is 0 - cannot map subresource");
return false;
}
SDefaultFrameBufferTexture* pDefaultFramebufferTexture(static_cast<SDefaultFrameBufferTexture*>(pResource));
switch (MapType)
{
case D3D11_MAP_READ:
case D3D11_MAP_READ_WRITE:
case D3D11_MAP_WRITE:
break;
default:
DXGL_ERROR("Unsupported map operation type for default frame buffer");
return false;
}
return MapTexSubresource<SSingleTexImpl<STex2DUncompressed> >(pDefaultFramebufferTexture, uSubresource, MapType, MapFlags, pMappedResource, pContext);
}
void SDefaultFrameBufferTexture::UnmapSubresource(SResource* pResource, uint32 uSubresource, CContext* pContext)
{
if (uSubresource > 0)
{
DXGL_ERROR("The only valid subresource index for the default frame buffer is 0 - cannot unmap subresource");
return;
}
SDefaultFrameBufferTexture* pDefaultFramebufferTexture(static_cast<SDefaultFrameBufferTexture*>(pResource));
UnmapTexSubresource<SSingleTexImpl<STex2DUncompressed> >(pDefaultFramebufferTexture, uSubresource, pContext);
}
const SGIFormatInfo* GetCompatibleTextureFormatInfo(EGIFormat* peGIFormat)
{
const SGIFormatInfo* pFormatInfo(GetGIFormatInfo(*peGIFormat));
if (pFormatInfo->m_pTexture != NULL)
{
return pFormatInfo;
}
if (pFormatInfo->m_eTypelessFormat != eGIF_NUM && pFormatInfo->m_eTypelessFormat != *peGIFormat)
{
*peGIFormat = pFormatInfo->m_eTypelessFormat;
pFormatInfo = GetGIFormatInfo(pFormatInfo->m_eTypelessFormat);
if (pFormatInfo->m_pTexture != NULL)
{
return pFormatInfo;
}
}
*peGIFormat = eGIF_NUM;
return NULL;
}
STexturePtr CreateTexture1D(const D3D11_TEXTURE1D_DESC& kDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateTexture1D")
EGIFormat eGIFormat(GetGIFormat(kDesc.Format));
const SGIFormatInfo* pFormatInfo(NULL);
if (eGIFormat == eGIF_NUM ||
(pFormatInfo = GetCompatibleTextureFormatInfo(&eGIFormat)) == NULL)
{
DXGL_ERROR("Invalid format for 1D texture");
return NULL;
}
uint32 uNumElements(kDesc.ArraySize);
bool bArray(kDesc.ArraySize > 1 || (kDesc.MiscFlags & D3D11_RESOURCE_MISC_DXGL_FORCE_ARRAY));
STexturePtr spTexture(
new STexture(
kDesc.Width, 1, 1,
bArray ? MTLTextureType1DArray : MTLTextureType1D,
eGIFormat, GetNumMipLevels(kDesc), kDesc.ArraySize));
if (kDesc.Usage == D3D11_USAGE_STAGING)
{
if (pFormatInfo->m_pTexture->m_bCompressed)
{
InitializeTexture<SStagingTexImpl<STex1DCompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
else
{
InitializeTexture<SStagingTexImpl<STex1DUncompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
}
else
{
if (pFormatInfo->m_pTexture->m_bCompressed)
{
if (bArray)
{
InitializeTexture<SArrayTexImpl<STex2DCompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
else
{
InitializeTexture<SSingleTexImpl<STex1DCompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
}
else
{
if (bArray)
{
InitializeTexture<SArrayTexImpl<STex2DUncompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
else
{
InitializeTexture<SSingleTexImpl<STex1DUncompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
}
}
return spTexture;
}
void InitializeTexture2D(STexture* pTexture, bool bArray, bool bStaging, const D3D11_SUBRESOURCE_DATA* pInitialData, uint32 uCPUAccess, CDevice* pDevice /*CContext* pContext*/, const SGIFormatInfo* pFormatInfo, const uint32 uBindFlags)
{
if (bStaging)
{
if (pFormatInfo->m_pTexture->m_bCompressed)
{
InitializeTexture<SStagingTexImpl<STex2DCompressed> >(pTexture, pInitialData, uCPUAccess, pDevice, pFormatInfo, uBindFlags);
}
else
{
InitializeTexture<SStagingTexImpl<STex2DUncompressed> >(pTexture, pInitialData, uCPUAccess, pDevice, pFormatInfo, uBindFlags);
}
}
else
{
if (pFormatInfo->m_pTexture->m_bCompressed)
{
if (bArray)
{
InitializeTexture<SArrayTexImpl<STex3DCompressed> >(pTexture, pInitialData, uCPUAccess, pDevice, pFormatInfo, uBindFlags);
}
else
{
InitializeTexture<SSingleTexImpl<STex2DCompressed> >(pTexture, pInitialData, uCPUAccess, pDevice, pFormatInfo, uBindFlags);
}
}
else
{
if (bArray)
{
InitializeTexture<SArrayTexImpl<STex3DUncompressed> >(pTexture, pInitialData, uCPUAccess, pDevice, pFormatInfo, uBindFlags);
}
else
{
InitializeTexture<SSingleTexImpl<STex2DUncompressed> >(pTexture, pInitialData, uCPUAccess, pDevice, pFormatInfo, uBindFlags);
}
}
}
}
STexturePtr CreateTexture2D(const D3D11_TEXTURE2D_DESC& kDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateTexture2D")
EGIFormat eGIFormat(GetGIFormat(kDesc.Format));
const SGIFormatInfo* pFormatInfo(NULL);
if (eGIFormat == eGIF_NUM ||
(pFormatInfo = GetCompatibleTextureFormatInfo(&eGIFormat)) == NULL)
{
DXGL_ERROR("Invalid format for 2D texture");
return NULL;
}
bool bStaging(kDesc.Usage == D3D11_USAGE_STAGING);
if (kDesc.SampleDesc.Count > 1)
{
DXGL_NOT_IMPLEMENTED
return NULL;
}
else
{
if ((kDesc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) != 0)
{
bool bArray(kDesc.ArraySize > 6 || (kDesc.MiscFlags & D3D11_RESOURCE_MISC_DXGL_FORCE_ARRAY));
if (bArray)
{
DXGL_NOT_IMPLEMENTED;
return NULL;
}
STexturePtr spTexture(
new STexture(
kDesc.Width, kDesc.Height, 1,
MTLTextureTypeCube,
eGIFormat, GetNumMipLevels(kDesc), kDesc.ArraySize));
InitializeTexture2D(spTexture, bArray, bStaging, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
return spTexture;
}
else
{
bool bArray(kDesc.ArraySize > 1 || (kDesc.MiscFlags & D3D11_RESOURCE_MISC_DXGL_FORCE_ARRAY));
STexturePtr spTexture(
new STexture(
kDesc.Width, kDesc.Height, 1,
bArray ? MTLTextureType2DArray : MTLTextureType2D,
eGIFormat, GetNumMipLevels(kDesc), kDesc.ArraySize));
InitializeTexture2D(spTexture, bArray, bStaging, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
return spTexture;
}
}
}
STexturePtr CreateTexture3D(const D3D11_TEXTURE3D_DESC& kDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateTexture3D")
EGIFormat eGIFormat(GetGIFormat(kDesc.Format));
const SGIFormatInfo* pFormatInfo(NULL);
if (eGIFormat == eGIF_NUM ||
(pFormatInfo = GetCompatibleTextureFormatInfo(&eGIFormat)) == NULL)
{
DXGL_ERROR("Invalid format for 3D texture");
return NULL;
}
STexturePtr spTexture(
new STexture(
kDesc.Width, kDesc.Height, kDesc.Depth,
MTLTextureType3D,
eGIFormat, GetNumMipLevels(kDesc), 1));
if (kDesc.Usage == D3D11_USAGE_STAGING)
{
if (pFormatInfo->m_pTexture->m_bCompressed)
{
InitializeTexture<SStagingTexImpl<STex3DCompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
else
{
InitializeTexture<SStagingTexImpl<STex3DUncompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
}
else
{
if (pFormatInfo->m_pTexture->m_bCompressed)
{
InitializeTexture<SSingleTexImpl<STex3DCompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
else
{
InitializeTexture<SSingleTexImpl<STex3DUncompressed> >(spTexture, pInitialData, kDesc.CPUAccessFlags, pDevice, pFormatInfo, kDesc.BindFlags);
}
}
return spTexture;
}
void UpdateRingBuffer(SBuffer* pBuffer, CContext* pContext, bool checkIfBufferIsMapped)
{
MemRingBufferStorage memAllocMode = GetMemAllocModeBasedOnSize(pBuffer->m_uMapSize);
id<MTLBuffer> mtlBuffer = GetMtlBufferBasedOnSize(pBuffer);
assert(pBuffer->m_BufferShared);
bool checkForMapping = checkIfBufferIsMapped ? pBuffer->m_bMapped : true;
// Igor: pBuffer->m_bMapped is checked here because we don't want to do anything if the buffer is not mapped.
if ((pBuffer->m_eUsage == eBU_Default) && checkForMapping)
{
id<MTLBuffer> tmpBuffer = pContext->GetRingBuffer(memAllocMode);
size_t unusedOffset = 0;
void* pTempData = pContext->AllocateMemoryInRingBuffer(pBuffer->m_uMapSize, memAllocMode, unusedOffset);
size_t tmpOffset = (uint8*)pTempData - (uint8*)tmpBuffer.contents;
cryMemcpy(pTempData, pBuffer->m_pSystemMemoryCopy + pBuffer->m_uMapOffset, pBuffer->m_uMapSize);
id<MTLBlitCommandEncoder> blitCommandEncoder = pContext->GetBlitCommandEncoder();
[blitCommandEncoder copyFromBuffer: tmpBuffer
sourceOffset: tmpOffset
toBuffer: mtlBuffer
destinationOffset: pBuffer->m_uMapOffset
size: pBuffer->m_uMapSize];
pBuffer->m_uMapOffset = 0;
pBuffer->m_uMapSize = 0;
}
#if defined(AZ_PLATFORM_MAC)
else
{
//If this buffer was using the faster ring buffer synchronize with the GPU
if (memAllocMode == MEM_MANAGED_RINGBUFFER)
{
[pBuffer->m_BufferManaged didModifyRange: NSMakeRange(pBuffer->m_uMapOffset, pBuffer->m_uMapSize)];
}
}
#endif
}
struct SDefaultBufferImpl
{
static void UpdateBufferSubresource(SResource* pResource, uint32 uSubresource, const D3D11_BOX* pDstBox, const void* pSrcData, uint32, uint32, CContext* pContext)
{
DXGL_SCOPED_PROFILE("SDefaultBufferImpl::UpdateBufferSubresource")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
assert(pBuffer->m_BufferShared);
size_t ringBufferOffsetOut = 0;
id<MTLBuffer> tmpBuffer = pContext->GetRingBuffer(MEM_SHARED_RINGBUFFER);
void* pTempData = pContext->AllocateMemoryInRingBuffer(pBuffer->m_uSize, MEM_SHARED_RINGBUFFER, ringBufferOffsetOut);
size_t tmpOffset = (uint8*)pTempData - (uint8*)tmpBuffer.contents;
cryMemcpy(pTempData, pSrcData, pDstBox ? pDstBox->right - pDstBox->left : pBuffer->m_BufferShared.length);
id<MTLBlitCommandEncoder> blitCommandEncoder = pContext->GetBlitCommandEncoder();
[blitCommandEncoder copyFromBuffer: tmpBuffer
sourceOffset: tmpOffset
toBuffer: pBuffer->m_BufferShared
destinationOffset: pDstBox ? pDstBox->left : 0
size: pDstBox ? pDstBox->right - pDstBox->left : pBuffer->m_BufferShared.length];
}
};
struct SDynamicBufferImpl
{
static bool MapBufferRange(SBuffer* pBuffer, size_t uOffset, size_t uSize, D3D11_MAP eMapType, uint32 uMapFlags, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("SDynamicBufferImpl::MapBufferRange")
// Confetti BEGIN: Igor Lobanchikov
size_t ringBufferOffsetOut = 0;
DXMETAL_TODO("Add more buffer usage types for optimization purposes.");
// Igor: Use local copy now, copy it to ring buffer when rendering the actual geometry
// Note: vertex buffer must be 256 bytes aligned when rendering.
// Igor: eBU_MapInRingBuffer is set for constant buffer. So use ring buffer for constant buffer updates
switch (pBuffer->m_eUsage)
{
case eBU_Default:
{
assert(pBuffer->m_pSystemMemoryCopy);
pMappedResource->pData = pBuffer->m_pSystemMemoryCopy + uOffset;
assert(pBuffer->m_BufferShared);
pBuffer->m_bMapped = true;
break;
}
case eBU_MapInRingBufferTTLFrame:
{
MemRingBufferStorage memAllocMode = GetMemAllocModeBasedOnSize(uSize);
if (!pBuffer->m_BufferShared)
{
pBuffer->m_BufferShared = pContext->GetRingBuffer(MEM_SHARED_RINGBUFFER);
[pBuffer->m_BufferShared retain];
}
#if defined(AZ_PLATFORM_MAC)
if (!pBuffer->m_BufferManaged)
{
pBuffer->m_BufferManaged = pContext->GetRingBuffer(MEM_MANAGED_RINGBUFFER);
[pBuffer->m_BufferManaged retain];
}
#endif
pBuffer->m_bMapped = true;
if (eMapType == D3D11_MAP_WRITE_NO_OVERWRITE)
{
if (!pBuffer->m_pMappedData)
{
pBuffer->m_pMappedData = pContext->AllocateMemoryInRingBuffer(pBuffer->m_uSize, memAllocMode, ringBufferOffsetOut);
}
}
else
{
// The only other possible mode for dynamic buffers is D3D11_MAP_WRITE_DISCARD
assert(eMapType == D3D11_MAP_WRITE_DISCARD);
pBuffer->m_pMappedData = pContext->AllocateMemoryInRingBuffer(pBuffer->m_uSize, memAllocMode, ringBufferOffsetOut);
}
pMappedResource->pData = (uint8*)pBuffer->m_pMappedData;
break;
}
default:
DXMETAL_NOT_IMPLEMENTED;
}
// Confetti End: Igor Lobanchikov
pMappedResource->RowPitch = 0; // Meaningless for buffers
pMappedResource->DepthPitch = 0; // Meaningless for buffers
pBuffer->m_uMapOffset = ringBufferOffsetOut; // This is needed to synchronize with the GPU (didModifyRange)
pBuffer->m_uMapSize = uSize;
return true;
}
static bool MapBuffer(SResource* pResource, uint32 uSubresource, D3D11_MAP eMapType, uint32 uMapFlags, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("SDynamicBufferImpl::MapBuffer")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
return MapBufferRange(pBuffer, (size_t)0, (size_t)pBuffer->m_uSize, eMapType, uMapFlags, pMappedResource, pContext);
}
static void UnmapBuffer(SResource* pResource, UINT Subresource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("SDynamicBufferImpl::UnmapBuffer")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
//Update the ring buffer with the final rendering data
bool checkIfBufferIsMapped = true;//Check to make sure this buffer is mapped if it is eBU_Default
UpdateRingBuffer(pBuffer, pContext, checkIfBufferIsMapped);
pBuffer->m_bMapped = false;
}
static void UpdateBufferSubresource(SResource* pResource, uint32 uSubresource, const D3D11_BOX* pDstBox, const void* pSrcData, uint32, uint32, CContext* pContext)
{
DXGL_SCOPED_PROFILE("SDynamicBufferImpl::UpdateBufferSubresource")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
assert(uSubresource == 0);
uint32 uDstOffset, uDstSize;
if (pDstBox != NULL)
{
uDstOffset = pDstBox->left;
uDstSize = pDstBox->right - pDstBox->left;
}
else
{
uDstOffset = 0;
uDstSize = pBuffer->m_uSize;
}
//Update the resource
if (pBuffer->m_pSystemMemoryCopy)
{
cryMemcpy(pBuffer->m_pSystemMemoryCopy + uDstOffset, static_cast<const uint8*>(pSrcData), uDstSize);
}
assert(pBuffer->m_eUsage == eBU_Default);
assert(pBuffer->m_BufferShared);
//Update the ring buffer with the final rendering data
bool checkIfBufferIsMapped = false;//Check to make sure this buffer is mapped if it is eBU_Default
UpdateRingBuffer(pBuffer, pContext, checkIfBufferIsMapped);
}
};
struct SStagingBufferImpl
{
static bool MapBufferRange(SBuffer* pBuffer, size_t uOffset, size_t uSize, D3D11_MAP, uint32, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext*)
{
DXGL_SCOPED_PROFILE("SStagingBufferImpl::MapBufferRange")
// Confetti BEGIN: Igor Lobanchikov
pMappedResource->pData = pBuffer->m_pSystemMemoryCopy + uOffset;
// Confetti End: Igor Lobanchikov
pMappedResource->RowPitch = 0; // Meaningless for buffers
pMappedResource->DepthPitch = 0; // Meaningless for buffers
return true;
}
static bool MapBuffer(SResource* pResource, uint32, D3D11_MAP, uint32, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext*)
{
DXGL_SCOPED_PROFILE("SStagingBufferImpl::MapBuffer")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
pMappedResource->pData = pBuffer->m_pSystemMemoryCopy;
// Confetti End: Igor Lobanchikov
pMappedResource->RowPitch = 0; // Meaningless for buffers
pMappedResource->DepthPitch = 0; // Meaningless for buffers
return true;
}
static void UnmapBuffer(SResource*, UINT, CContext*)
{
}
static void UpdateBufferSubresource(SResource* pResource, uint32 uSubresource, const D3D11_BOX* pDstBox, const void* pSrcData, uint32, uint32, CContext*)
{
DXGL_SCOPED_PROFILE("SStagingBufferImpl::UpdateBufferSubresource")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
assert(uSubresource == 0);
// Confetti BEGIN: Igor Lobanchikov
if (pDstBox != NULL)
{
cryMemcpy(pBuffer->m_pSystemMemoryCopy + pDstBox->left, pSrcData, pDstBox->right - pDstBox->left);
}
else
{
cryMemcpy(pBuffer->m_pSystemMemoryCopy, pSrcData, pBuffer->m_uSize);
}
// Confetti End: Igor Lobanchikov
}
};
struct STransientBufferImpl
{
static bool MapBufferRange(SBuffer* pBuffer, size_t uOffset, size_t uSize, D3D11_MAP eMapType, uint32 uMapFlags, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("STransientBufferImpl::MapBufferRange")
assert(pBuffer->m_eUsage == eBU_MapInRingBufferTTLOnce);
assert(!pBuffer->m_pSystemMemoryCopy);
size_t ringBufferOffsetOut = 0;
MemRingBufferStorage memAllocMode = GetMemAllocModeBasedOnSize(uSize);
if (!pBuffer->m_BufferShared)
{
pBuffer->m_BufferShared = pContext->GetRingBuffer(MEM_SHARED_RINGBUFFER);
[pBuffer->m_BufferShared retain];
}
#if defined(AZ_PLATFORM_MAC)
if (!pBuffer->m_BufferManaged)
{
pBuffer->m_BufferManaged = pContext->GetRingBuffer(MEM_MANAGED_RINGBUFFER);
[pBuffer->m_BufferManaged retain];
}
#endif
pBuffer->m_bMapped = true;
if (eMapType == D3D11_MAP_WRITE_NO_OVERWRITE)
{
assert(uOffset + uSize <= pBuffer->m_uSize);
pBuffer->m_pMappedData = pContext->AllocateMemoryInRingBuffer(uSize, memAllocMode, ringBufferOffsetOut);
}
else
{
// The only other possible mode for dynamic buffers is D3D11_MAP_WRITE_DISCARD
assert(eMapType == D3D11_MAP_WRITE_DISCARD);
assert(uSize <= pBuffer->m_uSize);
pBuffer->m_pMappedData = pContext->AllocateMemoryInRingBuffer(uSize, memAllocMode, ringBufferOffsetOut);
}
pMappedResource->pData = (uint8*)pBuffer->m_pMappedData;
pMappedResource->RowPitch = 0; // Meaningless for buffers
pMappedResource->DepthPitch = 0; // Meaningless for buffers
pBuffer->m_uMapOffset = ringBufferOffsetOut; // This is needed to synchronize with the GPU (didModifyRange)
pBuffer->m_uMapSize = uSize;
pBuffer->m_pTransientMappedData.push_back(pBuffer->m_pMappedData);
return true;
}
static void UnmapBuffer(SResource* pResource, UINT Subresource, CContext* pContext)
{
DXGL_SCOPED_PROFILE("STransientBufferImpl::UnmapBuffer")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
assert(pBuffer->m_eUsage == eBU_MapInRingBufferTTLOnce);
#if defined(AZ_PLATFORM_MAC)
//If this buffer was using the faster ring buffer synchronize with the GPU
MemRingBufferStorage memAllocMode = GetMemAllocModeBasedOnSize(pBuffer->m_uMapSize);
if (memAllocMode == MEM_MANAGED_RINGBUFFER)
{
[pBuffer->m_BufferManaged didModifyRange: NSMakeRange(pBuffer->m_uMapOffset, pBuffer->m_uMapSize)];
}
#endif
pBuffer->m_bMapped = false;
}
};
struct SDirectAccessBufferImpl
{
static bool MapBufferRange(SBuffer* pBuffer, size_t uOffset, size_t uSize, D3D11_MAP, uint32, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext*)
{
DXGL_SCOPED_PROFILE("SDirectAccessBufferImpl::MapBufferRange")
assert(pBuffer->m_BufferShared);
assert(pBuffer->m_eUsage == eBU_DirectAccess);
//DirectAccess buffers allocate from shared memory only.
pMappedResource->pData = (uint8*)pBuffer->m_BufferShared.contents + uOffset;
pMappedResource->RowPitch = 0; // Meaningless for buffers
pMappedResource->DepthPitch = 0; // Meaningless for buffers
return true;
}
static bool MapBuffer(SResource* pResource, uint32, D3D11_MAP, uint32, D3D11_MAPPED_SUBRESOURCE* pMappedResource, CContext*)
{
DXGL_SCOPED_PROFILE("SDirectAccessBufferImpl::MapBuffer")
SBuffer * pBuffer(static_cast<SBuffer*>(pResource));
assert(pBuffer->m_BufferShared);
assert(pBuffer->m_eUsage == eBU_DirectAccess);
//DirectAccess buffers allocate from shared memory only.
pMappedResource->pData = (uint8*)pBuffer->m_BufferShared.contents;
pMappedResource->RowPitch = 0; // Meaningless for buffers
pMappedResource->DepthPitch = 0; // Meaningless for buffers
return true;
}
static void UnmapBuffer(SResource*, UINT, CContext*)
{
}
};
SBufferPtr CreateBuffer(const D3D11_BUFFER_DESC& kDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateBuffer")
SBufferPtr spBuffer(new SBuffer());
spBuffer->m_uSize = kDesc.ByteWidth;
for (UINT uBindMask = 1; uBindMask != 0; uBindMask <<= 1)
{
switch (kDesc.BindFlags & uBindMask)
{
case 0:
break;
case D3D11_BIND_VERTEX_BUFFER:
spBuffer->m_kBindings.Set(eBB_Array, true);
break;
case D3D11_BIND_INDEX_BUFFER:
spBuffer->m_kBindings.Set(eBB_ElementArray, true);
break;
case D3D11_BIND_CONSTANT_BUFFER:
spBuffer->m_kBindings.Set(eBB_UniformBuffer, true);
break;
#if DXGL_SUPPORT_TEXTURE_BUFFERS
case D3D11_BIND_SHADER_RESOURCE:
spBuffer->m_kBindings.Set(eBB_Texture, true);
break;
#endif //DXGL_SUPPORT_TEXTURE_BUFFERS
case D3D11_BIND_UNORDERED_ACCESS:
if ((kDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) != 0)
{
#if DXGL_SUPPORT_SHADER_STORAGE_BLOCKS
spBuffer->m_kBindings.Set(eBB_ShaderStorage, true);
break;
#endif //DXGL_SUPPORT_SHADER_STORAGE_BLOCKS
}
else
{
#if DXGL_SUPPORT_TEXTURE_BUFFERS
spBuffer->m_kBindings.Set(eBB_Texture, true);
break;
#endif //DXGL_SUPPORT_TEXTURE_BUFFERS
}
default:
DXGL_TODO("Support more buffer bindings");
DXGL_ERROR("Buffer binding not supported");
return NULL;
}
}
bool bVideoMemory = false, bAllocateSystemMemory = false;
switch (kDesc.Usage)
{
case D3D11_USAGE_DEFAULT:
spBuffer->m_pfUpdateSubresource = &SDefaultBufferImpl::UpdateBufferSubresource;
case D3D11_USAGE_IMMUTABLE:
if ((kDesc.CPUAccessFlags & D3D11_CPU_ACCESS_WRITE) == 0)
{
spBuffer->m_eUsage = eBU_Default;//GL_STATIC_READ;
}
else if ((kDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) == 0)
{
spBuffer->m_eUsage = eBU_Default;//GL_STATIC_DRAW;
}
else
{
spBuffer->m_eUsage = eBU_Default;//GL_STATIC_COPY;
}
bVideoMemory = true;
bAllocateSystemMemory = false;
break;
case D3D11_USAGE_DYNAMIC:
spBuffer->m_pfMapSubresource = &SDynamicBufferImpl::MapBuffer;
spBuffer->m_pfUnmapSubresource = &SDynamicBufferImpl::UnmapBuffer;
spBuffer->m_pfUpdateSubresource = &SDynamicBufferImpl::UpdateBufferSubresource;
spBuffer->m_pfMapBufferRange = &SDynamicBufferImpl::MapBufferRange;
if ((kDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) != 0)
{
DXGL_ERROR("Cannot create a buffer with dynamic usage that is CPU readable");
return NULL;
}
if ((kDesc.BindFlags & D3D11_BIND_CONSTANT_BUFFER) != 0)
{
// Assuming that constant buffers are accessed more frequently and usually discarded on updates
spBuffer->m_eUsage = eBU_MapInRingBufferTTLFrame;//GL_DYNAMIC_DRAW;
}
else
{
spBuffer->m_eUsage = eBU_Default;//GL_STREAM_DRAW;
}
// Confetti BEGIN: Igor Lobanchikov
if (spBuffer->m_eUsage == eBU_Default)
{
bVideoMemory = true;
// Igor: we always map the system memory, then copy to ring buffer and use GPU to copy from ring buffer to the actual buffer.
// Slow but safe.
// This path should never be used. Consider using other approaches.
bAllocateSystemMemory = true;
}
else
{
bVideoMemory = false;
bAllocateSystemMemory = false;
}
// Confetti End: Igor Lobanchikov
break;
case D3D11_USAGE_STAGING:
spBuffer->m_pfMapSubresource = &SStagingBufferImpl::MapBuffer;
spBuffer->m_pfUnmapSubresource = &SStagingBufferImpl::UnmapBuffer;
spBuffer->m_pfUpdateSubresource = &SStagingBufferImpl::UpdateBufferSubresource;
spBuffer->m_pfMapBufferRange = &SStagingBufferImpl::MapBufferRange;
spBuffer->m_eUsage = eBU_Default;//GL_NONE;
AZ_Assert(!(kDesc.CPUAccessFlags & D3D11_CPU_ACCESS_WRITE), "The resource should not be writable by CPU");
AZ_Assert((kDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ), "The resource should be readable by CPU");
bVideoMemory = false;
bAllocateSystemMemory = true;
break;
case D3D11_USAGE_TRANSIENT:
spBuffer->m_pfUnmapSubresource = &STransientBufferImpl::UnmapBuffer;
spBuffer->m_pfMapBufferRange = &STransientBufferImpl::MapBufferRange;
spBuffer->m_eUsage = eBU_MapInRingBufferTTLOnce;
// Igor: this buffer never own memory but rather borrows it from the ring buffer
bVideoMemory = false;
bAllocateSystemMemory = false;
if ((kDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) != 0)
{
DXGL_ERROR("Cannot create a buffer with transient usage that is CPU readable");
return NULL;
}
break;
default:
case D3D11_USAGE_DIRECT_ACCESS:
spBuffer->m_pfUnmapSubresource = &SDirectAccessBufferImpl::UnmapBuffer;
spBuffer->m_pfMapBufferRange = &SDirectAccessBufferImpl::MapBufferRange;
spBuffer->m_pfMapSubresource = &SDirectAccessBufferImpl::MapBuffer;
spBuffer->m_eUsage = eBU_DirectAccess;
bVideoMemory = true;
bAllocateSystemMemory = false;
break;
DXGL_ERROR("Buffer usage not supported");
return NULL;
}
if (bVideoMemory)
{
// Confetti BEGIN: Igor Lobanchikov
id<MTLDevice> Device = pDevice->GetMetalDevice();
if (kDesc.BindFlags & D3D11_BIND_UNORDERED_ACCESS)
{
spBuffer->m_BufferShared = [Device newBufferWithLength:spBuffer->m_uSize options:MTLResourceStorageModeShared];
}
else
{
spBuffer->m_BufferShared = [Device newBufferWithLength:spBuffer->m_uSize options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
}
if (pInitialData != NULL)
{
cryMemcpy(spBuffer->m_BufferShared.contents, pInitialData->pSysMem, kDesc.ByteWidth);
}
// Confetti End: Igor Lobanchikov
}
if (bAllocateSystemMemory)
{
spBuffer->m_pSystemMemoryCopy = static_cast<uint8*>(Memalign(kDesc.ByteWidth, MIN_MAPPED_RESOURCE_ALIGNMENT));
}
if (spBuffer->m_pSystemMemoryCopy != NULL && pInitialData != NULL)
{
cryMemcpy(spBuffer->m_pSystemMemoryCopy, pInitialData->pSysMem, kDesc.ByteWidth);
}
return spBuffer;
}
template <typename ViewDesc, typename View>
struct SResourceViewBaseImpl
{
typedef ViewDesc TViewDesc;
typedef View TView;
typedef _smart_ptr<TView> TViewPtr;
};
struct SShaderResourceViewImpl
: SResourceViewBaseImpl<D3D11_SHADER_RESOURCE_VIEW_DESC, SShaderResourceView>
{
enum EViewDimension
{
DIMENSION_BUFFER = D3D11_SRV_DIMENSION_BUFFER,
DIMENSION_TEXTURE1D = D3D11_SRV_DIMENSION_TEXTURE1D,
DIMENSION_TEXTURE1DARRAY = D3D11_SRV_DIMENSION_TEXTURE1DARRAY,
DIMENSION_TEXTURE2D = D3D11_SRV_DIMENSION_TEXTURE2D,
DIMENSION_TEXTURE2DARRAY = D3D11_SRV_DIMENSION_TEXTURE2DARRAY,
DIMENSION_TEXTURE2DMS = D3D11_SRV_DIMENSION_TEXTURE2DMS,
DIMENSION_TEXTURE2DMSARRAY = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY,
DIMENSION_TEXTURE3D = D3D11_SRV_DIMENSION_TEXTURE3D,
DIMENSION_TEXTURECUBE = D3D11_SRV_DIMENSION_TEXTURECUBE,
DIMENSION_TEXTURECUBEARRAY = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY,
DIMENSION_BUFFEREX = D3D11_SRV_DIMENSION_BUFFEREX
};
static SResourceViewBaseImpl::TViewPtr GetView(STexture* pTexture, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMinLevel, uint32 uNumLevels, uint32 uMinElement, uint32 uNumElements, CDevice* pDevice)
{
SShaderTextureViewConfiguration kConfiguration(GetGIFormat(eDXGIFormat), eViewType, uMinLevel, uNumLevels, uMinElement, uNumElements);
SShaderTextureView* pExistingView(pTexture->m_pShaderViewsHead);
while (pExistingView != NULL)
{
if (pExistingView->m_kConfiguration == kConfiguration)
{
return pExistingView;
}
pExistingView = pExistingView->m_pNextView;
}
return pTexture->CreateShaderView(kConfiguration, pDevice);
}
static SResourceViewBaseImpl::TViewPtr GetBufferView(SBuffer* pBuffer, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMinLevel, uint32 uNumLevels, uint32 uMinElement, uint32 uNumElements, CDevice* pDevice)
{
SShaderBufferViewConfiguration kConfiguration(GetGIFormat(eDXGIFormat), eViewType, uMinLevel, uNumLevels, uMinElement, uNumElements);
return pBuffer->CreateShaderView(kConfiguration, pDevice);
}
template <typename DimDesc>
static TViewPtr GetViewMip(STexture* pTexture, const DimDesc& kDimDesc, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMinElement, uint32 uNumElements, CDevice* pDevice)
{
uint32 uNumMipLevels(kDimDesc.MipLevels == -1 ? (pTexture->m_uNumMipLevels - kDimDesc.MostDetailedMip) : kDimDesc.MipLevels);
return GetView(pTexture, eDXGIFormat, eViewType, kDimDesc.MostDetailedMip, uNumMipLevels, uMinElement, uNumElements, pDevice);
}
template <typename DimDesc>
static TViewPtr GetViewLayers(STexture* pTexture, const DimDesc& kDimDesc, DXGI_FORMAT eDXGIFormat, uint32 uMinLevel, uint32 uNumLevels, MTLTextureType eViewType, CDevice* pDevice)
{
return GetView(pTexture, eDXGIFormat, eViewType, uMinLevel, uNumLevels, kDimDesc.FirstArraySlice, kDimDesc.ArraySize, pDevice);
}
template <typename DimDesc>
static TViewPtr GetViewMipLayers(STexture* pTexture, const DimDesc& kDimDesc, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, CDevice* pDevice)
{
return GetViewMip(pTexture, kDimDesc, eDXGIFormat, eViewType, kDimDesc.FirstArraySlice, kDimDesc.ArraySize, pDevice);
}
};
template <typename ViewDesc>
struct SOutputMergerViewImpl
: SResourceViewBaseImpl<ViewDesc, SOutputMergerView>
{
static typename SOutputMergerViewImpl::TViewPtr GetView(STexture* pTexture, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMipLevel, uint32, uint32 uMinElement, uint32 uNumElements, CDevice* pDevice)
{
return pTexture->GetCompatibleOutputMergerView(SOutputMergerTextureViewConfiguration(GetGIFormat(eDXGIFormat), uMipLevel, uMinElement, uNumElements), pDevice);
}
static typename SOutputMergerViewImpl::TViewPtr GetBufferView(SBuffer* pBuffer, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMinLevel, uint32 uNumLevels, uint32 uMinElement, uint32 uNumElements, CDevice* pDevice)
{
//not implemented
CRY_ASSERT(0);
return NULL;
}
template <typename DimDesc>
static typename SOutputMergerViewImpl::TViewPtr GetViewMip(STexture* pTexture, const DimDesc& kDimDesc, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMinElement, uint32 uNumElements, CDevice* pDevice)
{
return GetView(pTexture, eDXGIFormat, eViewType, kDimDesc.MipSlice, 1, uMinElement, uNumElements, pDevice);
}
template <typename DimDesc>
static typename SOutputMergerViewImpl::TViewPtr GetViewLayers(STexture* pTexture, const DimDesc& kDimDesc, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, uint32 uMinLevel, uint32 uNumLevels, CDevice* pDevice)
{
return GetView(pTexture, eDXGIFormat, eViewType, uMinLevel, uNumLevels, kDimDesc.FirstArraySlice, kDimDesc.ArraySize, pDevice);
}
template <typename DimDesc>
static typename SOutputMergerViewImpl::TViewPtr GetViewMipLayers(STexture* pTexture, const DimDesc& kDimDesc, DXGI_FORMAT eDXGIFormat, MTLTextureType eViewType, CDevice* pDevice)
{
return GetViewMip(pTexture, kDimDesc, eDXGIFormat, eViewType, kDimDesc.FirstArraySlice, kDimDesc.ArraySize, pDevice);
}
};
struct SRenderTargetViewImpl
: SOutputMergerViewImpl<D3D11_RENDER_TARGET_VIEW_DESC>
{
enum EViewDimension
{
DIMENSION_BUFFER = D3D11_RTV_DIMENSION_BUFFER,
DIMENSION_TEXTURE1D = D3D11_RTV_DIMENSION_TEXTURE1D,
DIMENSION_TEXTURE1DARRAY = D3D11_RTV_DIMENSION_TEXTURE1DARRAY,
DIMENSION_TEXTURE2D = D3D11_RTV_DIMENSION_TEXTURE2D,
DIMENSION_TEXTURE2DARRAY = D3D11_RTV_DIMENSION_TEXTURE2DARRAY,
DIMENSION_TEXTURE2DMS = D3D11_RTV_DIMENSION_TEXTURE2DMS,
DIMENSION_TEXTURE2DMSARRAY = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY,
DIMENSION_TEXTURE3D = D3D11_RTV_DIMENSION_TEXTURE3D
};
};
struct SDepthStencilViewImpl
: SOutputMergerViewImpl<D3D11_DEPTH_STENCIL_VIEW_DESC>
{
enum EViewDimension
{
DIMENSION_TEXTURE1D = D3D11_DSV_DIMENSION_TEXTURE1D,
DIMENSION_TEXTURE1DARRAY = D3D11_DSV_DIMENSION_TEXTURE1DARRAY,
DIMENSION_TEXTURE2D = D3D11_DSV_DIMENSION_TEXTURE2D,
DIMENSION_TEXTURE2DARRAY = D3D11_DSV_DIMENSION_TEXTURE2DARRAY,
DIMENSION_TEXTURE2DMS = D3D11_DSV_DIMENSION_TEXTURE2DMS,
DIMENSION_TEXTURE2DMSARRAY = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY,
};
};
template <typename Impl>
typename Impl::TViewPtr GetTexture1DView(STexture* pTexture, const typename Impl::TViewDesc& kViewDesc, CDevice* pDevice)
{
using ViewDimensionType = decltype(kViewDesc.ViewDimension);
switch (kViewDesc.ViewDimension)
{
case static_cast<ViewDimensionType>(Impl::DIMENSION_TEXTURE1D):
return Impl::GetViewMip(pTexture, kViewDesc.Texture1D, kViewDesc.Format, MTLTextureType1D, 0, 1, pDevice);
case static_cast<ViewDimensionType>(Impl::DIMENSION_TEXTURE1DARRAY):
return Impl::GetViewMipLayers(pTexture, kViewDesc.Texture1DArray, kViewDesc.Format, MTLTextureType1DArray, pDevice);
}
return NULL;
}
template <typename Impl>
typename Impl::TViewPtr GetTexture2DView(STexture* pTexture, const typename Impl::TViewDesc& kViewDesc, CDevice* pDevice)
{
using ViewDimensionType = decltype(kViewDesc.ViewDimension);
switch (kViewDesc.ViewDimension)
{
case static_cast<ViewDimensionType>(Impl::DIMENSION_TEXTURE2D):
return Impl::GetViewMip(pTexture, kViewDesc.Texture2D, kViewDesc.Format, MTLTextureType2D, 0, 1, pDevice);
case static_cast<ViewDimensionType>(Impl::DIMENSION_TEXTURE2DARRAY):
return Impl::GetViewMipLayers(pTexture, kViewDesc.Texture2DArray, kViewDesc.Format, MTLTextureType2DArray, pDevice);
#if DXGL_SUPPORT_MULTISAMPLED_TEXTURES
case static_cast<ViewDimensionType>(Impl::DIMENSION_TEXTURE2DMS):
return Impl::GetView(pTexture, kViewDesc.Format, GL_TEXTURE_2D_MULTISAMPLE, 0, 1, 0, 1, pDevice);
#endif //DXGL_SUPPORT_MULTISAMPLED_TEXTURES
}
return NULL;
}
template <typename Impl>
typename Impl::TViewPtr GetTextureCubeView(STexture* pTexture, const typename Impl::TViewDesc& kViewDesc, CDevice* pDevice)
{
using ViewDimensionType = decltype(kViewDesc.ViewDimension);
switch (kViewDesc.ViewDimension)
{
case static_cast<ViewDimensionType>(D3D11_SRV_DIMENSION_TEXTURECUBE):
DXGL_TODO("Check if 6 is correct");
return Impl::GetViewMip(pTexture, kViewDesc.TextureCube, kViewDesc.Format, MTLTextureTypeCube, 0, 6, pDevice);
}
return NULL;
}
template <typename Impl>
typename Impl::TViewPtr GetTexture3DView(STexture* pTexture, const typename Impl::TViewDesc& kViewDesc, CDevice* pDevice)
{
if ((uint32)kViewDesc.ViewDimension == (uint32)Impl::DIMENSION_TEXTURE3D)
{
return Impl::GetViewMip(pTexture, kViewDesc.Texture3D, kViewDesc.Format, MTLTextureType3D, 0, 1, pDevice);
}
return NULL;
}
SShaderResourceViewImpl a;
// Confetti BEGIN: Igor Lobanchikov
template <>
SRenderTargetViewImpl::TViewPtr GetTexture3DView<SRenderTargetViewImpl>(STexture* pTexture, const SRenderTargetViewImpl::TViewDesc& kViewDesc, CDevice* pDevice)
{
// DX11 does not support the array 3D texture rendering so route 3D slice down as the arraiy slice
// iOS does not support rendering into the multiple slices at the same time, so the check is performed later in
// the pipeline.
// Igor: double check the following code when we meet this firts. This wasn't used hence wasn't tested.
DXGL_NOT_IMPLEMENTED;
// Confetti End: Igor Lobanchikov
if ((uint32)kViewDesc.ViewDimension == (uint32)SRenderTargetViewImpl::DIMENSION_TEXTURE3D)
{
return SRenderTargetViewImpl::GetViewMip(pTexture, kViewDesc.Texture3D, kViewDesc.Format, MTLTextureType3D,
kViewDesc.Texture3D.FirstWSlice, kViewDesc.Texture3D.WSize, pDevice);
}
return NULL;
}
// Confetti End: Igor Lobanchikov
template <typename Impl>
typename Impl::TViewPtr GetBufferView(SBuffer* pBuffer, const typename Impl::TViewDesc& kViewDesc, CDevice* pDevice)
{
return Impl::GetBufferView(pBuffer, kViewDesc.Format, MTLTextureType1D, 1, 1, 0, 1, pDevice);
}
template <typename Impl>
typename Impl::TViewPtr GetBufferViewEx(SBuffer* pBuffer, const typename Impl::TViewDesc& kViewDesc, CDevice* pDevice)
{
DXMETAL_NOT_IMPLEMENTED
CryLog("TODO: GetBufferViewEX");
return NULL;
}
SShaderResourceViewPtr CreateShaderResourceView(SResource* pResource, D3D11_RESOURCE_DIMENSION eDimension, const D3D11_SHADER_RESOURCE_VIEW_DESC& kViewDesc, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateShaderResourceView")
typedef SShaderResourceViewImpl TImpl;
SShaderResourceViewPtr spView;
switch (eDimension)
{
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
spView = GetTexture1DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
break;
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
spView = GetTexture2DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
if (spView == NULL)
{
spView = GetTextureCubeView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
}
break;
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
spView = GetTexture3DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
break;
case D3D11_RESOURCE_DIMENSION_BUFFER:
spView = GetBufferView<TImpl>(static_cast<SBuffer*>(pResource), kViewDesc, pDevice);
if (spView == NULL)
{
spView = GetBufferViewEx<TImpl>(static_cast<SBuffer*>(pResource), kViewDesc, pDevice);
}
break;
default:
DXGL_ERROR("Invalid resource dimension for shader resource");
return NULL;
}
if (spView == NULL)
{
DXGL_ERROR("Invalid shader resource view paramters");
}
return spView;
}
SOutputMergerViewPtr CreateRenderTargetView(SResource* pResource, D3D11_RESOURCE_DIMENSION eDimension, const D3D11_RENDER_TARGET_VIEW_DESC& kViewDesc, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateRenderTargetView")
typedef SRenderTargetViewImpl TImpl;
switch (eDimension)
{
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
return GetTexture1DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
return GetTexture2DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
return GetTexture3DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
case D3D11_RESOURCE_DIMENSION_BUFFER:
return GetBufferView<TImpl>(static_cast<SBuffer*>(pResource), kViewDesc, pDevice);
}
DXGL_ERROR("Invalid resource dimension for render target");
return NULL;
}
SOutputMergerViewPtr CreateDepthStencilView(SResource* pResource, D3D11_RESOURCE_DIMENSION eDimension, const D3D11_DEPTH_STENCIL_VIEW_DESC& kViewDesc, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateDepthStencilView")
typedef SDepthStencilViewImpl TImpl;
switch (eDimension)
{
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
return GetTexture1DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
return GetTexture2DView<TImpl>(static_cast<STexture*>(pResource), kViewDesc, pDevice);
}
DXGL_ERROR("Invalid resource dimension for render target");
return NULL;
}
SQueryPtr CreateQuery(const D3D11_QUERY_DESC& kDesc, CDevice* pDevice /*CContext* pContext*/)
{
DXGL_SCOPED_PROFILE("CreateQuery")
SQueryPtr spQuery(NULL);
switch (kDesc.Query)
{
case D3D11_QUERY_OCCLUSION:
{
SOcclusionQuery* pOcclusionQuery(new SOcclusionQuery());
spQuery = pOcclusionQuery;
}
break;
case D3D11_QUERY_EVENT:
spQuery = new SFenceSync();
break;
case D3D11_QUERY_TIMESTAMP:
case D3D11_QUERY_TIMESTAMP_DISJOINT:
case D3D11_QUERY_PIPELINE_STATISTICS:
case D3D11_QUERY_OCCLUSION_PREDICATE:
case D3D11_QUERY_SO_STATISTICS:
case D3D11_QUERY_SO_OVERFLOW_PREDICATE:
case D3D11_QUERY_SO_STATISTICS_STREAM0:
case D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0:
case D3D11_QUERY_SO_STATISTICS_STREAM1:
case D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1:
case D3D11_QUERY_SO_STATISTICS_STREAM2:
case D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2:
case D3D11_QUERY_SO_STATISTICS_STREAM3:
case D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3:
DXGL_NOT_IMPLEMENTED
break;
}
return spQuery;
}
SDefaultFrameBufferTexturePtr CreateBackBufferTexture(const D3D11_TEXTURE2D_DESC& kDesc)
{
DXGL_SCOPED_PROFILE("CreateBackBufferTexture")
EGIFormat eGIFormat(GetGIFormat(kDesc.Format));
if (eGIFormat == eGIF_NUM)
{
return NULL;
}
return new SDefaultFrameBufferTexture(kDesc.Width, kDesc.Height, eGIFormat);
}
typedef void (* CopyTextureBoxFunc)(STexture*, STexPos, STexSubresourceID, STexture*, STexPos, STexSubresourceID, STexSize, CContext*);
void CopySystemTextureBox(
STexture* pDstTexture, STexPos kDstPos, STexSubresourceID kDstSubID,
STexture* pSrcTexture, STexPos kSrcPos, STexSubresourceID kSrcSubID,
STexSize kBoxSize, CContext* pContext)
{
UINT uDstSubresource(D3D11CalcSubresource(kDstSubID.m_iMipLevel, kDstSubID.m_uElement, pDstTexture->m_uNumMipLevels));
UINT uSrcSubresource(D3D11CalcSubresource(kSrcSubID.m_iMipLevel, kSrcSubID.m_uElement, pSrcTexture->m_uNumMipLevels));
D3D11_BOX kDstBox;
kDstBox.left = kDstPos.x;
kDstBox.top = kDstPos.y;
kDstBox.front = kDstPos.z;
kDstBox.right = kDstPos.x + kBoxSize.x;
kDstBox.bottom = kDstPos.y + kBoxSize.y;
kDstBox.back = kDstPos.z + kBoxSize.z;
D3D11_MAPPED_SUBRESOURCE kSrcMapped;
pSrcTexture->m_pfMapSubresource(pSrcTexture, uSrcSubresource, D3D11_MAP_READ, 0, &kSrcMapped, pContext);
pDstTexture->m_pfUpdateSubresource(pDstTexture, uDstSubresource, &kDstBox, kSrcMapped.pData, kSrcMapped.RowPitch, kSrcMapped.DepthPitch, pContext);
pSrcTexture->m_pfUnmapSubresource(pSrcTexture, uSrcSubresource, pContext);
}
void CopyTextureWithBlitCommandEncoder(
STexture* pDstTexture, STexPos kDstPos, STexSubresourceID kDstSubID,
STexture* pSrcTexture, STexPos kSrcPos, STexSubresourceID kSrcSubID,
STexSize kBoxSize, CContext* pContext)
{
MTLOrigin sourceOrigin = MTLOriginMake(kSrcPos.x, kSrcPos.y, kSrcPos.z);
MTLSize sourceSize = MTLSizeMake(kBoxSize.x, kBoxSize.y, kBoxSize.z);
MTLOrigin destinationOrigin = {static_cast<NSUInteger>(kDstPos.x),
static_cast<NSUInteger>(kDstPos.y),
static_cast<NSUInteger>(kDstPos.z)};
id<MTLBlitCommandEncoder> blitCommandEncoder = pContext->GetBlitCommandEncoder();
[blitCommandEncoder copyFromTexture: pSrcTexture->m_Texture
sourceSlice: kSrcSubID.m_uElement
sourceLevel: kSrcSubID.m_iMipLevel
sourceOrigin: sourceOrigin
sourceSize: sourceSize
toTexture: pDstTexture->m_Texture
destinationSlice: kDstSubID.m_uElement
destinationLevel: kDstSubID.m_iMipLevel
destinationOrigin: destinationOrigin];
#if defined AZ_PLATFORM_MAC
if (pDstTexture->m_Texture.storageMode == MTLStorageModeManaged)
{
// Need to synchronize the CPU/GPU versions of the texture if it is
// in manged storage mode otherwise the CPU may not see any of the
// writes the GPU does to the texture
[blitCommandEncoder synchronizeTexture: pDstTexture->m_Texture
slice: kDstSubID.m_uElement
level: kDstSubID.m_iMipLevel];
}
#endif
}
template <CopyTextureBoxFunc pfCopyTextureBox>
void CopyTextureImpl(STexture* pDstTexture, STexture* pSrcTexture, CContext* pContext)
{
DXGL_TODO("Check if there's a better way to do this");
STexSubresourceID kSubID;
for (kSubID.m_iMipLevel = 0; kSubID.m_iMipLevel < (GLint)pDstTexture->m_uNumMipLevels; ++kSubID.m_iMipLevel)
{
STexBox kBox;
GetTextureBox(kBox, pDstTexture, kSubID.m_iMipLevel, GetGIFormatInfo(pDstTexture->m_eFormat), true);
for (kSubID.m_uElement = 0; kSubID.m_uElement < pDstTexture->m_uNumElements; ++kSubID.m_uElement)
{
pfCopyTextureBox(
pDstTexture, kBox.m_kOffset, kSubID,
pSrcTexture, kBox.m_kOffset, kSubID,
kBox.m_kSize, pContext);
}
}
}
void CopyTexture(STexture* pDstTexture, STexture* pSrcTexture, CContext* pContext)
{
DXGL_SCOPED_PROFILE("CopyTexture")
if (pSrcTexture->m_uNumMipLevels != pDstTexture->m_uNumMipLevels ||
pSrcTexture->m_uNumElements != pDstTexture->m_uNumElements ||
pSrcTexture->m_iWidth != pDstTexture->m_iWidth ||
pSrcTexture->m_iHeight != pDstTexture->m_iHeight ||
pSrcTexture->m_iDepth != pDstTexture->m_iDepth)
{
DXGL_ERROR("Source and destination textures to copy don't match");
return;
}
// Confetti BEGIN: Igor Lobanchikov
CopyTextureImpl<CopyTextureWithBlitCommandEncoder>(pDstTexture, pSrcTexture, pContext);
// Confetti End: Igor Lobanchikov
}
template <CopyTextureBoxFunc pfCopyTextureBox>
void CopySubTextureImpl(
STexture* pDstTexture, uint32 uDstSubresource, uint32 uDstX, uint32 uDstY, uint32 uDstZ,
STexture* pSrcTexture, uint32 uSrcSubresource, const D3D11_BOX* pSrcBox, CContext* pContext)
{
STexSubresourceID kDstSubID;
kDstSubID.m_iMipLevel = uDstSubresource % pDstTexture->m_uNumMipLevels;
kDstSubID.m_uElement = uDstSubresource / pDstTexture->m_uNumMipLevels;
STexSubresourceID kSrcSubID;
kSrcSubID.m_iMipLevel = uSrcSubresource % pSrcTexture->m_uNumMipLevels;
kSrcSubID.m_uElement = uSrcSubresource / pSrcTexture->m_uNumMipLevels;
STexBox kSrcBox;
GetTextureBox(kSrcBox, pSrcTexture, kSrcSubID.m_iMipLevel, pSrcBox, GetGIFormatInfo(pSrcTexture->m_eFormat), true);
STexPos kDstPos(uDstX, uDstY, uDstZ);
pfCopyTextureBox(
pDstTexture, kDstPos, kDstSubID,
pSrcTexture, kSrcBox.m_kOffset, kSrcSubID,
kSrcBox.m_kSize, pContext);
}
void CopySubTexture(
STexture* pDstTexture, uint32 uDstSubresource, uint32 uDstX, uint32 uDstY, uint32 uDstZ,
STexture* pSrcTexture, uint32 uSrcSubresource, const D3D11_BOX* pSrcBox, CContext* pContext)
{
DXGL_SCOPED_PROFILE("CopySubTexture")
// Confetti BEGIN: Igor Lobanchikov
assert(pDstTexture->m_Texture);
assert(pSrcTexture->m_Texture);
if (pDstTexture->m_eFormat != pSrcTexture->m_eFormat)
{
pContext->TrySlowCopySubresource(pDstTexture, uDstSubresource, uDstX, uDstY, uDstZ, pSrcTexture, uSrcSubresource, pSrcBox);
return;
}
CopySubTextureImpl<CopyTextureWithBlitCommandEncoder>(pDstTexture, uDstSubresource, uDstX, uDstY, uDstZ, pSrcTexture, uSrcSubresource, pSrcBox, pContext);
}
void CopySubBufferInternal(SBuffer* pDstBuffer, SBuffer* pSrcBuffer, uint32 uDstOffset, uint32 uSrcOffset, uint32 uSize, CContext* pContext)
{
if (pSrcBuffer->m_pSystemMemoryCopy != NULL && pDstBuffer->m_pSystemMemoryCopy != NULL)
{
cryMemcpy(pDstBuffer->m_pSystemMemoryCopy + uDstOffset, pSrcBuffer->m_pSystemMemoryCopy + uSrcOffset, uSize);
}
// Confetti BEGIN: Igor Lobanchikov
assert(pDstBuffer->m_BufferShared);
// assert(pSrcBuffer->m_Buffer);
size_t ringBufferOffsetOut = 0;
MemRingBufferStorage memAllocMode = GetMemAllocModeBasedOnSize(uSize);
id<MTLBuffer> tmpBuffer = pSrcBuffer->m_BufferShared;
if (!tmpBuffer)
{
assert(pSrcBuffer->m_pSystemMemoryCopy);
tmpBuffer = pContext->GetRingBuffer(memAllocMode);
void* pTempData = pContext->AllocateMemoryInRingBuffer(uSize, memAllocMode, ringBufferOffsetOut);
size_t tmpOffset = (uint8*)pTempData - (uint8*)tmpBuffer.contents;
cryMemcpy(pTempData, pSrcBuffer->m_pSystemMemoryCopy + uSrcOffset, uSize);
uSrcOffset = tmpOffset;
}
id<MTLBlitCommandEncoder> blitCommandEncoder = pContext->GetBlitCommandEncoder();
[blitCommandEncoder copyFromBuffer: tmpBuffer sourceOffset: uSrcOffset toBuffer: pDstBuffer->m_BufferShared destinationOffset: uDstOffset size: uSize];
// Confetti End: Igor Lobanchikov
}
void CopyBuffer(SBuffer* pDstBuffer, SBuffer* pSrcBuffer, CContext* pContext)
{
DXGL_SCOPED_PROFILE("CopyBuffer")
if (pSrcBuffer->m_uSize != pDstBuffer->m_uSize)
{
DXGL_ERROR("Source and destination buffers to copy don't match");
return;
}
CopySubBufferInternal(pDstBuffer, pSrcBuffer, 0, 0, pSrcBuffer->m_uSize, pContext);
}
void CopySubBuffer(
SBuffer* pDstBuffer, uint32 uDstSubresource, uint32 uDstX, uint32, uint32,
SBuffer* pSrcBuffer, uint32 uSrcSubresource, const D3D11_BOX* pSrcBox, CContext* pContext)
{
DXGL_SCOPED_PROFILE("CopySubBuffer")
uint32 uSrcBegin, uSrcEnd;
if (pSrcBox != NULL)
{
uSrcBegin = pSrcBox->left;
uSrcEnd = pSrcBox->right;
}
else
{
uSrcBegin = 0;
uSrcEnd = pSrcBuffer->m_uSize;
}
uint32 uSize(uSrcEnd - uSrcBegin);
if (uSrcBegin > pSrcBuffer->m_uSize ||
uSrcEnd > pSrcBuffer->m_uSize ||
uDstX + uSize > pDstBuffer->m_uSize)
{
DXGL_ERROR("Source or destination range out of bounds");
return;
}
if (pDstBuffer != pSrcBuffer)
{
CopySubBufferInternal(pDstBuffer, pSrcBuffer, uDstX, uSrcBegin, uSize, pContext);
}
else
{
// Igor: check if this works as expected once triggered.
assert(!"Not tested");
// Igor: don't want to copy
if (uDstX == uSrcBegin)
{
return;
}
// copy forward
else if (uSrcBegin > uDstX && uSrcBegin < uDstX + uSize)
{
uint32 chunkSize = uSrcBegin - uDstX;
while (uSize)
{
chunkSize = min(chunkSize, uSize);
CopySubBufferInternal(pDstBuffer, pSrcBuffer, uDstX, uSrcBegin, chunkSize, pContext);
pDstBuffer += chunkSize;
pSrcBuffer += chunkSize;
uSize -= chunkSize;
}
}
// copy backward
else if (uDstX > uSrcBegin && uDstX < uSrcBegin + uSize)
{
uint32 chunkSize = uDstX - uSrcBegin;
uDstX = uSrcBegin + uSize;
uSrcBegin = uDstX - chunkSize;
while (uSize)
{
chunkSize = min(chunkSize, uSize);
CopySubBufferInternal(pDstBuffer, pSrcBuffer, uDstX, uSrcBegin, chunkSize, pContext);
pDstBuffer -= chunkSize;
pSrcBuffer -= chunkSize;
uSize -= chunkSize;
}
}
// default behaviour
else
{
CopySubBufferInternal(pDstBuffer, pSrcBuffer, uDstX, uSrcBegin, uSize, pContext);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink