wine/wine-staging
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-staging.git synced 2025-12-15 08:03:15 -08:00
Code Issues Packages Projects Releases Wiki Activity

Updated d3dx11_43-D3DX11CreateTextureFromMemory patchset

Browse Source 
Thanks Connor McAdams.
This commit is contained in:
Alistair Leslie-Hughes
2025-09-20 07:17:15 +10:00
parent 112b476921
commit 27156e4a6e
19 changed files with 5522 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0001-d3dx11_42-Implement-D3DX11CreateTextureFromMemory.patch
View File

@@ -1,406 +0,0 @@
From 18e01f69f4a3ad85253bb73dcd3ff197074c8810 Mon Sep 17 00:00:00 2001
From: Alistair Leslie-Hughes <leslie_alistair@hotmail.com>
Date: Tue, 3 Aug 2021 11:13:18 +1000
Subject: [PATCH] d3dx11_42: Implement D3DX11CreateTextureFromMemory
Signed-off-by: Alistair Leslie-Hughes <leslie_alistair@hotmail.com>
---
dlls/d3dx11_43/texture.c | 365 ++++++++++++++++++++++++++++++++++++++-
1 file changed, 359 insertions(+), 6 deletions(-)
diff --git a/dlls/d3dx11_43/texture.c b/dlls/d3dx11_43/texture.c
index cbf3b630f58..0bc5ef9ab03 100644
--- a/dlls/d3dx11_43/texture.c
+++ b/dlls/d3dx11_43/texture.c
@@ -15,12 +15,15 @@
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#define COBJMACROS
#include "d3dx11.h"
#include "d3dcompiler.h"
#include "dxhelpers.h"
+#include "wincodec.h"
#include "wine/debug.h"
+#include "wine/heap.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
@@ -277,16 +280,366 @@ HRESULT WINAPI D3DX11CreateTextureFromFileW(ID3D11Device *device, const WCHAR *f
return E_NOTIMPL;
}
-HRESULT WINAPI D3DX11CreateTextureFromMemory(ID3D11Device *device, const void *data,
- SIZE_T data_size, D3DX11_IMAGE_LOAD_INFO *load_info, ID3DX11ThreadPump *pump,
- ID3D11Resource **texture, HRESULT *hresult)
+static const DXGI_FORMAT block_compressed_formats[] =
+{
+ DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_BC1_UNORM_SRGB,
+ DXGI_FORMAT_BC2_TYPELESS, DXGI_FORMAT_BC2_UNORM, DXGI_FORMAT_BC2_UNORM_SRGB,
+ DXGI_FORMAT_BC3_TYPELESS, DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_BC3_UNORM_SRGB,
+ DXGI_FORMAT_BC4_TYPELESS, DXGI_FORMAT_BC4_UNORM, DXGI_FORMAT_BC4_SNORM,
+ DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_UNORM, DXGI_FORMAT_BC5_SNORM,
+ DXGI_FORMAT_BC6H_TYPELESS, DXGI_FORMAT_BC6H_UF16, DXGI_FORMAT_BC6H_SF16,
+ DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_BC7_UNORM_SRGB
+};
+
+static BOOL is_block_compressed(DXGI_FORMAT format)
{
- FIXME("device %p, data %p, data_size %Iu, load_info %p, pump %p, texture %p, hresult %p stub.\n",
- device, data, data_size, load_info, pump, texture, hresult);
+ unsigned int i;
- return E_NOTIMPL;
+ for (i = 0; i < ARRAY_SIZE(block_compressed_formats); ++i)
+ if (format == block_compressed_formats[i])
+ return TRUE;
+
+ return FALSE;
+}
+
+static unsigned int get_bpp_from_format(DXGI_FORMAT format)
+{
+ switch (format)
+ {
+ case DXGI_FORMAT_R32G32B32A32_TYPELESS:
+ case DXGI_FORMAT_R32G32B32A32_FLOAT:
+ case DXGI_FORMAT_R32G32B32A32_UINT:
+ case DXGI_FORMAT_R32G32B32A32_SINT:
+ return 128;
+ case DXGI_FORMAT_R32G32B32_TYPELESS:
+ case DXGI_FORMAT_R32G32B32_FLOAT:
+ case DXGI_FORMAT_R32G32B32_UINT:
+ case DXGI_FORMAT_R32G32B32_SINT:
+ return 96;
+ case DXGI_FORMAT_R16G16B16A16_TYPELESS:
+ case DXGI_FORMAT_R16G16B16A16_FLOAT:
+ case DXGI_FORMAT_R16G16B16A16_UNORM:
+ case DXGI_FORMAT_R16G16B16A16_UINT:
+ case DXGI_FORMAT_R16G16B16A16_SNORM:
+ case DXGI_FORMAT_R16G16B16A16_SINT:
+ case DXGI_FORMAT_R32G32_TYPELESS:
+ case DXGI_FORMAT_R32G32_FLOAT:
+ case DXGI_FORMAT_R32G32_UINT:
+ case DXGI_FORMAT_R32G32_SINT:
+ case DXGI_FORMAT_R32G8X24_TYPELESS:
+ case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
+ case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
+ case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
+ case DXGI_FORMAT_Y416:
+ case DXGI_FORMAT_Y210:
+ case DXGI_FORMAT_Y216:
+ return 64;
+ case DXGI_FORMAT_R10G10B10A2_TYPELESS:
+ case DXGI_FORMAT_R10G10B10A2_UNORM:
+ case DXGI_FORMAT_R10G10B10A2_UINT:
+ case DXGI_FORMAT_R11G11B10_FLOAT:
+ case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+ case DXGI_FORMAT_R8G8B8A8_UNORM:
+ case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+ case DXGI_FORMAT_R8G8B8A8_UINT:
+ case DXGI_FORMAT_R8G8B8A8_SNORM:
+ case DXGI_FORMAT_R8G8B8A8_SINT:
+ case DXGI_FORMAT_R16G16_TYPELESS:
+ case DXGI_FORMAT_R16G16_FLOAT:
+ case DXGI_FORMAT_R16G16_UNORM:
+ case DXGI_FORMAT_R16G16_UINT:
+ case DXGI_FORMAT_R16G16_SNORM:
+ case DXGI_FORMAT_R16G16_SINT:
+ case DXGI_FORMAT_R32_TYPELESS:
+ case DXGI_FORMAT_D32_FLOAT:
+ case DXGI_FORMAT_R32_FLOAT:
+ case DXGI_FORMAT_R32_UINT:
+ case DXGI_FORMAT_R32_SINT:
+ case DXGI_FORMAT_R24G8_TYPELESS:
+ case DXGI_FORMAT_D24_UNORM_S8_UINT:
+ case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
+ case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
+ case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
+ case DXGI_FORMAT_R8G8_B8G8_UNORM:
+ case DXGI_FORMAT_G8R8_G8B8_UNORM:
+ case DXGI_FORMAT_B8G8R8A8_UNORM:
+ case DXGI_FORMAT_B8G8R8X8_UNORM:
+ case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
+ case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+ case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+ case DXGI_FORMAT_B8G8R8X8_TYPELESS:
+ case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+ case DXGI_FORMAT_AYUV:
+ case DXGI_FORMAT_Y410:
+ case DXGI_FORMAT_YUY2:
+ return 32;
+ case DXGI_FORMAT_P010:
+ case DXGI_FORMAT_P016:
+ return 24;
+ case DXGI_FORMAT_R8G8_TYPELESS:
+ case DXGI_FORMAT_R8G8_UNORM:
+ case DXGI_FORMAT_R8G8_UINT:
+ case DXGI_FORMAT_R8G8_SNORM:
+ case DXGI_FORMAT_R8G8_SINT:
+ case DXGI_FORMAT_R16_TYPELESS:
+ case DXGI_FORMAT_R16_FLOAT:
+ case DXGI_FORMAT_D16_UNORM:
+ case DXGI_FORMAT_R16_UNORM:
+ case DXGI_FORMAT_R16_UINT:
+ case DXGI_FORMAT_R16_SNORM:
+ case DXGI_FORMAT_R16_SINT:
+ case DXGI_FORMAT_B5G6R5_UNORM:
+ case DXGI_FORMAT_B5G5R5A1_UNORM:
+ case DXGI_FORMAT_A8P8:
+ case DXGI_FORMAT_B4G4R4A4_UNORM:
+ return 16;
+ case DXGI_FORMAT_NV12:
+ case DXGI_FORMAT_420_OPAQUE:
+ case DXGI_FORMAT_NV11:
+ return 12;
+ case DXGI_FORMAT_R8_TYPELESS:
+ case DXGI_FORMAT_R8_UNORM:
+ case DXGI_FORMAT_R8_UINT:
+ case DXGI_FORMAT_R8_SNORM:
+ case DXGI_FORMAT_R8_SINT:
+ case DXGI_FORMAT_A8_UNORM:
+ case DXGI_FORMAT_AI44:
+ case DXGI_FORMAT_IA44:
+ case DXGI_FORMAT_P8:
+ case DXGI_FORMAT_BC2_TYPELESS:
+ case DXGI_FORMAT_BC2_UNORM:
+ case DXGI_FORMAT_BC2_UNORM_SRGB:
+ case DXGI_FORMAT_BC3_TYPELESS:
+ case DXGI_FORMAT_BC3_UNORM:
+ case DXGI_FORMAT_BC3_UNORM_SRGB:
+ case DXGI_FORMAT_BC5_TYPELESS:
+ case DXGI_FORMAT_BC5_UNORM:
+ case DXGI_FORMAT_BC5_SNORM:
+ case DXGI_FORMAT_BC6H_TYPELESS:
+ case DXGI_FORMAT_BC6H_UF16:
+ case DXGI_FORMAT_BC6H_SF16:
+ case DXGI_FORMAT_BC7_TYPELESS:
+ case DXGI_FORMAT_BC7_UNORM:
+ case DXGI_FORMAT_BC7_UNORM_SRGB:
+ return 8;
+ case DXGI_FORMAT_BC1_TYPELESS:
+ case DXGI_FORMAT_BC1_UNORM:
+ case DXGI_FORMAT_BC1_UNORM_SRGB:
+ case DXGI_FORMAT_BC4_TYPELESS:
+ case DXGI_FORMAT_BC4_UNORM:
+ case DXGI_FORMAT_BC4_SNORM:
+ return 4;
+ case DXGI_FORMAT_R1_UNORM:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static const struct
+{
+ const GUID *wic_guid;
+ DXGI_FORMAT dxgi_format;
+}
+wic_pixel_formats[] =
+{
+ { &GUID_WICPixelFormatBlackWhite, DXGI_FORMAT_R1_UNORM },
+ { &GUID_WICPixelFormat8bppAlpha, DXGI_FORMAT_A8_UNORM },
+ { &GUID_WICPixelFormat8bppGray, DXGI_FORMAT_R8_UNORM },
+ { &GUID_WICPixelFormat16bppGray, DXGI_FORMAT_R16_UNORM },
+ { &GUID_WICPixelFormat16bppGrayHalf, DXGI_FORMAT_R16_FLOAT },
+ { &GUID_WICPixelFormat32bppGrayFloat, DXGI_FORMAT_R32_FLOAT },
+ { &GUID_WICPixelFormat16bppBGR565, DXGI_FORMAT_B5G6R5_UNORM },
+ { &GUID_WICPixelFormat16bppBGRA5551, DXGI_FORMAT_B5G5R5A1_UNORM },
+ { &GUID_WICPixelFormat32bppBGR, DXGI_FORMAT_B8G8R8X8_UNORM },
+ { &GUID_WICPixelFormat32bppBGRA, DXGI_FORMAT_B8G8R8A8_UNORM },
+ { &GUID_WICPixelFormat32bppRGBA, DXGI_FORMAT_R8G8B8A8_UNORM },
+ { &GUID_WICPixelFormat32bppRGBA, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB },
+ { &GUID_WICPixelFormat32bppRGBA1010102, DXGI_FORMAT_R10G10B10A2_UNORM },
+ { &GUID_WICPixelFormat32bppRGBA1010102XR, DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM },
+ { &GUID_WICPixelFormat64bppRGBA, DXGI_FORMAT_R16G16B16A16_UNORM },
+ { &GUID_WICPixelFormat64bppRGBAHalf, DXGI_FORMAT_R16G16B16A16_FLOAT },
+ { &GUID_WICPixelFormat96bppRGBFloat, DXGI_FORMAT_R32G32B32_FLOAT },
+ { &GUID_WICPixelFormat128bppRGBAFloat, DXGI_FORMAT_R32G32B32A32_FLOAT }
+};
+
+static const GUID *dxgi_format_to_wic_guid(DXGI_FORMAT format)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(wic_pixel_formats); ++i)
+ {
+ if (wic_pixel_formats[i].dxgi_format == format)
+ return wic_pixel_formats[i].wic_guid;
+ }
+
+ return NULL;
}
+HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT sdk_version, IWICImagingFactory **imaging_factory);
+
+HRESULT WINAPI D3DX11CreateTextureFromMemory(ID3D11Device *device, const void *src_data,
+ SIZE_T src_data_size, D3DX11_IMAGE_LOAD_INFO *load_info, ID3DX11ThreadPump *pump,
+ ID3D11Resource **texture, HRESULT *hresult)
+ {
+ unsigned int frame_count, width, height, stride, frame_size;
+ IWICFormatConverter *converter = NULL;
+ IWICDdsFrameDecode *dds_frame = NULL;
+ D3D11_TEXTURE2D_DESC texture_2d_desc;
+ D3D11_SUBRESOURCE_DATA resource_data;
+ IWICBitmapFrameDecode *frame = NULL;
+ IWICImagingFactory *factory = NULL;
+ IWICBitmapDecoder *decoder = NULL;
+ ID3D11Texture2D *texture_2d;
+ D3DX11_IMAGE_INFO img_info;
+ IWICStream *stream = NULL;
+ const GUID *dst_format;
+ BYTE *buffer = NULL;
+ BOOL can_convert;
+ GUID src_format;
+ HRESULT hr;
+
+ TRACE("device %p, data %p, data_size %Iu, load_info %p, pump %p, texture %p, hresult %p.\n",
+ device, src_data, src_data_size, load_info, pump, texture, hresult);
+
+ if (!src_data || !src_data_size || !texture)
+ return E_FAIL;
+ if (pump)
+ FIXME("Thread pump is not supported yet.\n");
+
+ if (load_info)
+ {
+ img_info.Width = load_info->Width;
+ img_info.Height = load_info->Height;
+ img_info.Depth = load_info->Depth;
+ img_info.ArraySize = 1;
+ img_info.MipLevels = load_info->MipLevels;
+ img_info.MiscFlags = load_info->MiscFlags;
+ img_info.Format = load_info->Format;
+ }
+ else
+ {
+ if (FAILED(D3DX11GetImageInfoFromMemory(src_data, src_data_size, NULL, &img_info, NULL)))
+ return E_FAIL;
+ if (img_info.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE)
+ {
+ FIXME("Cube map is not supported.\n");
+ return E_FAIL;
+ }
+ }
+
+ if (FAILED(hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory)))
+ goto end;
+ if (FAILED(hr = IWICImagingFactory_CreateStream(factory, &stream)))
+ goto end;
+ if (FAILED(hr = IWICStream_InitializeFromMemory(stream, (BYTE *)src_data, src_data_size)))
+ goto end;
+ if (FAILED(hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream *)stream, NULL, 0, &decoder)))
+ goto end;
+ if (FAILED(hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count)) || !frame_count)
+ goto end;
+ if (FAILED(hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame)))
+ goto end;
+ if (FAILED(hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &src_format)))
+ goto end;
+
+ width = img_info.Width;
+ height = img_info.Height;
+ if (is_block_compressed(img_info.Format))
+ {
+ width = (width + 3) & ~3;
+ height = (height + 3) & ~3;
+ }
+ stride = (width * get_bpp_from_format(img_info.Format) + 7) / 8;
+ frame_size = stride * height;
+
+ if (!(buffer = heap_alloc(frame_size)))
+ {
+ hr = E_FAIL;
+ goto end;
+ }
+
+ if (is_block_compressed(img_info.Format))
+ {
+ if (FAILED(hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICDdsFrameDecode, (void **)&dds_frame)))
+ goto end;
+ if (FAILED(hr = IWICDdsFrameDecode_CopyBlocks(dds_frame, NULL, stride * 4, frame_size, buffer)))
+ goto end;
+ }
+ else
+ {
+ if (!(dst_format = dxgi_format_to_wic_guid(img_info.Format)))
+ {
+ hr = E_FAIL;
+ FIXME("Unsupported DXGI format %#x.\n", img_info.Format);
+ goto end;
+ }
+
+ if (IsEqualGUID(&src_format, dst_format))
+ {
+ if (FAILED(hr = IWICBitmapFrameDecode_CopyPixels(frame, NULL, stride, frame_size, buffer)))
+ goto end;
+ }
+ else
+ {
+ if (FAILED(hr = IWICImagingFactory_CreateFormatConverter(factory, &converter)))
+ goto end;
+ if (FAILED(hr = IWICFormatConverter_CanConvert(converter, &src_format, dst_format, &can_convert)))
+ goto end;
+ if (!can_convert)
+ {
+ WARN("Format converting %s to %s is not supported by WIC.\n",
+ debugstr_guid(&src_format), debugstr_guid(dst_format));
+ goto end;
+ }
+ if (FAILED(hr = IWICFormatConverter_Initialize(converter, (IWICBitmapSource *)frame, dst_format,
+ WICBitmapDitherTypeErrorDiffusion, 0, 0, WICBitmapPaletteTypeCustom)))
+ goto end;
+ if (FAILED(hr = IWICFormatConverter_CopyPixels(converter, NULL, stride, frame_size, buffer)))
+ goto end;
+ }
+ }
+
+ memset(&texture_2d_desc, 0, sizeof(texture_2d_desc));
+ texture_2d_desc.Width = width;
+ texture_2d_desc.Height = height;
+ texture_2d_desc.MipLevels = 1;
+ texture_2d_desc.ArraySize = img_info.ArraySize;
+ texture_2d_desc.Format = img_info.Format;
+ texture_2d_desc.SampleDesc.Count = 1;
+ texture_2d_desc.Usage = D3D11_USAGE_DEFAULT;
+ texture_2d_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+ texture_2d_desc.MiscFlags = img_info.MiscFlags;
+
+ resource_data.pSysMem = buffer;
+ resource_data.SysMemPitch = stride;
+ resource_data.SysMemSlicePitch = frame_size;
+
+ if (FAILED(hr = ID3D11Device_CreateTexture2D(device, &texture_2d_desc, &resource_data, &texture_2d)))
+ goto end;
+
+ *texture = (ID3D11Resource *)texture_2d;
+ hr = S_OK;
+
+end:
+ if (converter)
+ IWICFormatConverter_Release(converter);
+ if (dds_frame)
+ IWICDdsFrameDecode_Release(dds_frame);
+ if (buffer)
+ heap_free(buffer);
+ if (frame)
+ IWICBitmapFrameDecode_Release(frame);
+ if (decoder)
+ IWICBitmapDecoder_Release(decoder);
+ if (stream)
+ IWICStream_Release(stream);
+ if (factory)
+ IWICImagingFactory_Release(factory);
+
+ return hr;
+ }
+
HRESULT WINAPI D3DX11SaveTextureToFileW(ID3D11DeviceContext *context, ID3D11Resource *texture,
D3DX11_IMAGE_FILE_FORMAT format, const WCHAR *filename)
{
--
2.51.0

37
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0001-d3dx9-Add-an-optimization-to-stb_dxt.patch Normal file
View File

@@ -0,0 +1,37 @@
From 4d8b800f0ebe625824b12b081026283e4c3c1efc Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Thu, 8 Aug 2024 07:30:25 -0400
Subject: [PATCH] d3dx9: Add an optimization to stb_dxt.
This optimzation helps us to more closely match the output of native
d3dx's DXT compression, which helps with d3dx10 tests.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx9_36/stb_dxt.h | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/dlls/d3dx9_36/stb_dxt.h b/dlls/d3dx9_36/stb_dxt.h
index c25f6b015da..2b40829deac 100644
--- a/dlls/d3dx9_36/stb_dxt.h
+++ b/dlls/d3dx9_36/stb_dxt.h
@@ -565,6 +565,16 @@ static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int
dest[1] = (unsigned char)mn;
dest += 2;
+ /*
+ * Wine specific optimization to more closely match Windows behavior: If
+ * max is equal to minimum, just set all bits to 0 (which means the value
+ * is the value of max in this case).
+ */
+ if (mx == mn) {
+ memset(dest, 0, 6);
+ return;
+ }
+
// determine bias and emit color indices
// given the choice of mx/mn, these indices are optimal:
// http://fgiesen.wordpress.com/2009/12/15/dxt5-alpha-block-index-determination/
--
2.51.0

222
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0002-d3dx10-Use-shared-code-in-load_texture_data-when-pos.patch Normal file
View File

@@ -0,0 +1,222 @@
From 3f2a65b69375bc84e10f4a4cc32c1d7ed34d4acb Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Mon, 15 Sep 2025 14:23:52 -0400
Subject: [PATCH] d3dx10: Use shared code in load_texture_data() when possible.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 2 +-
dlls/d3dx10_43/texture.c | 112 +++++++++++++++++++++++++++++++++-
dlls/d3dx9_36/d3dx_helpers.c | 6 +-
dlls/d3dx9_36/d3dx_helpers.h | 4 ++
4 files changed, 118 insertions(+), 6 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 75e4b4023d8..119b74c7ece 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -1579,7 +1579,7 @@ static void check_texture2d_data(ID3D10Texture2D *texture, const struct test_ima
{
line_match = !memcmp(expected_data + stride * i,
(BYTE *)map.pData + map.RowPitch * i, stride);
- todo_wine_if(is_block_compressed(image->expected_info.Format)
+ todo_wine_if(is_block_compressed(image->expected_info.Format) && image->data != test_dds_dxt5
&& (image->expected_info.Width % 4 != 0 || image->expected_info.Height % 4 != 0))
ok_(__FILE__, line)(line_match, "Data mismatch for line %u, array slice %u.\n", i, array_slice);
if (!line_match)
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index ab488dcfa2f..f578ab0f789 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -873,6 +873,93 @@ static HRESULT convert_image(IWICImagingFactory *factory, IWICBitmapFrameDecode
return hr;
}
+static HRESULT d3dx_load_texture_data(struct d3dx_image *image, D3DX10_IMAGE_LOAD_INFO *load_info,
+ const D3DX10_IMAGE_INFO *img_info, D3D10_SUBRESOURCE_DATA **resource_data)
+{
+ const struct pixel_format_desc *fmt_desc, *src_desc;
+ D3DX10_IMAGE_LOAD_INFO tmp_load_info = *load_info;
+ uint32_t i, j, pixels_size, pixels_offset;
+ uint8_t *res_data = NULL, *pixels_buffer;
+ HRESULT hr = S_OK;
+
+ if (img_info->ImageFileFormat == D3DX10_IFF_BMP)
+ return E_NOTIMPL;
+
+ fmt_desc = get_d3dx_pixel_format_info(d3dx_pixel_format_id_from_dxgi_format(img_info->Format));
+ if (fmt_desc->format == D3DX_PIXEL_FORMAT_COUNT)
+ {
+ FIXME("Unknown DXGI format supplied, %#x.\n", img_info->Format);
+ return E_NOTIMPL;
+ }
+
+ /* Potentially round up width/height to align with block size. */
+ tmp_load_info.Width = (img_info->Width + fmt_desc->block_width - 1) & ~(fmt_desc->block_width - 1);
+ tmp_load_info.Height = (img_info->Height + fmt_desc->block_height - 1) & ~(fmt_desc->block_height - 1);
+ tmp_load_info.Depth = img_info->Depth;
+ tmp_load_info.MipLevels = img_info->MipLevels;
+ tmp_load_info.Format = img_info->Format;
+
+ pixels_size = d3dx_calculate_layer_pixels_size(fmt_desc->format, tmp_load_info.Width, tmp_load_info.Height,
+ tmp_load_info.Depth, tmp_load_info.MipLevels) * img_info->ArraySize;
+ pixels_offset = (sizeof(**resource_data) * tmp_load_info.MipLevels * img_info->ArraySize);
+ if (!(res_data = malloc(pixels_size + pixels_offset)))
+ return E_FAIL;
+
+ pixels_buffer = res_data + pixels_offset;
+ *resource_data = (D3D10_SUBRESOURCE_DATA *)res_data;
+
+ src_desc = get_d3dx_pixel_format_info(image->format);
+ for (i = 0; i < img_info->ArraySize; ++i)
+ {
+ struct volume dst_size = { tmp_load_info.Width, tmp_load_info.Height, tmp_load_info.Depth };
+
+ for (j = 0; j < tmp_load_info.MipLevels; ++j)
+ {
+ const RECT unaligned_rect = { 0, 0, dst_size.width, dst_size.height };
+ struct d3dx_pixels src_pixels, dst_pixels;
+ uint32_t dst_row_pitch, dst_slice_pitch;
+
+ hr = d3dx_image_get_pixels(image, i, j, &src_pixels);
+ if (FAILED(hr))
+ break;
+
+ hr = d3dx_calculate_pixels_size(fmt_desc->format, dst_size.width, dst_size.height, &dst_row_pitch,
+ &dst_slice_pitch);
+ if (FAILED(hr))
+ break;
+
+ set_d3dx_pixels(&dst_pixels, pixels_buffer, dst_row_pitch, dst_slice_pitch, NULL, dst_size.width,
+ dst_size.height, dst_size.depth, &unaligned_rect);
+
+ hr = d3dx_load_pixels_from_pixels(&dst_pixels, fmt_desc, &src_pixels, src_desc, D3DX10_FILTER_POINT, 0);
+ if (FAILED(hr))
+ break;
+
+ (*resource_data)[i * tmp_load_info.MipLevels + j].pSysMem = pixels_buffer;
+ (*resource_data)[i * tmp_load_info.MipLevels + j].SysMemPitch = dst_row_pitch;
+ (*resource_data)[i * tmp_load_info.MipLevels + j].SysMemSlicePitch = dst_slice_pitch;
+
+ pixels_buffer += dst_slice_pitch * dst_size.depth;
+ d3dx_get_next_mip_level_size(&dst_size);
+ }
+ }
+
+ if (FAILED(hr))
+ {
+ *resource_data = NULL;
+ free(res_data);
+ return hr;
+ }
+
+ *load_info = tmp_load_info;
+ load_info->Usage = D3D10_USAGE_DEFAULT;
+ load_info->BindFlags = D3D10_BIND_SHADER_RESOURCE;
+ load_info->CpuAccessFlags = 0;
+ load_info->MiscFlags = img_info->MiscFlags;
+
+ return S_OK;
+}
+
HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO *load_info,
D3D10_SUBRESOURCE_DATA **resource_data)
{
@@ -885,9 +972,13 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
BYTE *res_data = NULL, *buffer;
D3DX10_IMAGE_INFO img_info;
IWICStream *stream = NULL;
+ struct d3dx_image image;
const GUID *dst_format;
HRESULT hr;
+ if (!data || !size)
+ return E_FAIL;
+
if (load_info->Width != D3DX10_DEFAULT)
FIXME("load_info->Width is ignored.\n");
if (load_info->Height != D3DX10_DEFAULT)
@@ -915,15 +1006,32 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
if (load_info->pSrcInfo)
FIXME("load_info->pSrcInfo is ignored.\n");
- if (FAILED(D3DX10GetImageInfoFromMemory(data, size, NULL, &img_info, NULL)))
+ hr = d3dx_image_init(data, size, &image, 0, D3DX_IMAGE_SUPPORT_DXT10);
+ if (FAILED(hr))
return E_FAIL;
+
+ hr = d3dx10_image_info_from_d3dx_image(&img_info, &image);
+ if (FAILED(hr))
+ {
+ WARN("Invalid or unsupported image file, hr %#lx.\n", hr);
+ hr = E_FAIL;
+ goto end;
+ }
+
if ((!(img_info.MiscFlags & D3D10_RESOURCE_MISC_TEXTURECUBE) || img_info.ArraySize != 6)
&& img_info.ArraySize != 1)
{
FIXME("img_info.ArraySize = %u not supported.\n", img_info.ArraySize);
- return E_NOTIMPL;
+ hr = E_NOTIMPL;
+ goto end;
}
+ if (SUCCEEDED(hr = d3dx_load_texture_data(&image, load_info, &img_info, resource_data)))
+ {
+ TRACE("Successfully used shared code to load texture data.\n");
+ res_data = NULL;
+ goto end;
+ }
if (FAILED(hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory)))
goto end;
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index 60394ca1d9b..76763c4521f 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -377,7 +377,7 @@ static HRESULT dds_pixel_format_from_d3dx_pixel_format_id(struct dds_pixel_forma
return D3D_OK;
}
-static enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(DXGI_FORMAT format)
+enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(uint32_t format)
{
switch (format)
{
@@ -417,7 +417,7 @@ static enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(DXGI_FORM
}
}
-static void d3dx_get_next_mip_level_size(struct volume *size)
+void d3dx_get_next_mip_level_size(struct volume *size)
{
size->width = max(size->width / 2, 1);
size->height = max(size->height / 2, 1);
@@ -431,7 +431,7 @@ static const char *debug_volume(const struct volume *volume)
return wine_dbg_sprintf("(%ux%ux%u)", volume->width, volume->height, volume->depth);
}
-static HRESULT d3dx_calculate_pixels_size(enum d3dx_pixel_format_id format, uint32_t width, uint32_t height,
+HRESULT d3dx_calculate_pixels_size(enum d3dx_pixel_format_id format, uint32_t width, uint32_t height,
uint32_t *pitch, uint32_t *size)
{
const struct pixel_format_desc *format_desc = get_d3dx_pixel_format_info(format);
diff --git a/dlls/d3dx9_36/d3dx_helpers.h b/dlls/d3dx9_36/d3dx_helpers.h
index 8263d832bfa..91839296b47 100644
--- a/dlls/d3dx9_36/d3dx_helpers.h
+++ b/dlls/d3dx9_36/d3dx_helpers.h
@@ -391,6 +391,10 @@ void format_to_d3dx_color(const struct pixel_format_desc *format, const BYTE *sr
struct d3dx_color *dst);
void format_from_d3dx_color(const struct pixel_format_desc *format, const struct d3dx_color *src, BYTE *dst);
+enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(uint32_t format);
+void d3dx_get_next_mip_level_size(struct volume *size);
+HRESULT d3dx_calculate_pixels_size(enum d3dx_pixel_format_id format, uint32_t width, uint32_t height,
+ uint32_t *pitch, uint32_t *size);
uint32_t d3dx_calculate_layer_pixels_size(enum d3dx_pixel_format_id format, uint32_t width, uint32_t height,
uint32_t depth, uint32_t mip_levels);
HRESULT d3dx_init_dds_header(struct dds_header *header, enum d3dx_resource_type resource_type,
--
2.51.0

25
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0002-d3dx9-Add-support-for-GUID_WICPixelFormat16bppGray.patch
View File

@@ -1,25 +0,0 @@
From 3c5ed75d72440b3c1ff668c3aece8216b561bece Mon Sep 17 00:00:00 2001
From: Alistair Leslie-Hughes <leslie_alistair@hotmail.com>
Date: Sat, 13 Sep 2025 08:17:15 +1000
Subject: [PATCH] d3dx9: Add support for GUID_WICPixelFormat16bppGray
Stop error with HighFleet on startup.
---
dlls/d3dx9_36/d3dx_helpers.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index 60394ca1d9b..26b00191b68 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -140,6 +140,7 @@ static const struct
{ &GUID_WICPixelFormat2bppIndexed, D3DX_PIXEL_FORMAT_P2_UINT },
{ &GUID_WICPixelFormat4bppIndexed, D3DX_PIXEL_FORMAT_P4_UINT },
{ &GUID_WICPixelFormat8bppGray, D3DX_PIXEL_FORMAT_L8_UNORM },
+ { &GUID_WICPixelFormat16bppGray, D3DX_PIXEL_FORMAT_R16_UNORM },
{ &GUID_WICPixelFormat16bppBGR555, D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM },
{ &GUID_WICPixelFormat16bppBGR565, D3DX_PIXEL_FORMAT_B5G6R5_UNORM },
{ &GUID_WICPixelFormat24bppBGR, D3DX_PIXEL_FORMAT_B8G8R8_UNORM },
--
2.51.0

119
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0003-d3dx10-Add-support-for-decompressing-BC4-and-BC5-for.patch Normal file
View File

@@ -0,0 +1,119 @@
From 38bc3286663b541150cfd34e01b33ee09f738ab7 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Mon, 15 Sep 2025 14:39:47 -0400
Subject: [PATCH] d3dx10: Add support for decompressing BC4 and BC5 formats.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/texture.c | 1 +
dlls/d3dx9_36/bcdec.h | 6 +++---
dlls/d3dx9_36/d3dx_helpers.c | 21 +++++++++++++++++++++
dlls/d3dx9_36/d3dx_helpers.h | 1 +
4 files changed, 26 insertions(+), 3 deletions(-)
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index f578ab0f789..a3acd063ac9 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -113,6 +113,7 @@ static DXGI_FORMAT dxgi_format_from_d3dx_pixel_format_id(enum d3dx_pixel_format_
case D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM: return DXGI_FORMAT_R10G10B10A2_UNORM;
case D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM;
case D3DX_PIXEL_FORMAT_R8_UNORM: return DXGI_FORMAT_R8_UNORM;
+ case D3DX_PIXEL_FORMAT_R8_SNORM: return DXGI_FORMAT_R8_SNORM;
case D3DX_PIXEL_FORMAT_R8G8_UNORM: return DXGI_FORMAT_R8G8_UNORM;
case D3DX_PIXEL_FORMAT_R16_UNORM: return DXGI_FORMAT_R16_UNORM;
case D3DX_PIXEL_FORMAT_R16G16_UNORM: return DXGI_FORMAT_R16G16_UNORM;
diff --git a/dlls/d3dx9_36/bcdec.h b/dlls/d3dx9_36/bcdec.h
index 5ead984c466..1b57a454926 100644
--- a/dlls/d3dx9_36/bcdec.h
+++ b/dlls/d3dx9_36/bcdec.h
@@ -90,9 +90,9 @@
BCDECDEF void bcdec_bc1(const void* compressedBlock, void* decompressedBlock, int destinationPitch);
BCDECDEF void bcdec_bc2(const void* compressedBlock, void* decompressedBlock, int destinationPitch);
BCDECDEF void bcdec_bc3(const void* compressedBlock, void* decompressedBlock, int destinationPitch);
-#ifdef WINE_UNUSED /* unused for now in Wine */
BCDECDEF void bcdec_bc4(const void* compressedBlock, void* decompressedBlock, int destinationPitch);
BCDECDEF void bcdec_bc5(const void* compressedBlock, void* decompressedBlock, int destinationPitch);
+#ifdef WINE_UNUSED /* unused for now in Wine */
BCDECDEF void bcdec_bc6h_float(const void* compressedBlock, void* decompressedBlock, int destinationPitch, int isSigned);
BCDECDEF void bcdec_bc6h_half(const void* compressedBlock, void* decompressedBlock, int destinationPitch, int isSigned);
BCDECDEF void bcdec_bc7(const void* compressedBlock, void* decompressedBlock, int destinationPitch);
@@ -275,8 +275,6 @@ BCDECDEF void bcdec_bc3(const void* compressedBlock, void* decompressedBlock, in
bcdec__smooth_alpha_block(compressedBlock, ((char*)decompressedBlock) + 3, destinationPitch, 4);
}
-#ifdef WINE_UNUSED /* unused for now in Wine */
-
BCDECDEF void bcdec_bc4(const void* compressedBlock, void* decompressedBlock, int destinationPitch) {
bcdec__smooth_alpha_block(compressedBlock, decompressedBlock, destinationPitch, 1);
}
@@ -286,6 +284,8 @@ BCDECDEF void bcdec_bc5(const void* compressedBlock, void* decompressedBlock, in
bcdec__smooth_alpha_block(((char*)compressedBlock) + 8, ((char*)decompressedBlock) + 1, destinationPitch, 2);
}
+#ifdef WINE_UNUSED /* unused for now in Wine */
+
/* http://graphics.stanford.edu/~seander/bithacks.html#VariableSignExtend */
static int bcdec__extend_sign(int val, int bits) {
return (val << (32 - bits)) >> (32 - bits);
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index 76763c4521f..afbacecf320 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -81,6 +81,7 @@ static const struct pixel_format_desc formats[] =
{D3DX_PIXEL_FORMAT_R16G16B16_UNORM, { 0, 16, 16, 16}, { 0, 0, 16, 32}, 6, 1, 1, 6, CTYPE_EMPTY, CTYPE_UNORM, FMT_FLAG_INTERNAL},
{D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM, {16, 16, 16, 16}, {48, 0, 16, 32}, 8, 1, 1, 8, CTYPE_UNORM, CTYPE_UNORM, 0 },
{D3DX_PIXEL_FORMAT_R8_UNORM, { 0, 8, 0, 0}, { 0, 0, 0, 0}, 1, 1, 1, 1, CTYPE_EMPTY, CTYPE_UNORM, FMT_FLAG_DXGI},
+ {D3DX_PIXEL_FORMAT_R8_SNORM, { 0, 8, 0, 0}, { 0, 0, 0, 0}, 1, 1, 1, 1, CTYPE_EMPTY, CTYPE_SNORM, FMT_FLAG_DXGI},
{D3DX_PIXEL_FORMAT_R8G8_UNORM, { 0, 8, 8, 0}, { 0, 0, 8, 0}, 2, 1, 1, 2, CTYPE_EMPTY, CTYPE_UNORM, FMT_FLAG_DXGI},
{D3DX_PIXEL_FORMAT_R16_UNORM, { 0, 16, 0, 0}, { 0, 0, 0, 0}, 2, 1, 1, 2, CTYPE_EMPTY, CTYPE_UNORM, FMT_FLAG_DXGI},
{D3DX_PIXEL_FORMAT_R16G16_UNORM, { 0, 16, 16, 0}, { 0, 0, 16, 0}, 4, 1, 1, 4, CTYPE_EMPTY, CTYPE_UNORM, 0 },
@@ -390,6 +391,7 @@ enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(uint32_t format)
case DXGI_FORMAT_R10G10B10A2_UNORM: return D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM;
case DXGI_FORMAT_R16G16B16A16_UNORM: return D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM;
case DXGI_FORMAT_R8_UNORM: return D3DX_PIXEL_FORMAT_R8_UNORM;
+ case DXGI_FORMAT_R8_SNORM: return D3DX_PIXEL_FORMAT_R8_SNORM;
case DXGI_FORMAT_R8G8_UNORM: return D3DX_PIXEL_FORMAT_R8G8_UNORM;
case DXGI_FORMAT_R16_UNORM: return D3DX_PIXEL_FORMAT_R16_UNORM;
case DXGI_FORMAT_R16G16_UNORM: return D3DX_PIXEL_FORMAT_R16G16_UNORM;
@@ -2553,6 +2555,25 @@ static HRESULT d3dx_pixels_decompress(struct d3dx_pixels *pixels, const struct p
decompress_bcn_block = bcdec_bc3;
break;
+ case D3DX_PIXEL_FORMAT_BC4_UNORM:
+ case D3DX_PIXEL_FORMAT_BC4_SNORM:
+ if (desc->rgb_type == CTYPE_UNORM)
+ uncompressed_desc = get_d3dx_pixel_format_info(D3DX_PIXEL_FORMAT_R8_UNORM);
+ else
+ uncompressed_desc = get_d3dx_pixel_format_info(D3DX_PIXEL_FORMAT_R8_SNORM);
+ decompress_bcn_block = bcdec_bc4;
+ break;
+
+ case D3DX_PIXEL_FORMAT_BC5_UNORM:
+ case D3DX_PIXEL_FORMAT_BC5_SNORM:
+ if (desc->rgb_type == CTYPE_UNORM)
+ uncompressed_desc = get_d3dx_pixel_format_info(D3DX_PIXEL_FORMAT_R8G8_UNORM);
+ else
+ uncompressed_desc = get_d3dx_pixel_format_info(D3DX_PIXEL_FORMAT_R8G8_SNORM);
+ decompress_bcn_block = bcdec_bc5;
+ break;
+
+
default:
FIXME("Unexpected compressed texture format %u.\n", desc->format);
return E_NOTIMPL;
diff --git a/dlls/d3dx9_36/d3dx_helpers.h b/dlls/d3dx9_36/d3dx_helpers.h
index 91839296b47..663febd279b 100644
--- a/dlls/d3dx9_36/d3dx_helpers.h
+++ b/dlls/d3dx9_36/d3dx_helpers.h
@@ -188,6 +188,7 @@ enum d3dx_pixel_format_id
D3DX_PIXEL_FORMAT_R16G16B16_UNORM,
D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM,
D3DX_PIXEL_FORMAT_R8_UNORM,
+ D3DX_PIXEL_FORMAT_R8_SNORM,
D3DX_PIXEL_FORMAT_R8G8_UNORM,
D3DX_PIXEL_FORMAT_R16_UNORM,
D3DX_PIXEL_FORMAT_R16G16_UNORM,
--
2.51.0

49
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0003-d3dx9_36-Use-correct-pixel-type-for-DXT-format.patch
View File

@@ -1,49 +0,0 @@
From 9d0bf8024bf5d97540fd1fa7456766fea808bc20 Mon Sep 17 00:00:00 2001
From: Alistair Leslie-Hughes <leslie_alistair@hotmail.com>
Date: Sat, 13 Sep 2025 08:17:15 +1000
Subject: [PATCH] d3dx9_36: Use correct pixel type for DXT* format
Required for Puyo-Puyo tetris.
---
dlls/d3dx9_36/d3dx_helpers.c | 18 ++++++++++++++++--
1 file changed, 16 insertions(+), 2 deletions(-)
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index 26b00191b68..694b1b53548 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -290,8 +290,8 @@ static enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dds_pixel_format(cons
{
uint32_t i;
- TRACE("pixel_format: size %lu, flags %#lx, fourcc %#lx, bpp %lu.\n", pixel_format->size,
- pixel_format->flags, pixel_format->fourcc, pixel_format->bpp);
+ TRACE("pixel_format: size %lu, flags %#lx, fourcc %s, bpp %lu.\n", pixel_format->size,
+ pixel_format->flags, debugstr_fourcc(pixel_format->fourcc), pixel_format->bpp);
TRACE("rmask %#lx, gmask %#lx, bmask %#lx, amask %#lx.\n", pixel_format->rmask, pixel_format->gmask,
pixel_format->bmask, pixel_format->amask);
@@ -1152,6 +1152,20 @@ static HRESULT d3dx_initialize_image_from_dds(const void *src_data, uint32_t src
if ((image->format = d3dx_pixel_format_id_from_dds_pixel_format(&header->pixel_format)) == D3DX_PIXEL_FORMAT_COUNT)
return D3DXERR_INVALIDDATA;
+ switch (image->format)
+ {
+ case D3DX_PIXEL_FORMAT_DXT1_UNORM:
+ case D3DX_PIXEL_FORMAT_DXT2_UNORM:
+ case D3DX_PIXEL_FORMAT_DXT3_UNORM:
+ case D3DX_PIXEL_FORMAT_DXT4_UNORM:
+ case D3DX_PIXEL_FORMAT_DXT5_UNORM:
+ image->format = D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM;
+ break;
+ default:
+ /* Leave format as is */
+ break;
+ }
+
image->image_file_format = D3DX_IMAGE_FILE_FORMAT_DDS;
image->layer_count = 1;
if (header->flags & DDS_DEPTH)
--
2.51.0

90
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0004-d3dx10-Add-support-for-compressing-BC4-and-BC5-forma.patch Normal file
View File

@@ -0,0 +1,90 @@
From 92319f7205bce8ecb23e3c17141d8a371cb01e47 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Mon, 15 Sep 2025 14:46:56 -0400
Subject: [PATCH] d3dx10: Add support for compressing BC4 and BC5 formats.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx9_36/d3dx_helpers.c | 26 ++++++++++++++++++++++++++
dlls/d3dx9_36/stb_dxt.h | 5 -----
2 files changed, 26 insertions(+), 5 deletions(-)
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index afbacecf320..aae7efccf69 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -2789,6 +2789,16 @@ static void d3dx_compress_block(enum d3dx_pixel_format_id fmt, uint8_t *block_bu
stb_compress_dxt_block(dst_buf, block_buf, TRUE, 0);
break;
+ case D3DX_PIXEL_FORMAT_BC4_UNORM:
+ case D3DX_PIXEL_FORMAT_BC4_SNORM:
+ stb_compress_bc4_block(dst_buf, block_buf);
+ break;
+
+ case D3DX_PIXEL_FORMAT_BC5_UNORM:
+ case D3DX_PIXEL_FORMAT_BC5_SNORM:
+ stb_compress_bc5_block(dst_buf, block_buf);
+ break;
+
default:
assert(0);
break;
@@ -2818,6 +2828,22 @@ static HRESULT d3dx_pixels_compress(struct d3dx_pixels *src_pixels,
assert(src_desc->format == D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM);
break;
+ case D3DX_PIXEL_FORMAT_BC4_UNORM:
+ assert(src_desc->format == D3DX_PIXEL_FORMAT_R8_UNORM);
+ break;
+
+ case D3DX_PIXEL_FORMAT_BC4_SNORM:
+ assert(src_desc->format == D3DX_PIXEL_FORMAT_R8_SNORM);
+ break;
+
+ case D3DX_PIXEL_FORMAT_BC5_UNORM:
+ assert(src_desc->format == D3DX_PIXEL_FORMAT_R8G8_UNORM);
+ break;
+
+ case D3DX_PIXEL_FORMAT_BC5_SNORM:
+ assert(src_desc->format == D3DX_PIXEL_FORMAT_R8G8_SNORM);
+ break;
+
default:
FIXME("Unexpected compressed texture format %u.\n", dst_desc->format);
return E_NOTIMPL;
diff --git a/dlls/d3dx9_36/stb_dxt.h b/dlls/d3dx9_36/stb_dxt.h
index 2b40829deac..46375273e64 100644
--- a/dlls/d3dx9_36/stb_dxt.h
+++ b/dlls/d3dx9_36/stb_dxt.h
@@ -56,10 +56,8 @@ extern "C" {
#define STB_DXT_HIGHQUAL 2 // high quality mode, does two refinement steps instead of 1. ~30-40% slower.
STBDDEF void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src_rgba_four_bytes_per_pixel, int alpha, int mode);
-#ifdef WINE_UNUSED /* unused for now in Wine */
STBDDEF void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src_r_one_byte_per_pixel);
STBDDEF void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src_rg_two_byte_per_pixel);
-#endif /* WINE_UNUSED */
#define STB_COMPRESS_DXT_BLOCK
@@ -626,8 +624,6 @@ void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int a
stb__CompressColorBlock(dest,(unsigned char*) src,mode);
}
-#ifdef WINE_UNUSED /* unused for now in Wine */
-
void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src)
{
stb__CompressAlphaBlock(dest,(unsigned char*) src, 1);
@@ -638,7 +634,6 @@ void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src)
stb__CompressAlphaBlock(dest,(unsigned char*) src,2);
stb__CompressAlphaBlock(dest + 8,(unsigned char*) src+1,2);
}
-#endif /* WINE_UNUSED */
#endif // STB_DXT_IMPLEMENTATION
--
2.51.0

248
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0005-d3dx10-Exclusively-use-shared-code-to-load-DDS-files.patch Normal file
View File

@@ -0,0 +1,248 @@
From a94c1e21dd77923b37d2ce7ad10d3235c148cbb3 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Thu, 8 Aug 2024 09:06:03 -0400
Subject: [PATCH] d3dx10: Exclusively use shared code to load DDS files in
load_texture_data().
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/texture.c | 171 ++++++-----------------------------
dlls/d3dx9_36/d3dx_helpers.c | 4 +
2 files changed, 31 insertions(+), 144 deletions(-)
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index a3acd063ac9..7b2490a4d00 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -805,32 +805,6 @@ void init_load_info(const D3DX10_IMAGE_LOAD_INFO *load_info, D3DX10_IMAGE_LOAD_I
out->pSrcInfo = NULL;
}
-static HRESULT dds_get_frame_info(IWICDdsFrameDecode *frame, const D3DX10_IMAGE_INFO *img_info,
- WICDdsFormatInfo *format_info, unsigned int *stride, unsigned int *frame_size)
-{
- unsigned int width, height;
- HRESULT hr;
-
- if (FAILED(hr = IWICDdsFrameDecode_GetFormatInfo(frame, format_info)))
- return hr;
- if (FAILED(hr = IWICDdsFrameDecode_GetSizeInBlocks(frame, &width, &height)))
- return hr;
-
- if (img_info->Format == format_info->DxgiFormat)
- {
- *stride = width * format_info->BytesPerBlock;
- *frame_size = *stride * height;
- }
- else
- {
- width *= format_info->BlockWidth;
- height *= format_info->BlockHeight;
- *stride = (width * get_bpp_from_format(img_info->Format) + 7) / 8;
- *frame_size = *stride * height;
- }
- return S_OK;
-}
-
static HRESULT convert_image(IWICImagingFactory *factory, IWICBitmapFrameDecode *frame,
const GUID *dst_format, unsigned int stride, unsigned int frame_size, BYTE *buffer)
{
@@ -964,12 +938,10 @@ static HRESULT d3dx_load_texture_data(struct d3dx_image *image, D3DX10_IMAGE_LOA
HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO *load_info,
D3D10_SUBRESOURCE_DATA **resource_data)
{
- unsigned int stride, frame_size, i, j;
- IWICDdsFrameDecode *dds_frame = NULL;
IWICBitmapFrameDecode *frame = NULL;
IWICImagingFactory *factory = NULL;
- IWICDdsDecoder *dds_decoder = NULL;
IWICBitmapDecoder *decoder = NULL;
+ unsigned int stride, frame_size;
BYTE *res_data = NULL, *buffer;
D3DX10_IMAGE_INFO img_info;
IWICStream *stream = NULL;
@@ -1033,6 +1005,10 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
res_data = NULL;
goto end;
}
+ else if (img_info.ImageFileFormat == D3DX10_IFF_DDS)
+ {
+ goto end;
+ }
if (FAILED(hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory)))
goto end;
@@ -1042,122 +1018,32 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
goto end;
if (FAILED(hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream *)stream, NULL, 0, &decoder)))
goto end;
+ if (FAILED(hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame)))
+ goto end;
- if (img_info.ImageFileFormat == D3DX10_IFF_DDS)
- {
- WICDdsFormatInfo format_info;
- size_t size = 0;
-
- if (FAILED(hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICDdsDecoder, (void **)&dds_decoder)))
- goto end;
-
- for (i = 0; i < img_info.ArraySize; ++i)
- {
- for (j = 0; j < img_info.MipLevels; ++j)
- {
- if (FAILED(hr = IWICDdsDecoder_GetFrame(dds_decoder, i, j, 0, &frame)))
- goto end;
- if (FAILED(hr = IWICBitmapFrameDecode_QueryInterface(frame,
- &IID_IWICDdsFrameDecode, (void **)&dds_frame)))
- goto end;
- if (FAILED(hr = dds_get_frame_info(dds_frame, &img_info, &format_info, &stride, &frame_size)))
- goto end;
-
- if (!i && !j)
- {
- img_info.Width = (img_info.Width + format_info.BlockWidth - 1) & ~(format_info.BlockWidth - 1);
- img_info.Height = (img_info.Height + format_info.BlockHeight - 1) & ~(format_info.BlockHeight - 1);
- }
-
- size += sizeof(**resource_data) + frame_size;
-
- IWICDdsFrameDecode_Release(dds_frame);
- dds_frame = NULL;
- IWICBitmapFrameDecode_Release(frame);
- frame = NULL;
- }
- }
-
- if (!(res_data = malloc(size)))
- {
- hr = E_FAIL;
- goto end;
- }
- *resource_data = (D3D10_SUBRESOURCE_DATA *)res_data;
+ stride = (img_info.Width * get_bpp_from_format(img_info.Format) + 7) / 8;
+ frame_size = stride * img_info.Height;
- size = 0;
- for (i = 0; i < img_info.ArraySize; ++i)
- {
- for (j = 0; j < img_info.MipLevels; ++j)
- {
- if (FAILED(hr = IWICDdsDecoder_GetFrame(dds_decoder, i, j, 0, &frame)))
- goto end;
- if (FAILED(hr = IWICBitmapFrameDecode_QueryInterface(frame,
- &IID_IWICDdsFrameDecode, (void **)&dds_frame)))
- goto end;
- if (FAILED(hr = dds_get_frame_info(dds_frame, &img_info, &format_info, &stride, &frame_size)))
- goto end;
-
- buffer = res_data + sizeof(**resource_data) * img_info.ArraySize * img_info.MipLevels + size;
- size += frame_size;
-
- if (img_info.Format == format_info.DxgiFormat)
- {
- if (FAILED(hr = IWICDdsFrameDecode_CopyBlocks(dds_frame, NULL, stride, frame_size, buffer)))
- goto end;
- }
- else
- {
- if (!(dst_format = dxgi_format_to_wic_guid(img_info.Format)))
- {
- hr = E_FAIL;
- FIXME("Unsupported DXGI format %#x.\n", img_info.Format);
- goto end;
- }
- if (FAILED(hr = convert_image(factory, frame, dst_format, stride, frame_size, buffer)))
- goto end;
- }
-
- IWICDdsFrameDecode_Release(dds_frame);
- dds_frame = NULL;
- IWICBitmapFrameDecode_Release(frame);
- frame = NULL;
-
- (*resource_data)[i * img_info.MipLevels + j].pSysMem = buffer;
- (*resource_data)[i * img_info.MipLevels + j].SysMemPitch = stride;
- (*resource_data)[i * img_info.MipLevels + j].SysMemSlicePitch = frame_size;
- }
- }
- }
- else
+ if (!(res_data = malloc(sizeof(**resource_data) + frame_size)))
{
- if (FAILED(hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame)))
- goto end;
-
- stride = (img_info.Width * get_bpp_from_format(img_info.Format) + 7) / 8;
- frame_size = stride * img_info.Height;
-
- if (!(res_data = malloc(sizeof(**resource_data) + frame_size)))
- {
- hr = E_FAIL;
- goto end;
- }
- buffer = res_data + sizeof(**resource_data);
-
- if (!(dst_format = dxgi_format_to_wic_guid(img_info.Format)))
- {
- hr = E_FAIL;
- FIXME("Unsupported DXGI format %#x.\n", img_info.Format);
- goto end;
- }
- if (FAILED(hr = convert_image(factory, frame, dst_format, stride, frame_size, buffer)))
- goto end;
+ hr = E_FAIL;
+ goto end;
+ }
+ buffer = res_data + sizeof(**resource_data);
- *resource_data = (D3D10_SUBRESOURCE_DATA *)res_data;
- (*resource_data)->pSysMem = buffer;
- (*resource_data)->SysMemPitch = stride;
- (*resource_data)->SysMemSlicePitch = frame_size;
+ if (!(dst_format = dxgi_format_to_wic_guid(img_info.Format)))
+ {
+ hr = E_FAIL;
+ FIXME("Unsupported DXGI format %#x.\n", img_info.Format);
+ goto end;
}
+ if (FAILED(hr = convert_image(factory, frame, dst_format, stride, frame_size, buffer)))
+ goto end;
+
+ *resource_data = (D3D10_SUBRESOURCE_DATA *)res_data;
+ (*resource_data)->pSysMem = buffer;
+ (*resource_data)->SysMemPitch = stride;
+ (*resource_data)->SysMemSlicePitch = frame_size;
load_info->Width = img_info.Width;
load_info->Height = img_info.Height;
@@ -1171,10 +1057,7 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
hr = S_OK;
end:
- if (dds_decoder)
- IWICDdsDecoder_Release(dds_decoder);
- if (dds_frame)
- IWICDdsFrameDecode_Release(dds_frame);
+ d3dx_image_cleanup(&image);
free(res_data);
if (frame)
IWICBitmapFrameDecode_Release(frame);
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index aae7efccf69..23b8bdabd6a 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -408,6 +408,10 @@ enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(uint32_t format)
case DXGI_FORMAT_BC1_UNORM: return D3DX_PIXEL_FORMAT_BC1_UNORM;
case DXGI_FORMAT_BC2_UNORM: return D3DX_PIXEL_FORMAT_BC2_UNORM;
case DXGI_FORMAT_BC3_UNORM: return D3DX_PIXEL_FORMAT_BC3_UNORM;
+ case DXGI_FORMAT_BC4_UNORM: return D3DX_PIXEL_FORMAT_BC4_UNORM;
+ case DXGI_FORMAT_BC4_SNORM: return D3DX_PIXEL_FORMAT_BC4_SNORM;
+ case DXGI_FORMAT_BC5_UNORM: return D3DX_PIXEL_FORMAT_BC5_UNORM;
+ case DXGI_FORMAT_BC5_SNORM: return D3DX_PIXEL_FORMAT_BC5_SNORM;
case DXGI_FORMAT_R8G8B8A8_SNORM: return D3DX_PIXEL_FORMAT_R8G8B8A8_SNORM;
case DXGI_FORMAT_R8G8_SNORM: return D3DX_PIXEL_FORMAT_R8G8_SNORM;
case DXGI_FORMAT_R16G16_SNORM: return D3DX_PIXEL_FORMAT_R16G16_SNORM;
--
2.51.0

518
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0006-d3dx10-Exclusively-use-shared-code-in-load_texture_d.patch Normal file
View File

File diff suppressed because it is too large Load Diff

862
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0007-d3dx10-tests-Add-tests-for-the-D3DX10_IMAGE_LOAD_INF.patch Normal file
View File

File diff suppressed because it is too large Load Diff

220
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0008-d3dx10-Set-D3DX10_IMAGE_LOAD_INFO-pSrcInfo-value-if-.patch Normal file
View File

@@ -0,0 +1,220 @@
From 60ece0635b1d6f5176190a4c2fa68fc9b7a8d9cd Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Wed, 17 Sep 2025 15:05:17 -0400
Subject: [PATCH] d3dx10: Set D3DX10_IMAGE_LOAD_INFO pSrcInfo value if passed
in.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 116 ++++++++++++++++++++++++++++++++++
dlls/d3dx10_43/texture.c | 4 +-
2 files changed, 118 insertions(+), 2 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 6155855713e..f660b9a2953 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -2964,6 +2964,12 @@ static void test_D3DX10CreateAsyncTextureInfoProcessor(void)
CoUninitialize();
}
+static const D3DX10_IMAGE_LOAD_INFO d3dx10_default_load_info =
+{
+ D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT,
+ D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, NULL
+};
+
static void test_D3DX10CreateAsyncTextureProcessor(void)
{
ID3DX10DataProcessor *dp;
@@ -2998,6 +3004,9 @@ static void test_D3DX10CreateAsyncTextureProcessor(void)
for (i = 0; i < ARRAY_SIZE(test_image); ++i)
{
+ D3DX10_IMAGE_LOAD_INFO load_info = d3dx10_default_load_info;
+ D3DX10_IMAGE_INFO info = { 0 };
+
winetest_push_context("Test %u", i);
hr = D3DX10CreateAsyncTextureProcessor(device, NULL, &dp);
@@ -3018,6 +3027,27 @@ static void test_D3DX10CreateAsyncTextureProcessor(void)
hr = ID3DX10DataProcessor_Destroy(dp);
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+ /* Check that D3DX10_IMAGE_INFO argument is set. */
+ load_info.pSrcInfo = &info;
+ hr = D3DX10CreateAsyncTextureProcessor(device, &load_info, &dp);
+ ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+ hr = ID3DX10DataProcessor_Process(dp, (void *)test_image[i].data, test_image[i].size);
+ ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP),
+ "Got unexpected hr %#lx.\n", hr);
+ if (hr == S_OK)
+ {
+ hr = ID3DX10DataProcessor_CreateDeviceObject(dp, (void **)&resource);
+ ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+ check_resource_info(resource, test_image + i, __LINE__);
+ check_resource_data(resource, test_image + i, __LINE__);
+ check_image_info(&info, test_image + i, __LINE__);
+ ID3D10Resource_Release(resource);
+ }
+
+ hr = ID3DX10DataProcessor_Destroy(dp);
+ ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
winetest_pop_context();
}
@@ -4117,6 +4147,8 @@ static void test_create_texture(void)
for (i = 0; i < ARRAY_SIZE(test_image); ++i)
{
+ D3DX10_IMAGE_INFO info = { 0 };
+
winetest_push_context("Test %u", i);
hr2 = 0xdeadbeef;
@@ -4131,6 +4163,22 @@ static void test_create_texture(void)
ID3D10Resource_Release(resource);
}
+ /* Check that D3DX10_IMAGE_INFO argument is set. */
+ load_info = d3dx10_default_load_info;
+ load_info.pSrcInfo = &info;
+ hr2 = 0xdeadbeef;
+ hr = D3DX10CreateTextureFromMemory(device, test_image[i].data, test_image[i].size, &load_info, NULL, &resource, &hr2);
+ ok(hr == hr2, "Got unexpected hr2 %#lx.\n", hr2);
+ ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP),
+ "Got unexpected hr %#lx.\n", hr);
+ if (hr == S_OK)
+ {
+ check_resource_info(resource, test_image + i, __LINE__);
+ check_resource_data(resource, test_image + i, __LINE__);
+ check_image_info(&info, test_image + i, __LINE__);
+ ID3D10Resource_Release(resource);
+ }
+
winetest_pop_context();
}
@@ -4274,6 +4322,8 @@ static void test_create_texture(void)
for (i = 0; i < ARRAY_SIZE(test_image); ++i)
{
+ D3DX10_IMAGE_INFO info = { 0 };
+
winetest_push_context("Test %u", i);
create_file(test_filename, test_image[i].data, test_image[i].size, path);
@@ -4301,6 +4351,37 @@ static void test_create_texture(void)
ID3D10Resource_Release(resource);
}
+ /* Check that D3DX10_IMAGE_INFO argument is set. */
+ load_info = d3dx10_default_load_info;
+ load_info.pSrcInfo = &info;
+ hr2 = 0xdeadbeef;
+ hr = D3DX10CreateTextureFromFileW(device, path, &load_info, NULL, &resource, &hr2);
+ ok(hr == hr2, "Got unexpected hr2 %#lx.\n", hr2);
+ ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP),
+ "Got unexpected hr %#lx.\n", hr);
+ if (hr == S_OK)
+ {
+ check_resource_info(resource, test_image + i, __LINE__);
+ check_resource_data(resource, test_image + i, __LINE__);
+ check_image_info(&info, test_image + i, __LINE__);
+ ID3D10Resource_Release(resource);
+ }
+
+ load_info = d3dx10_default_load_info;
+ load_info.pSrcInfo = &info;
+ hr2 = 0xdeadbeef;
+ hr = D3DX10CreateTextureFromFileA(device, get_str_a(path), &load_info, NULL, &resource, &hr2);
+ ok(hr == hr2, "Got unexpected hr2 %#lx.\n", hr2);
+ ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP),
+ "Got unexpected hr %#lx.\n", hr);
+ if (hr == S_OK)
+ {
+ check_resource_info(resource, test_image + i, __LINE__);
+ check_resource_data(resource, test_image + i, __LINE__);
+ check_image_info(&info, test_image + i, __LINE__);
+ ID3D10Resource_Release(resource);
+ }
+
delete_file(test_filename);
winetest_pop_context();
}
@@ -4351,6 +4432,8 @@ static void test_create_texture(void)
for (i = 0; i < ARRAY_SIZE(test_image); ++i)
{
+ D3DX10_IMAGE_INFO info = { 0 };
+
winetest_push_context("Test %u", i);
resource_module = create_resource_module(test_resource_name, test_image[i].data, test_image[i].size);
@@ -4385,6 +4468,39 @@ static void test_create_texture(void)
ID3D10Resource_Release(resource);
}
+ /* Check that D3DX10_IMAGE_INFO argument is set. */
+ load_info = d3dx10_default_load_info;
+ load_info.pSrcInfo = &info;
+ hr2 = 0xdeadbeef;
+ hr = D3DX10CreateTextureFromResourceW(device, resource_module,
+ test_resource_name, &load_info, NULL, &resource, &hr2);
+ ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP),
+ "Got unexpected hr %#lx.\n", hr);
+ ok(hr == hr2, "Got unexpected hr2 %#lx.\n", hr2);
+ if (hr == S_OK)
+ {
+ check_resource_info(resource, test_image + i, __LINE__);
+ check_resource_data(resource, test_image + i, __LINE__);
+ check_image_info(&info, test_image + i, __LINE__);
+ ID3D10Resource_Release(resource);
+ }
+
+ load_info = d3dx10_default_load_info;
+ load_info.pSrcInfo = &info;
+ hr2 = 0xdeadbeef;
+ hr = D3DX10CreateTextureFromResourceA(device, resource_module,
+ get_str_a(test_resource_name), &load_info, NULL, &resource, &hr2);
+ ok(hr == S_OK || broken(hr == E_FAIL && test_image[i].expected_info.ImageFileFormat == D3DX10_IFF_WMP),
+ "Got unexpected hr %#lx.\n", hr);
+ ok(hr == hr2, "Got unexpected hr2 %#lx.\n", hr2);
+ if (hr == S_OK)
+ {
+ check_resource_info(resource, test_image + i, __LINE__);
+ check_resource_data(resource, test_image + i, __LINE__);
+ check_image_info(&info, test_image + i, __LINE__);
+ ID3D10Resource_Release(resource);
+ }
+
delete_resource_module(test_resource_name, resource_module);
winetest_pop_context();
}
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index 2c09040838b..4d279bccbd5 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -666,8 +666,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
FIXME("load_info->Filter is ignored.\n");
if (load_info->MipFilter != D3DX10_DEFAULT)
FIXME("load_info->MipFilter is ignored.\n");
- if (load_info->pSrcInfo)
- FIXME("load_info->pSrcInfo is ignored.\n");
*resource_data = NULL;
hr = d3dx_image_init(data, size, &image, 0, D3DX_IMAGE_SUPPORT_DXT10);
@@ -764,6 +762,8 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
load_info->BindFlags = D3D10_BIND_SHADER_RESOURCE;
load_info->CpuAccessFlags = 0;
load_info->MiscFlags = img_info.MiscFlags;
+ if (load_info->pSrcInfo)
+ *load_info->pSrcInfo = img_info;
end:
d3dx_image_cleanup(&image);
--
2.51.0

