Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-21 14:23:02 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added external texture parameter. (#3596)

Browse Source 
* Added external texture parameter.

* Use uint64_t instead of uintptr_t for external texture because VkImage is always 64-bit.
This commit is contained in:
Branimir Karadžić
2026-02-18 12:12:37 -08:00
committed by GitHub
parent 02e04fb458
commit 40e614c45d
24 changed files with 762 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/bgfx.cpp
View File

@@ -473,7 +473,7 @@ namespace bgfx
bx::write(&writer, tc, bx::ErrorAssert{});
rci->destroyTexture(_handle);
rci->createTexture(_handle, mem, _flags, 0);
rci->createTexture(_handle, mem, _flags, 0, 0);
release(mem);
@@ -1631,6 +1631,8 @@ namespace bgfx
CAPS_FLAGS(BGFX_CAPS_TEXTURE_COMPARE_LEQUAL),
CAPS_FLAGS(BGFX_CAPS_TEXTURE_CUBE_ARRAY),
CAPS_FLAGS(BGFX_CAPS_TEXTURE_DIRECT_ACCESS),
CAPS_FLAGS(BGFX_CAPS_TEXTURE_EXTERNAL),
CAPS_FLAGS(BGFX_CAPS_TEXTURE_EXTERNAL_SHARED),
CAPS_FLAGS(BGFX_CAPS_TEXTURE_READ_BACK),
CAPS_FLAGS(BGFX_CAPS_TRANSPARENT_BACKBUFFER),
CAPS_FLAGS(BGFX_CAPS_VARIABLE_RATE_SHADING),
@@ -3293,7 +3295,11 @@ namespace bgfx
uint8_t skip;
_cmdbuf.read(skip);
void* ptr = m_renderCtx->createTexture(handle, mem, flags, skip);
uintptr_t external;
_cmdbuf.read(external);
void* ptr = m_renderCtx->createTexture(handle, mem, flags, skip, external);
if (NULL != ptr)
{
setDirectAccessPtr(handle, ptr);
@@ -3599,6 +3605,7 @@ namespace bgfx
: ndt(NULL)
, nwh(NULL)
, context(NULL)
, queue(NULL)
, backBuffer(NULL)
, backBufferDS(NULL)
, type(NativeWindowHandleType::Default)
@@ -4997,7 +5004,7 @@ namespace bgfx
TextureHandle createTexture(const Memory* _mem, uint64_t _flags, uint8_t _skip, TextureInfo* _info)
{
BX_ASSERT(NULL != _mem, "_mem can't be NULL");
return s_ctx->createTexture(_mem, _flags, _skip, _info, BackbufferRatio::Count, false);
return s_ctx->createTexture(_mem, _flags, _skip, _info, BackbufferRatio::Count, false, 0);
}
void getTextureSizeFromRatio(BackbufferRatio::Enum _ratio, uint16_t& _width, uint16_t& _height)
@@ -5018,7 +5025,17 @@ namespace bgfx
_height = bx::max<uint16_t>(1, _height);
}
static TextureHandle createTexture2D(BackbufferRatio::Enum _ratio, uint16_t _width, uint16_t _height, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
static TextureHandle createTexture2D(
BackbufferRatio::Enum _ratio
, uint16_t _width
, uint16_t _height
, bool _hasMips
, uint16_t _numLayers
, TextureFormat::Enum _format
, uint64_t _flags
, const Memory* _mem
, uint64_t _external
)
{
if (BackbufferRatio::Count != _ratio)
{
@@ -5067,23 +5084,36 @@ namespace bgfx
tc.m_mem = _mem;
bx::write(&writer, tc, bx::ErrorAssert{});
return s_ctx->createTexture(mem, _flags, 0, NULL, _ratio, NULL != _mem);
return s_ctx->createTexture(mem, _flags, 0, NULL, _ratio, NULL != _mem, _external);
}
TextureHandle createTexture2D(uint16_t _width, uint16_t _height, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
TextureHandle createTexture2D(uint16_t _width, uint16_t _height, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem, uint64_t _external)
{
BX_ASSERT(false
|| 0 == _external
|| 0 != (g_caps.supported & BGFX_CAPS_TEXTURE_EXTERNAL)
, "External texture is not supported! "
"Use bgfx::getCaps to check `BGFX_CAPS_TEXTURE_EXTERNAL` backend renderer capabilities."
);
BX_ASSERT(_width > 0 && _height > 0, "Invalid texture size (width %d, height %d).", _width, _height);
return createTexture2D(BackbufferRatio::Count, _width, _height, _hasMips, _numLayers, _format, _flags, _mem);
return createTexture2D(BackbufferRatio::Count, _width, _height, _hasMips, _numLayers, _format, _flags, _mem, _external);
}
TextureHandle createTexture2D(BackbufferRatio::Enum _ratio, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags)
{
BX_ASSERT(_ratio < BackbufferRatio::Count, "Invalid back buffer ratio.");
return createTexture2D(_ratio, 0, 0, _hasMips, _numLayers, _format, _flags, NULL);
return createTexture2D(_ratio, 0, 0, _hasMips, _numLayers, _format, _flags, NULL, 0);
}
TextureHandle createTexture3D(uint16_t _width, uint16_t _height, uint16_t _depth, bool _hasMips, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
TextureHandle createTexture3D(uint16_t _width, uint16_t _height, uint16_t _depth, bool _hasMips, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem, uint64_t _external)
{
BX_ASSERT(false
|| 0 == _external
|| 0 != (g_caps.supported & BGFX_CAPS_TEXTURE_EXTERNAL)
, "External texture is not supported! "
"Use bgfx::getCaps to check `BGFX_CAPS_TEXTURE_EXTERNAL` backend renderer capabilities."
);
bx::ErrorAssert err;
isTextureValid(_width, _height, _depth, false, 1, _format, _flags, &err);
@@ -5123,11 +5153,18 @@ namespace bgfx
tc.m_mem = _mem;
bx::write(&writer, tc, bx::ErrorAssert{});
return s_ctx->createTexture(mem, _flags, 0, NULL, BackbufferRatio::Count, NULL != _mem);
return s_ctx->createTexture(mem, _flags, 0, NULL, BackbufferRatio::Count, NULL != _mem, _external);
}
TextureHandle createTextureCube(uint16_t _size, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem)
TextureHandle createTextureCube(uint16_t _size, bool _hasMips, uint16_t _numLayers, TextureFormat::Enum _format, uint64_t _flags, const Memory* _mem, uint64_t _external)
{
BX_ASSERT(false
|| 0 == _external
|| 0 != (g_caps.supported & BGFX_CAPS_TEXTURE_EXTERNAL)
, "External texture is not supported! "
"Use bgfx::getCaps to check `BGFX_CAPS_TEXTURE_EXTERNAL` backend renderer capabilities."
);
bx::ErrorAssert err;
isTextureValid(_size, _size, 0, true, _numLayers, _format, _flags, &err);
@@ -5168,7 +5205,7 @@ namespace bgfx
tc.m_mem = _mem;
bx::write(&writer, tc, bx::ErrorAssert{});
return s_ctx->createTexture(mem, _flags, 0, NULL, BackbufferRatio::Count, NULL != _mem);
return s_ctx->createTexture(mem, _flags, 0, NULL, BackbufferRatio::Count, NULL != _mem, _external);
}
void setName(TextureHandle _handle, const char* _name, int32_t _len)
@@ -5999,6 +6036,8 @@ static_assert( (0
| BGFX_CAPS_TEXTURE_BLIT
| BGFX_CAPS_TEXTURE_CUBE_ARRAY
| BGFX_CAPS_TEXTURE_DIRECT_ACCESS
| BGFX_CAPS_TEXTURE_EXTERNAL
| BGFX_CAPS_TEXTURE_EXTERNAL_SHARED
| BGFX_CAPS_TEXTURE_READ_BACK
| BGFX_CAPS_VERTEX_ATTRIB_HALF
| BGFX_CAPS_VERTEX_ATTRIB_UINT10
@@ -6027,6 +6066,8 @@ static_assert( (0
^ BGFX_CAPS_TEXTURE_BLIT
^ BGFX_CAPS_TEXTURE_CUBE_ARRAY
^ BGFX_CAPS_TEXTURE_DIRECT_ACCESS
^ BGFX_CAPS_TEXTURE_EXTERNAL
^ BGFX_CAPS_TEXTURE_EXTERNAL_SHARED
^ BGFX_CAPS_TEXTURE_READ_BACK
^ BGFX_CAPS_VERTEX_ATTRIB_HALF
^ BGFX_CAPS_VERTEX_ATTRIB_UINT10

12
src/bgfx.idl.inl
View File

@@ -469,10 +469,10 @@ BGFX_C_API bgfx_texture_handle_t bgfx_create_texture(const bgfx_memory_t* _mem,
return handle_ret.c;
}
BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_2d(uint16_t _width, uint16_t _height, bool _hasMips, uint16_t _numLayers, bgfx_texture_format_t _format, uint64_t _flags, const bgfx_memory_t* _mem)
BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_2d(uint16_t _width, uint16_t _height, bool _hasMips, uint16_t _numLayers, bgfx_texture_format_t _format, uint64_t _flags, const bgfx_memory_t* _mem, uint64_t _external)
{
union { bgfx_texture_handle_t c; bgfx::TextureHandle cpp; } handle_ret;
handle_ret.cpp = bgfx::createTexture2D(_width, _height, _hasMips, _numLayers, (bgfx::TextureFormat::Enum)_format, _flags, (const bgfx::Memory*)_mem);
handle_ret.cpp = bgfx::createTexture2D(_width, _height, _hasMips, _numLayers, (bgfx::TextureFormat::Enum)_format, _flags, (const bgfx::Memory*)_mem, _external);
return handle_ret.c;
}
@@ -483,17 +483,17 @@ BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_2d_scaled(bgfx_backbuffer_r
return handle_ret.c;
}
BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_3d(uint16_t _width, uint16_t _height, uint16_t _depth, bool _hasMips, bgfx_texture_format_t _format, uint64_t _flags, const bgfx_memory_t* _mem)
BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_3d(uint16_t _width, uint16_t _height, uint16_t _depth, bool _hasMips, bgfx_texture_format_t _format, uint64_t _flags, const bgfx_memory_t* _mem, uint64_t _external)
{
union { bgfx_texture_handle_t c; bgfx::TextureHandle cpp; } handle_ret;
handle_ret.cpp = bgfx::createTexture3D(_width, _height, _depth, _hasMips, (bgfx::TextureFormat::Enum)_format, _flags, (const bgfx::Memory*)_mem);
handle_ret.cpp = bgfx::createTexture3D(_width, _height, _depth, _hasMips, (bgfx::TextureFormat::Enum)_format, _flags, (const bgfx::Memory*)_mem, _external);
return handle_ret.c;
}
BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_cube(uint16_t _size, bool _hasMips, uint16_t _numLayers, bgfx_texture_format_t _format, uint64_t _flags, const bgfx_memory_t* _mem)
BGFX_C_API bgfx_texture_handle_t bgfx_create_texture_cube(uint16_t _size, bool _hasMips, uint16_t _numLayers, bgfx_texture_format_t _format, uint64_t _flags, const bgfx_memory_t* _mem, uint64_t _external)
{
union { bgfx_texture_handle_t c; bgfx::TextureHandle cpp; } handle_ret;
handle_ret.cpp = bgfx::createTextureCube(_size, _hasMips, _numLayers, (bgfx::TextureFormat::Enum)_format, _flags, (const bgfx::Memory*)_mem);
handle_ret.cpp = bgfx::createTextureCube(_size, _hasMips, _numLayers, (bgfx::TextureFormat::Enum)_format, _flags, (const bgfx::Memory*)_mem, _external);
return handle_ret.c;
}

5
src/bgfx_p.h
View File

@@ -3687,7 +3687,7 @@ namespace bgfx
virtual void destroyShader(ShaderHandle _handle) = 0;
virtual void createProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh) = 0;
virtual void destroyProgram(ProgramHandle _handle) = 0;
virtual void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) = 0;
virtual void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) = 0;
virtual void updateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem) = 0;
virtual void readTexture(TextureHandle _handle, void* _data, uint8_t _mip) = 0;
virtual void resizeTexture(TextureHandle _handle, uint16_t _width, uint16_t _height, uint8_t _numMips, uint16_t _numLayers) = 0;
@@ -5103,7 +5103,7 @@ namespace bgfx
}
}
BGFX_API_FUNC(TextureHandle createTexture(const Memory* _mem, uint64_t _flags, uint8_t _skip, TextureInfo* _info, BackbufferRatio::Enum _ratio, bool _immutable) )
BGFX_API_FUNC(TextureHandle createTexture(const Memory* _mem, uint64_t _flags, uint8_t _skip, TextureInfo* _info, BackbufferRatio::Enum _ratio, bool _immutable, uint64_t _external) )
{
BGFX_MUTEX_SCOPE(m_resourceApiLock);
@@ -5181,6 +5181,7 @@ namespace bgfx
cmdbuf.write(_mem);
cmdbuf.write(_flags);
cmdbuf.write(_skip);
cmdbuf.write(_external);
setDebugNameForHandle(handle);

303
src/renderer_d3d11.cpp
View File

@@ -423,6 +423,7 @@ namespace bgfx { namespace d3d11
static const GUID WKPDID_D3DDebugObjectName = { 0x429b8c22, 0x9188, 0x4b0c, { 0x87, 0x42, 0xac, 0xb0, 0xbf, 0x85, 0xc2, 0x00 } };
static const GUID IID_ID3D11Texture2D = { 0x6f15aaf2, 0xd208, 0x4e89, { 0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c } };
static const GUID IID_ID3D11Resource = { 0xdc8e63f3, 0xd12b, 0x4952, { 0xb4, 0x7b, 0x5e, 0x45, 0x02, 0x6a, 0x86, 0x2d } };
static const GUID IID_ID3D11Device1 = { 0xa04bfb29, 0x08ef, 0x43d6, { 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86 } };
static const GUID IID_ID3D11Device2 = { 0x9d06dffa, 0xd1e5, 0x4d07, { 0x83, 0xa8, 0x1b, 0xb1, 0x23, 0xf2, 0xf8, 0x41 } };
static const GUID IID_ID3D11Device3 = { 0xa05c8c37, 0xd2c6, 0x4732, { 0xb3, 0xa0, 0x9c, 0xe0, 0xb0, 0xdc, 0x9a, 0xe6 } };
@@ -1250,6 +1251,7 @@ namespace bgfx { namespace d3d11
| ((m_featureLevel >= D3D_FEATURE_LEVEL_11_0)
? BGFX_CAPS_PRIMITIVE_ID
: 0)
| BGFX_CAPS_TEXTURE_EXTERNAL
);
m_timerQuerySupport = m_featureLevel >= D3D_FEATURE_LEVEL_10_0;
@@ -1861,9 +1863,10 @@ namespace bgfx { namespace d3d11
m_program[_handle.idx].destroy();
}
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) override
{
return m_textures[_handle.idx].create(_mem, _flags, _skip);
BX_UNUSED(_external);
return m_textures[_handle.idx].create(_mem, _flags, _skip, _external);
}
void updateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem) override
@@ -1915,7 +1918,7 @@ namespace bgfx { namespace d3d11
bx::write(&writer, tc, bx::ErrorAssert{});
texture.destroy();
texture.create(mem, texture.m_flags, 0);
texture.create(mem, texture.m_flags, 0, NULL);
release(mem);
}
@@ -4477,7 +4480,7 @@ namespace bgfx { namespace d3d11
}
}
void* TextureD3D11::create(const Memory* _mem, uint64_t _flags, uint8_t _skip)
void* TextureD3D11::create(const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external)
{
void* directAccessPtr = NULL;
@@ -4602,12 +4605,14 @@ namespace bgfx { namespace d3d11
}
}
const bool writeOnly = 0 != (m_flags&(BGFX_TEXTURE_RT_WRITE_ONLY|BGFX_TEXTURE_READ_BACK) );
const bool computeWrite = 0 != (m_flags&BGFX_TEXTURE_COMPUTE_WRITE);
const bool renderTarget = 0 != (m_flags&BGFX_TEXTURE_RT_MASK);
const bool srgb = 0 != (m_flags&BGFX_TEXTURE_SRGB);
const bool blit = 0 != (m_flags&BGFX_TEXTURE_BLIT_DST);
const bool readBack = 0 != (m_flags&BGFX_TEXTURE_READ_BACK);
const bool writeOnly = 0 != (m_flags & (BGFX_TEXTURE_RT_WRITE_ONLY|BGFX_TEXTURE_READ_BACK) );
const bool computeWrite = 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
const bool renderTarget = 0 != (m_flags & BGFX_TEXTURE_RT_MASK);
const bool srgb = 0 != (m_flags & BGFX_TEXTURE_SRGB);
const bool blit = 0 != (m_flags & BGFX_TEXTURE_BLIT_DST);
const bool readBack = 0 != (m_flags & BGFX_TEXTURE_READ_BACK);
const bool externalShared = 0 != (m_flags & BGFX_TEXTURE_EXTERNAL_SHARED);
const uint32_t msaaQuality = bx::uint32_satsub( (m_flags&BGFX_TEXTURE_RT_MSAA_MASK)>>BGFX_TEXTURE_RT_MSAA_SHIFT, 1);
const DXGI_SAMPLE_DESC& msaa = s_msaa[msaaQuality];
const bool msaaSample = true
@@ -4651,161 +4656,185 @@ namespace bgfx { namespace d3d11
&& !writeOnly
;
switch (m_type)
if (NULL != _external)
{
case Texture2D:
case TextureCube:
if (externalShared)
{
D3D11_TEXTURE2D_DESC desc = {};
desc.Width = ti.width;
desc.Height = ti.height;
desc.MipLevels = ti.numMips;
desc.ArraySize = numSides;
desc.Format = format;
desc.SampleDesc = msaa;
desc.Usage = kk == 0 || blit ? D3D11_USAGE_DEFAULT : D3D11_USAGE_IMMUTABLE;
desc.BindFlags = writeOnly ? 0 : D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
DX_CHECK(s_renderD3D11->m_device->OpenSharedResource(HANDLE(_external), IID_ID3D11Resource, (void**)&m_ptr) );
}
else
{
m_ptr = (ID3D11Resource*)(_external);
}
if (bimg::isDepth(bimg::TextureFormat::Enum(m_textureFormat) ) )
m_flags |= BGFX_SAMPLER_INTERNAL_SHARED;
}
else
{
switch (m_type)
{
case Texture2D:
case TextureCube:
{
desc.BindFlags |= D3D11_BIND_DEPTH_STENCIL;
desc.Usage = D3D11_USAGE_DEFAULT;
}
else if (renderTarget)
{
desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.MiscFlags |= 0
| (1 < ti.numMips ? D3D11_RESOURCE_MISC_GENERATE_MIPS : 0)
;
}
D3D11_TEXTURE2D_DESC desc = {};
desc.Width = ti.width;
desc.Height = ti.height;
desc.MipLevels = ti.numMips;
desc.ArraySize = numSides;
desc.Format = format;
desc.SampleDesc = msaa;
desc.Usage = kk == 0 || blit ? D3D11_USAGE_DEFAULT : D3D11_USAGE_IMMUTABLE;
desc.BindFlags = writeOnly ? 0 : D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
if (computeWrite)
{
desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
desc.Usage = D3D11_USAGE_DEFAULT;
}
if (readBack)
{
desc.BindFlags = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
}
if (imageContainer.m_cubeMap)
{
desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
if (1 < ti.numLayers)
if (bimg::isDepth(bimg::TextureFormat::Enum(m_textureFormat) ) )
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
srvd.TextureCubeArray.MipLevels = ti.numMips;
srvd.TextureCubeArray.NumCubes = ti.numLayers;
desc.BindFlags |= D3D11_BIND_DEPTH_STENCIL;
desc.Usage = D3D11_USAGE_DEFAULT;
}
else
else if (renderTarget)
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
srvd.TextureCube.MipLevels = ti.numMips;
desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.MiscFlags |= 0
| (1 < ti.numMips ? D3D11_RESOURCE_MISC_GENERATE_MIPS : 0)
;
}
}
else
{
if (msaaSample)
if (computeWrite)
{
desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
desc.Usage = D3D11_USAGE_DEFAULT;
}
if (readBack)
{
desc.BindFlags = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
}
if (imageContainer.m_cubeMap)
{
desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
if (1 < ti.numLayers)
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY;
srvd.Texture2DMSArray.ArraySize = ti.numLayers;
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
srvd.TextureCubeArray.MipLevels = ti.numMips;
srvd.TextureCubeArray.NumCubes = ti.numLayers;
}
else
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
srvd.TextureCube.MipLevels = ti.numMips;
}
}
else
{
if (1 < ti.numLayers)
if (msaaSample)
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
srvd.Texture2DArray.MipLevels = ti.numMips;
srvd.Texture2DArray.ArraySize = ti.numLayers;
if (1 < ti.numLayers)
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY;
srvd.Texture2DMSArray.ArraySize = ti.numLayers;
}
else
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
}
}
else
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvd.Texture2D.MipLevels = ti.numMips;
if (1 < ti.numLayers)
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
srvd.Texture2DArray.MipLevels = ti.numMips;
srvd.Texture2DArray.ArraySize = ti.numLayers;
}
else
{
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvd.Texture2D.MipLevels = ti.numMips;
}
}
}
}
if (needResolve)
{
DX_CHECK(s_renderD3D11->m_device->CreateTexture2D(&desc, NULL, &m_rt2d) );
desc.BindFlags &= ~(D3D11_BIND_RENDER_TARGET|D3D11_BIND_DEPTH_STENCIL);
desc.SampleDesc = s_msaa[0];
}
desc.MiscFlags |= externalShared ? D3D11_RESOURCE_MISC_SHARED : 0;
if (directAccess)
{
directAccessPtr = m_dar.createTexture2D(&desc, kk == 0 ? NULL : srd, &m_texture2d);
if (needResolve)
{
DX_CHECK(s_renderD3D11->m_device->CreateTexture2D(&desc, NULL, &m_rt2d) );
desc.BindFlags &= ~(D3D11_BIND_RENDER_TARGET|D3D11_BIND_DEPTH_STENCIL);
desc.SampleDesc = s_msaa[0];
}
if (directAccess)
{
directAccessPtr = m_dar.createTexture2D(&desc, kk == 0 ? NULL : srd, &m_texture2d);
}
else
{
DX_CHECK(s_renderD3D11->m_device->CreateTexture2D(&desc, kk == 0 ? NULL : srd, &m_texture2d) );
}
}
else
break;
case Texture3D:
{
DX_CHECK(s_renderD3D11->m_device->CreateTexture2D(&desc, kk == 0 ? NULL : srd, &m_texture2d) );
D3D11_TEXTURE3D_DESC desc = {};
desc.Width = ti.width;
desc.Height = ti.height;
desc.Depth = ti.depth;
desc.MipLevels = ti.numMips;
desc.Format = format;
desc.Usage = kk == 0 || blit ? D3D11_USAGE_DEFAULT : D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
if (renderTarget)
{
desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.MiscFlags |= 0
| (1 < ti.numMips ? D3D11_RESOURCE_MISC_GENERATE_MIPS : 0)
;
}
if (computeWrite)
{
desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
desc.Usage = D3D11_USAGE_DEFAULT;
}
if (readBack)
{
desc.BindFlags = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
}
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
srvd.Texture3D.MipLevels = ti.numMips;
desc.MiscFlags |= externalShared ? D3D11_RESOURCE_MISC_SHARED : 0;
if (directAccess)
{
directAccessPtr = m_dar.createTexture3D(&desc, kk == 0 ? NULL : srd, &m_texture3d);
}
else
{
DX_CHECK(s_renderD3D11->m_device->CreateTexture3D(&desc, kk == 0 ? NULL : srd, &m_texture3d) );
}
}
break;
}
break;
case Texture3D:
if (externalShared)
{
D3D11_TEXTURE3D_DESC desc = {};
desc.Width = ti.width;
desc.Height = ti.height;
desc.Depth = ti.depth;
desc.MipLevels = ti.numMips;
desc.Format = format;
desc.Usage = kk == 0 || blit ? D3D11_USAGE_DEFAULT : D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
if (renderTarget)
{
desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.MiscFlags |= 0
| (1 < ti.numMips ? D3D11_RESOURCE_MISC_GENERATE_MIPS : 0)
;
}
if (computeWrite)
{
desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
desc.Usage = D3D11_USAGE_DEFAULT;
}
if (readBack)
{
desc.BindFlags = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
}
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
srvd.Texture3D.MipLevels = ti.numMips;
if (directAccess)
{
directAccessPtr = m_dar.createTexture3D(&desc, kk == 0 ? NULL : srd, &m_texture3d);
}
else
{
DX_CHECK(s_renderD3D11->m_device->CreateTexture3D(&desc, kk == 0 ? NULL : srd, &m_texture3d) );
}
}
break;
}
if (!writeOnly)
@@ -4843,6 +4872,7 @@ namespace bgfx { namespace d3d11
DX_RELEASE(m_rt, 0);
DX_RELEASE(m_srv, 0);
DX_RELEASE(m_uav, 0);
if (0 == (m_flags & BGFX_SAMPLER_INTERNAL_SHARED) )
{
DX_RELEASE(m_ptr, 0);
@@ -5099,7 +5129,6 @@ namespace bgfx { namespace d3d11
DX_CHECK(device->CreateDepthStencilView(depthStencil, NULL, &m_dsv) );
DX_RELEASE(depthStencil, 0);
m_srv[0] = NULL;
m_nwh = _nwh;
m_denseIdx = _denseIdx;
m_num = 1;
@@ -5324,9 +5353,13 @@ namespace bgfx { namespace d3d11
break;
}
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc{};
texture.m_srv->GetDesc(&srvDesc);
DX_CHECK(s_renderD3D11->m_device->CreateShaderResourceView(texture.m_ptr, &srvDesc, &m_srv[m_num]));
if (NULL != texture.m_srv)
{
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc{};
texture.m_srv->GetDesc(&srvDesc);
DX_CHECK(s_renderD3D11->m_device->CreateShaderResourceView(texture.m_ptr, &srvDesc, &m_srv[m_num]));
}
m_num++;
}
else

5
src/renderer_d3d11.h
View File

@@ -284,7 +284,7 @@ namespace bgfx { namespace d3d11
{
}
void* create(const Memory* _mem, uint64_t _flags, uint8_t _skip);
void* create(const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external);
void destroy();
void overrideInternal(uintptr_t _ptr, uint16_t _layerIndex);
void update(uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem);
@@ -335,6 +335,9 @@ namespace bgfx { namespace d3d11
, m_numUav(0)
, m_needPresent(false)
{
bx::memSet(m_rtv, 0, sizeof(m_rtv) );
bx::memSet(m_uav, 0, sizeof(m_uav) );
bx::memSet(m_srv, 0, sizeof(m_srv) );
}
void create(uint8_t _num, const Attachment* _attachment);

172
src/renderer_d3d12.cpp
View File

@@ -547,12 +547,12 @@ namespace bgfx { namespace d3d12
#endif // BX_PLATFORM_WINDOWS
}
ID3D12Resource* createCommittedResource(ID3D12Device* _device, HeapProperty::Enum _heapProperty, const D3D12_RESOURCE_DESC* _resourceDesc, const D3D12_CLEAR_VALUE* _clearValue, bool _memSet = false)
ID3D12Resource* createCommittedResource(ID3D12Device* _device, HeapProperty::Enum _heapProperty, const D3D12_RESOURCE_DESC* _resourceDesc, const D3D12_CLEAR_VALUE* _clearValue, bool _memSet = false, D3D12_HEAP_FLAGS _heapFlags = D3D12_HEAP_FLAG_NONE)
{
const HeapProperty& heapProperty = s_heapProperties[_heapProperty];
ID3D12Resource* resource;
DX_CHECK(_device->CreateCommittedResource(&heapProperty.m_properties
, D3D12_HEAP_FLAG_NONE
, _heapFlags
, _resourceDesc
, heapProperty.m_state
, _clearValue
@@ -581,7 +581,7 @@ namespace bgfx { namespace d3d12
return resource;
}
ID3D12Resource* createCommittedResource(ID3D12Device* _device, HeapProperty::Enum _heapProperty, uint64_t _size, D3D12_RESOURCE_FLAGS _flags = D3D12_RESOURCE_FLAG_NONE)
ID3D12Resource* createCommittedResource(ID3D12Device* _device, HeapProperty::Enum _heapProperty, uint64_t _size, D3D12_RESOURCE_FLAGS _flags = D3D12_RESOURCE_FLAG_NONE, D3D12_HEAP_FLAGS _heapFlags = D3D12_HEAP_FLAG_NONE)
{
D3D12_RESOURCE_DESC resourceDesc = {};
resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
@@ -596,7 +596,7 @@ namespace bgfx { namespace d3d12
resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
resourceDesc.Flags = _flags;
return createCommittedResource(_device, _heapProperty, &resourceDesc, NULL);
return createCommittedResource(_device, _heapProperty, &resourceDesc, NULL, false, _heapFlags);
}
inline bool isLost(HRESULT _hr)
@@ -1254,7 +1254,7 @@ namespace bgfx { namespace d3d12
initHeapProperties(m_device);
m_cmd.init(m_device);
m_cmd.init(m_device, (ID3D12CommandQueue*)g_platformData.queue);
m_device->SetPrivateDataInterface(IID_ID3D12CommandQueue, m_cmd.m_commandQueue);
errorState = ErrorState::CreatedCommandQueue;
@@ -1624,6 +1624,7 @@ namespace bgfx { namespace d3d12
| BGFX_CAPS_TEXTURE_COMPARE_ALL
| BGFX_CAPS_TEXTURE_CUBE_ARRAY
| (m_directAccessSupport ? BGFX_CAPS_TEXTURE_DIRECT_ACCESS : 0)
| BGFX_CAPS_TEXTURE_EXTERNAL
| BGFX_CAPS_TEXTURE_READ_BACK
| (m_variableRateShadingSupport ? BGFX_CAPS_VARIABLE_RATE_SHADING : 0)
| BGFX_CAPS_VERTEX_ATTRIB_HALF
@@ -2125,9 +2126,9 @@ namespace bgfx { namespace d3d12
m_program[_handle.idx].destroy();
}
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) override
{
return m_textures[_handle.idx].create(_mem, _flags, _skip);
return m_textures[_handle.idx].create(_mem, _flags, _skip, _external);
}
void updateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem) override
@@ -2216,7 +2217,7 @@ namespace bgfx { namespace d3d12
bx::write(&writer, tc, bx::ErrorAssert{});
texture.destroy();
texture.create(mem, texture.m_flags, 0);
texture.create(mem, texture.m_flags, 0, 0);
release(mem);
}
@@ -2940,7 +2941,10 @@ namespace bgfx { namespace d3d12
{
FrameBufferD3D12& frameBuffer = m_frameBuffers[m_fbh.idx];
if (m_rtMsaa) frameBuffer.resolve();
if (m_rtMsaa)
{
frameBuffer.resolve();
}
if (NULL == frameBuffer.m_swapChain)
{
@@ -2967,7 +2971,7 @@ namespace bgfx { namespace d3d12
if (NULL != m_swapChain)
{
m_rtvHandle = getCPUHandleHeapStart(m_rtvDescriptorHeap);
uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
const uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
m_rtvHandle.ptr += m_backBufferColorIdx * rtvDescriptorSize;
m_dsvHandle = getCPUHandleHeapStart(m_dsvDescriptorHeap);
@@ -4271,18 +4275,27 @@ namespace bgfx { namespace d3d12
return gpuHandle;
}
void CommandQueueD3D12::init(ID3D12Device* _device)
void CommandQueueD3D12::init(ID3D12Device* _device, ID3D12CommandQueue* _queue)
{
D3D12_COMMAND_QUEUE_DESC queueDesc;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
queueDesc.Priority = 0;
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.NodeMask = 1;
DX_CHECK(_device->CreateCommandQueue(
&queueDesc
, IID_ID3D12CommandQueue
, (void**)&m_commandQueue
) );
m_externalQueue = NULL != _queue;
if (NULL != _queue)
{
m_commandQueue = _queue;
}
else
{
D3D12_COMMAND_QUEUE_DESC queueDesc;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
queueDesc.Priority = 0;
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.NodeMask = 1;
DX_CHECK(_device->CreateCommandQueue(
&queueDesc
, IID_ID3D12CommandQueue
, (void**)&m_commandQueue
) );
}
m_completedFence = 0;
m_currentFence = 0;
@@ -4349,7 +4362,10 @@ namespace bgfx { namespace d3d12
DX_RELEASE(m_commandList[ii].m_commandList, 0);
}
DX_RELEASE(m_commandQueue, 0);
if (!m_externalQueue)
{
DX_RELEASE(m_commandQueue, 0);
}
const D3D12_RANGE range =
{
@@ -4384,6 +4400,11 @@ namespace bgfx { namespace d3d12
const uint32_t currentIdx = m_control.m_current;
CommandList& commandList = m_commandList[currentIdx];
for (TextureHandle th : m_external)
{
s_renderD3D12->m_textures[th.idx].setState(commandList.m_commandList, D3D12_RESOURCE_STATE_COMMON);
}
commandList.m_commandList->EndQuery(
m_pipelineStatsQueryHeap
, D3D12_QUERY_TYPE_PIPELINE_STATISTICS
@@ -4485,6 +4506,25 @@ namespace bgfx { namespace d3d12
return false;
}
void CommandQueueD3D12::addExternal(TextureHandle _handle)
{
m_external.push_back(_handle);
}
void CommandQueueD3D12::removeExternal(TextureHandle _handle)
{
for (ExternalTextureArray::iterator it = m_external.begin(), itEnd = m_external.end(); it != itEnd; ++it)
{
if (it->idx == _handle.idx)
{
m_external.erase(it);
return;
}
}
BX_ASSERT(false, "Removing external texture failed!");
}
void BatchD3D12::create(uint32_t _maxDrawPerBatch)
{
m_maxDrawPerBatch = _maxDrawPerBatch;
@@ -5392,7 +5432,7 @@ namespace bgfx { namespace d3d12
return result;
}
void* TextureD3D12::create(const Memory* _mem, uint64_t _flags, uint8_t _skip)
void* TextureD3D12::create(const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external)
{
bimg::ImageContainer imageContainer;
@@ -5447,10 +5487,11 @@ namespace bgfx { namespace d3d12
const bool compressed = bimg::isCompressed(bimg::TextureFormat::Enum(m_textureFormat) );
const bool swizzle = TextureFormat::BGRA8 == m_textureFormat && 0 != (m_flags&BGFX_TEXTURE_COMPUTE_WRITE);
const bool writeOnly = 0 != (m_flags&BGFX_TEXTURE_RT_WRITE_ONLY);
const bool computeWrite = 0 != (m_flags&BGFX_TEXTURE_COMPUTE_WRITE);
const bool renderTarget = 0 != (m_flags&BGFX_TEXTURE_RT_MASK);
const bool blit = 0 != (m_flags&BGFX_TEXTURE_BLIT_DST);
const bool writeOnly = 0 != (m_flags & BGFX_TEXTURE_RT_WRITE_ONLY);
const bool computeWrite = 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
const bool renderTarget = 0 != (m_flags & BGFX_TEXTURE_RT_MASK);
const bool blit = 0 != (m_flags & BGFX_TEXTURE_BLIT_DST);
const bool externalShared = 0 != (m_flags & BGFX_TEXTURE_EXTERNAL_SHARED);
const uint32_t msaaQuality = bx::uint32_satsub((m_flags & BGFX_TEXTURE_RT_MSAA_MASK) >> BGFX_TEXTURE_RT_MSAA_SHIFT, 1);
const DXGI_SAMPLE_DESC& msaa = s_msaa[msaaQuality];
@@ -5720,7 +5761,46 @@ namespace bgfx { namespace d3d12
break;
}
m_ptr = createCommittedResource(device, HeapProperty::Texture, &resourceDesc, clearValue, renderTarget);
if (0 != _external)
{
if (externalShared)
{
DX_CHECK(device->OpenSharedHandle(HANDLE(_external), IID_ID3D12Resource, (void**)&m_ptr) );
}
else
{
m_ptr = (ID3D12Resource*)_external;
}
m_flags |= BGFX_SAMPLER_INTERNAL_SHARED;
m_state = D3D12_RESOURCE_STATE_COMMON;
s_renderD3D12->m_cmd.addExternal({ uint16_t(this - s_renderD3D12->m_textures) });
}
else
{
m_ptr = createCommittedResource(
device
, HeapProperty::Texture
, &resourceDesc
, clearValue
, renderTarget
, externalShared
? D3D12_HEAP_FLAG_SHARED
: D3D12_HEAP_FLAG_NONE
);
if (externalShared)
{
DX_CHECK(device->CreateSharedHandle(
m_ptr
, NULL
, GENERIC_ALL
, NULL
, &m_handle
) );
}
}
if (directAccess)
{
@@ -5751,10 +5831,6 @@ namespace bgfx { namespace d3d12
s_renderD3D12->m_cmd.release(staging);
}
else
{
setState(commandList, state);
}
if (0 != kk)
{
@@ -5801,17 +5877,33 @@ namespace bgfx { namespace d3d12
m_directAccessPtr = NULL;
}
if (0 == (m_flags & BGFX_SAMPLER_INTERNAL_SHARED) )
const bool external = 0 != (m_flags & BGFX_SAMPLER_INTERNAL_SHARED);
const bool externalShared = 0 != (m_flags & BGFX_TEXTURE_EXTERNAL_SHARED);
if (externalShared)
{
#if !BX_PLATFORM_LINUX
CloseHandle(m_handle);
m_handle = NULL;
#endif // !BX_PLATFORM_LINUX
}
if (external)
{
s_renderD3D12->m_cmd.removeExternal({ uint16_t(this - s_renderD3D12->m_textures) });
}
else
{
s_renderD3D12->m_cmd.release(m_ptr);
m_ptr = NULL;
m_state = D3D12_RESOURCE_STATE_COMMON;
}
if (NULL != m_singleMsaa)
{
s_renderD3D12->m_cmd.release(m_singleMsaa);
m_singleMsaa = NULL;
}
m_ptr = NULL;
m_state = D3D12_RESOURCE_STATE_COMMON;
if (NULL != m_singleMsaa)
{
s_renderD3D12->m_cmd.release(m_singleMsaa);
m_singleMsaa = NULL;
}
}
}

13
src/renderer_d3d12.h
View File

@@ -309,6 +309,7 @@ namespace bgfx { namespace d3d12
TextureD3D12()
: m_ptr(NULL)
, m_singleMsaa(NULL)
, m_handle(NULL)
, m_directAccessPtr(NULL)
, m_state(D3D12_RESOURCE_STATE_COMMON)
, m_numMips(0)
@@ -317,7 +318,7 @@ namespace bgfx { namespace d3d12
bx::memSet(&m_uavd, 0, sizeof(m_uavd) );
}
void* create(const Memory* _mem, uint64_t _flags, uint8_t _skip);
void* create(const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external);
void destroy();
void overrideInternal(uintptr_t _ptr);
void update(ID3D12GraphicsCommandList* _commandList, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem);
@@ -328,6 +329,7 @@ namespace bgfx { namespace d3d12
D3D12_UNORDERED_ACCESS_VIEW_DESC m_uavd;
ID3D12Resource* m_ptr;
ID3D12Resource* m_singleMsaa;
HANDLE m_handle;
void* m_directAccessPtr;
D3D12_RESOURCE_STATES m_state;
uint64_t m_flags;
@@ -390,11 +392,12 @@ namespace bgfx { namespace d3d12
: m_currentFence(0)
, m_completedFence(0)
, m_control(BX_COUNTOF(m_commandList) )
, m_externalQueue(false)
{
static_assert(BX_COUNTOF(m_commandList) == BX_COUNTOF(m_release) );
}
void init(ID3D12Device* _device);
void init(ID3D12Device* _device, ID3D12CommandQueue* _queue);
void shutdown();
ID3D12GraphicsCommandList* alloc();
uint64_t kick();
@@ -403,6 +406,9 @@ namespace bgfx { namespace d3d12
void release(ID3D12Resource* _ptr);
bool consume(uint32_t _ms = UINT32_MAX);
void addExternal(TextureHandle _handle);
void removeExternal(TextureHandle _handle);
struct CommandList
{
ID3D12GraphicsCommandList* m_commandList;
@@ -455,7 +461,10 @@ namespace bgfx { namespace d3d12
CommandList m_commandList[kMaxCommandLists];
typedef stl::vector<ID3D12Resource*> ResourceArray;
ResourceArray m_release[kMaxCommandLists];
typedef stl::vector<TextureHandle> ExternalTextureArray;
ExternalTextureArray m_external;
bx::RingBufferControl m_control;
bool m_externalQueue;
ID3D12Resource* m_pipelineStatsReadBack;
ID3D12QueryHeap* m_pipelineStatsQueryHeap;

3
src/renderer_gl.cpp
View File

@@ -3393,8 +3393,9 @@ namespace bgfx { namespace gl
m_program[_handle.idx].destroy();
}
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) override
{
BX_UNUSED(_external);
m_textures[_handle.idx].create(_mem, _flags, _skip);
return NULL;
}

27
src/renderer_mtl.h
View File

@@ -1392,30 +1392,9 @@ namespace bgfx { namespace mtl
}
}
void create(const Memory* _mem, uint64_t _flags, uint8_t _skip);
void destroy()
{
if (0 == (m_flags & BGFX_SAMPLER_INTERNAL_SHARED) )
{
MTL_RELEASE_W(m_ptr, 0);
MTL_RELEASE_W(m_ptrMsaa, 0);
}
MTL_RELEASE_W(m_ptrStencil, 0);
for (uint32_t ii = 0; ii < m_numMips; ++ii)
{
MTL_RELEASE_W(m_ptrMips[ii], 0);
}
}
void overrideInternal(uintptr_t _ptr)
{
destroy();
m_flags |= BGFX_SAMPLER_INTERNAL_SHARED;
m_ptr = id<MTLTexture>(_ptr);
}
void create(const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external);
void destroy();
void overrideInternal(uintptr_t _ptr);
void update(
uint8_t _side

42
src/renderer_mtl.mm
View File

@@ -611,6 +611,7 @@ static_assert(BX_COUNTOF(s_accessNames) == Access::Count, "Invalid s_accessNames
| BGFX_CAPS_TEXTURE_2D_ARRAY
| BGFX_CAPS_TEXTURE_3D
| BGFX_CAPS_TEXTURE_BLIT
| BGFX_CAPS_TEXTURE_EXTERNAL
| BGFX_CAPS_TEXTURE_READ_BACK
| BGFX_CAPS_VERTEX_ATTRIB_HALF
| BGFX_CAPS_VERTEX_ATTRIB_UINT10
@@ -1076,9 +1077,9 @@ static_assert(BX_COUNTOF(s_accessNames) == Access::Count, "Invalid s_accessNames
m_program[_handle.idx].destroy();
}
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) override
{
m_textures[_handle.idx].create(_mem, _flags, _skip);
m_textures[_handle.idx].create(_mem, _flags, _skip, _external);
return NULL;
}
@@ -1145,7 +1146,7 @@ static_assert(BX_COUNTOF(s_accessNames) == Access::Count, "Invalid s_accessNames
bx::write(&writer, tc, bx::ErrorAssert{});
texture.destroy();
texture.create(mem, texture.m_flags, 0);
texture.create(mem, texture.m_flags, 0, 0);
release(mem);
}
@@ -3008,7 +3009,7 @@ BX_PRAGMA_DIAGNOSTIC_POP();
BufferMtl::create(_size, _data, _flags, stride, true);
}
void TextureMtl::create(const Memory* _mem, uint64_t _flags, uint8_t _skip)
void TextureMtl::create(const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external)
{
m_sampler = s_renderMtl->getSamplerState(uint32_t(_flags) );
@@ -3149,7 +3150,15 @@ BX_PRAGMA_DIAGNOSTIC_POP();
}
}
m_ptr = s_renderMtl->m_device.newTextureWithDescriptor(desc);
if (0 != _external)
{
m_ptr = id<MTLTexture>(_external);
m_flags |= BGFX_SAMPLER_INTERNAL_SHARED;
}
else
{
m_ptr = s_renderMtl->m_device.newTextureWithDescriptor(desc);
}
if (sampleCount > 1)
{
@@ -3257,6 +3266,29 @@ BX_PRAGMA_DIAGNOSTIC_POP();
}
}
void TextureMtl::destroy()
{
if (0 == (m_flags & BGFX_SAMPLER_INTERNAL_SHARED) )
{
MTL_RELEASE_W(m_ptr, 0);
}
MTL_RELEASE_W(m_ptrMsaa, 0);
MTL_RELEASE_W(m_ptrStencil, 0);
for (uint32_t ii = 0; ii < m_numMips; ++ii)
{
MTL_RELEASE_W(m_ptrMips[ii], 0);
}
}
void TextureMtl::overrideInternal(uintptr_t _ptr)
{
destroy();
m_flags |= BGFX_SAMPLER_INTERNAL_SHARED;
m_ptr = id<MTLTexture>(_ptr);
}
void TextureMtl::update(uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem)
{
const uint32_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) );

2
src/renderer_noop.cpp
View File

@@ -164,7 +164,7 @@ namespace bgfx { namespace noop
{
}
void* createTexture(TextureHandle /*_handle*/, const Memory* /*_mem*/, uint64_t /*_flags*/, uint8_t /*_skip*/) override
void* createTexture(TextureHandle /*_handle*/, const Memory* /*_mem*/, uint64_t /*_flags*/, uint8_t /*_skip*/, uint64_t /*_external*/) override
{
return NULL;
}

209
src/renderer_vk.cpp
View File

@@ -2418,9 +2418,9 @@ VK_IMPORT_DEVICE
m_program[_handle.idx].destroy();
}
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) override
{
return m_textures[_handle.idx].create(m_commandBuffer, _mem, _flags, _skip);
return m_textures[_handle.idx].create(m_commandBuffer, _mem, _flags, _skip, _external);
}
void updateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem) override
@@ -2481,7 +2481,7 @@ VK_IMPORT_DEVICE
bx::write(&writer, tc, bx::ErrorAssert{});
destroyTexture(_handle);
createTexture(_handle, mem, flags, 0);
createTexture(_handle, mem, flags, 0, 0);
bgfx::release(mem);
}
@@ -2989,10 +2989,10 @@ VK_IMPORT_DEVICE
for (uint8_t ii = 0, num = oldFrameBuffer.m_num; ii < num; ++ii)
{
TextureVK& texture = m_textures[oldFrameBuffer.m_texture[ii].idx];
texture.setImageMemoryBarrier(m_commandBuffer, texture.m_sampledLayout);
texture.setState(m_commandBuffer, texture.m_sampledLayout);
if (VK_NULL_HANDLE != texture.m_singleMsaaImage)
{
texture.setImageMemoryBarrier(m_commandBuffer, texture.m_sampledLayout, true);
texture.setState(m_commandBuffer, texture.m_sampledLayout, true);
}
}
@@ -3003,7 +3003,7 @@ VK_IMPORT_DEVICE
if (!writeOnly)
{
texture.setImageMemoryBarrier(m_commandBuffer, texture.m_sampledLayout);
texture.setState(m_commandBuffer, texture.m_sampledLayout);
}
}
}
@@ -3013,7 +3013,7 @@ VK_IMPORT_DEVICE
for (uint8_t ii = 0, num = newFrameBuffer.m_num; ii < num; ++ii)
{
TextureVK& texture = m_textures[newFrameBuffer.m_texture[ii].idx];
texture.setImageMemoryBarrier(
texture.setState(
m_commandBuffer
, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
);
@@ -3022,7 +3022,7 @@ VK_IMPORT_DEVICE
if (isValid(newFrameBuffer.m_depth) )
{
TextureVK& texture = m_textures[newFrameBuffer.m_depth.idx];
texture.setImageMemoryBarrier(
texture.setState(
m_commandBuffer
, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
);
@@ -6323,13 +6323,13 @@ retry:
? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
;
setImageMemoryBarrier(_commandBuffer, layout);
setState(_commandBuffer, layout);
}
return result;
}
VkResult TextureVK::createImages(VkCommandBuffer _commandBuffer)
VkResult TextureVK::createImages(VkCommandBuffer _commandBuffer, uint64_t _external)
{
BGFX_PROFILER_SCOPE("TextureVK::createImages", kColorResource);
@@ -6388,28 +6388,40 @@ retry:
;
ici.tiling = VK_IMAGE_TILING_OPTIMAL;
result = vkCreateImage(device, &ici, allocatorCb, &m_textureImage);
if (VK_SUCCESS != result)
if (0 != _external)
{
BX_TRACE("Create texture image error: vkCreateImage failed %d: %s.", result, getName(result) );
return result;
static_assert(sizeof(m_textureImage) == sizeof(_external), "Size must match!");
bx::memCopy(&m_textureImage, &_external, sizeof(VkImage) );
m_textureDeviceMem = {};
m_flags |= BGFX_SAMPLER_INTERNAL_SHARED;
s_renderVK->m_cmd.addExternal({ uint16_t(this - s_renderVK->m_textures) });
}
VkMemoryRequirements imageMemReq;
vkGetImageMemoryRequirements(device, m_textureImage, &imageMemReq);
result = s_renderVK->allocateMemory(&imageMemReq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &m_textureDeviceMem, false);
if (VK_SUCCESS != result)
else
{
BX_TRACE("Create texture image error: allocateMemory failed %d: %s.", result, getName(result) );
return result;
}
result = vkCreateImage(device, &ici, allocatorCb, &m_textureImage);
if (VK_SUCCESS != result)
{
BX_TRACE("Create texture image error: vkCreateImage failed %d: %s.", result, getName(result) );
return result;
}
result = vkBindImageMemory(device, m_textureImage, m_textureDeviceMem.mem, m_textureDeviceMem.offset);
if (VK_SUCCESS != result)
{
BX_TRACE("Create texture image error: vkBindImageMemory failed %d: %s.", result, getName(result) );
return result;
VkMemoryRequirements imageMemReq;
vkGetImageMemoryRequirements(device, m_textureImage, &imageMemReq);
result = s_renderVK->allocateMemory(&imageMemReq, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &m_textureDeviceMem, false);
if (VK_SUCCESS != result)
{
BX_TRACE("Create texture image error: allocateMemory failed %d: %s.", result, getName(result) );
return result;
}
result = vkBindImageMemory(device, m_textureImage, m_textureDeviceMem.mem, m_textureDeviceMem.offset);
if (VK_SUCCESS != result)
{
BX_TRACE("Create texture image error: vkBindImageMemory failed %d: %s.", result, getName(result) );
return result;
}
}
m_sampledLayout = m_flags & BGFX_TEXTURE_COMPUTE_WRITE
@@ -6455,13 +6467,13 @@ retry:
return result;
}
setImageMemoryBarrier(_commandBuffer, m_sampledLayout, true);
setState(_commandBuffer, m_sampledLayout, true);
}
return result;
}
void* TextureVK::create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip)
void* TextureVK::create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external)
{
BGFX_PROFILER_SCOPE("TextureVK::create", kColorResource);
@@ -6535,12 +6547,13 @@ retry:
const bool compressed = bimg::isCompressed(bimg::TextureFormat::Enum(m_textureFormat) );
const bool swizzle = TextureFormat::BGRA8 == m_textureFormat && 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
const bool writeOnly = 0 != (m_flags & BGFX_TEXTURE_RT_WRITE_ONLY);
const bool computeWrite = 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
const bool renderTarget = 0 != (m_flags & BGFX_TEXTURE_RT_MASK);
const bool blit = 0 != (m_flags & BGFX_TEXTURE_BLIT_DST);
const bool writeOnly = 0 != (m_flags & BGFX_TEXTURE_RT_WRITE_ONLY);
const bool computeWrite = 0 != (m_flags & BGFX_TEXTURE_COMPUTE_WRITE);
const bool renderTarget = 0 != (m_flags & BGFX_TEXTURE_RT_MASK);
const bool blit = 0 != (m_flags & BGFX_TEXTURE_BLIT_DST);
const bool externalShared = 0 != (m_flags & BGFX_TEXTURE_EXTERNAL_SHARED);
BX_UNUSED(swizzle, writeOnly, computeWrite, renderTarget, blit);
BX_UNUSED(swizzle, writeOnly, computeWrite, renderTarget, blit, externalShared);
BX_TRACE(
"Texture %3d: %s (requested: %s), %dx%dx%d%s RT[%c], BO[%c], CW[%c]%s."
@@ -6557,7 +6570,7 @@ retry:
, swizzle ? " (swizzle BGRA8 -> RGBA8)" : ""
);
VK_CHECK(createImages(_commandBuffer) );
VK_CHECK(createImages(_commandBuffer, _external) );
// decode images
struct ImageInfo
@@ -6741,7 +6754,7 @@ retry:
}
else
{
setImageMemoryBarrier(_commandBuffer, m_sampledLayout);
setState(_commandBuffer, m_sampledLayout);
}
bx::free(g_allocator, bufferCopyInfo);
@@ -6765,10 +6778,20 @@ retry:
m_readback.destroy();
if (VK_NULL_HANDLE != m_textureImage)
const bool external = 0 != (m_flags & BGFX_SAMPLER_INTERNAL_SHARED);
// const bool externalShared = 0 != (m_flags & BGFX_TEXTURE_EXTERNAL_SHARED);
if (external)
{
s_renderVK->release(m_textureImage);
s_renderVK->recycleMemory(m_textureDeviceMem);
s_renderVK->m_cmd.removeExternal({ uint16_t(this - s_renderVK->m_textures) });
}
else
{
if (VK_NULL_HANDLE != m_textureImage)
{
s_renderVK->release(m_textureImage);
s_renderVK->recycleMemory(m_textureDeviceMem);
}
}
if (VK_NULL_HANDLE != m_singleMsaaImage)
@@ -6888,8 +6911,8 @@ retry:
if (needResolve)
{
setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true);
setState(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
setState(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true);
VkImageResolve resolve;
resolve.srcOffset.x = 0;
@@ -6925,7 +6948,7 @@ retry:
{
BGFX_PROFILER_SCOPE("Resolve - Generate Mipmaps", kColorResource);
setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
setState(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
int32_t mipWidth = bx::max<int32_t>(int32_t(m_width) >> _mip, 1);
int32_t mipHeight = bx::max<int32_t>(int32_t(m_height) >> _mip, 1);
@@ -6962,7 +6985,7 @@ retry:
blit.dstOffsets[1] = { mipWidth, mipHeight, 1 };
blit.dstSubresource.mipLevel = i;
vk::setImageMemoryBarrier(
setImageMemoryBarrier(
_commandBuffer
, m_textureImage
, m_aspectFlags
@@ -6986,7 +7009,7 @@ retry:
);
}
vk::setImageMemoryBarrier(
setImageMemoryBarrier(
_commandBuffer
, m_textureImage
, m_aspectFlags
@@ -6999,8 +7022,8 @@ retry:
);
}
setImageMemoryBarrier(_commandBuffer, oldLayout);
setImageMemoryBarrier(_commandBuffer, oldSingleMsaaLayout, true);
setState(_commandBuffer, oldLayout);
setState(_commandBuffer, oldSingleMsaaLayout, true);
}
void TextureVK::copyBufferToTexture(VkCommandBuffer _commandBuffer, VkBuffer _stagingBuffer, uint32_t _bufferImageCopyCount, VkBufferImageCopy* _bufferImageCopy)
@@ -7012,7 +7035,7 @@ retry:
: m_currentImageLayout
;
setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
setState(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
bimg::TextureFormat::Enum format = bimg::TextureFormat::Enum(m_textureFormat);
const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(format);
@@ -7035,14 +7058,15 @@ retry:
, _bufferImageCopy
);
setImageMemoryBarrier(_commandBuffer, oldLayout);
setState(_commandBuffer, oldLayout);
}
VkImageLayout TextureVK::setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage)
void TextureVK::setState(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage)
{
if (_singleMsaaImage && VK_NULL_HANDLE == m_singleMsaaImage)
if (_singleMsaaImage
&& VK_NULL_HANDLE == m_singleMsaaImage)
{
return VK_IMAGE_LAYOUT_UNDEFINED;
return;
}
VkImageLayout& currentLayout = _singleMsaaImage
@@ -7050,28 +7074,23 @@ retry:
: m_currentImageLayout
;
const VkImageLayout oldLayout = currentLayout;
if (currentLayout == _newImageLayout)
if (currentLayout != _newImageLayout)
{
return oldLayout;
const VkImage image = _singleMsaaImage
? m_singleMsaaImage
: m_textureImage
;
setImageMemoryBarrier(
_commandBuffer
, image
, m_aspectFlags
, currentLayout
, _newImageLayout
);
currentLayout = _newImageLayout;
}
const VkImage image = _singleMsaaImage
? m_singleMsaaImage
: m_textureImage
;
vk::setImageMemoryBarrier(
_commandBuffer
, image
, m_aspectFlags
, currentLayout
, _newImageLayout
);
currentLayout = _newImageLayout;
return oldLayout;
}
VkResult TextureVK::createView(uint32_t _layer, uint32_t _numLayers, uint32_t _mip, uint32_t _numMips, VkImageViewType _type, VkImageAspectFlags _aspectMask, bool _renderTarget, ::VkImageView* _view) const
@@ -7081,18 +7100,18 @@ retry:
if (VK_IMAGE_VIEW_TYPE_3D == m_type)
{
BX_ASSERT(false
|| !_renderTarget
|| !(m_aspectFlags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) )
|| !_renderTarget
|| !(m_aspectFlags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) )
, "3D image can't be a depth attachment"
);
);
}
if (VK_IMAGE_VIEW_TYPE_CUBE == _type
|| VK_IMAGE_VIEW_TYPE_CUBE_ARRAY == _type)
{
BX_ASSERT(_numLayers % 6 == 0, "");
BX_ASSERT(
VK_IMAGE_VIEW_TYPE_3D != m_type
BX_ASSERT(false
|| VK_IMAGE_VIEW_TYPE_3D != m_type
, "3D image can't be aliased as a cube texture"
);
}
@@ -8746,6 +8765,11 @@ retry:
{
const VkDevice device = s_renderVK->m_device;
for (TextureHandle th : m_external)
{
s_renderVK->m_textures[th.idx].setState(m_activeCommandBuffer, VK_IMAGE_LAYOUT_UNDEFINED);
}
setMemoryBarrier(
m_activeCommandBuffer
, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
@@ -8865,6 +8889,25 @@ retry:
m_release[m_consumeIndex].clear();
}
void CommandQueueVK::addExternal(TextureHandle _handle)
{
m_external.push_back(_handle);
}
void CommandQueueVK::removeExternal(TextureHandle _handle)
{
for (ExternalTextureArray::iterator it = m_external.begin(), itEnd = m_external.end(); it != itEnd; ++it)
{
if (it->idx == _handle.idx)
{
m_external.erase(it);
return;
}
}
BX_ASSERT(false, "Removing external texture failed!");
}
void RendererContextVK::submitBlit(BlitState& _bs, uint16_t _view)
{
BGFX_PROFILER_SCOPE("RendererContextVK::submitBlit", kColorFrame);
@@ -8896,15 +8939,17 @@ retry:
TextureVK& src = m_textures[blit.m_src.idx];
TextureVK& dst = m_textures[blit.m_dst.idx];
src.setImageMemoryBarrier(
src.setState(
m_commandBuffer
, blit.m_src.idx == blit.m_dst.idx ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
, blit.m_src.idx == blit.m_dst.idx
? VK_IMAGE_LAYOUT_GENERAL
: VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
, VK_NULL_HANDLE != src.m_singleMsaaImage
);
if (blit.m_src.idx != blit.m_dst.idx)
{
dst.setImageMemoryBarrier(m_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
dst.setState(m_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
}
const uint16_t srcSamples = VK_NULL_HANDLE != src.m_singleMsaaImage ? 1 : src.m_sampler.Count;
@@ -8981,8 +9026,8 @@ retry:
TextureVK& src = m_textures[blit.m_src.idx];
TextureVK& dst = m_textures[blit.m_dst.idx];
src.setImageMemoryBarrier(m_commandBuffer, srcLayouts[item], VK_NULL_HANDLE != src.m_singleMsaaImage);
dst.setImageMemoryBarrier(m_commandBuffer, dstLayouts[item]);
src.setState(m_commandBuffer, srcLayouts[item], VK_NULL_HANDLE != src.m_singleMsaaImage);
dst.setState(m_commandBuffer, dstLayouts[item]);
}
}

19
src/renderer_vk.h
View File

@@ -746,7 +746,7 @@ VK_DESTROY_FUNC(DescriptorSet);
{
}
void* create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip);
void* create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external);
// internal render target
VkResult create(VkCommandBuffer _commandBuffer, uint32_t _width, uint32_t _height, uint64_t _flags, VkFormat _format);
@@ -756,7 +756,7 @@ VK_DESTROY_FUNC(DescriptorSet);
void resolve(VkCommandBuffer _commandBuffer, uint8_t _resolve, uint32_t _layer, uint32_t _numLayers, uint32_t _mip);
void copyBufferToTexture(VkCommandBuffer _commandBuffer, VkBuffer _stagingBuffer, uint32_t _bufferImageCopyCount, VkBufferImageCopy* _bufferImageCopy);
VkImageLayout setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage = false);
void setState(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage = false);
VkResult createView(uint32_t _layer, uint32_t _numLayers, uint32_t _mip, uint32_t _numMips, VkImageViewType _type, VkImageAspectFlags _aspectMask, bool _renderTarget, ::VkImageView* _view) const;
@@ -778,20 +778,20 @@ VK_DESTROY_FUNC(DescriptorSet);
VkComponentMapping m_components;
VkImageAspectFlags m_aspectFlags;
VkImage m_textureImage;
VkImage m_textureImage;
DeviceMemoryAllocationVK m_textureDeviceMem;
VkImageLayout m_currentImageLayout;
VkImageLayout m_currentImageLayout;
VkImage m_singleMsaaImage;
VkImage m_singleMsaaImage;
DeviceMemoryAllocationVK m_singleMsaaDeviceMem;
VkImageLayout m_currentSingleMsaaImageLayout;
VkImageLayout m_currentSingleMsaaImageLayout;
VkImageLayout m_sampledLayout;
ReadbackVK m_readback;
private:
VkResult createImages(VkCommandBuffer _commandBuffer);
VkResult createImages(VkCommandBuffer _commandBuffer, uint64_t _external = 0);
static VkImageAspectFlags getAspectMask(VkFormat _format);
};
@@ -947,6 +947,9 @@ VK_DESTROY_FUNC(DescriptorSet);
void recycleMemory(DeviceMemoryAllocationVK _mem);
void consume();
void addExternal(TextureHandle _handle);
void removeExternal(TextureHandle _handle);
uint32_t m_queueFamily;
VkQueue m_queue;
@@ -984,6 +987,8 @@ VK_DESTROY_FUNC(DescriptorSet);
typedef stl::vector<Resource> ResourceArray;
ResourceArray m_release[BGFX_CONFIG_MAX_FRAME_LATENCY];
stl::vector<DeviceMemoryAllocationVK> m_recycleAllocs[BGFX_CONFIG_MAX_FRAME_LATENCY];
typedef stl::vector<TextureHandle> ExternalTextureArray;
ExternalTextureArray m_external;
private:
template<typename Ty>

3
src/renderer_webgpu.cpp
View File

@@ -1493,8 +1493,9 @@ WGPU_IMPORT
m_program[_handle.idx].destroy();
}
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip) override
void* createTexture(TextureHandle _handle, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external) override
{
BX_UNUSED(_external);
m_textures[_handle.idx].create(_mem, _flags, _skip);
return NULL;
}

4
src/version.h
View File

@@ -9,5 +9,5 @@
*
*/
#define BGFX_REV_NUMBER 9143
#define BGFX_REV_SHA1 "90d61887acd560b9c1eca2a0d76b7f0fe1ad8866"
#define BGFX_REV_NUMBER 9149
#define BGFX_REV_SHA1 "f446c319d65b5e9a4d4070100e3fc571f5b35ea5"