dll/directx/wine/d3d9/vertexdeclaration.c

   1 /*
   2  * IDirect3DVertexDeclaration9 implementation
   3  *
   4  * Copyright 2002-2003 Raphael Junqueira
   5  *                     Jason Edmeades
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "d3d9_private.h"
  23
  24 static const struct
  25 {
  26     enum wined3d_format_id format;
  27     unsigned int component_count;
  28     unsigned int component_size;
  29 }
  30 d3d_dtype_lookup[] =
  31 {
  32     /* D3DDECLTYPE_FLOAT1    */ {WINED3DFMT_R32_FLOAT,          1, sizeof(float)},
  33     /* D3DDECLTYPE_FLOAT2    */ {WINED3DFMT_R32G32_FLOAT,       2, sizeof(float)},
  34     /* D3DDECLTYPE_FLOAT3    */ {WINED3DFMT_R32G32B32_FLOAT,    3, sizeof(float)},
  35     /* D3DDECLTYPE_FLOAT4    */ {WINED3DFMT_R32G32B32A32_FLOAT, 4, sizeof(float)},
  36     /* D3DDECLTYPE_D3DCOLOR  */ {WINED3DFMT_B8G8R8A8_UNORM,     4, sizeof(BYTE)},
  37     /* D3DDECLTYPE_UBYTE4    */ {WINED3DFMT_R8G8B8A8_UINT,      4, sizeof(BYTE)},
  38     /* D3DDECLTYPE_SHORT2    */ {WINED3DFMT_R16G16_SINT,        2, sizeof(short int)},
  39     /* D3DDECLTYPE_SHORT4    */ {WINED3DFMT_R16G16B16A16_SINT,  4, sizeof(short int)},
  40     /* D3DDECLTYPE_UBYTE4N   */ {WINED3DFMT_R8G8B8A8_UNORM,     4, sizeof(BYTE)},
  41     /* D3DDECLTYPE_SHORT2N   */ {WINED3DFMT_R16G16_SNORM,       2, sizeof(short int)},
  42     /* D3DDECLTYPE_SHORT4N   */ {WINED3DFMT_R16G16B16A16_SNORM, 4, sizeof(short int)},
  43     /* D3DDECLTYPE_USHORT2N  */ {WINED3DFMT_R16G16_UNORM,       2, sizeof(short int)},
  44     /* D3DDECLTYPE_USHORT4N  */ {WINED3DFMT_R16G16B16A16_UNORM, 4, sizeof(short int)},
  45     /* D3DDECLTYPE_UDEC3     */ {WINED3DFMT_R10G10B10A2_UINT,   3, sizeof(short int)},
  46     /* D3DDECLTYPE_DEC3N     */ {WINED3DFMT_R10G10B10A2_SNORM,  3, sizeof(short int)},
  47     /* D3DDECLTYPE_FLOAT16_2 */ {WINED3DFMT_R16G16_FLOAT,       2, sizeof(short int)},
  48     /* D3DDECLTYPE_FLOAT16_4 */ {WINED3DFMT_R16G16B16A16_FLOAT, 4, sizeof(short int)}
  49 };
  50
  51 static inline struct d3d9_vertex_declaration *impl_from_IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9 *iface)
  52 {
  53     return CONTAINING_RECORD(iface, struct d3d9_vertex_declaration, IDirect3DVertexDeclaration9_iface);
  54 }
  55
  56 HRESULT vdecl_convert_fvf(
  57     DWORD fvf,
  58     D3DVERTEXELEMENT9** ppVertexElements) {
  59
  60     unsigned int idx, idx2;
  61     unsigned int offset;
  62     BOOL has_pos = (fvf & D3DFVF_POSITION_MASK) != 0;
  63     BOOL has_blend = (fvf & D3DFVF_XYZB5) > D3DFVF_XYZRHW;
  64     BOOL has_blend_idx = has_blend &&
  65        (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB5) ||
  66         (fvf & D3DFVF_LASTBETA_D3DCOLOR) ||
  67         (fvf & D3DFVF_LASTBETA_UBYTE4));
  68     BOOL has_normal = (fvf & D3DFVF_NORMAL) != 0;
  69     BOOL has_psize = (fvf & D3DFVF_PSIZE) != 0;
  70
  71     BOOL has_diffuse = (fvf & D3DFVF_DIFFUSE) != 0;
  72     BOOL has_specular = (fvf & D3DFVF_SPECULAR) !=0;
  73
  74     DWORD num_textures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
  75     DWORD texcoords = (fvf & 0xFFFF0000) >> 16;
  76
  77     D3DVERTEXELEMENT9 end_element = D3DDECL_END();
  78     D3DVERTEXELEMENT9 *elements = NULL;
  79
  80     unsigned int size;
  81     DWORD num_blends = 1 + (((fvf & D3DFVF_XYZB5) - D3DFVF_XYZB1) >> 1);
  82     if (has_blend_idx) num_blends--;
  83
  84     /* Compute declaration size */
  85     size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
  86            has_psize + has_diffuse + has_specular + num_textures + 1;
  87
  88     /* convert the declaration */
  89     elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(D3DVERTEXELEMENT9));
  90     if (!elements) return D3DERR_OUTOFVIDEOMEMORY;
  91
  92     elements[size-1] = end_element;
  93     idx = 0;
  94     if (has_pos) {
  95         if (!has_blend && (fvf & D3DFVF_XYZRHW)) {
  96             elements[idx].Type = D3DDECLTYPE_FLOAT4;
  97             elements[idx].Usage = D3DDECLUSAGE_POSITIONT;
  98         }
  99         else if (!has_blend && (fvf & D3DFVF_XYZW) == D3DFVF_XYZW) {
 100             elements[idx].Type = D3DDECLTYPE_FLOAT4;
 101             elements[idx].Usage = D3DDECLUSAGE_POSITION;
 102         }
 103         else {
 104             elements[idx].Type = D3DDECLTYPE_FLOAT3;
 105             elements[idx].Usage = D3DDECLUSAGE_POSITION;
 106         }
 107         elements[idx].UsageIndex = 0;
 108         idx++;
 109     }
 110     if (has_blend && (num_blends > 0)) {
 111         if (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB2) && (fvf & D3DFVF_LASTBETA_D3DCOLOR))
 112             elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
 113         else {
 114             switch(num_blends) {
 115                 case 1: elements[idx].Type = D3DDECLTYPE_FLOAT1; break;
 116                 case 2: elements[idx].Type = D3DDECLTYPE_FLOAT2; break;
 117                 case 3: elements[idx].Type = D3DDECLTYPE_FLOAT3; break;
 118                 case 4: elements[idx].Type = D3DDECLTYPE_FLOAT4; break;
 119                 default:
 120                     ERR("Unexpected amount of blend values: %u\n", num_blends);
 121             }
 122         }
 123         elements[idx].Usage = D3DDECLUSAGE_BLENDWEIGHT;
 124         elements[idx].UsageIndex = 0;
 125         idx++;
 126     }
 127     if (has_blend_idx) {
 128         if (fvf & D3DFVF_LASTBETA_UBYTE4 ||
 129             (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB2) && (fvf & D3DFVF_LASTBETA_D3DCOLOR)))
 130             elements[idx].Type = D3DDECLTYPE_UBYTE4;
 131         else if (fvf & D3DFVF_LASTBETA_D3DCOLOR)
 132             elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
 133         else
 134             elements[idx].Type = D3DDECLTYPE_FLOAT1;
 135         elements[idx].Usage = D3DDECLUSAGE_BLENDINDICES;
 136         elements[idx].UsageIndex = 0;
 137         idx++;
 138     }
 139     if (has_normal) {
 140         elements[idx].Type = D3DDECLTYPE_FLOAT3;
 141         elements[idx].Usage = D3DDECLUSAGE_NORMAL;
 142         elements[idx].UsageIndex = 0;
 143         idx++;
 144     }
 145     if (has_psize) {
 146         elements[idx].Type = D3DDECLTYPE_FLOAT1;
 147         elements[idx].Usage = D3DDECLUSAGE_PSIZE;
 148         elements[idx].UsageIndex = 0;
 149         idx++;
 150     }
 151     if (has_diffuse) {
 152         elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
 153         elements[idx].Usage = D3DDECLUSAGE_COLOR;
 154         elements[idx].UsageIndex = 0;
 155         idx++;
 156     }
 157     if (has_specular) {
 158         elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
 159         elements[idx].Usage = D3DDECLUSAGE_COLOR;
 160         elements[idx].UsageIndex = 1;
 161         idx++;
 162     }
 163     for (idx2 = 0; idx2 < num_textures; idx2++) {
 164         unsigned int numcoords = (texcoords >> (idx2*2)) & 0x03;
 165         switch (numcoords) {
 166             case D3DFVF_TEXTUREFORMAT1:
 167                 elements[idx].Type = D3DDECLTYPE_FLOAT1;
 168                 break;
 169             case D3DFVF_TEXTUREFORMAT2:
 170                 elements[idx].Type = D3DDECLTYPE_FLOAT2;
 171                 break;
 172             case D3DFVF_TEXTUREFORMAT3:
 173                 elements[idx].Type = D3DDECLTYPE_FLOAT3;
 174                 break;
 175             case D3DFVF_TEXTUREFORMAT4:
 176                 elements[idx].Type = D3DDECLTYPE_FLOAT4;
 177                 break;
 178         }
 179         elements[idx].Usage = D3DDECLUSAGE_TEXCOORD;
 180         elements[idx].UsageIndex = idx2;
 181         idx++;
 182     }
 183
 184     /* Now compute offsets, and initialize the rest of the fields */
 185     for (idx = 0, offset = 0; idx < size-1; idx++) {
 186         elements[idx].Stream = 0;
 187         elements[idx].Method = D3DDECLMETHOD_DEFAULT;
 188         elements[idx].Offset = offset;
 189         offset += d3d_dtype_lookup[elements[idx].Type].component_count
 190                 * d3d_dtype_lookup[elements[idx].Type].component_size;
 191     }
 192
 193     *ppVertexElements = elements;
 194     return D3D_OK;
 195 }
 196
 197 static HRESULT WINAPI d3d9_vertex_declaration_QueryInterface(IDirect3DVertexDeclaration9 *iface,
 198         REFIID riid, void **out)
 199 {
 200     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 201
 202     if (IsEqualGUID(riid, &IID_IDirect3DVertexDeclaration9)
 203             || IsEqualGUID(riid, &IID_IUnknown))
 204     {
 205         IDirect3DVertexDeclaration9_AddRef(iface);
 206         *out = iface;
 207         return S_OK;
 208     }
 209
 210     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 211
 212     *out = NULL;
 213     return E_NOINTERFACE;
 214 }
 215
 216 static ULONG WINAPI d3d9_vertex_declaration_AddRef(IDirect3DVertexDeclaration9 *iface)
 217 {
 218     struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface);
 219     ULONG refcount = InterlockedIncrement(&declaration->refcount);
 220
 221     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 222
 223     if (refcount == 1)
 224     {
 225         IDirect3DDevice9Ex_AddRef(declaration->parent_device);
 226         wined3d_mutex_lock();
 227         wined3d_vertex_declaration_incref(declaration->wined3d_declaration);
 228         wined3d_mutex_unlock();
 229     }
 230
 231     return refcount;
 232 }
 233
 234 static ULONG WINAPI d3d9_vertex_declaration_Release(IDirect3DVertexDeclaration9 *iface)
 235 {
 236     struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface);
 237     ULONG refcount = InterlockedDecrement(&declaration->refcount);
 238
 239     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 240
 241     if (!refcount)
 242     {
 243         IDirect3DDevice9Ex *parent_device = declaration->parent_device;
 244         wined3d_mutex_lock();
 245         wined3d_vertex_declaration_decref(declaration->wined3d_declaration);
 246         wined3d_mutex_unlock();
 247
 248         /* Release the device last, as it may cause the device to be destroyed. */
 249         IDirect3DDevice9Ex_Release(parent_device);
 250     }
 251
 252     return refcount;
 253 }
 254
 255 static HRESULT WINAPI d3d9_vertex_declaration_GetDevice(IDirect3DVertexDeclaration9 *iface, IDirect3DDevice9 **device)
 256 {
 257     struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface);
 258
 259     TRACE("iface %p, device %p.\n", iface, device);
 260
 261     *device = (IDirect3DDevice9 *)declaration->parent_device;
 262     IDirect3DDevice9_AddRef(*device);
 263
 264     TRACE("Returning device %p.\n", *device);
 265
 266     return D3D_OK;
 267 }
 268
 269 static HRESULT WINAPI d3d9_vertex_declaration_GetDeclaration(IDirect3DVertexDeclaration9 *iface,
 270         D3DVERTEXELEMENT9 *elements, UINT *element_count)
 271 {
 272     struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface);
 273
 274     TRACE("iface %p, elements %p, element_count %p.\n", iface, elements, element_count);
 275
 276     *element_count = declaration->element_count;
 277
 278     /* Passing a NULL elements is used to just retrieve the number of elements */
 279     if (!elements)
 280         return D3D_OK;
 281
 282     TRACE("Copying %p to %p.\n", declaration->elements, elements);
 283     memcpy(elements, declaration->elements, sizeof(*declaration->elements) * declaration->element_count);
 284
 285     return D3D_OK;
 286 }
 287
 288 static const struct IDirect3DVertexDeclaration9Vtbl d3d9_vertex_declaration_vtbl =
 289 {
 290     /* IUnknown */
 291     d3d9_vertex_declaration_QueryInterface,
 292     d3d9_vertex_declaration_AddRef,
 293     d3d9_vertex_declaration_Release,
 294     /* IDirect3DVertexDeclaration9 */
 295     d3d9_vertex_declaration_GetDevice,
 296     d3d9_vertex_declaration_GetDeclaration,
 297 };
 298
 299 struct d3d9_vertex_declaration *unsafe_impl_from_IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9 *iface)
 300 {
 301     if (!iface)
 302         return NULL;
 303     assert(iface->lpVtbl == &d3d9_vertex_declaration_vtbl);
 304     return CONTAINING_RECORD(iface, struct d3d9_vertex_declaration, IDirect3DVertexDeclaration9_iface);
 305 }
 306
 307 static void STDMETHODCALLTYPE d3d9_vertexdeclaration_wined3d_object_destroyed(void *parent)
 308 {
 309     struct d3d9_vertex_declaration *declaration = parent;
 310     HeapFree(GetProcessHeap(), 0, declaration->elements);
 311     HeapFree(GetProcessHeap(), 0, declaration);
 312 }
 313
 314 static const struct wined3d_parent_ops d3d9_vertexdeclaration_wined3d_parent_ops =
 315 {
 316     d3d9_vertexdeclaration_wined3d_object_destroyed,
 317 };
 318
 319 static HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elements,
 320         struct wined3d_vertex_element **wined3d_elements, UINT *element_count)
 321 {
 322     const D3DVERTEXELEMENT9* element;
 323     UINT count = 1;
 324     UINT i;
 325
 326     TRACE("d3d9_elements %p, wined3d_elements %p\n", d3d9_elements, wined3d_elements);
 327
 328     element = d3d9_elements;
 329     while (element++->Stream != 0xff && count++ < 128);
 330
 331     if (count == 128) return E_FAIL;
 332
 333     /* Skip the END element */
 334     --count;
 335
 336     *wined3d_elements = HeapAlloc(GetProcessHeap(), 0, count * sizeof(**wined3d_elements));
 337     if (!*wined3d_elements) {
 338         FIXME("Memory allocation failed\n");
 339         return D3DERR_OUTOFVIDEOMEMORY;
 340     }
 341
 342     for (i = 0; i < count; ++i)
 343     {
 344         if (d3d9_elements[i].Type >= (sizeof(d3d_dtype_lookup) / sizeof(*d3d_dtype_lookup)))
 345         {
 346             WARN("Invalid element type %#x.\n", d3d9_elements[i].Type);
 347             HeapFree(GetProcessHeap(), 0, *wined3d_elements);
 348             return E_FAIL;
 349         }
 350         (*wined3d_elements)[i].format = d3d_dtype_lookup[d3d9_elements[i].Type].format;
 351         (*wined3d_elements)[i].input_slot = d3d9_elements[i].Stream;
 352         (*wined3d_elements)[i].offset = d3d9_elements[i].Offset;
 353         (*wined3d_elements)[i].output_slot = ~0U;
 354         (*wined3d_elements)[i].method = d3d9_elements[i].Method;
 355         (*wined3d_elements)[i].usage = d3d9_elements[i].Usage;
 356         (*wined3d_elements)[i].usage_idx = d3d9_elements[i].UsageIndex;
 357     }
 358
 359     *element_count = count;
 360
 361     return D3D_OK;
 362 }
 363
 364 static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaration,
 365         struct d3d9_device *device, const D3DVERTEXELEMENT9 *elements)
 366 {
 367     struct wined3d_vertex_element *wined3d_elements;
 368     UINT wined3d_element_count;
 369     UINT element_count;
 370     HRESULT hr;
 371
 372     hr = convert_to_wined3d_declaration(elements, &wined3d_elements, &wined3d_element_count);
 373     if (FAILED(hr))
 374     {
 375         WARN("Failed to create wined3d vertex declaration elements, hr %#x.\n", hr);
 376         return hr;
 377     }
 378
 379     declaration->IDirect3DVertexDeclaration9_iface.lpVtbl = &d3d9_vertex_declaration_vtbl;
 380     declaration->refcount = 1;
 381
 382     element_count = wined3d_element_count + 1;
 383     declaration->elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(*declaration->elements));
 384     if (!declaration->elements)
 385     {
 386         HeapFree(GetProcessHeap(), 0, wined3d_elements);
 387         ERR("Failed to allocate vertex declaration elements memory.\n");
 388         return D3DERR_OUTOFVIDEOMEMORY;
 389     }
 390     memcpy(declaration->elements, elements, element_count * sizeof(*elements));
 391     declaration->element_count = element_count;
 392
 393     wined3d_mutex_lock();
 394     hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
 395             declaration, &d3d9_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_declaration);
 396     wined3d_mutex_unlock();
 397     HeapFree(GetProcessHeap(), 0, wined3d_elements);
 398     if (FAILED(hr))
 399     {
 400         HeapFree(GetProcessHeap(), 0, declaration->elements);
 401         WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
 402         return hr;
 403     }
 404
 405     declaration->parent_device = &device->IDirect3DDevice9Ex_iface;
 406     IDirect3DDevice9Ex_AddRef(declaration->parent_device);
 407
 408     return D3D_OK;
 409 }
 410
 411 HRESULT d3d9_vertex_declaration_create(struct d3d9_device *device,
 412         const D3DVERTEXELEMENT9 *elements, struct d3d9_vertex_declaration **declaration)
 413 {
 414     struct d3d9_vertex_declaration *object;
 415     HRESULT hr;
 416
 417     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 418     if (!object)
 419         return E_OUTOFMEMORY;
 420
 421     hr = vertexdeclaration_init(object, device, elements);
 422     if (FAILED(hr))
 423     {
 424         WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
 425         HeapFree(GetProcessHeap(), 0, object);
 426         return hr;
 427     }
 428
 429     TRACE("Created vertex declaration %p.\n", object);
 430     *declaration = object;
 431
 432     return D3D_OK;
 433 }