dlls/wined3d/vertexdeclaration.c

   1 /*
   2  * vertex declaration implementation
   3  *
   4  * Copyright 2002-2005 Raphael Junqueira
   5  * Copyright 2004 Jason Edmeades
   6  * Copyright 2004 Christian Costa
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2009 Henri Verbeet for CodeWeavers
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27 #include "wined3d_private.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(d3d_decl);
  30
  31 static void dump_wined3d_vertex_element(const struct wined3d_vertex_element *element)
  32 {
  33     TRACE("                 format: %s (%#x)\n", debug_d3dformat(element->format), element->format);
  34     TRACE("             input_slot: %u\n", element->input_slot);
  35     TRACE("                 offset: %u\n", element->offset);
  36     TRACE("            output_slot: %u\n", element->output_slot);
  37     TRACE("       input slot class: %s\n", debug_d3dinput_classification(element->input_slot_class));
  38     TRACE("instance data step rate: %u\n", element->instance_data_step_rate);
  39     TRACE("                 method: %s (%#x)\n", debug_d3ddeclmethod(element->method), element->method);
  40     TRACE("                  usage: %s (%#x)\n", debug_d3ddeclusage(element->usage), element->usage);
  41     TRACE("              usage_idx: %u\n", element->usage_idx);
  42 }
  43
  44 ULONG CDECL wined3d_vertex_declaration_incref(struct wined3d_vertex_declaration *declaration)
  45 {
  46     ULONG refcount = InterlockedIncrement(&declaration->ref);
  47
  48     TRACE("%p increasing refcount to %u.\n", declaration, refcount);
  49
  50     return refcount;
  51 }
  52
  53 static void wined3d_vertex_declaration_destroy_object(void *object)
  54 {
  55     struct wined3d_vertex_declaration *declaration = object;
  56
  57     HeapFree(GetProcessHeap(), 0, declaration->elements);
  58     HeapFree(GetProcessHeap(), 0, declaration);
  59 }
  60
  61 ULONG CDECL wined3d_vertex_declaration_decref(struct wined3d_vertex_declaration *declaration)
  62 {
  63     ULONG refcount = InterlockedDecrement(&declaration->ref);
  64
  65     TRACE("%p decreasing refcount to %u.\n", declaration, refcount);
  66
  67     if (!refcount)
  68     {
  69         declaration->parent_ops->wined3d_object_destroyed(declaration->parent);
  70         wined3d_cs_destroy_object(declaration->device->cs,
  71                 wined3d_vertex_declaration_destroy_object, declaration);
  72     }
  73
  74     return refcount;
  75 }
  76
  77 void * CDECL wined3d_vertex_declaration_get_parent(const struct wined3d_vertex_declaration *declaration)
  78 {
  79     TRACE("declaration %p.\n", declaration);
  80
  81     return declaration->parent;
  82 }
  83
  84 static BOOL declaration_element_valid_ffp(const struct wined3d_vertex_element *element)
  85 {
  86     switch(element->usage)
  87     {
  88         case WINED3D_DECL_USAGE_POSITION:
  89         case WINED3D_DECL_USAGE_POSITIONT:
  90             switch(element->format)
  91             {
  92                 case WINED3DFMT_R32G32_FLOAT:
  93                 case WINED3DFMT_R32G32B32_FLOAT:
  94                 case WINED3DFMT_R32G32B32A32_FLOAT:
  95                 case WINED3DFMT_R16G16_SINT:
  96                 case WINED3DFMT_R16G16B16A16_SINT:
  97                 case WINED3DFMT_R16G16_FLOAT:
  98                 case WINED3DFMT_R16G16B16A16_FLOAT:
  99                     return TRUE;
 100                 default:
 101                     return FALSE;
 102             }
 103
 104         case WINED3D_DECL_USAGE_BLEND_WEIGHT:
 105             switch(element->format)
 106             {
 107                 case WINED3DFMT_R32_FLOAT:
 108                 case WINED3DFMT_R32G32_FLOAT:
 109                 case WINED3DFMT_R32G32B32_FLOAT:
 110                 case WINED3DFMT_R32G32B32A32_FLOAT:
 111                 case WINED3DFMT_B8G8R8A8_UNORM:
 112                 case WINED3DFMT_R8G8B8A8_UINT:
 113                 case WINED3DFMT_R16G16_SINT:
 114                 case WINED3DFMT_R16G16B16A16_SINT:
 115                 case WINED3DFMT_R16G16_FLOAT:
 116                 case WINED3DFMT_R16G16B16A16_FLOAT:
 117                     return TRUE;
 118                 default:
 119                     return FALSE;
 120             }
 121
 122         case WINED3D_DECL_USAGE_NORMAL:
 123             switch(element->format)
 124             {
 125                 case WINED3DFMT_R32G32B32_FLOAT:
 126                 case WINED3DFMT_R32G32B32A32_FLOAT:
 127                 case WINED3DFMT_R16G16B16A16_SINT:
 128                 case WINED3DFMT_R16G16B16A16_FLOAT:
 129                     return TRUE;
 130                 default:
 131                     return FALSE;
 132             }
 133
 134         case WINED3D_DECL_USAGE_TEXCOORD:
 135             switch(element->format)
 136             {
 137                 case WINED3DFMT_R32_FLOAT:
 138                 case WINED3DFMT_R32G32_FLOAT:
 139                 case WINED3DFMT_R32G32B32_FLOAT:
 140                 case WINED3DFMT_R32G32B32A32_FLOAT:
 141                 case WINED3DFMT_R16G16_SINT:
 142                 case WINED3DFMT_R16G16B16A16_SINT:
 143                 case WINED3DFMT_R16G16_FLOAT:
 144                 case WINED3DFMT_R16G16B16A16_FLOAT:
 145                     return TRUE;
 146                 default:
 147                     return FALSE;
 148             }
 149
 150         case WINED3D_DECL_USAGE_COLOR:
 151             switch(element->format)
 152             {
 153                 case WINED3DFMT_R32G32B32_FLOAT:
 154                 case WINED3DFMT_R32G32B32A32_FLOAT:
 155                 case WINED3DFMT_B8G8R8A8_UNORM:
 156                 case WINED3DFMT_R8G8B8A8_UINT:
 157                 case WINED3DFMT_R16G16B16A16_SINT:
 158                 case WINED3DFMT_R8G8B8A8_UNORM:
 159                 case WINED3DFMT_R16G16B16A16_SNORM:
 160                 case WINED3DFMT_R16G16B16A16_UNORM:
 161                 case WINED3DFMT_R16G16B16A16_FLOAT:
 162                     return TRUE;
 163                 default:
 164                     return FALSE;
 165             }
 166
 167         default:
 168             return FALSE;
 169     }
 170 }
 171
 172 static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declaration,
 173         struct wined3d_device *device, const struct wined3d_vertex_element *elements, UINT element_count,
 174         void *parent, const struct wined3d_parent_ops *parent_ops)
 175 {
 176     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 177     unsigned int i;
 178
 179     if (TRACE_ON(d3d_decl))
 180     {
 181         for (i = 0; i < element_count; ++i)
 182         {
 183             dump_wined3d_vertex_element(elements + i);
 184         }
 185     }
 186
 187     declaration->ref = 1;
 188     declaration->parent = parent;
 189     declaration->parent_ops = parent_ops;
 190     declaration->device = device;
 191     if (!(declaration->elements = wined3d_calloc(element_count, sizeof(*declaration->elements))))
 192     {
 193         ERR("Failed to allocate elements memory.\n");
 194         return E_OUTOFMEMORY;
 195     }
 196     declaration->element_count = element_count;
 197
 198     /* Do some static analysis on the elements to make reading the
 199      * declaration more comfortable for the drawing code. */
 200     for (i = 0; i < element_count; ++i)
 201     {
 202         struct wined3d_vertex_declaration_element *e = &declaration->elements[i];
 203
 204         e->format = wined3d_get_format(gl_info, elements[i].format, 0);
 205         e->ffp_valid = declaration_element_valid_ffp(&elements[i]);
 206         e->input_slot = elements[i].input_slot;
 207         e->offset = elements[i].offset;
 208         e->output_slot = elements[i].output_slot;
 209         e->input_slot_class = elements[i].input_slot_class;
 210         e->instance_data_step_rate = elements[i].instance_data_step_rate;
 211         e->method = elements[i].method;
 212         e->usage = elements[i].usage;
 213         e->usage_idx = elements[i].usage_idx;
 214
 215         if (e->usage == WINED3D_DECL_USAGE_POSITIONT)
 216             declaration->position_transformed = TRUE;
 217
 218         /* Find the streams used in the declaration. The vertex buffers have
 219          * to be loaded when drawing, but filter tesselation pseudo streams. */
 220         if (e->input_slot >= MAX_STREAMS) continue;
 221
 222         if (!e->format->gl_vtx_format)
 223         {
 224             FIXME("The application tries to use an unsupported format (%s), returning E_FAIL.\n",
 225                     debug_d3dformat(elements[i].format));
 226             HeapFree(GetProcessHeap(), 0, declaration->elements);
 227             return E_FAIL;
 228         }
 229
 230         if (e->offset == WINED3D_APPEND_ALIGNED_ELEMENT)
 231         {
 232             const struct wined3d_vertex_declaration_element *prev;
 233             unsigned int j;
 234
 235             e->offset = 0;
 236             for (j = 1; j <= i; ++j)
 237             {
 238                 prev = &declaration->elements[i - j];
 239                 if (prev->input_slot == e->input_slot)
 240                 {
 241                     e->offset = (prev->offset + prev->format->byte_count + 3) & ~3;
 242                     break;
 243                 }
 244             }
 245         }
 246
 247         if (e->offset & 0x3)
 248         {
 249             WARN("Declaration element %u is not 4 byte aligned(%u), returning E_FAIL.\n", i, e->offset);
 250             HeapFree(GetProcessHeap(), 0, declaration->elements);
 251             return E_FAIL;
 252         }
 253
 254         if (elements[i].format == WINED3DFMT_R16G16_FLOAT || elements[i].format == WINED3DFMT_R16G16B16A16_FLOAT)
 255         {
 256             if (!gl_info->supported[ARB_HALF_FLOAT_VERTEX]) declaration->half_float_conv_needed = TRUE;
 257         }
 258     }
 259
 260     return WINED3D_OK;
 261 }
 262
 263 HRESULT CDECL wined3d_vertex_declaration_create(struct wined3d_device *device,
 264         const struct wined3d_vertex_element *elements, UINT element_count, void *parent,
 265         const struct wined3d_parent_ops *parent_ops, struct wined3d_vertex_declaration **declaration)
 266 {
 267     struct wined3d_vertex_declaration *object;
 268     HRESULT hr;
 269
 270     TRACE("device %p, elements %p, element_count %u, parent %p, parent_ops %p, declaration %p.\n",
 271             device, elements, element_count, parent, parent_ops, declaration);
 272
 273     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 274     if(!object)
 275         return E_OUTOFMEMORY;
 276
 277     hr = vertexdeclaration_init(object, device, elements, element_count, parent, parent_ops);
 278     if (FAILED(hr))
 279     {
 280         WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
 281         HeapFree(GetProcessHeap(), 0, object);
 282         return hr;
 283     }
 284
 285     TRACE("Created vertex declaration %p.\n", object);
 286     *declaration = object;
 287
 288     return WINED3D_OK;
 289 }
 290
 291 struct wined3d_fvf_convert_state
 292 {
 293     const struct wined3d_gl_info *gl_info;
 294     struct wined3d_vertex_element *elements;
 295     UINT offset;
 296     UINT idx;
 297 };
 298
 299 static void append_decl_element(struct wined3d_fvf_convert_state *state,
 300         enum wined3d_format_id format_id, enum wined3d_decl_usage usage, UINT usage_idx)
 301 {
 302     struct wined3d_vertex_element *elements = state->elements;
 303     const struct wined3d_format *format;
 304     UINT offset = state->offset;
 305     UINT idx = state->idx;
 306
 307     elements[idx].format = format_id;
 308     elements[idx].input_slot = 0;
 309     elements[idx].offset = offset;
 310     elements[idx].output_slot = WINED3D_OUTPUT_SLOT_SEMANTIC;
 311     elements[idx].input_slot_class = WINED3D_INPUT_PER_VERTEX_DATA;
 312     elements[idx].instance_data_step_rate = 0;
 313     elements[idx].method = WINED3D_DECL_METHOD_DEFAULT;
 314     elements[idx].usage = usage;
 315     elements[idx].usage_idx = usage_idx;
 316
 317     format = wined3d_get_format(state->gl_info, format_id, 0);
 318     state->offset += format->attribute_size;
 319     ++state->idx;
 320 }
 321
 322 static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info *gl_info,
 323         DWORD fvf, struct wined3d_vertex_element **elements)
 324 {
 325     BOOL has_pos = !!(fvf & WINED3DFVF_POSITION_MASK);
 326     BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
 327     BOOL has_blend_idx = has_blend &&
 328        (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB5) ||
 329         (fvf & WINED3DFVF_LASTBETA_D3DCOLOR) ||
 330         (fvf & WINED3DFVF_LASTBETA_UBYTE4));
 331     BOOL has_normal = !!(fvf & WINED3DFVF_NORMAL);
 332     BOOL has_psize = !!(fvf & WINED3DFVF_PSIZE);
 333     BOOL has_diffuse = !!(fvf & WINED3DFVF_DIFFUSE);
 334     BOOL has_specular = !!(fvf & WINED3DFVF_SPECULAR);
 335
 336     DWORD num_textures = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
 337     DWORD texcoords = (fvf & 0xffff0000) >> 16;
 338     struct wined3d_fvf_convert_state state;
 339     unsigned int size;
 340     unsigned int idx;
 341     DWORD num_blends = 1 + (((fvf & WINED3DFVF_XYZB5) - WINED3DFVF_XYZB1) >> 1);
 342     if (has_blend_idx) num_blends--;
 343
 344     /* Compute declaration size */
 345     size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
 346            has_psize + has_diffuse + has_specular + num_textures;
 347
 348     state.gl_info = gl_info;
 349     if (!(state.elements = wined3d_calloc(size, sizeof(*state.elements))))
 350         return ~0u;
 351     state.offset = 0;
 352     state.idx = 0;
 353
 354     if (has_pos)
 355     {
 356         if (!has_blend && (fvf & WINED3DFVF_XYZRHW))
 357             append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_POSITIONT, 0);
 358         else if ((fvf & WINED3DFVF_XYZW) == WINED3DFVF_XYZW)
 359             append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_POSITION, 0);
 360         else
 361             append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_POSITION, 0);
 362     }
 363
 364     if (has_blend && (num_blends > 0))
 365     {
 366         if ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
 367             append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 368         else
 369         {
 370             switch (num_blends)
 371             {
 372                 case 1:
 373                     append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 374                     break;
 375                 case 2:
 376                     append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 377                     break;
 378                 case 3:
 379                     append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 380                     break;
 381                 case 4:
 382                     append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 383                     break;
 384                 default:
 385                     ERR("Unexpected amount of blend values: %u\n", num_blends);
 386             }
 387         }
 388     }
 389
 390     if (has_blend_idx)
 391     {
 392         if ((fvf & WINED3DFVF_LASTBETA_UBYTE4)
 393                 || ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
 394             append_decl_element(&state, WINED3DFMT_R8G8B8A8_UINT, WINED3D_DECL_USAGE_BLEND_INDICES, 0);
 395         else if (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)
 396             append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_BLEND_INDICES, 0);
 397         else
 398             append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_BLEND_INDICES, 0);
 399     }
 400
 401     if (has_normal)
 402         append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_NORMAL, 0);
 403     if (has_psize)
 404         append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_PSIZE, 0);
 405     if (has_diffuse)
 406         append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_COLOR, 0);
 407     if (has_specular)
 408         append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_COLOR, 1);
 409
 410     for (idx = 0; idx < num_textures; ++idx)
 411     {
 412         switch ((texcoords >> (idx * 2)) & 0x03)
 413         {
 414             case WINED3DFVF_TEXTUREFORMAT1:
 415                 append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 416                 break;
 417             case WINED3DFVF_TEXTUREFORMAT2:
 418                 append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 419                 break;
 420             case WINED3DFVF_TEXTUREFORMAT3:
 421                 append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 422                 break;
 423             case WINED3DFVF_TEXTUREFORMAT4:
 424                 append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 425                 break;
 426         }
 427     }
 428
 429     *elements = state.elements;
 430     return size;
 431 }
 432
 433 HRESULT CDECL wined3d_vertex_declaration_create_from_fvf(struct wined3d_device *device,
 434         DWORD fvf, void *parent, const struct wined3d_parent_ops *parent_ops,
 435         struct wined3d_vertex_declaration **declaration)
 436 {
 437     struct wined3d_vertex_element *elements;
 438     unsigned int size;
 439     DWORD hr;
 440
 441     TRACE("device %p, fvf %#x, parent %p, parent_ops %p, declaration %p.\n",
 442             device, fvf, parent, parent_ops, declaration);
 443
 444     size = convert_fvf_to_declaration(&device->adapter->gl_info, fvf, &elements);
 445     if (size == ~0U) return E_OUTOFMEMORY;
 446
 447     hr = wined3d_vertex_declaration_create(device, elements, size, parent, parent_ops, declaration);
 448     HeapFree(GetProcessHeap(), 0, elements);
 449     return hr;
 450 }