234
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0009-d3dx10-Create-3D-textures-for-images-representing-3D.patch Normal file
View File

@@ -0,0 +1,234 @@
From da45b8dd00ab02ba03d8608afdf32085f5d28603 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Wed, 17 Sep 2025 15:26:50 -0400
Subject: [PATCH] d3dx10: Create 3D textures for images representing 3D
textures.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/async.c | 11 +++++-
dlls/d3dx10_43/tests/d3dx10.c | 35 ++++++++++++------
dlls/d3dx10_43/texture.c | 69 +++++++++++++++++++++++++++--------
3 files changed, 86 insertions(+), 29 deletions(-)
diff --git a/dlls/d3dx10_43/async.c b/dlls/d3dx10_43/async.c
index 62627886804..e2cd14a7736 100644
--- a/dlls/d3dx10_43/async.c
+++ b/dlls/d3dx10_43/async.c
@@ -322,6 +322,8 @@ struct texture_processor
{
ID3DX10DataProcessor ID3DX10DataProcessor_iface;
ID3D10Device *device;
+ D3DX10_IMAGE_INFO img_info;
+ D3DX10_IMAGE_INFO *img_info_out;
D3DX10_IMAGE_LOAD_INFO load_info;
D3D10_SUBRESOURCE_DATA *resource_data;
};
@@ -334,6 +336,7 @@ static inline struct texture_processor *texture_processor_from_ID3DX10DataProces
static HRESULT WINAPI texture_processor_Process(ID3DX10DataProcessor *iface, void *data, SIZE_T size)
{
struct texture_processor *processor = texture_processor_from_ID3DX10DataProcessor(iface);
+ HRESULT hr;
TRACE("iface %p, data %p, size %Iu.\n", iface, data, size);
@@ -343,7 +346,10 @@ static HRESULT WINAPI texture_processor_Process(ID3DX10DataProcessor *iface, voi
free(processor->resource_data);
processor->resource_data = NULL;
}
- return load_texture_data(data, size, &processor->load_info, &processor->resource_data);
+ hr = load_texture_data(data, size, &processor->load_info, &processor->resource_data);
+ if (SUCCEEDED(hr) && processor->img_info_out)
+ *processor->img_info_out = processor->img_info;
+ return hr;
}
static HRESULT WINAPI texture_processor_CreateDeviceObject(ID3DX10DataProcessor *iface, void **object)
@@ -594,7 +600,10 @@ HRESULT WINAPI D3DX10CreateAsyncTextureProcessor(ID3D10Device *device,
object->ID3DX10DataProcessor_iface.lpVtbl = &texture_processor_vtbl;
object->device = device;
ID3D10Device_AddRef(device);
+ if (load_info)
+ object->img_info_out = load_info->pSrcInfo;
init_load_info(load_info, &object->load_info);
+ object->load_info.pSrcInfo = &object->img_info;
*processor = &object->ID3DX10DataProcessor_iface;
return S_OK;
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index f660b9a2953..818889138a5 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -20,6 +20,7 @@
#include "initguid.h"
#include "d3d10_1.h"
#include "d3dx10.h"
+#include "wine/wined3d.h"
#include "wine/test.h"
#include <stdint.h>
@@ -69,6 +70,8 @@
#define DDS_PF_BUMPLUMINANCE 0x00040000
#define DDS_PF_BUMPDUDV 0x00080000
+static bool wined3d_opengl;
+
struct dds_pixel_format
{
DWORD size;
@@ -1751,13 +1754,8 @@ static void check_test_image_load_info_resource_(uint32_t line, ID3D10Resource *
HRESULT hr;
ID3D10Resource_GetType(resource, &resource_dimension);
- todo_wine_if(image_load_info->expected_type == D3D10_RESOURCE_DIMENSION_TEXTURE3D)
- ok(resource_dimension == image_load_info->expected_type, "Got unexpected ResourceDimension %u, expected %u.\n",
- resource_dimension, image_load_info->expected_type);
-
- if (resource_dimension != image_load_info->expected_type)
- return;
-
+ ok(resource_dimension == image_load_info->expected_type, "Got unexpected ResourceDimension %u, expected %u.\n",
+ resource_dimension, image_load_info->expected_type);
switch (resource_dimension)
{
case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
@@ -1826,10 +1824,9 @@ static void check_resource_info(ID3D10Resource *resource, const struct test_imag
}
ID3D10Resource_GetType(resource, &resource_dimension);
- todo_wine_if (image->expected_info.ResourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE3D)
- ok(resource_dimension == image->expected_info.ResourceDimension,
- "Got unexpected ResourceDimension %u, expected %u.\n",
- resource_dimension, image->expected_info.ResourceDimension);
+ ok(resource_dimension == image->expected_info.ResourceDimension,
+ "Got unexpected ResourceDimension %u, expected %u.\n",
+ resource_dimension, image->expected_info.ResourceDimension);
switch (resource_dimension)
{
@@ -2022,7 +2019,10 @@ static void check_resource_data(ID3D10Resource *resource, const struct test_imag
if (SUCCEEDED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture3D, (void **)&texture3d)))
{
- check_texture3d_data(texture3d, image, line);
+ if (wined3d_opengl && is_block_compressed(image->expected_info.Format))
+ skip("Skipping compressed format 3D texture readback test.\n");
+ else
+ check_texture3d_data(texture3d, image, line);
ID3D10Texture3D_Release(texture3d);
}
else if (SUCCEEDED(ID3D10Resource_QueryInterface(resource, &IID_ID3D10Texture2D, (void **)&texture2d)))
@@ -5992,6 +5992,17 @@ static void test_preprocess_shader(void)
START_TEST(d3dx10)
{
+ HMODULE wined3d;
+
+ if ((wined3d = GetModuleHandleA("wined3d.dll")))
+ {
+ enum wined3d_renderer (CDECL *p_wined3d_get_renderer)(void);
+
+ if ((p_wined3d_get_renderer = (void *)GetProcAddress(wined3d, "wined3d_get_renderer"))
+ && p_wined3d_get_renderer() == WINED3D_RENDERER_OPENGL)
+ wined3d_opengl = true;
+ }
+
test_D3DX10UnsetAllDeviceObjects();
test_D3DX10CreateAsyncMemoryLoader();
test_D3DX10CreateAsyncFileLoader();
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index 4d279bccbd5..a21ce7ff139 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -439,9 +439,12 @@ static HRESULT create_texture(ID3D10Device *device, const void *data, SIZE_T siz
{
D3D10_SUBRESOURCE_DATA *resource_data;
D3DX10_IMAGE_LOAD_INFO load_info_copy;
+ D3DX10_IMAGE_INFO img_info;
HRESULT hr;
init_load_info(load_info, &load_info_copy);
+ if (!load_info_copy.pSrcInfo)
+ load_info_copy.pSrcInfo = &img_info;
if (FAILED((hr = load_texture_data(data, size, &load_info_copy, &resource_data))))
return hr;
@@ -774,25 +777,59 @@ end:
HRESULT create_d3d_texture(ID3D10Device *device, D3DX10_IMAGE_LOAD_INFO *load_info,
D3D10_SUBRESOURCE_DATA *resource_data, ID3D10Resource **texture)
{
- D3D10_TEXTURE2D_DESC texture_2d_desc;
- ID3D10Texture2D *texture_2d;
HRESULT hr;
- memset(&texture_2d_desc, 0, sizeof(texture_2d_desc));
- texture_2d_desc.Width = load_info->Width;
- texture_2d_desc.Height = load_info->Height;
- texture_2d_desc.MipLevels = load_info->MipLevels;
- texture_2d_desc.ArraySize = load_info->MiscFlags & D3D10_RESOURCE_MISC_TEXTURECUBE ? 6 : 1;
- texture_2d_desc.Format = load_info->Format;
- texture_2d_desc.SampleDesc.Count = 1;
- texture_2d_desc.Usage = load_info->Usage;
- texture_2d_desc.BindFlags = load_info->BindFlags;
- texture_2d_desc.MiscFlags = load_info->MiscFlags;
-
- if (FAILED(hr = ID3D10Device_CreateTexture2D(device, &texture_2d_desc, resource_data, &texture_2d)))
- return hr;
+ *texture = NULL;
+ switch (load_info->pSrcInfo->ResourceDimension)
+ {
+ case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
+ {
+ D3D10_TEXTURE2D_DESC texture_2d_desc = { 0 };
+ ID3D10Texture2D *texture_2d;
+
+ texture_2d_desc.Width = load_info->Width;
+ texture_2d_desc.Height = load_info->Height;
+ texture_2d_desc.MipLevels = load_info->MipLevels;
+ texture_2d_desc.ArraySize = load_info->pSrcInfo->ArraySize;
+ texture_2d_desc.Format = load_info->Format;
+ texture_2d_desc.SampleDesc.Count = 1;
+ texture_2d_desc.Usage = load_info->Usage;
+ texture_2d_desc.BindFlags = load_info->BindFlags;
+ texture_2d_desc.CPUAccessFlags = load_info->CpuAccessFlags;
+ texture_2d_desc.MiscFlags = load_info->MiscFlags;
+
+ if (FAILED(hr = ID3D10Device_CreateTexture2D(device, &texture_2d_desc, resource_data, &texture_2d)))
+ return hr;
+ *texture = (ID3D10Resource *)texture_2d;
+ break;
+ }
+
+ case D3D10_RESOURCE_DIMENSION_TEXTURE3D:
+ {
+ D3D10_TEXTURE3D_DESC texture_3d_desc = { 0 };
+ ID3D10Texture3D *texture_3d;
+
+ texture_3d_desc.Width = load_info->Width;
+ texture_3d_desc.Height = load_info->Height;
+ texture_3d_desc.Depth = load_info->Depth;
+ texture_3d_desc.MipLevels = load_info->MipLevels;
+ texture_3d_desc.Format = load_info->Format;
+ texture_3d_desc.Usage = load_info->Usage;
+ texture_3d_desc.BindFlags = load_info->BindFlags;
+ texture_3d_desc.CPUAccessFlags = load_info->CpuAccessFlags;
+ texture_3d_desc.MiscFlags = load_info->MiscFlags;
+
+ if (FAILED(hr = ID3D10Device_CreateTexture3D(device, &texture_3d_desc, resource_data, &texture_3d)))
+ return hr;
+ *texture = (ID3D10Resource *)texture_3d;
+ break;
+ }
+
+ default:
+ FIXME("Unhandled resource dimension %d.\n", load_info->pSrcInfo->ResourceDimension);
+ return E_NOTIMPL;
+ }
- *texture = (ID3D10Resource *)texture_2d;
return S_OK;
}
--
2.51.0

138
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0010-d3dx10-Handle-filter-value-passed-in-via-D3DX10_IMAG.patch Normal file
View File

@@ -0,0 +1,138 @@
From 24011cea5836f9b2b4cecbf971fe4b6400ebb9d5 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Thu, 18 Sep 2025 11:42:06 -0400
Subject: [PATCH] d3dx10: Handle filter value passed in via
D3DX10_IMAGE_LOAD_INFO.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 2 +-
dlls/d3dx10_43/texture.c | 12 +++++++++---
dlls/d3dx9_36/d3dx9_private.h | 10 +---------
dlls/d3dx9_36/d3dx_helpers.c | 9 +++++++++
dlls/d3dx9_36/d3dx_helpers.h | 2 ++
dlls/d3dx9_36/texture.c | 2 +-
6 files changed, 23 insertions(+), 14 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 818889138a5..4be5d37d70d 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -1086,7 +1086,7 @@ static const struct test_invalid_image_load_info
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, (D3D10_USAGE)D3DX10_DEFAULT,
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, 7, D3DX10_DEFAULT
},
- D3DERR_INVALIDCALL, D3DERR_INVALIDCALL, .todo_hr = TRUE, .todo_process_hr = TRUE
+ D3DERR_INVALIDCALL, D3DERR_INVALIDCALL
},
/* Invalid mipfilter value, only checked if mips are generated. */
{
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index a21ce7ff139..bb1e1456fc2 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -665,12 +665,18 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
FIXME("load_info->MiscFlags is ignored.\n");
if (load_info->Format != D3DX10_DEFAULT)
FIXME("load_info->Format is ignored.\n");
- if (load_info->Filter != D3DX10_DEFAULT)
- FIXME("load_info->Filter is ignored.\n");
if (load_info->MipFilter != D3DX10_DEFAULT)
FIXME("load_info->MipFilter is ignored.\n");
*resource_data = NULL;
+ if (!load_info->Filter || load_info->Filter == D3DX10_DEFAULT)
+ load_info->Filter = D3DX10_FILTER_TRIANGLE | D3DX10_FILTER_DITHER;
+ if (FAILED(hr = d3dx_validate_filter(load_info->Filter)))
+ {
+ ERR("Invalid filter argument %#x.\n", load_info->Filter);
+ return hr;
+ }
+
hr = d3dx_image_init(data, size, &image, 0, D3DX_IMAGE_SUPPORT_DXT10);
if (FAILED(hr))
return E_FAIL;
@@ -741,7 +747,7 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
set_d3dx_pixels(&dst_pixels, pixels_buffer, dst_row_pitch, dst_slice_pitch, NULL, dst_size.width,
dst_size.height, dst_size.depth, &unaligned_rect);
- hr = d3dx_load_pixels_from_pixels(&dst_pixels, fmt_desc, &src_pixels, src_desc, D3DX10_FILTER_POINT, 0);
+ hr = d3dx_load_pixels_from_pixels(&dst_pixels, fmt_desc, &src_pixels, src_desc, load_info->Filter, 0);
if (FAILED(hr))
break;
diff --git a/dlls/d3dx9_36/d3dx9_private.h b/dlls/d3dx9_36/d3dx9_private.h
index 655529b004b..394b1a1cee2 100644
--- a/dlls/d3dx9_36/d3dx9_private.h
+++ b/dlls/d3dx9_36/d3dx9_private.h
@@ -35,20 +35,12 @@
#define FOURCC_TX_1 0x54580100
#define D3DX9_FILTER_INVALID_BITS 0xff80fff8
-static inline HRESULT d3dx9_validate_filter(uint32_t filter)
-{
- if ((filter & D3DX9_FILTER_INVALID_BITS) || !(filter & 0x7) || ((filter & 0x7) > D3DX_FILTER_BOX))
- return D3DERR_INVALIDCALL;
-
- return D3D_OK;
-}
-
static inline HRESULT d3dx9_handle_load_filter(DWORD *filter)
{
if (*filter == D3DX_DEFAULT)
*filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
- return d3dx9_validate_filter(*filter);
+ return d3dx_validate_filter(*filter);
}
BOOL d3dximage_info_from_d3dx_image(D3DXIMAGE_INFO *info, struct d3dx_image *image);
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index 13ecc81018d..ddd208913af 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -53,6 +53,15 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
#define D3DX_FILTER_SRGB_OUT 0x00400000
#define D3DX_FILTER_SRGB 0x00600000
+#define D3DX_FILTER_INVALID_BITS 0xff80fff8
+HRESULT d3dx_validate_filter(uint32_t filter)
+{
+ if ((filter & D3DX_FILTER_INVALID_BITS) || !(filter & 0x7) || ((filter & 0x7) > D3DX_FILTER_BOX))
+ return D3DERR_INVALIDCALL;
+
+ return D3D_OK;
+}
+
HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory**);
/************************************************************
diff --git a/dlls/d3dx9_36/d3dx_helpers.h b/dlls/d3dx9_36/d3dx_helpers.h
index 663febd279b..c7292990799 100644
--- a/dlls/d3dx9_36/d3dx_helpers.h
+++ b/dlls/d3dx9_36/d3dx_helpers.h
@@ -386,6 +386,8 @@ static inline BOOL is_conversion_to_supported(const struct pixel_format_desc *fo
return !is_index_format(format) && !is_packed_format(format) && !is_unknown_format(format);
}
+HRESULT d3dx_validate_filter(uint32_t filter);
+
const struct pixel_format_desc *get_d3dx_pixel_format_info(enum d3dx_pixel_format_id format);
void format_to_d3dx_color(const struct pixel_format_desc *format, const BYTE *src, const PALETTEENTRY *palette,
diff --git a/dlls/d3dx9_36/texture.c b/dlls/d3dx9_36/texture.c
index 02bfbca2cc6..c64f9564406 100644
--- a/dlls/d3dx9_36/texture.c
+++ b/dlls/d3dx9_36/texture.c
@@ -59,7 +59,7 @@ HRESULT WINAPI D3DXFilterTexture(IDirect3DBaseTexture9 *texture,
if (!texture)
return D3DERR_INVALIDCALL;
- if (filter != D3DX_DEFAULT && FAILED(hr = d3dx9_validate_filter(filter)))
+ if (filter != D3DX_DEFAULT && FAILED(hr = d3dx_validate_filter(filter)))
return hr;
if (srclevel == D3DX_DEFAULT)
--
2.51.0

69
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0011-d3dx10-Add-support-for-custom-texture-dimension-argu.patch Normal file
View File

@@ -0,0 +1,69 @@
From 167f1d10d28e0935feabf82b5d9f429cbef2001d Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Thu, 18 Sep 2025 13:18:04 -0400
Subject: [PATCH] d3dx10: Add support for custom texture dimension arguments in
D3DX10_IMAGE_LOAD_INFO.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 2 +-
dlls/d3dx10_43/texture.c | 23 ++++++++++++++---------
2 files changed, 15 insertions(+), 10 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 4be5d37d70d..8248461c970 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -1077,7 +1077,7 @@ static const struct test_invalid_image_load_info
D3DX10_DEFAULT, D3DX10_DEFAULT, 2, D3DX10_DEFAULT, D3DX10_DEFAULT, (D3D10_USAGE)D3DX10_DEFAULT,
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT
},
- E_FAIL, E_FAIL, .todo_hr = TRUE, .todo_process_hr = TRUE
+ E_FAIL, E_FAIL
},
/* Invalid filter value. */
{
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index bb1e1456fc2..fc9841cc279 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -645,12 +645,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
if (!data || !size)
return E_FAIL;
- if (load_info->Width != D3DX10_DEFAULT)
- FIXME("load_info->Width is ignored.\n");
- if (load_info->Height != D3DX10_DEFAULT)
- FIXME("load_info->Height is ignored.\n");
- if (load_info->Depth != D3DX10_DEFAULT)
- FIXME("load_info->Depth is ignored.\n");
if (load_info->FirstMipLevel != D3DX10_DEFAULT)
FIXME("load_info->FirstMipLevel is ignored.\n");
if (load_info->MipLevels != D3DX10_DEFAULT)
@@ -706,9 +700,20 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
}
/* Potentially round up width/height to align with block size. */
- load_info->Width = (img_info.Width + fmt_desc->block_width - 1) & ~(fmt_desc->block_width - 1);
- load_info->Height = (img_info.Height + fmt_desc->block_height - 1) & ~(fmt_desc->block_height - 1);
- load_info->Depth = img_info.Depth;
+ if (!load_info->Width || load_info->Width == D3DX10_FROM_FILE || load_info->Width == D3DX10_DEFAULT)
+ load_info->Width = (img_info.Width + fmt_desc->block_width - 1) & ~(fmt_desc->block_width - 1);
+ if (!load_info->Height || load_info->Height == D3DX10_FROM_FILE || load_info->Height == D3DX10_DEFAULT)
+ load_info->Height = (img_info.Height + fmt_desc->block_height - 1) & ~(fmt_desc->block_height - 1);
+ if (!load_info->Depth || load_info->Depth == D3DX10_FROM_FILE || load_info->Depth == D3DX10_DEFAULT)
+ load_info->Depth = img_info.Depth;
+
+ if ((load_info->Depth > 1) && (img_info.ResourceDimension != D3D10_RESOURCE_DIMENSION_TEXTURE3D))
+ {
+ ERR("Invalid depth value %u for image with dimension %d.\n", load_info->Depth, img_info.ResourceDimension);
+ hr = E_FAIL;
+ goto end;
+ }
+
load_info->MipLevels = img_info.MipLevels;
load_info->Format = img_info.Format;
--
2.51.0

323
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0012-d3dx10-Add-support-for-generating-mipmaps-to-load_te.patch Normal file
View File

@@ -0,0 +1,323 @@
From c69ef561499aa26de02b67d3ef0df888e603b448 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Fri, 19 Sep 2025 10:48:28 -0400
Subject: [PATCH] d3dx10: Add support for generating mipmaps to
load_texture_data().
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 3 +-
dlls/d3dx10_43/texture.c | 97 ++++++++++++++++++++++-------------
dlls/d3dx9_36/d3dx_helpers.c | 69 +++++++++++++++++++++++++
dlls/d3dx9_36/d3dx_helpers.h | 17 ++++++
4 files changed, 147 insertions(+), 39 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 8248461c970..6e5cc1bb146 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -1104,7 +1104,7 @@ static const struct test_invalid_image_load_info
2, 2, D3DX10_DEFAULT, D3DX10_DEFAULT, 2, (D3D10_USAGE)D3DX10_DEFAULT,
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, 7
},
- D3DERR_INVALIDCALL, D3DERR_INVALIDCALL, .todo_hr = TRUE, .todo_process_hr = TRUE
+ D3DERR_INVALIDCALL, D3DERR_INVALIDCALL
},
/*
* Usage/BindFlags/CpuAccessFlags are validated in the call to
@@ -1840,7 +1840,6 @@ static void check_resource_info(ID3D10Resource *resource, const struct test_imag
ok_(__FILE__, line)(desc_2d.Height == expected_height,
"Got unexpected Height %u, expected %u.\n",
desc_2d.Height, expected_height);
- todo_wine_if(expected_mip_levels != image->expected_info.MipLevels)
ok_(__FILE__, line)(desc_2d.MipLevels == expected_mip_levels,
"Got unexpected MipLevels %u, expected %u.\n",
desc_2d.MipLevels, expected_mip_levels);
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index fc9841cc279..3348911cdff 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -636,10 +636,11 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
D3D10_SUBRESOURCE_DATA **resource_data)
{
const struct pixel_format_desc *fmt_desc, *src_desc;
- uint32_t i, j, pixels_size, pixels_offset;
- uint8_t *res_data = NULL, *pixels_buffer;
+ struct d3dx_subresource_data *sub_rsrcs = NULL;
+ uint32_t loaded_mip_levels, max_mip_levels;
D3DX10_IMAGE_INFO img_info;
struct d3dx_image image;
+ unsigned int i, j;
HRESULT hr = S_OK;
if (!data || !size)
@@ -647,8 +648,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
if (load_info->FirstMipLevel != D3DX10_DEFAULT)
FIXME("load_info->FirstMipLevel is ignored.\n");
- if (load_info->MipLevels != D3DX10_DEFAULT)
- FIXME("load_info->MipLevels is ignored.\n");
if (load_info->Usage != D3DX10_DEFAULT)
FIXME("load_info->Usage is ignored.\n");
if (load_info->BindFlags != D3DX10_DEFAULT)
@@ -659,8 +658,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
FIXME("load_info->MiscFlags is ignored.\n");
if (load_info->Format != D3DX10_DEFAULT)
FIXME("load_info->Format is ignored.\n");
- if (load_info->MipFilter != D3DX10_DEFAULT)
- FIXME("load_info->MipFilter is ignored.\n");
*resource_data = NULL;
if (!load_info->Filter || load_info->Filter == D3DX10_DEFAULT)
@@ -714,64 +711,90 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
goto end;
}
- load_info->MipLevels = img_info.MipLevels;
+ max_mip_levels = d3dx_get_max_mip_levels_for_size(load_info->Width, load_info->Height, load_info->Depth);
+ if (!load_info->MipLevels || load_info->MipLevels == D3DX10_DEFAULT || load_info->MipLevels == D3DX10_FROM_FILE)
+ load_info->MipLevels = (load_info->MipLevels == D3DX10_FROM_FILE) ? img_info.MipLevels : max_mip_levels;
+ load_info->MipLevels = min(max_mip_levels, load_info->MipLevels);
load_info->Format = img_info.Format;
- pixels_size = d3dx_calculate_layer_pixels_size(fmt_desc->format, load_info->Width, load_info->Height,
- load_info->Depth, load_info->MipLevels) * img_info.ArraySize;
- pixels_offset = (sizeof(**resource_data) * load_info->MipLevels * img_info.ArraySize);
- if (!(res_data = malloc(pixels_size + pixels_offset)))
- {
- hr = E_OUTOFMEMORY;
+ hr = d3dx_create_subresource_data_for_texture(load_info->Width, load_info->Height, load_info->Depth,
+ load_info->MipLevels, img_info.ArraySize, fmt_desc, &sub_rsrcs);
+ if (FAILED(hr))
goto end;
- }
-
- pixels_buffer = res_data + pixels_offset;
- *resource_data = (D3D10_SUBRESOURCE_DATA *)res_data;
src_desc = get_d3dx_pixel_format_info(image.format);
+ loaded_mip_levels = min(img_info.MipLevels, load_info->MipLevels);
for (i = 0; i < img_info.ArraySize; ++i)
{
struct volume dst_size = { load_info->Width, load_info->Height, load_info->Depth };
- for (j = 0; j < load_info->MipLevels; ++j)
+ for (j = 0; j < loaded_mip_levels; ++j)
{
+ struct d3dx_subresource_data *sub_rsrc = &sub_rsrcs[i * load_info->MipLevels + j];
const RECT unaligned_rect = { 0, 0, dst_size.width, dst_size.height };
struct d3dx_pixels src_pixels, dst_pixels;
- uint32_t dst_row_pitch, dst_slice_pitch;
hr = d3dx_image_get_pixels(&image, i, j, &src_pixels);
if (FAILED(hr))
- break;
+ goto end;
- hr = d3dx_calculate_pixels_size(fmt_desc->format, dst_size.width, dst_size.height, &dst_row_pitch,
- &dst_slice_pitch);
- if (FAILED(hr))
- break;
-
- set_d3dx_pixels(&dst_pixels, pixels_buffer, dst_row_pitch, dst_slice_pitch, NULL, dst_size.width,
+ set_d3dx_pixels(&dst_pixels, sub_rsrc->data, sub_rsrc->row_pitch, sub_rsrc->slice_pitch, NULL, dst_size.width,
dst_size.height, dst_size.depth, &unaligned_rect);
hr = d3dx_load_pixels_from_pixels(&dst_pixels, fmt_desc, &src_pixels, src_desc, load_info->Filter, 0);
if (FAILED(hr))
- break;
+ goto end;
- (*resource_data)[i * load_info->MipLevels + j].pSysMem = pixels_buffer;
- (*resource_data)[i * load_info->MipLevels + j].SysMemPitch = dst_row_pitch;
- (*resource_data)[i * load_info->MipLevels + j].SysMemSlicePitch = dst_slice_pitch;
-
- pixels_buffer += dst_slice_pitch * dst_size.depth;
d3dx_get_next_mip_level_size(&dst_size);
}
}
- if (FAILED(hr))
+ if (loaded_mip_levels < load_info->MipLevels)
{
- *resource_data = NULL;
- goto end;
+ struct volume base_level_size = { load_info->Width, load_info->Height, load_info->Depth };
+ const uint32_t base_level = loaded_mip_levels - 1;
+
+ if (!load_info->MipFilter || load_info->MipFilter == D3DX10_DEFAULT)
+ load_info->MipFilter = D3DX10_FILTER_LINEAR;
+ if (FAILED(hr = d3dx_validate_filter(load_info->MipFilter)))
+ {
+ ERR("Invalid mip filter argument %#x.\n", load_info->MipFilter);
+ goto end;
+ }
+
+ d3dx_get_mip_level_size(&base_level_size, base_level);
+ for (i = 0; i < img_info.ArraySize; ++i)
+ {
+ struct volume src_size, dst_size;
+
+ src_size = dst_size = base_level_size;
+ for (j = base_level; j < (load_info->MipLevels - 1); ++j)
+ {
+ struct d3dx_subresource_data *dst_data = &sub_rsrcs[i * load_info->MipLevels + j + 1];
+ struct d3dx_subresource_data *src_data = &sub_rsrcs[i * load_info->MipLevels + j];
+ const RECT src_unaligned_rect = { 0, 0, src_size.width, src_size.height };
+ struct d3dx_pixels src_pixels, dst_pixels;
+ RECT dst_unaligned_rect;
+
+ d3dx_get_next_mip_level_size(&dst_size);
+ SetRect(&dst_unaligned_rect, 0, 0, dst_size.width, dst_size.height);
+ set_d3dx_pixels(&dst_pixels, dst_data->data, dst_data->row_pitch, dst_data->slice_pitch, NULL,
+ dst_size.width, dst_size.height, dst_size.depth, &dst_unaligned_rect);
+ set_d3dx_pixels(&src_pixels, src_data->data, src_data->row_pitch, src_data->slice_pitch, NULL,
+ src_size.width, src_size.height, src_size.depth, &src_unaligned_rect);
+
+ hr = d3dx_load_pixels_from_pixels(&dst_pixels, fmt_desc, &src_pixels, fmt_desc, load_info->MipFilter, 0);
+ if (FAILED(hr))
+ goto end;
+
+ src_size = dst_size;
+ }
+ }
}
- res_data = NULL;
+ *resource_data = (D3D10_SUBRESOURCE_DATA *)sub_rsrcs;
+ sub_rsrcs = NULL;
+
load_info->Usage = D3D10_USAGE_DEFAULT;
load_info->BindFlags = D3D10_BIND_SHADER_RESOURCE;
load_info->CpuAccessFlags = 0;
@@ -781,7 +804,7 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
end:
d3dx_image_cleanup(&image);
- free(res_data);
+ free(sub_rsrcs);
return hr;
}
diff --git a/dlls/d3dx9_36/d3dx_helpers.c b/dlls/d3dx9_36/d3dx_helpers.c
index ddd208913af..7cfa85e1e1f 100644
--- a/dlls/d3dx9_36/d3dx_helpers.c
+++ b/dlls/d3dx9_36/d3dx_helpers.c
@@ -439,6 +439,28 @@ void d3dx_get_next_mip_level_size(struct volume *size)
size->depth = max(size->depth / 2, 1);
}
+void d3dx_get_mip_level_size(struct volume *size, uint32_t level)
+{
+ uint32_t i;
+
+ for (i = 0; i < level; ++i)
+ d3dx_get_next_mip_level_size(size);
+}
+
+uint32_t d3dx_get_max_mip_levels_for_size(uint32_t width, uint32_t height, uint32_t depth)
+{
+ struct volume tmp = { width, height, depth };
+ uint32_t mip_levels = 1;
+
+ while (!(tmp.width == 1 && tmp.height == 1 && tmp.depth == 1))
+ {
+ d3dx_get_next_mip_level_size(&tmp);
+ mip_levels++;
+ }
+
+ return mip_levels;
+}
+
static const char *debug_volume(const struct volume *volume)
{
if (!volume)
@@ -3130,3 +3152,50 @@ void get_aligned_rect(uint32_t left, uint32_t top, uint32_t right, uint32_t bott
aligned_rect->bottom = min((aligned_rect->bottom + fmt_desc->block_height - 1)
& ~(fmt_desc->block_height - 1), height);
}
+
+HRESULT d3dx_create_subresource_data_for_texture(uint32_t width, uint32_t height, uint32_t depth,
+ uint32_t mip_levels, uint32_t layer_count, const struct pixel_format_desc *fmt_desc,
+ struct d3dx_subresource_data **out_sub_rsrc_data)
+{
+ struct d3dx_subresource_data *sub_rsrcs = NULL;
+ uint8_t *sub_rsrc_data = NULL, *pixels_ptr;
+ uint32_t pixels_size, pixels_offset;
+ unsigned int i, j;
+ HRESULT hr = S_OK;
+
+ *out_sub_rsrc_data = NULL;
+ pixels_offset = sizeof(*sub_rsrcs) * mip_levels * layer_count;
+ pixels_size = d3dx_calculate_layer_pixels_size(fmt_desc->format, width, height, depth, mip_levels) * layer_count;
+ if (!(sub_rsrc_data = malloc(pixels_size + pixels_offset)))
+ return E_OUTOFMEMORY;
+
+ sub_rsrcs = (struct d3dx_subresource_data *)sub_rsrc_data;
+ pixels_ptr = sub_rsrc_data + pixels_offset;
+ for (i = 0; i < layer_count; ++i)
+ {
+ struct volume size = { width, height, depth };
+
+ for (j = 0; j < mip_levels; ++j)
+ {
+ uint32_t row_pitch, slice_pitch;
+
+ hr = d3dx_calculate_pixels_size(fmt_desc->format, size.width, size.height, &row_pitch, &slice_pitch);
+ if (FAILED(hr))
+ goto exit;
+
+ sub_rsrcs[i * mip_levels + j].data = pixels_ptr;
+ sub_rsrcs[i * mip_levels + j].row_pitch = row_pitch;
+ sub_rsrcs[i * mip_levels + j].slice_pitch = slice_pitch;
+
+ pixels_ptr += slice_pitch * size.depth;
+ d3dx_get_next_mip_level_size(&size);
+ }
+ }
+
+ *out_sub_rsrc_data = sub_rsrcs;
+ sub_rsrc_data = NULL;
+
+exit:
+ free(sub_rsrc_data);
+ return hr;
+}
diff --git a/dlls/d3dx9_36/d3dx_helpers.h b/dlls/d3dx9_36/d3dx_helpers.h
index c7292990799..ee189a3a79c 100644
--- a/dlls/d3dx9_36/d3dx_helpers.h
+++ b/dlls/d3dx9_36/d3dx_helpers.h
@@ -396,6 +396,8 @@ void format_from_d3dx_color(const struct pixel_format_desc *format, const struct
enum d3dx_pixel_format_id d3dx_pixel_format_id_from_dxgi_format(uint32_t format);
void d3dx_get_next_mip_level_size(struct volume *size);
+void d3dx_get_mip_level_size(struct volume *size, uint32_t level);
+uint32_t d3dx_get_max_mip_levels_for_size(uint32_t width, uint32_t height, uint32_t depth);
HRESULT d3dx_calculate_pixels_size(enum d3dx_pixel_format_id format, uint32_t width, uint32_t height,
uint32_t *pitch, uint32_t *size);
uint32_t d3dx_calculate_layer_pixels_size(enum d3dx_pixel_format_id format, uint32_t width, uint32_t height,
@@ -430,6 +432,21 @@ struct d3dx_buffer_wrapper
HRESULT d3dx_save_pixels_to_memory(struct d3dx_pixels *src_pixels, const struct pixel_format_desc *src_fmt_desc,
enum d3dx_image_file_format file_format, const struct d3dx_buffer_wrapper *wrapper, struct d3dx_buffer *dst_buffer);
+/*
+ * Structure that is able to be cast to D3D10_SUBRESOURCE_DATA and
+ * D3D11_SUBRESOURCE_DATA.
+ */
+struct d3dx_subresource_data
+{
+ const void *data;
+ UINT row_pitch;
+ UINT slice_pitch;
+};
+
+HRESULT d3dx_create_subresource_data_for_texture(uint32_t width, uint32_t height, uint32_t depth,
+ uint32_t mip_levels, uint32_t layer_count, const struct pixel_format_desc *fmt_desc,
+ struct d3dx_subresource_data **out_sub_rsrc_data);
+
/* debug helpers */
const char *debug_d3dx_image_file_format(enum d3dx_image_file_format format);
#endif /* __WINE_D3DX_HELPERS_H */
--
2.51.0

50
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0013-d3dx10-Add-support-for-the-format-field-in-D3DX10_IM.patch Normal file
View File

@@ -0,0 +1,50 @@
From e851890d08e8b98fc1efc1c28b96244546a63e0c Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Fri, 19 Sep 2025 10:52:08 -0400
Subject: [PATCH] d3dx10: Add support for the format field in
D3DX10_IMAGE_LOAD_INFO.
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/texture.c | 9 ++++-----
1 file changed, 4 insertions(+), 5 deletions(-)
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index 3348911cdff..302efeccac1 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -656,8 +656,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
FIXME("load_info->CpuAccessFlags is ignored.\n");
if (load_info->MiscFlags != D3DX10_DEFAULT)
FIXME("load_info->MiscFlags is ignored.\n");
- if (load_info->Format != D3DX10_DEFAULT)
- FIXME("load_info->Format is ignored.\n");
*resource_data = NULL;
if (!load_info->Filter || load_info->Filter == D3DX10_DEFAULT)
@@ -688,10 +686,12 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
goto end;
}
- fmt_desc = get_d3dx_pixel_format_info(d3dx_pixel_format_id_from_dxgi_format(img_info.Format));
+ if (load_info->Format == D3DX10_DEFAULT || load_info->Format == DXGI_FORMAT_FROM_FILE)
+ load_info->Format = img_info.Format;
+ fmt_desc = get_d3dx_pixel_format_info(d3dx_pixel_format_id_from_dxgi_format(load_info->Format));
if (fmt_desc->format == D3DX_PIXEL_FORMAT_COUNT)
{
- FIXME("Unknown DXGI format supplied, %#x.\n", img_info.Format);
+ FIXME("Unknown DXGI format supplied, %#x.\n", load_info->Format);
hr = E_NOTIMPL;
goto end;
}
@@ -715,7 +715,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
if (!load_info->MipLevels || load_info->MipLevels == D3DX10_DEFAULT || load_info->MipLevels == D3DX10_FROM_FILE)
load_info->MipLevels = (load_info->MipLevels == D3DX10_FROM_FILE) ? img_info.MipLevels : max_mip_levels;
load_info->MipLevels = min(max_mip_levels, load_info->MipLevels);
- load_info->Format = img_info.Format;
hr = d3dx_create_subresource_data_for_texture(load_info->Width, load_info->Height, load_info->Depth,
load_info->MipLevels, img_info.ArraySize, fmt_desc, &sub_rsrcs);
--
2.51.0

68
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0014-d3dx10-Handle-FirstMipLevel-argument-in-load_texture.patch Normal file
View File

@@ -0,0 +1,68 @@
From 1a2093da3b46e635f99bb09d1c0ec336d8206b66 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Fri, 19 Sep 2025 11:37:58 -0400
Subject: [PATCH] d3dx10: Handle FirstMipLevel argument in load_texture_data().
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 2 +-
dlls/d3dx10_43/texture.c | 9 +++++----
2 files changed, 6 insertions(+), 5 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 6e5cc1bb146..2f26f8e14f1 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -4247,7 +4247,7 @@ static void test_create_texture(void)
for (mip_level = 0; mip_level < 4; ++mip_level)
{
winetest_push_context("MipLevel %u", mip_level);
- todo_wine_if(i && mip_level != 3) check_texture_sub_resource_color(tex_2d, mip_level, NULL,
+ check_texture_sub_resource_color(tex_2d, mip_level, NULL,
dds_24bit_8_8_mip_level_expected[min(3, mip_level + i)], 0);
winetest_pop_context();
}
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index 302efeccac1..cd5fc112110 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -646,8 +646,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
if (!data || !size)
return E_FAIL;
- if (load_info->FirstMipLevel != D3DX10_DEFAULT)
- FIXME("load_info->FirstMipLevel is ignored.\n");
if (load_info->Usage != D3DX10_DEFAULT)
FIXME("load_info->Usage is ignored.\n");
if (load_info->BindFlags != D3DX10_DEFAULT)
@@ -686,6 +684,9 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
goto end;
}
+ if (load_info->FirstMipLevel == D3DX10_DEFAULT || (load_info->FirstMipLevel >= img_info.MipLevels))
+ load_info->FirstMipLevel = 0;
+
if (load_info->Format == D3DX10_DEFAULT || load_info->Format == DXGI_FORMAT_FROM_FILE)
load_info->Format = img_info.Format;
fmt_desc = get_d3dx_pixel_format_info(d3dx_pixel_format_id_from_dxgi_format(load_info->Format));
@@ -722,7 +723,7 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
goto end;
src_desc = get_d3dx_pixel_format_info(image.format);
- loaded_mip_levels = min(img_info.MipLevels, load_info->MipLevels);
+ loaded_mip_levels = min((img_info.MipLevels - load_info->FirstMipLevel), load_info->MipLevels);
for (i = 0; i < img_info.ArraySize; ++i)
{
struct volume dst_size = { load_info->Width, load_info->Height, load_info->Depth };
@@ -733,7 +734,7 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
const RECT unaligned_rect = { 0, 0, dst_size.width, dst_size.height };
struct d3dx_pixels src_pixels, dst_pixels;
- hr = d3dx_image_get_pixels(&image, i, j, &src_pixels);
+ hr = d3dx_image_get_pixels(&image, i, j + load_info->FirstMipLevel, &src_pixels);
if (FAILED(hr))
goto end;
--
2.51.0

109
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0015-d3dx10-Pass-D3DX10_IMAGE_LOAD_INFO-texture-creation-.patch Normal file
View File

@@ -0,0 +1,109 @@
From ee999e236f7de9c21cc6cdd9d1e2ecfe85ee43e7 Mon Sep 17 00:00:00 2001
From: Connor McAdams <cmcadams@codeweavers.com>
Date: Fri, 19 Sep 2025 11:45:26 -0400
Subject: [PATCH] d3dx10: Pass D3DX10_IMAGE_LOAD_INFO texture creation
arguments through in load_texture_data().
Signed-off-by: Connor McAdams <cmcadams@codeweavers.com>
---
dlls/d3dx10_43/tests/d3dx10.c | 12 ++++++------
dlls/d3dx10_43/texture.c | 18 +++++-------------
2 files changed, 11 insertions(+), 19 deletions(-)
diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c
index 2f26f8e14f1..c6cd1fa88cd 100644
--- a/dlls/d3dx10_43/tests/d3dx10.c
+++ b/dlls/d3dx10_43/tests/d3dx10.c
@@ -1034,7 +1034,7 @@ test_image_load_info[] =
(D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET), 0,
(D3D10_RESOURCE_MISC_GENERATE_MIPS | D3D10_RESOURCE_MISC_TEXTURECUBE) } },
{ 4, 4, 1, 6, 3, DDS_RESOURCE_MISC_TEXTURECUBE, DXGI_FORMAT_BC1_UNORM, D3D10_RESOURCE_DIMENSION_TEXTURE2D,
- D3DX10_IFF_DDS }, .todo_resource_desc = TRUE,
+ D3DX10_IFF_DDS }
},
/*
* Even with the autogen mips misc flag specified, the mip levels argument
@@ -1050,7 +1050,7 @@ test_image_load_info[] =
(D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET), 0,
(D3D10_RESOURCE_MISC_GENERATE_MIPS | D3D10_RESOURCE_MISC_TEXTURECUBE) } },
{ 4, 4, 1, 6, 3, DDS_RESOURCE_MISC_TEXTURECUBE, DXGI_FORMAT_BC1_UNORM, D3D10_RESOURCE_DIMENSION_TEXTURE2D,
- D3DX10_IFF_DDS }, .todo_resource_desc = TRUE,
+ D3DX10_IFF_DDS }
},
};
@@ -1116,7 +1116,7 @@ static const struct test_invalid_image_load_info
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3D10_CPU_ACCESS_READ, D3D10_USAGE_DYNAMIC,
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT
},
- E_INVALIDARG, S_OK, E_INVALIDARG, .todo_hr = TRUE, .todo_create_device_object_hr = TRUE,
+ E_INVALIDARG, S_OK, E_INVALIDARG
},
{
test_dds_32bpp, sizeof(test_dds_32bpp),
@@ -1124,7 +1124,7 @@ static const struct test_invalid_image_load_info
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3D10_USAGE_DEFAULT,
D3D10_BIND_DEPTH_STENCIL, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT
},
- E_INVALIDARG, S_OK, E_INVALIDARG, .todo_hr = TRUE, .todo_create_device_object_hr = TRUE,
+ E_INVALIDARG, S_OK, E_INVALIDARG
},
/*
* D3D10_RESOURCE_MISC_GENERATE_MIPS requires binding as a shader resource
@@ -1136,7 +1136,7 @@ static const struct test_invalid_image_load_info
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3D10_USAGE_DEFAULT,
D3DX10_DEFAULT, D3DX10_DEFAULT, D3D10_RESOURCE_MISC_GENERATE_MIPS, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT
},
- E_INVALIDARG, S_OK, E_INVALIDARG, .todo_hr = TRUE, .todo_create_device_object_hr = TRUE,
+ E_INVALIDARG, S_OK, E_INVALIDARG
},
/* Can't set the cube texture flag if the image isn't a cube texture. */
{
@@ -1145,7 +1145,7 @@ static const struct test_invalid_image_load_info
D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT, D3D10_USAGE_DEFAULT,
D3DX10_DEFAULT, D3DX10_DEFAULT, D3D10_RESOURCE_MISC_TEXTURECUBE, D3DX10_DEFAULT, D3DX10_DEFAULT, D3DX10_DEFAULT
},
- E_INVALIDARG, S_OK, E_INVALIDARG, .todo_hr = TRUE, .todo_create_device_object_hr = TRUE,
+ E_INVALIDARG, S_OK, E_INVALIDARG
},
};
diff --git a/dlls/d3dx10_43/texture.c b/dlls/d3dx10_43/texture.c
index cd5fc112110..80f17fdde0f 100644
--- a/dlls/d3dx10_43/texture.c
+++ b/dlls/d3dx10_43/texture.c
@@ -646,15 +646,6 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
if (!data || !size)
return E_FAIL;
- if (load_info->Usage != D3DX10_DEFAULT)
- FIXME("load_info->Usage is ignored.\n");
- if (load_info->BindFlags != D3DX10_DEFAULT)
- FIXME("load_info->BindFlags is ignored.\n");
- if (load_info->CpuAccessFlags != D3DX10_DEFAULT)
- FIXME("load_info->CpuAccessFlags is ignored.\n");
- if (load_info->MiscFlags != D3DX10_DEFAULT)
- FIXME("load_info->MiscFlags is ignored.\n");
-
*resource_data = NULL;
if (!load_info->Filter || load_info->Filter == D3DX10_DEFAULT)
load_info->Filter = D3DX10_FILTER_TRIANGLE | D3DX10_FILTER_DITHER;
@@ -795,10 +786,11 @@ HRESULT load_texture_data(const void *data, SIZE_T size, D3DX10_IMAGE_LOAD_INFO
*resource_data = (D3D10_SUBRESOURCE_DATA *)sub_rsrcs;
sub_rsrcs = NULL;
- load_info->Usage = D3D10_USAGE_DEFAULT;
- load_info->BindFlags = D3D10_BIND_SHADER_RESOURCE;
- load_info->CpuAccessFlags = 0;
- load_info->MiscFlags = img_info.MiscFlags;
+ load_info->Usage = (load_info->Usage == D3DX10_DEFAULT) ? D3D10_USAGE_DEFAULT : load_info->Usage;
+ load_info->BindFlags = (load_info->BindFlags == D3DX10_DEFAULT) ? D3D10_BIND_SHADER_RESOURCE : load_info->BindFlags;
+ load_info->CpuAccessFlags = (load_info->CpuAccessFlags == D3DX10_DEFAULT) ? 0 : load_info->CpuAccessFlags;
+ load_info->MiscFlags = (load_info->MiscFlags == D3DX10_DEFAULT) ? 0 : load_info->MiscFlags;
+ load_info->MiscFlags |= img_info.MiscFlags;
if (load_info->pSrcInfo)
*load_info->pSrcInfo = img_info;
--
2.51.0

2215
patches/d3dx11_43-D3DX11CreateTextureFromMemory/0016-d3dx11-Implement-D3DX11CreateTextureFromMemory-using.patch Normal file
View File

File diff suppressed because it is too large Load Diff