git.oblomov.eu Git - wine/blob - dlls/d3dcompiler_43/d3dcompiler_43_main.c

   1 /*
   2  * Direct3D shader compiler main file
   3  *
   4  * Copyright 2010 Matteo Bruni for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wine/debug.h"
  29
  30 #include "d3dcompiler_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
  33
  34 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
  35 {
  36     switch (reason)
  37     {
  38         case DLL_WINE_PREATTACH:
  39             return FALSE; /* prefer native version */
  40         case DLL_PROCESS_ATTACH:
  41             DisableThreadLibraryCalls(inst);
  42             break;
  43         case DLL_PROCESS_DETACH:
  44             break;
  45     }
  46     return TRUE;
  47 }
  48
  49 HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3DBlob **blob)
  50 {
  51     struct d3dcompiler_blob *object;
  52     HRESULT hr;
  53
  54     TRACE("data_size %lu, blob %p\n", data_size, blob);
  55
  56     if (!blob)
  57     {
  58         WARN("Invalid blob specified.\n");
  59         return D3DERR_INVALIDCALL;
  60     }
  61
  62     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
  63     if (!object)
  64     {
  65         ERR("Failed to allocate D3D blob object memory\n");
  66         return E_OUTOFMEMORY;
  67     }
  68
  69     hr = d3dcompiler_blob_init(object, data_size);
  70     if (FAILED(hr))
  71     {
  72         WARN("Failed to initialize blob, hr %#x.\n", hr);
  73         HeapFree(GetProcessHeap(), 0, object);
  74         return hr;
  75     }
  76
  77     *blob = (ID3DBlob *)object;
  78
  79     TRACE("Created ID3DBlob %p\n", object);
  80
  81     return S_OK;
  82 }
  83
  84 HRESULT WINAPI D3DGetBlobPart(const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob)
  85 {
  86     TRACE("data %p, data_size %lu, part %s, flags %#x, blob %p\n", data,
  87            data_size, debug_d3dcompiler_d3d_blob_part(part), flags, blob);
  88
  89     return d3dcompiler_get_blob_part(data, data_size, part, flags, blob);
  90 }
  91
  92 HRESULT WINAPI D3DGetInputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob)
  93 {
  94     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
  95
  96     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, blob);
  97 }
  98
  99 HRESULT WINAPI D3DGetOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob)
 100 {
 101     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 102
 103     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_OUTPUT_SIGNATURE_BLOB, 0, blob);
 104 }
 105
 106 HRESULT WINAPI D3DGetInputAndOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob)
 107 {
 108     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 109
 110     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB, 0, blob);
 111 }
 112
 113 HRESULT WINAPI D3DGetDebugInfo(const void *data, SIZE_T data_size, ID3DBlob **blob)
 114 {
 115     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 116
 117     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_DEBUG_INFO, 0, blob);
 118 }
 119
 120 HRESULT WINAPI D3DStripShader(const void *data, SIZE_T data_size, UINT flags, ID3D10Blob **blob)
 121 {
 122     TRACE("data %p, data_size %lu, flags %#x, blob %p\n", data, data_size, flags, blob);
 123
 124     return d3dcompiler_strip_shader(data, data_size, flags, blob);
 125 }
 126
 127 HRESULT WINAPI D3DReflect(const void *data, SIZE_T data_size, REFIID riid, void **reflector)
 128 {
 129     struct d3dcompiler_shader_reflection *object;
 130     HRESULT hr;
 131     const DWORD *temp = data;
 132
 133     TRACE("data %p, data_size %lu, riid %s, blob %p\n", data, data_size, debugstr_guid(riid), reflector);
 134
 135     if (!data || data_size < 32)
 136     {
 137         WARN("Invalid argument supplied.\n");
 138         return D3DERR_INVALIDCALL;
 139     }
 140
 141     if (temp[6] != data_size)
 142     {
 143         WARN("Wrong size supplied.\n");
 144         return E_FAIL;
 145     }
 146
 147     if (!IsEqualGUID(riid, &IID_ID3D11ShaderReflection))
 148     {
 149         WARN("Wrong riid %s, accept only %s!\n", debugstr_guid(riid), debugstr_guid(&IID_ID3D11ShaderReflection));
 150         return E_NOINTERFACE;
 151     }
 152
 153     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 154     if (!object)
 155     {
 156         ERR("Failed to allocate D3D compiler shader reflection object memory\n");
 157         return E_OUTOFMEMORY;
 158     }
 159
 160     hr = d3dcompiler_shader_reflection_init(object, data, data_size);
 161     if (FAILED(hr))
 162     {
 163         WARN("Failed to initialize shader reflection\n");
 164         HeapFree(GetProcessHeap(), 0, object);
 165         return hr;
 166     }
 167
 168     *reflector = object;
 169
 170     TRACE("Created ID3D11ShaderReflection %p\n", object);
 171
 172     return S_OK;
 173 }