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 #include "config.h"
  20 #include "wine/port.h"
  21 #include "d3d10_1.h"
  22 #include "d3dx10.h"
  23 #include "d3dx10core.h"
  24 #include "d3dcompiler.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/unicode.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  30
  31 struct asyncdataloader
  32 {
  33     ID3DX10DataLoader ID3DX10DataLoader_iface;
  34
  35     union
  36     {
  37         struct
  38         {
  39             WCHAR *path;
  40         } file;
  41         struct
  42         {
  43             HMODULE module;
  44             HRSRC rsrc;
  45         } resource;
  46     } u;
  47     void *data;
  48     SIZE_T size;
  49 };
  50
  51 static inline struct asyncdataloader *impl_from_ID3DX10DataLoader(ID3DX10DataLoader *iface)
  52 {
  53     return CONTAINING_RECORD(iface, struct asyncdataloader, ID3DX10DataLoader_iface);
  54 }
  55
  56 static HRESULT WINAPI memorydataloader_Load(ID3DX10DataLoader *iface)
  57 {
  58     TRACE("iface %p.\n", iface);
  59     return S_OK;
  60 }
  61
  62 static HRESULT WINAPI memorydataloader_Decompress(ID3DX10DataLoader *iface, void **data, SIZE_T *size)
  63 {
  64     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
  65
  66     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
  67
  68     *data = loader->data;
  69     *size = loader->size;
  70
  71     return S_OK;
  72 }
  73
  74 static HRESULT WINAPI memorydataloader_Destroy(ID3DX10DataLoader *iface)
  75 {
  76     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
  77
  78     TRACE("iface %p.\n", iface);
  79
  80     HeapFree(GetProcessHeap(), 0, loader);
  81     return S_OK;
  82 }
  83
  84 static const ID3DX10DataLoaderVtbl memorydataloadervtbl =
  85 {
  86     memorydataloader_Load,
  87     memorydataloader_Decompress,
  88     memorydataloader_Destroy
  89 };
  90
  91 static HRESULT WINAPI filedataloader_Load(ID3DX10DataLoader *iface)
  92 {
  93     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
  94     DWORD size, read_len;
  95     HANDLE file;
  96     void *data;
  97     BOOL ret;
  98
  99     TRACE("iface %p.\n", iface);
 100
 101     /* Always buffer file contents, even if Load() was already called. */
 102     file = CreateFileW(loader->u.file.path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
 103             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 104     if (file == INVALID_HANDLE_VALUE)
 105         return D3D10_ERROR_FILE_NOT_FOUND;
 106
 107     size = GetFileSize(file, NULL);
 108     data = HeapAlloc(GetProcessHeap(), 0, size);
 109     if (!data)
 110     {
 111         CloseHandle(file);
 112         return E_OUTOFMEMORY;
 113     }
 114
 115     ret = ReadFile(file, data, size, &read_len, NULL);
 116     CloseHandle(file);
 117     if (!ret)
 118     {
 119         ERR("Failed to read file contents.\n");
 120         HeapFree(GetProcessHeap(), 0, data);
 121         return E_FAIL;
 122     }
 123
 124     HeapFree(GetProcessHeap(), 0, loader->data);
 125     loader->data = data;
 126     loader->size = size;
 127
 128     return S_OK;
 129 }
 130
 131 static HRESULT WINAPI filedataloader_Decompress(ID3DX10DataLoader *iface, void **data, SIZE_T *size)
 132 {
 133     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 134
 135     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 136
 137     if (!loader->data)
 138         return E_FAIL;
 139
 140     *data = loader->data;
 141     *size = loader->size;
 142
 143     return S_OK;
 144 }
 145
 146 static HRESULT WINAPI filedataloader_Destroy(ID3DX10DataLoader *iface)
 147 {
 148     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 149
 150     TRACE("iface %p.\n", iface);
 151
 152     HeapFree(GetProcessHeap(), 0, loader->u.file.path);
 153     HeapFree(GetProcessHeap(), 0, loader->data);
 154     HeapFree(GetProcessHeap(), 0, loader);
 155
 156     return S_OK;
 157 }
 158
 159 static const ID3DX10DataLoaderVtbl filedataloadervtbl =
 160 {
 161     filedataloader_Load,
 162     filedataloader_Decompress,
 163     filedataloader_Destroy
 164 };
 165
 166 static HRESULT WINAPI resourcedataloader_Load(ID3DX10DataLoader *iface)
 167 {
 168     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 169     HGLOBAL hglobal;
 170
 171     TRACE("iface %p.\n", iface);
 172
 173     if (loader->data)
 174         return S_OK;
 175
 176     hglobal = LoadResource(loader->u.resource.module, loader->u.resource.rsrc);
 177     if (!hglobal)
 178     {
 179         ERR("Failed to load resource.\n");
 180         return E_FAIL;
 181     }
 182
 183     loader->data = LockResource(hglobal);
 184     loader->size = SizeofResource(loader->u.resource.module, loader->u.resource.rsrc);
 185
 186     return S_OK;
 187 }
 188
 189 static HRESULT WINAPI resourcedataloader_Decompress(ID3DX10DataLoader *iface, void **data, SIZE_T *size)
 190 {
 191     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 192
 193     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 194
 195     if (!loader->data)
 196         return E_FAIL;
 197
 198     *data = loader->data;
 199     *size = loader->size;
 200
 201     return S_OK;
 202 }
 203
 204 static HRESULT WINAPI resourcedataloader_Destroy(ID3DX10DataLoader *iface)
 205 {
 206     struct asyncdataloader *loader = impl_from_ID3DX10DataLoader(iface);
 207
 208     TRACE("iface %p.\n", iface);
 209
 210     HeapFree(GetProcessHeap(), 0, loader);
 211
 212     return S_OK;
 213 }
 214
 215 static const ID3DX10DataLoaderVtbl resourcedataloadervtbl =
 216 {
 217     resourcedataloader_Load,
 218     resourcedataloader_Decompress,
 219     resourcedataloader_Destroy
 220 };
 221
 222 HRESULT WINAPI D3DX10CompileFromMemory(const char *data, SIZE_T data_size, const char *filename,
 223         const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point,
 224         const char *target, UINT sflags, UINT eflags, ID3DX10ThreadPump *pump, ID3D10Blob **shader,
 225         ID3D10Blob **error_messages, HRESULT *hresult)
 226 {
 227     TRACE("data %s, data_size %lu, filename %s, defines %p, include %p, entry_point %s, target %s, "
 228             "sflags %#x, eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n",
 229             debugstr_a(data), data_size, debugstr_a(filename), defines, include, debugstr_a(entry_point),
 230             debugstr_a(target), sflags, eflags, pump, shader, error_messages, hresult);
 231
 232     if (pump)
 233         FIXME("Unimplemented ID3DX10ThreadPump handling.\n");
 234
 235     return D3DCompile(data, data_size, filename, defines, include, entry_point, target,
 236             sflags, eflags, shader, error_messages);
 237 }
 238
 239 HRESULT WINAPI D3DX10CreateEffectPoolFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines,
 240         ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device,
 241         ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
 242 {
 243     FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
 244             "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
 245             debugstr_a(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
 246             pump, effectpool, errors, hresult);
 247
 248     return E_NOTIMPL;
 249 }
 250
 251 HRESULT WINAPI D3DX10CreateEffectPoolFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines,
 252         ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device,
 253         ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
 254 {
 255     FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
 256             "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
 257             debugstr_w(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
 258             pump, effectpool, errors, hresult);
 259
 260     return E_NOTIMPL;
 261 }
 262
 263 HRESULT WINAPI D3DX10CreateAsyncMemoryLoader(const void *data, SIZE_T data_size, ID3DX10DataLoader **loader)
 264 {
 265     struct asyncdataloader *object;
 266
 267     TRACE("data %p, data_size %lu, loader %p.\n", data, data_size, loader);
 268
 269     if (!data || !loader)
 270         return E_FAIL;
 271
 272     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 273     if (!object)
 274         return E_OUTOFMEMORY;
 275
 276     object->ID3DX10DataLoader_iface.lpVtbl = &memorydataloadervtbl;
 277     object->data = (void *)data;
 278     object->size = data_size;
 279
 280     *loader = &object->ID3DX10DataLoader_iface;
 281
 282     return S_OK;
 283 }
 284
 285 HRESULT WINAPI D3DX10CreateAsyncFileLoaderA(const char *filename, ID3DX10DataLoader **loader)
 286 {
 287     WCHAR *filename_w;
 288     HRESULT hr;
 289     int len;
 290
 291     TRACE("filename %s, loader %p.\n", debugstr_a(filename), loader);
 292
 293     if (!filename || !loader)
 294         return E_FAIL;
 295
 296     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 297     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*filename_w));
 298     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 299
 300     hr = D3DX10CreateAsyncFileLoaderW(filename_w, loader);
 301
 302     HeapFree(GetProcessHeap(), 0, filename_w);
 303
 304     return hr;
 305 }
 306
 307 HRESULT WINAPI D3DX10CreateAsyncFileLoaderW(const WCHAR *filename, ID3DX10DataLoader **loader)
 308 {
 309     struct asyncdataloader *object;
 310
 311     TRACE("filename %s, loader %p.\n", debugstr_w(filename), loader);
 312
 313     if (!filename || !loader)
 314         return E_FAIL;
 315
 316     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 317     if (!object)
 318         return E_OUTOFMEMORY;
 319
 320     object->ID3DX10DataLoader_iface.lpVtbl = &filedataloadervtbl;
 321     object->u.file.path = HeapAlloc(GetProcessHeap(), 0, (strlenW(filename) + 1) * sizeof(WCHAR));
 322     if (!object->u.file.path)
 323     {
 324         HeapFree(GetProcessHeap(), 0, object);
 325         return E_OUTOFMEMORY;
 326     }
 327     strcpyW(object->u.file.path, filename);
 328     object->data = NULL;
 329     object->size = 0;
 330
 331     *loader = &object->ID3DX10DataLoader_iface;
 332
 333     return S_OK;
 334 }
 335
 336 HRESULT WINAPI D3DX10CreateAsyncResourceLoaderA(HMODULE module, const char *resource, ID3DX10DataLoader **loader)
 337 {
 338     struct asyncdataloader *object;
 339     HRSRC rsrc;
 340
 341     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_a(resource), loader);
 342
 343     if (!loader)
 344         return E_FAIL;
 345
 346     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 347     if (!object)
 348         return E_OUTOFMEMORY;
 349
 350     if (!(rsrc = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 351     {
 352         ERR("Failed to find resource.\n");
 353         HeapFree(GetProcessHeap(), 0, object);
 354         return D3DX10_ERR_INVALID_DATA;
 355     }
 356
 357     object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 358     object->u.resource.module = module;
 359     object->u.resource.rsrc = rsrc;
 360     object->data = NULL;
 361     object->size = 0;
 362
 363     *loader = &object->ID3DX10DataLoader_iface;
 364
 365     return S_OK;
 366 }
 367
 368 HRESULT WINAPI D3DX10CreateAsyncResourceLoaderW(HMODULE module, const WCHAR *resource, ID3DX10DataLoader **loader)
 369 {
 370     struct asyncdataloader *object;
 371     HRSRC rsrc;
 372
 373     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_w(resource), loader);
 374
 375     if (!loader)
 376         return E_FAIL;
 377
 378     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 379     if (!object)
 380         return E_OUTOFMEMORY;
 381
 382     if (!(rsrc = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 383     {
 384         ERR("Failed to find resource.\n");
 385         HeapFree(GetProcessHeap(), 0, object);
 386         return D3DX10_ERR_INVALID_DATA;
 387     }
 388
 389     object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 390     object->u.resource.module = module;
 391     object->u.resource.rsrc = rsrc;
 392     object->data = NULL;
 393     object->size = 0;
 394
 395     *loader = &object->ID3DX10DataLoader_iface;
 396
 397     return S_OK;
 398 }