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_an(data, data_size), data_size, debugstr_a(filename), defines, include,
 230             debugstr_a(entry_point), debugstr_a(target), sflags, eflags, pump, shader,
 231             error_messages, hresult);
 232
 233     if (pump)
 234         FIXME("Unimplemented ID3DX10ThreadPump handling.\n");
 235
 236     return D3DCompile(data, data_size, filename, defines, include, entry_point, target,
 237             sflags, eflags, shader, error_messages);
 238 }
 239
 240 HRESULT WINAPI D3DX10CreateEffectPoolFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines,
 241         ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device,
 242         ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
 243 {
 244     FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
 245             "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
 246             debugstr_a(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
 247             pump, effectpool, errors, hresult);
 248
 249     return E_NOTIMPL;
 250 }
 251
 252 HRESULT WINAPI D3DX10CreateEffectPoolFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines,
 253         ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device,
 254         ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
 255 {
 256     FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
 257             "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
 258             debugstr_w(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
 259             pump, effectpool, errors, hresult);
 260
 261     return E_NOTIMPL;
 262 }
 263
 264 HRESULT WINAPI D3DX10CreateAsyncMemoryLoader(const void *data, SIZE_T data_size, ID3DX10DataLoader **loader)
 265 {
 266     struct asyncdataloader *object;
 267
 268     TRACE("data %p, data_size %lu, loader %p.\n", data, data_size, loader);
 269
 270     if (!data || !loader)
 271         return E_FAIL;
 272
 273     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 274     if (!object)
 275         return E_OUTOFMEMORY;
 276
 277     object->ID3DX10DataLoader_iface.lpVtbl = &memorydataloadervtbl;
 278     object->data = (void *)data;
 279     object->size = data_size;
 280
 281     *loader = &object->ID3DX10DataLoader_iface;
 282
 283     return S_OK;
 284 }
 285
 286 HRESULT WINAPI D3DX10CreateAsyncFileLoaderA(const char *filename, ID3DX10DataLoader **loader)
 287 {
 288     WCHAR *filename_w;
 289     HRESULT hr;
 290     int len;
 291
 292     TRACE("filename %s, loader %p.\n", debugstr_a(filename), loader);
 293
 294     if (!filename || !loader)
 295         return E_FAIL;
 296
 297     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 298     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*filename_w));
 299     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 300
 301     hr = D3DX10CreateAsyncFileLoaderW(filename_w, loader);
 302
 303     HeapFree(GetProcessHeap(), 0, filename_w);
 304
 305     return hr;
 306 }
 307
 308 HRESULT WINAPI D3DX10CreateAsyncFileLoaderW(const WCHAR *filename, ID3DX10DataLoader **loader)
 309 {
 310     struct asyncdataloader *object;
 311
 312     TRACE("filename %s, loader %p.\n", debugstr_w(filename), loader);
 313
 314     if (!filename || !loader)
 315         return E_FAIL;
 316
 317     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 318     if (!object)
 319         return E_OUTOFMEMORY;
 320
 321     object->ID3DX10DataLoader_iface.lpVtbl = &filedataloadervtbl;
 322     object->u.file.path = HeapAlloc(GetProcessHeap(), 0, (strlenW(filename) + 1) * sizeof(WCHAR));
 323     if (!object->u.file.path)
 324     {
 325         HeapFree(GetProcessHeap(), 0, object);
 326         return E_OUTOFMEMORY;
 327     }
 328     strcpyW(object->u.file.path, filename);
 329     object->data = NULL;
 330     object->size = 0;
 331
 332     *loader = &object->ID3DX10DataLoader_iface;
 333
 334     return S_OK;
 335 }
 336
 337 HRESULT WINAPI D3DX10CreateAsyncResourceLoaderA(HMODULE module, const char *resource, ID3DX10DataLoader **loader)
 338 {
 339     struct asyncdataloader *object;
 340     HRSRC rsrc;
 341
 342     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_a(resource), loader);
 343
 344     if (!loader)
 345         return E_FAIL;
 346
 347     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 348     if (!object)
 349         return E_OUTOFMEMORY;
 350
 351     if (!(rsrc = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 352     {
 353         ERR("Failed to find resource.\n");
 354         HeapFree(GetProcessHeap(), 0, object);
 355         return D3DX10_ERR_INVALID_DATA;
 356     }
 357
 358     object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 359     object->u.resource.module = module;
 360     object->u.resource.rsrc = rsrc;
 361     object->data = NULL;
 362     object->size = 0;
 363
 364     *loader = &object->ID3DX10DataLoader_iface;
 365
 366     return S_OK;
 367 }
 368
 369 HRESULT WINAPI D3DX10CreateAsyncResourceLoaderW(HMODULE module, const WCHAR *resource, ID3DX10DataLoader **loader)
 370 {
 371     struct asyncdataloader *object;
 372     HRSRC rsrc;
 373
 374     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_w(resource), loader);
 375
 376     if (!loader)
 377         return E_FAIL;
 378
 379     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 380     if (!object)
 381         return E_OUTOFMEMORY;
 382
 383     if (!(rsrc = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 384     {
 385         ERR("Failed to find resource.\n");
 386         HeapFree(GetProcessHeap(), 0, object);
 387         return D3DX10_ERR_INVALID_DATA;
 388     }
 389
 390     object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 391     object->u.resource.module = module;
 392     object->u.resource.rsrc = rsrc;
 393     object->data = NULL;
 394     object->size = 0;
 395
 396     *loader = &object->ID3DX10DataLoader_iface;
 397
 398     return S_OK;
 399 }