dlls/d3dx10_43/async.c

   1 /*
   2  * Copyright 2016 Andrey Gusev
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #include "d3d10_1.h"
  21 #include "d3dx10.h"
  22 #include "d3dcompiler.h"
  23 #include "dxhelpers.h"
  24
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  28
  29 struct asyncdataloader
  30 {
  31     ID3DX10DataLoader ID3DX10DataLoader_iface;
  32
  33     union
  34     {
  35         struct
  36         {
  37             WCHAR *path;
  38         } file;
  39         struct
  40         {
  41             HMODULE module;
  42             HRSRC rsrc;
  43         } resource;
  44     } u;
  45     void *data;
  46     DWORD size;
  47 };
  48
  49 static inline struct asyncdataloader *impl_from_ID3DX10DataLoader(ID3DX10DataLoader *iface)
  50 {
  51     return CONTAINING_RECORD(iface, struct asyncdataloader, ID3DX10DataLoader_iface);
  52 }
  53
  54 static HRESULT WINAPI memorydataloader_Load(ID3DX10DataLoader *iface)
  55 {
  56     TRACE("iface %p.\n", iface);
  57     return S_OK;
  58 }
  59
  60 static HRESULT WINAPI memorydataloader_Decompress(ID3DX10DataLoader *iface, void **data, SIZE_T *size)
  61 {
  62     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
  63
  64     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
  65
  66     *data = loader->data;
  67     *size = loader->size;
  68
  69     return S_OK;
  70 }
  71
  72 static HRESULT WINAPI memorydataloader_Destroy(ID3DX10DataLoader *iface)
  73 {
  74     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
  75
  76     TRACE("iface %p.\n", iface);
  77
  78     free(loader);
  79     return S_OK;
  80 }
  81
  82 static const ID3DX10DataLoaderVtbl memorydataloadervtbl =
  83 {
  84     memorydataloader_Load,
  85     memorydataloader_Decompress,
  86     memorydataloader_Destroy
  87 };
  88
  89 HRESULT load_file(const WCHAR *path, void **data, DWORD *size)
  90 {
  91     DWORD read_len;
  92     HANDLE file;
  93     BOOL ret;
  94
  95     file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
  96             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  97     if (file == INVALID_HANDLE_VALUE)
  98         return D3D10_ERROR_FILE_NOT_FOUND;
  99
 100     *size = GetFileSize(file, NULL);
 101     *data = malloc(*size);
 102     if (!*data)
 103     {
 104         CloseHandle(file);
 105         return E_OUTOFMEMORY;
 106     }
 107
 108     ret = ReadFile(file, *data, *size, &read_len, NULL);
 109     CloseHandle(file);
 110     if (!ret || read_len != *size)
 111     {
 112         WARN("Failed to read file contents.\n");
 113         free(*data);
 114         return E_FAIL;
 115     }
 116     return S_OK;
 117 }
 118
 119 static HRESULT WINAPI filedataloader_Load(ID3DX10DataLoader *iface)
 120 {
 121     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 122     void *data;
 123     DWORD size;
 124     HRESULT hr;
 125
 126     TRACE("iface %p.\n", iface);
 127
 128     /* Always buffer file contents, even if Load() was already called. */
 129     if (FAILED((hr = load_file(loader->u.file.path, &data, &size))))
 130         return hr;
 131
 132     free(loader->data);
 133     loader->data = data;
 134     loader->size = size;
 135
 136     return S_OK;
 137 }
 138
 139 static HRESULT WINAPI filedataloader_Decompress(ID3DX10DataLoader *iface, void **data, SIZE_T *size)
 140 {
 141     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 142
 143     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 144
 145     if (!loader->data)
 146         return E_FAIL;
 147
 148     *data = loader->data;
 149     *size = loader->size;
 150
 151     return S_OK;
 152 }
 153
 154 static HRESULT WINAPI filedataloader_Destroy(ID3DX10DataLoader *iface)
 155 {
 156     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 157
 158     TRACE("iface %p.\n", iface);
 159
 160     free(loader->u.file.path);
 161     free(loader->data);
 162     free(loader);
 163
 164     return S_OK;
 165 }
 166
 167 static const ID3DX10DataLoaderVtbl filedataloadervtbl =
 168 {
 169     filedataloader_Load,
 170     filedataloader_Decompress,
 171     filedataloader_Destroy
 172 };
 173
 174 static HRESULT load_resource_initA(HMODULE module, const char *resource, HRSRC *rsrc)
 175 {
 176     if (!(*rsrc = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 177         *rsrc = FindResourceA(module, resource, (const char *)RT_BITMAP);
 178     if (!*rsrc)
 179     {
 180         WARN("Failed to find resource.\n");
 181         return D3DX10_ERR_INVALID_DATA;
 182     }
 183     return S_OK;
 184 }
 185
 186 static HRESULT load_resource_initW(HMODULE module, const WCHAR *resource, HRSRC *rsrc)
 187 {
 188     if (!(*rsrc = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 189         *rsrc = FindResourceW(module, resource, (const WCHAR *)RT_BITMAP);
 190     if (!*rsrc)
 191     {
 192         WARN("Failed to find resource.\n");
 193         return D3DX10_ERR_INVALID_DATA;
 194     }
 195     return S_OK;
 196 }
 197
 198 static HRESULT load_resource(HMODULE module, HRSRC rsrc, void **data, DWORD *size)
 199 {
 200     HGLOBAL hglobal;
 201
 202     if (!(*size = SizeofResource(module, rsrc)))
 203         return D3DX10_ERR_INVALID_DATA;
 204     if (!(hglobal = LoadResource(module, rsrc)))
 205         return D3DX10_ERR_INVALID_DATA;
 206     if (!(*data = LockResource(hglobal)))
 207         return D3DX10_ERR_INVALID_DATA;
 208     return S_OK;
 209 }
 210
 211 HRESULT load_resourceA(HMODULE module, const char *resource, void **data, DWORD *size)
 212 {
 213     HRESULT hr;
 214     HRSRC rsrc;
 215
 216     if (FAILED((hr = load_resource_initA(module, resource, &rsrc))))
 217         return hr;
 218     return load_resource(module, rsrc, data, size);
 219 }
 220
 221 HRESULT load_resourceW(HMODULE module, const WCHAR *resource, void **data, DWORD *size)
 222 {
 223     HRESULT hr;
 224     HRSRC rsrc;
 225
 226     if ((FAILED(hr = load_resource_initW(module, resource, &rsrc))))
 227         return hr;
 228     return load_resource(module, rsrc, data, size);
 229 }
 230
 231 static HRESULT WINAPI resourcedataloader_Load(ID3DX10DataLoader *iface)
 232 {
 233     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 234
 235     TRACE("iface %p.\n", iface);
 236
 237     if (loader->data)
 238         return S_OK;
 239
 240     return load_resource(loader->u.resource.module, loader->u.resource.rsrc,
 241             &loader->data, &loader->size);
 242 }
 243
 244 static HRESULT WINAPI resourcedataloader_Decompress(ID3DX10DataLoader *iface, void **data, SIZE_T *size)
 245 {
 246     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 247
 248     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 249
 250     if (!loader->data)
 251         return E_FAIL;
 252
 253     *data = loader->data;
 254     *size = loader->size;
 255
 256     return S_OK;
 257 }
 258
 259 static HRESULT WINAPI resourcedataloader_Destroy(ID3DX10DataLoader *iface)
 260 {
 261     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 262
 263     TRACE("iface %p.\n", iface);
 264
 265     free(loader);
 266
 267     return S_OK;
 268 }
 269
 270 static const ID3DX10DataLoaderVtbl resourcedataloadervtbl =
 271 {
 272     resourcedataloader_Load,
 273     resourcedataloader_Decompress,
 274     resourcedataloader_Destroy
 275 };
 276
 277 struct texture_info_processor
 278 {
 279     ID3DX10DataProcessor ID3DX10DataProcessor_iface;
 280     D3DX10_IMAGE_INFO *info;
 281 };
 282
 283 static inline struct texture_info_processor *impl_from_ID3DX10DataProcessor(ID3DX10DataProcessor *iface)
 284 {
 285     return CONTAINING_RECORD(iface, struct texture_info_processor, ID3DX10DataProcessor_iface);
 286 }
 287
 288 static HRESULT WINAPI texture_info_processor_Process(ID3DX10DataProcessor *iface, void *data, SIZE_T size)
 289 {
 290     struct texture_info_processor *processor = impl_from_ID3DX10DataProcessor(iface);
 291
 292     TRACE("iface %p, data %p, size %Iu.\n", iface, data, size);
 293     return get_image_info(data, size, processor->info);
 294 }
 295
 296 static HRESULT WINAPI texture_info_processor_CreateDeviceObject(ID3DX10DataProcessor *iface, void **object)
 297 {
 298     TRACE("iface %p, object %p.\n", iface, object);
 299     return S_OK;
 300 }
 301
 302 static HRESULT WINAPI texture_info_processor_Destroy(ID3DX10DataProcessor *iface)
 303 {
 304     struct texture_info_processor *processor = impl_from_ID3DX10DataProcessor(iface);
 305
 306     TRACE("iface %p.\n", iface);
 307
 308     free(processor);
 309     return S_OK;
 310 }
 311
 312 static ID3DX10DataProcessorVtbl texture_info_processor_vtbl =
 313 {
 314     texture_info_processor_Process,
 315     texture_info_processor_CreateDeviceObject,
 316     texture_info_processor_Destroy
 317 };
 318
 319 struct texture_processor
 320 {
 321     ID3DX10DataProcessor ID3DX10DataProcessor_iface;
 322     ID3D10Device *device;
 323     D3DX10_IMAGE_LOAD_INFO load_info;
 324     D3D10_SUBRESOURCE_DATA *resource_data;
 325 };
 326
 327 static inline struct texture_processor *texture_processor_from_ID3DX10DataProcessor(ID3DX10DataProcessor *iface)
 328 {
 329     return CONTAINING_RECORD(iface, struct texture_processor, ID3DX10DataProcessor_iface);
 330 }
 331
 332 static HRESULT WINAPI texture_processor_Process(ID3DX10DataProcessor *iface, void *data, SIZE_T size)
 333 {
 334     struct texture_processor *processor = texture_processor_from_ID3DX10DataProcessor(iface);
 335
 336     TRACE("iface %p, data %p, size %Iu.\n", iface, data, size);
 337
 338     if (processor->resource_data)
 339     {
 340         WARN("Called multiple times.\n");
 341         free(processor->resource_data);
 342         processor->resource_data = NULL;
 343     }
 344     return load_texture_data(data, size, &processor->load_info, &processor->resource_data);
 345 }
 346
 347 static HRESULT WINAPI texture_processor_CreateDeviceObject(ID3DX10DataProcessor *iface, void **object)
 348 {
 349     struct texture_processor *processor = texture_processor_from_ID3DX10DataProcessor(iface);
 350
 351     TRACE("iface %p, object %p.\n", iface, object);
 352
 353     if (!processor->resource_data)
 354         return E_FAIL;
 355
 356     return create_d3d_texture(processor->device, &processor->load_info,
 357             processor->resource_data, (ID3D10Resource **)object);
 358 }
 359
 360 static HRESULT WINAPI texture_processor_Destroy(ID3DX10DataProcessor *iface)
 361 {
 362     struct texture_processor *processor = texture_processor_from_ID3DX10DataProcessor(iface);
 363
 364     TRACE("iface %p.\n", iface);
 365
 366     ID3D10Device_Release(processor->device);
 367     free(processor->resource_data);
 368     free(processor);
 369     return S_OK;
 370 }
 371
 372 static ID3DX10DataProcessorVtbl texture_processor_vtbl =
 373 {
 374     texture_processor_Process,
 375     texture_processor_CreateDeviceObject,
 376     texture_processor_Destroy
 377 };
 378
 379 HRESULT WINAPI D3DX10CompileFromMemory(const char *data, SIZE_T data_size, const char *filename,
 380         const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point,
 381         const char *target, UINT sflags, UINT eflags, ID3DX10ThreadPump *pump, ID3D10Blob **shader,
 382         ID3D10Blob **error_messages, HRESULT *hresult)
 383 {
 384     TRACE("data %s, data_size %Iu, filename %s, defines %p, include %p, entry_point %s, target %s, "
 385             "sflags %#x, eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n",
 386             debugstr_an(data, data_size), data_size, debugstr_a(filename), defines, include,
 387             debugstr_a(entry_point), debugstr_a(target), sflags, eflags, pump, shader,
 388             error_messages, hresult);
 389
 390     if (pump)
 391         FIXME("Unimplemented ID3DX10ThreadPump handling.\n");
 392
 393     return D3DCompile(data, data_size, filename, defines, include, entry_point, target,
 394             sflags, eflags, shader, error_messages);
 395 }
 396
 397 HRESULT WINAPI D3DX10CreateEffectPoolFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines,
 398         ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device,
 399         ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
 400 {
 401     FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
 402             "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
 403             debugstr_a(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
 404             pump, effectpool, errors, hresult);
 405
 406     return E_NOTIMPL;
 407 }
 408
 409 HRESULT WINAPI D3DX10CreateEffectPoolFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines,
 410         ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device,
 411         ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
 412 {
 413     FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
 414             "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
 415             debugstr_w(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
 416             pump, effectpool, errors, hresult);
 417
 418     return E_NOTIMPL;
 419 }
 420
 421 HRESULT WINAPI D3DX10CreateAsyncMemoryLoader(const void *data, SIZE_T data_size, ID3DX10DataLoader **loader)
 422 {
 423     struct asyncdataloader *object;
 424
 425     TRACE("data %p, data_size %Iu, loader %p.\n", data, data_size, loader);
 426
 427     if (!data || !loader)
 428         return E_FAIL;
 429
 430     object = calloc(1, sizeof(*object));
 431     if (!object)
 432         return E_OUTOFMEMORY;
 433
 434     object->ID3DX10DataLoader_iface.lpVtbl = &memorydataloadervtbl;
 435     object->data = (void *)data;
 436     object->size = data_size;
 437
 438     *loader = &object->ID3DX10DataLoader_iface;
 439
 440     return S_OK;
 441 }
 442
 443 HRESULT WINAPI D3DX10CreateAsyncFileLoaderA(const char *filename, ID3DX10DataLoader **loader)
 444 {
 445     WCHAR *filename_w;
 446     HRESULT hr;
 447     int len;
 448
 449     TRACE("filename %s, loader %p.\n", debugstr_a(filename), loader);
 450
 451     if (!filename || !loader)
 452         return E_FAIL;
 453
 454     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 455     filename_w = malloc(len * sizeof(*filename_w));
 456     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 457
 458     hr = D3DX10CreateAsyncFileLoaderW(filename_w, loader);
 459
 460     free(filename_w);
 461
 462     return hr;
 463 }
 464
 465 HRESULT WINAPI D3DX10CreateAsyncFileLoaderW(const WCHAR *filename, ID3DX10DataLoader **loader)
 466 {
 467     struct asyncdataloader *object;
 468
 469     TRACE("filename %s, loader %p.\n", debugstr_w(filename), loader);
 470
 471     if (!filename || !loader)
 472         return E_FAIL;
 473
 474     object = calloc(1, sizeof(*object));
 475     if (!object)
 476         return E_OUTOFMEMORY;
 477
 478     object->ID3DX10DataLoader_iface.lpVtbl = &filedataloadervtbl;
 479     object->u.file.path = malloc((lstrlenW(filename) + 1) * sizeof(WCHAR));
 480     if (!object->u.file.path)
 481     {
 482         free(object);
 483         return E_OUTOFMEMORY;
 484     }
 485     lstrcpyW(object->u.file.path, filename);
 486     object->data = NULL;
 487     object->size = 0;
 488
 489     *loader = &object->ID3DX10DataLoader_iface;
 490
 491     return S_OK;
 492 }
 493
 494 HRESULT WINAPI D3DX10CreateAsyncResourceLoaderA(HMODULE module, const char *resource, ID3DX10DataLoader **loader)
 495 {
 496     struct asyncdataloader *object;
 497     HRSRC rsrc;
 498     HRESULT hr;
 499
 500     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_a(resource), loader);
 501
 502     if (!loader)
 503         return E_FAIL;
 504
 505     object = calloc(1, sizeof(*object));
 506     if (!object)
 507         return E_OUTOFMEMORY;
 508
 509     if (FAILED((hr = load_resource_initA(module, resource, &rsrc))))
 510     {
 511         free(object);
 512         return hr;
 513     }
 514
 515     object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 516     object->u.resource.module = module;
 517     object->u.resource.rsrc = rsrc;
 518     object->data = NULL;
 519     object->size = 0;
 520
 521     *loader = &object->ID3DX10DataLoader_iface;
 522
 523     return S_OK;
 524 }
 525
 526 HRESULT WINAPI D3DX10CreateAsyncResourceLoaderW(HMODULE module, const WCHAR *resource, ID3DX10DataLoader **loader)
 527 {
 528     struct asyncdataloader *object;
 529     HRSRC rsrc;
 530     HRESULT hr;
 531
 532     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_w(resource), loader);
 533
 534     if (!loader)
 535         return E_FAIL;
 536
 537     object = calloc(1, sizeof(*object));
 538     if (!object)
 539         return E_OUTOFMEMORY;
 540
 541     if (FAILED((hr = load_resource_initW(module, resource, &rsrc))))
 542     {
 543         free(object);
 544         return hr;
 545     }
 546
 547     object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 548     object->u.resource.module = module;
 549     object->u.resource.rsrc = rsrc;
 550     object->data = NULL;
 551     object->size = 0;
 552
 553     *loader = &object->ID3DX10DataLoader_iface;
 554
 555     return S_OK;
 556 }
 557
 558 HRESULT WINAPI D3DX10CreateAsyncTextureInfoProcessor(D3DX10_IMAGE_INFO *info, ID3DX10DataProcessor **processor)
 559 {
 560     struct texture_info_processor *object;
 561
 562     TRACE("info %p, processor %p.\n", info, processor);
 563
 564     if (!processor)
 565         return E_INVALIDARG;
 566
 567     object = malloc(sizeof(*object));
 568     if (!object)
 569         return E_OUTOFMEMORY;
 570
 571     object->ID3DX10DataProcessor_iface.lpVtbl = &texture_info_processor_vtbl;
 572     object->info = info;
 573
 574     *processor = &object->ID3DX10DataProcessor_iface;
 575     return S_OK;
 576 }
 577
 578 HRESULT WINAPI D3DX10CreateAsyncTextureProcessor(ID3D10Device *device,
 579         D3DX10_IMAGE_LOAD_INFO *load_info, ID3DX10DataProcessor **processor)
 580 {
 581     struct texture_processor *object;
 582
 583     TRACE("device %p, load_info %p, processor %p.\n", device, load_info, processor);
 584
 585     if (!device || !processor)
 586         return E_INVALIDARG;
 587
 588     object = calloc(1, sizeof(*object));
 589     if (!object)
 590         return E_OUTOFMEMORY;
 591
 592     object->ID3DX10DataProcessor_iface.lpVtbl = &texture_processor_vtbl;
 593     object->device = device;
 594     ID3D10Device_AddRef(device);
 595     init_load_info(load_info, &object->load_info);
 596
 597     *processor = &object->ID3DX10DataProcessor_iface;
 598     return S_OK;
 599 }
 600
 601 HRESULT WINAPI D3DX10PreprocessShaderFromMemory(const char *data, SIZE_T data_size, const char *filename,
 602         const D3D10_SHADER_MACRO *defines, ID3DInclude *include, ID3DX10ThreadPump *pump, ID3D10Blob **shader_text,
 603         ID3D10Blob **errors, HRESULT *hresult)
 604 {
 605     FIXME("data %s, data_size %Iu, filename %s, defines %p, include %p, pump %p, shader_text %p, "
 606             "errors %p, hresult %p stub!\n",
 607             debugstr_an(data, data_size), data_size, debugstr_a(filename), defines, include, pump,
 608             shader_text, errors, hresult);
 609
 610     return E_NOTIMPL;
 611 }