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("     method: %s (%#x)\n", debug_d3ddeclmethod(element->method), element->method);
  38     TRACE("      usage: %s (%#x)\n", debug_d3ddeclusage(element->usage), element->usage);
  39     TRACE("  usage_idx: %u\n", element->usage_idx);
  40 }
  41
  42 ULONG CDECL wined3d_vertex_declaration_incref(struct wined3d_vertex_declaration *declaration)
  43 {
  44     ULONG refcount = InterlockedIncrement(&declaration->ref);
  45
  46     TRACE("%p increasing refcount to %u.\n", declaration, refcount);
  47
  48     return refcount;
  49 }
  50
  51 ULONG CDECL wined3d_vertex_declaration_decref(struct wined3d_vertex_declaration *declaration)
  52 {
  53     ULONG refcount = InterlockedDecrement(&declaration->ref);
  54
  55     TRACE("%p decreasing refcount to %u.\n", declaration, refcount);
  56
  57     if (!refcount)
  58     {
  59         HeapFree(GetProcessHeap(), 0, declaration->elements);
  60         declaration->parent_ops->wined3d_object_destroyed(declaration->parent);
  61         HeapFree(GetProcessHeap(), 0, declaration);
  62     }
  63
  64     return refcount;
  65 }
  66
  67 void * CDECL wined3d_vertex_declaration_get_parent(const struct wined3d_vertex_declaration *declaration)
  68 {
  69     TRACE("declaration %p.\n", declaration);
  70
  71     return declaration->parent;
  72 }
  73
  74 static BOOL declaration_element_valid_ffp(const struct wined3d_vertex_element *element)
  75 {
  76     switch(element->usage)
  77     {
  78         case WINED3D_DECL_USAGE_POSITION:
  79         case WINED3D_DECL_USAGE_POSITIONT:
  80             switch(element->format)
  81             {
  82                 case WINED3DFMT_R32G32_FLOAT:
  83                 case WINED3DFMT_R32G32B32_FLOAT:
  84                 case WINED3DFMT_R32G32B32A32_FLOAT:
  85                 case WINED3DFMT_R16G16_SINT:
  86                 case WINED3DFMT_R16G16B16A16_SINT:
  87                 case WINED3DFMT_R16G16_FLOAT:
  88                 case WINED3DFMT_R16G16B16A16_FLOAT:
  89                     return TRUE;
  90                 default:
  91                     return FALSE;
  92             }
  93
  94         case WINED3D_DECL_USAGE_BLEND_WEIGHT:
  95             switch(element->format)
  96             {
  97                 case WINED3DFMT_R32_FLOAT:
  98                 case WINED3DFMT_R32G32_FLOAT:
  99                 case WINED3DFMT_R32G32B32_FLOAT:
 100                 case WINED3DFMT_R32G32B32A32_FLOAT:
 101                 case WINED3DFMT_B8G8R8A8_UNORM:
 102                 case WINED3DFMT_R8G8B8A8_UINT:
 103                 case WINED3DFMT_R16G16_SINT:
 104                 case WINED3DFMT_R16G16B16A16_SINT:
 105                 case WINED3DFMT_R16G16_FLOAT:
 106                 case WINED3DFMT_R16G16B16A16_FLOAT:
 107                     return TRUE;
 108                 default:
 109                     return FALSE;
 110             }
 111
 112         case WINED3D_DECL_USAGE_NORMAL:
 113             switch(element->format)
 114             {
 115                 case WINED3DFMT_R32G32B32_FLOAT:
 116                 case WINED3DFMT_R32G32B32A32_FLOAT:
 117                 case WINED3DFMT_R16G16B16A16_SINT:
 118                 case WINED3DFMT_R16G16B16A16_FLOAT:
 119                     return TRUE;
 120                 default:
 121                     return FALSE;
 122             }
 123
 124         case WINED3D_DECL_USAGE_TEXCOORD:
 125             switch(element->format)
 126             {
 127                 case WINED3DFMT_R32_FLOAT:
 128                 case WINED3DFMT_R32G32_FLOAT:
 129                 case WINED3DFMT_R32G32B32_FLOAT:
 130                 case WINED3DFMT_R32G32B32A32_FLOAT:
 131                 case WINED3DFMT_R16G16_SINT:
 132                 case WINED3DFMT_R16G16B16A16_SINT:
 133                 case WINED3DFMT_R16G16_FLOAT:
 134                 case WINED3DFMT_R16G16B16A16_FLOAT:
 135                     return TRUE;
 136                 default:
 137                     return FALSE;
 138             }
 139
 140         case WINED3D_DECL_USAGE_COLOR:
 141             switch(element->format)
 142             {
 143                 case WINED3DFMT_R32G32B32_FLOAT:
 144                 case WINED3DFMT_R32G32B32A32_FLOAT:
 145                 case WINED3DFMT_B8G8R8A8_UNORM:
 146                 case WINED3DFMT_R8G8B8A8_UINT:
 147                 case WINED3DFMT_R16G16B16A16_SINT:
 148                 case WINED3DFMT_R8G8B8A8_UNORM:
 149                 case WINED3DFMT_R16G16B16A16_SNORM:
 150                 case WINED3DFMT_R16G16B16A16_UNORM:
 151                 case WINED3DFMT_R16G16B16A16_FLOAT:
 152                     return TRUE;
 153                 default:
 154                     return FALSE;
 155             }
 156
 157         default:
 158             return FALSE;
 159     }
 160 }
 161
 162 static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declaration,
 163         struct wined3d_device *device, const struct wined3d_vertex_element *elements, UINT element_count,
 164         void *parent, const struct wined3d_parent_ops *parent_ops)
 165 {
 166     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 167     unsigned int i;
 168
 169     if (TRACE_ON(d3d_decl))
 170     {
 171         for (i = 0; i < element_count; ++i)
 172         {
 173             dump_wined3d_vertex_element(elements + i);
 174         }
 175     }
 176
 177     declaration->ref = 1;
 178     declaration->parent = parent;
 179     declaration->parent_ops = parent_ops;
 180     declaration->device = device;
 181     declaration->elements = HeapAlloc(GetProcessHeap(), 0, sizeof(*declaration->elements) * element_count);
 182     if (!declaration->elements)
 183     {
 184         ERR("Failed to allocate elements memory.\n");
 185         return E_OUTOFMEMORY;
 186     }
 187     declaration->element_count = element_count;
 188
 189     /* Do some static analysis on the elements to make reading the
 190      * declaration more comfortable for the drawing code. */
 191     for (i = 0; i < element_count; ++i)
 192     {
 193         struct wined3d_vertex_declaration_element *e = &declaration->elements[i];
 194
 195         e->format = wined3d_get_format(gl_info, elements[i].format);
 196         e->ffp_valid = declaration_element_valid_ffp(&elements[i]);
 197         e->input_slot = elements[i].input_slot;
 198         e->offset = elements[i].offset;
 199         e->output_slot = elements[i].output_slot;
 200         e->method = elements[i].method;
 201         e->usage = elements[i].usage;
 202         e->usage_idx = elements[i].usage_idx;
 203
 204         if (e->usage == WINED3D_DECL_USAGE_POSITIONT)
 205             declaration->position_transformed = TRUE;
 206
 207         /* Find the streams used in the declaration. The vertex buffers have
 208          * to be loaded when drawing, but filter tesselation pseudo streams. */
 209         if (e->input_slot >= MAX_STREAMS) continue;
 210
 211         if (!e->format->gl_vtx_format)
 212         {
 213             FIXME("The application tries to use an unsupported format (%s), returning E_FAIL.\n",
 214                     debug_d3dformat(elements[i].format));
 215             HeapFree(GetProcessHeap(), 0, declaration->elements);
 216             return E_FAIL;
 217         }
 218
 219         if (e->offset & 0x3)
 220         {
 221             WARN("Declaration element %u is not 4 byte aligned(%u), returning E_FAIL.\n", i, e->offset);
 222             HeapFree(GetProcessHeap(), 0, declaration->elements);
 223             return E_FAIL;
 224         }
 225
 226         if (elements[i].format == WINED3DFMT_R16G16_FLOAT || elements[i].format == WINED3DFMT_R16G16B16A16_FLOAT)
 227         {
 228             if (!gl_info->supported[ARB_HALF_FLOAT_VERTEX]) declaration->half_float_conv_needed = TRUE;
 229         }
 230     }
 231
 232     return WINED3D_OK;
 233 }
 234
 235 HRESULT CDECL wined3d_vertex_declaration_create(struct wined3d_device *device,
 236         const struct wined3d_vertex_element *elements, UINT element_count, void *parent,
 237         const struct wined3d_parent_ops *parent_ops, struct wined3d_vertex_declaration **declaration)
 238 {
 239     struct wined3d_vertex_declaration *object;
 240     HRESULT hr;
 241
 242     TRACE("device %p, elements %p, element_count %u, parent %p, parent_ops %p, declaration %p.\n",
 243             device, elements, element_count, parent, parent_ops, declaration);
 244
 245     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 246     if(!object)
 247         return E_OUTOFMEMORY;
 248
 249     hr = vertexdeclaration_init(object, device, elements, element_count, parent, parent_ops);
 250     if (FAILED(hr))
 251     {
 252         WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
 253         HeapFree(GetProcessHeap(), 0, object);
 254         return hr;
 255     }
 256
 257     TRACE("Created vertex declaration %p.\n", object);
 258     *declaration = object;
 259
 260     return WINED3D_OK;
 261 }
 262
 263 struct wined3d_fvf_convert_state
 264 {
 265     const struct wined3d_gl_info *gl_info;
 266     struct wined3d_vertex_element *elements;
 267     UINT offset;
 268     UINT idx;
 269 };
 270
 271 static void append_decl_element(struct wined3d_fvf_convert_state *state,
 272         enum wined3d_format_id format_id, enum wined3d_decl_usage usage, UINT usage_idx)
 273 {
 274     struct wined3d_vertex_element *elements = state->elements;
 275     const struct wined3d_format *format;
 276     UINT offset = state->offset;
 277     UINT idx = state->idx;
 278
 279     elements[idx].format = format_id;
 280     elements[idx].input_slot = 0;
 281     elements[idx].offset = offset;
 282     elements[idx].output_slot = 0;
 283     elements[idx].method = WINED3D_DECL_METHOD_DEFAULT;
 284     elements[idx].usage = usage;
 285     elements[idx].usage_idx = usage_idx;
 286
 287     format = wined3d_get_format(state->gl_info, format_id);
 288     state->offset += format->component_count * format->component_size;
 289     ++state->idx;
 290 }
 291
 292 static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info *gl_info,
 293         DWORD fvf, struct wined3d_vertex_element **elements)
 294 {
 295     BOOL has_pos = !!(fvf & WINED3DFVF_POSITION_MASK);
 296     BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
 297     BOOL has_blend_idx = has_blend &&
 298        (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB5) ||
 299         (fvf & WINED3DFVF_LASTBETA_D3DCOLOR) ||
 300         (fvf & WINED3DFVF_LASTBETA_UBYTE4));
 301     BOOL has_normal = !!(fvf & WINED3DFVF_NORMAL);
 302     BOOL has_psize = !!(fvf & WINED3DFVF_PSIZE);
 303     BOOL has_diffuse = !!(fvf & WINED3DFVF_DIFFUSE);
 304     BOOL has_specular = !!(fvf & WINED3DFVF_SPECULAR);
 305
 306     DWORD num_textures = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
 307     DWORD texcoords = (fvf & 0xffff0000) >> 16;
 308     struct wined3d_fvf_convert_state state;
 309     unsigned int size;
 310     unsigned int idx;
 311     DWORD num_blends = 1 + (((fvf & WINED3DFVF_XYZB5) - WINED3DFVF_XYZB1) >> 1);
 312     if (has_blend_idx) num_blends--;
 313
 314     /* Compute declaration size */
 315     size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
 316            has_psize + has_diffuse + has_specular + num_textures;
 317
 318     state.gl_info = gl_info;
 319     state.elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*state.elements));
 320     if (!state.elements) return ~0U;
 321     state.offset = 0;
 322     state.idx = 0;
 323
 324     if (has_pos)
 325     {
 326         if (!has_blend && (fvf & WINED3DFVF_XYZRHW))
 327             append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_POSITIONT, 0);
 328         else if ((fvf & WINED3DFVF_XYZW) == WINED3DFVF_XYZW)
 329             append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_POSITION, 0);
 330         else
 331             append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_POSITION, 0);
 332     }
 333
 334     if (has_blend && (num_blends > 0))
 335     {
 336         if ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
 337             append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 338         else
 339         {
 340             switch (num_blends)
 341             {
 342                 case 1:
 343                     append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 344                     break;
 345                 case 2:
 346                     append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 347                     break;
 348                 case 3:
 349                     append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 350                     break;
 351                 case 4:
 352                     append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_BLEND_WEIGHT, 0);
 353                     break;
 354                 default:
 355                     ERR("Unexpected amount of blend values: %u\n", num_blends);
 356             }
 357         }
 358     }
 359
 360     if (has_blend_idx)
 361     {
 362         if ((fvf & WINED3DFVF_LASTBETA_UBYTE4)
 363                 || ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
 364             append_decl_element(&state, WINED3DFMT_R8G8B8A8_UINT, WINED3D_DECL_USAGE_BLEND_INDICES, 0);
 365         else if (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)
 366             append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_BLEND_INDICES, 0);
 367         else
 368             append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_BLEND_INDICES, 0);
 369     }
 370
 371     if (has_normal)
 372         append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_NORMAL, 0);
 373     if (has_psize)
 374         append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_PSIZE, 0);
 375     if (has_diffuse)
 376         append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_COLOR, 0);
 377     if (has_specular)
 378         append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3D_DECL_USAGE_COLOR, 1);
 379
 380     for (idx = 0; idx < num_textures; ++idx)
 381     {
 382         switch ((texcoords >> (idx * 2)) & 0x03)
 383         {
 384             case WINED3DFVF_TEXTUREFORMAT1:
 385                 append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 386                 break;
 387             case WINED3DFVF_TEXTUREFORMAT2:
 388                 append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 389                 break;
 390             case WINED3DFVF_TEXTUREFORMAT3:
 391                 append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 392                 break;
 393             case WINED3DFVF_TEXTUREFORMAT4:
 394                 append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_DECL_USAGE_TEXCOORD, idx);
 395                 break;
 396         }
 397     }
 398
 399     *elements = state.elements;
 400     return size;
 401 }
 402
 403 HRESULT CDECL wined3d_vertex_declaration_create_from_fvf(struct wined3d_device *device,
 404         DWORD fvf, void *parent, const struct wined3d_parent_ops *parent_ops,
 405         struct wined3d_vertex_declaration **declaration)
 406 {
 407     struct wined3d_vertex_element *elements;
 408     unsigned int size;
 409     DWORD hr;
 410
 411     TRACE("device %p, fvf %#x, parent %p, parent_ops %p, declaration %p.\n",
 412             device, fvf, parent, parent_ops, declaration);
 413
 414     size = convert_fvf_to_declaration(&device->adapter->gl_info, fvf, &elements);
 415     if (size == ~0U) return E_OUTOFMEMORY;
 416
 417     hr = wined3d_vertex_declaration_create(device, elements, size, parent, parent_ops, declaration);
 418     HeapFree(GetProcessHeap(), 0, elements);
 419     return hr;
 420 }