dlls/d3d10core/inputlayout.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   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
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "d3d10core_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10core);
  26
  27 struct input_signature_element
  28 {
  29     const char *semantic_name;
  30     UINT semantic_idx;
  31     DWORD unknown; /* system value semantic? */
  32     DWORD component_type;
  33     UINT register_idx;
  34     DWORD mask;
  35 };
  36
  37 struct input_signature
  38 {
  39     struct input_signature_element *elements;
  40     UINT element_count;
  41 };
  42
  43 static HRESULT parse_isgn(const char *data, struct input_signature *is)
  44 {
  45     struct input_signature_element *e;
  46     const char *ptr = data;
  47     unsigned int i;
  48     DWORD count;
  49
  50     read_dword(&ptr, &count);
  51     TRACE("%u elements\n", count);
  52
  53     skip_dword_unknown(&ptr, 1);
  54
  55     e = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*e));
  56     if (!e)
  57     {
  58         ERR("Failed to allocate input signature memory.\n");
  59         return E_OUTOFMEMORY;
  60     }
  61
  62     for (i = 0; i < count; ++i)
  63     {
  64         UINT name_offset;
  65
  66         read_dword(&ptr, &name_offset);
  67         e[i].semantic_name = data + name_offset;
  68         read_dword(&ptr, &e[i].semantic_idx);
  69         read_dword(&ptr, &e[i].unknown);
  70         read_dword(&ptr, &e[i].component_type);
  71         read_dword(&ptr, &e[i].register_idx);
  72         read_dword(&ptr, &e[i].mask);
  73
  74         TRACE("semantic: %s, semantic idx: %u, unknown %#x, type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
  75                 e[i].semantic_name, e[i].semantic_idx, e[i].unknown, e[i].component_type,
  76                 e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff);
  77     }
  78
  79     is->elements = e;
  80     is->element_count = count;
  81
  82     return S_OK;
  83 }
  84
  85 static HRESULT isgn_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
  86 {
  87     struct input_signature *is = ctx;
  88     const char *ptr = data;
  89     char tag_str[5];
  90
  91     switch(tag)
  92     {
  93         case TAG_ISGN:
  94             return parse_isgn(ptr, is);
  95
  96         default:
  97             memcpy(tag_str, &tag, 4);
  98             tag_str[4] = '\0';
  99             FIXME("Unhandled chunk %s\n", tag_str);
 100             return S_OK;
 101     }
 102 }
 103
 104 HRESULT d3d10_input_layout_to_wined3d_declaration(const D3D10_INPUT_ELEMENT_DESC *element_descs,
 105         UINT element_count, const void *shader_byte_code, SIZE_T shader_byte_code_length,
 106         WINED3DVERTEXELEMENT **wined3d_elements, UINT *wined3d_element_count)
 107 {
 108     struct input_signature is;
 109     HRESULT hr;
 110     UINT i;
 111
 112     hr = parse_dxbc(shader_byte_code, shader_byte_code_length, isgn_handler, &is);
 113     if (FAILED(hr))
 114     {
 115         ERR("Failed to parse input signature.\n");
 116         return E_FAIL;
 117     }
 118
 119     *wined3d_elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(**wined3d_elements));
 120     if (!*wined3d_elements)
 121     {
 122         ERR("Failed to allocate wined3d vertex element array memory.\n");
 123         HeapFree(GetProcessHeap(), 0, is.elements);
 124         return E_OUTOFMEMORY;
 125     }
 126     *wined3d_element_count = 0;
 127
 128     for (i = 0; i < element_count; ++i)
 129     {
 130         UINT j;
 131
 132         for (j = 0; j < is.element_count; ++j)
 133         {
 134             if (!strcmp(element_descs[i].SemanticName, is.elements[j].semantic_name)
 135                     && element_descs[i].SemanticIndex == is.elements[j].semantic_idx)
 136             {
 137                 WINED3DVERTEXELEMENT *e = &(*wined3d_elements)[(*wined3d_element_count)++];
 138                 const D3D10_INPUT_ELEMENT_DESC *f = &element_descs[i];
 139
 140                 e->format = wined3dformat_from_dxgi_format(f->Format);
 141                 e->input_slot = f->InputSlot;
 142                 e->offset = f->AlignedByteOffset;
 143                 e->output_slot = is.elements[j].register_idx;
 144                 e->method = WINED3DDECLMETHOD_DEFAULT;
 145                 e->usage = 0;
 146                 e->usage_idx = 0;
 147
 148                 if (f->AlignedByteOffset == D3D10_APPEND_ALIGNED_ELEMENT)
 149                     FIXME("D3D10_APPEND_ALIGNED_ELEMENT not supported\n");
 150                 if (f->InputSlotClass != D3D10_INPUT_PER_VERTEX_DATA)
 151                     FIXME("Ignoring input slot class (%#x)\n", f->InputSlotClass);
 152                 if (f->InstanceDataStepRate)
 153                     FIXME("Ignoring instace data step rate (%#x)\n", f->InstanceDataStepRate);
 154
 155                 break;
 156             }
 157         }
 158     }
 159
 160     HeapFree(GetProcessHeap(), 0, is.elements);
 161
 162     return S_OK;
 163 }
 164
 165 /* IUnknown methods */
 166
 167 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_QueryInterface(ID3D10InputLayout *iface,
 168         REFIID riid, void **object)
 169 {
 170     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 171
 172     if (IsEqualGUID(riid, &IID_ID3D10InputLayout)
 173             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 174             || IsEqualGUID(riid, &IID_IUnknown))
 175     {
 176         IUnknown_AddRef(iface);
 177         *object = iface;
 178         return S_OK;
 179     }
 180
 181     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 182
 183     *object = NULL;
 184     return E_NOINTERFACE;
 185 }
 186
 187 static ULONG STDMETHODCALLTYPE d3d10_input_layout_AddRef(ID3D10InputLayout *iface)
 188 {
 189     struct d3d10_input_layout *This = (struct d3d10_input_layout *)iface;
 190     ULONG refcount = InterlockedIncrement(&This->refcount);
 191
 192     TRACE("%p increasing refcount to %u\n", This, refcount);
 193
 194     return refcount;
 195 }
 196
 197 static ULONG STDMETHODCALLTYPE d3d10_input_layout_Release(ID3D10InputLayout *iface)
 198 {
 199     struct d3d10_input_layout *This = (struct d3d10_input_layout *)iface;
 200     ULONG refcount = InterlockedDecrement(&This->refcount);
 201
 202     TRACE("%p decreasing refcount to %u\n", This, refcount);
 203
 204     if (!refcount)
 205     {
 206         IWineD3DVertexDeclaration_Release(This->wined3d_decl);
 207         HeapFree(GetProcessHeap(), 0, This);
 208     }
 209
 210     return refcount;
 211 }
 212
 213 /* ID3D10DeviceChild methods */
 214
 215 static void STDMETHODCALLTYPE d3d10_input_layout_GetDevice(ID3D10InputLayout *iface, ID3D10Device **device)
 216 {
 217     FIXME("iface %p, device %p stub!\n", iface, device);
 218 }
 219
 220 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_GetPrivateData(ID3D10InputLayout *iface,
 221         REFGUID guid, UINT *data_size, void *data)
 222 {
 223     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 224             iface, debugstr_guid(guid), data_size, data);
 225
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_SetPrivateData(ID3D10InputLayout *iface,
 230         REFGUID guid, UINT data_size, const void *data)
 231 {
 232     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 233             iface, debugstr_guid(guid), data_size, data);
 234
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT STDMETHODCALLTYPE d3d10_input_layout_SetPrivateDataInterface(ID3D10InputLayout *iface,
 239         REFGUID guid, const IUnknown *data)
 240 {
 241     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 242
 243     return E_NOTIMPL;
 244 }
 245
 246 const struct ID3D10InputLayoutVtbl d3d10_input_layout_vtbl =
 247 {
 248     /* IUnknown methods */
 249     d3d10_input_layout_QueryInterface,
 250     d3d10_input_layout_AddRef,
 251     d3d10_input_layout_Release,
 252     /* ID3D10DeviceChild methods */
 253     d3d10_input_layout_GetDevice,
 254     d3d10_input_layout_GetPrivateData,
 255     d3d10_input_layout_SetPrivateData,
 256     d3d10_input_layout_SetPrivateDataInterface,
 257 };