dlls/d3d8/vertexdeclaration.c

   1 /*
   2  * IDirect3DVertexDeclaration8 implementation
   3  *
   4  * Copyright 2007 Henri Verbeet
   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 /* IDirect3DVertexDeclaration8 is internal to our implementation.
  22  * It's not visible in the API. */
  23
  24 #include "config.h"
  25 #include "d3d8_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
  28
  29 static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type)
  30 {
  31     switch (d3dvsdt_type)
  32     {
  33 #define D3DVSDT_TYPE_TO_STR(u) case u: return #u
  34         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1);
  35         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2);
  36         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3);
  37         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4);
  38         D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR);
  39         D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4);
  40         D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2);
  41         D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4);
  42 #undef D3DVSDT_TYPE_TO_STR
  43         default:
  44             FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type);
  45             return "unrecognized";
  46     }
  47 }
  48
  49 static const char *debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register)
  50 {
  51     switch (d3dvsde_register)
  52     {
  53 #define D3DVSDE_REGISTER_TO_STR(u) case u: return #u
  54         D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION);
  55         D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT);
  56         D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES);
  57         D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL);
  58         D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE);
  59         D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE);
  60         D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR);
  61         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0);
  62         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1);
  63         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2);
  64         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3);
  65         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4);
  66         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5);
  67         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6);
  68         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7);
  69         D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2);
  70         D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2);
  71 #undef D3DVSDE_REGISTER_TO_STR
  72         default:
  73             FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register);
  74             return "unrecognized";
  75     }
  76 }
  77
  78 size_t parse_token(const DWORD* pToken)
  79 {
  80     const DWORD token = *pToken;
  81     size_t tokenlen = 1;
  82
  83     switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
  84         case D3DVSD_TOKEN_NOP:
  85             TRACE(" 0x%08x NOP()\n", token);
  86             break;
  87
  88         case D3DVSD_TOKEN_STREAM:
  89             if (token & D3DVSD_STREAMTESSMASK)
  90             {
  91                 TRACE(" 0x%08x STREAM_TESS()\n", token);
  92             } else {
  93                 TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
  94             }
  95             break;
  96
  97         case D3DVSD_TOKEN_STREAMDATA:
  98             if (token & 0x10000000)
  99             {
 100                 TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
 101             } else {
 102                 DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
 103                 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 104                 TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
 105             }
 106             break;
 107
 108         case D3DVSD_TOKEN_TESSELLATOR:
 109             if (token & 0x10000000)
 110             {
 111                 DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
 112                 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 113                 TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
 114             } else {
 115                 DWORD type = ((token & D3DVSD_DATATYPEMASK)    >> D3DVSD_DATATYPESHIFT);
 116                 DWORD regout = ((token & D3DVSD_VERTEXREGMASK)   >> D3DVSD_VERTEXREGSHIFT);
 117                 DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
 118                 TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
 119                         debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
 120             }
 121             break;
 122
 123         case D3DVSD_TOKEN_CONSTMEM:
 124             {
 125                 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK)   >> D3DVSD_CONSTCOUNTSHIFT);
 126                 tokenlen = (4 * count) + 1;
 127             }
 128             break;
 129
 130         case D3DVSD_TOKEN_EXT:
 131             {
 132                 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
 133                 DWORD extinfo = ((token & D3DVSD_EXTINFOMASK)    >> D3DVSD_EXTINFOSHIFT);
 134                 TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo);
 135                 /* todo ... print extension */
 136                 tokenlen = count + 1;
 137             }
 138             break;
 139
 140         case D3DVSD_TOKEN_END:
 141             TRACE(" 0x%08x END()\n", token);
 142             break;
 143
 144         default:
 145             TRACE(" 0x%08x UNKNOWN\n", token);
 146             /* arg error */
 147     }
 148
 149     return tokenlen;
 150 }
 151
 152 void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader)
 153 {
 154     const DWORD *token = d3d8_elements;
 155
 156     while (*token != D3DVSD_END())
 157     {
 158         if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM)
 159         {
 160             DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
 161             DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
 162             HRESULT hr;
 163
 164             if (TRACE_ON(d3d8))
 165             {
 166                 DWORD i;
 167                 for (i = 0; i < count; ++i)
 168                 {
 169                     TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n",
 170                             constant_idx,
 171                             *(const float *)(token + i * 4 + 1),
 172                             *(const float *)(token + i * 4 + 2),
 173                             *(const float *)(token + i * 4 + 3),
 174                             *(const float *)(token + i * 4 + 4));
 175                 }
 176             }
 177             hr = wined3d_shader_set_local_constants_float(wined3d_vertex_shader,
 178                     constant_idx, (const float *)token + 1, count);
 179             if (FAILED(hr)) ERR("Failed setting shader constants\n");
 180         }
 181
 182         token += parse_token(token);
 183     }
 184 }
 185
 186 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
 187 static const size_t wined3d_type_sizes[] =
 188 {
 189     /*WINED3DDECLTYPE_FLOAT1*/    1 * sizeof(float),
 190     /*WINED3DDECLTYPE_FLOAT2*/    2 * sizeof(float),
 191     /*WINED3DDECLTYPE_FLOAT3*/    3 * sizeof(float),
 192     /*WINED3DDECLTYPE_FLOAT4*/    4 * sizeof(float),
 193     /*WINED3DDECLTYPE_D3DCOLOR*/  4 * sizeof(BYTE),
 194     /*WINED3DDECLTYPE_UBYTE4*/    4 * sizeof(BYTE),
 195     /*WINED3DDECLTYPE_SHORT2*/    2 * sizeof(short int),
 196     /*WINED3DDECLTYPE_SHORT4*/    4 * sizeof(short int),
 197     /*WINED3DDECLTYPE_UBYTE4N*/   4 * sizeof(BYTE),
 198     /*WINED3DDECLTYPE_SHORT2N*/   2 * sizeof(short int),
 199     /*WINED3DDECLTYPE_SHORT4N*/   4 * sizeof(short int),
 200     /*WINED3DDECLTYPE_USHORT2N*/  2 * sizeof(short int),
 201     /*WINED3DDECLTYPE_USHORT4N*/  4 * sizeof(short int),
 202     /*WINED3DDECLTYPE_UDEC3*/     3 * sizeof(short int),
 203     /*WINED3DDECLTYPE_DEC3N*/     3 * sizeof(short int),
 204     /*WINED3DDECLTYPE_FLOAT16_2*/ 2 * sizeof(short int),
 205     /*WINED3DDECLTYPE_FLOAT16_4*/ 4 * sizeof(short int)
 206 };
 207
 208 static const enum wined3d_format_id wined3d_format_lookup[] =
 209 {
 210     /*WINED3DDECLTYPE_FLOAT1*/    WINED3DFMT_R32_FLOAT,
 211     /*WINED3DDECLTYPE_FLOAT2*/    WINED3DFMT_R32G32_FLOAT,
 212     /*WINED3DDECLTYPE_FLOAT3*/    WINED3DFMT_R32G32B32_FLOAT,
 213     /*WINED3DDECLTYPE_FLOAT4*/    WINED3DFMT_R32G32B32A32_FLOAT,
 214     /*WINED3DDECLTYPE_D3DCOLOR*/  WINED3DFMT_B8G8R8A8_UNORM,
 215     /*WINED3DDECLTYPE_UBYTE4*/    WINED3DFMT_R8G8B8A8_UINT,
 216     /*WINED3DDECLTYPE_SHORT2*/    WINED3DFMT_R16G16_SINT,
 217     /*WINED3DDECLTYPE_SHORT4*/    WINED3DFMT_R16G16B16A16_SINT,
 218     /*WINED3DDECLTYPE_UBYTE4N*/   WINED3DFMT_R8G8B8A8_UNORM,
 219     /*WINED3DDECLTYPE_SHORT2N*/   WINED3DFMT_R16G16_SNORM,
 220     /*WINED3DDECLTYPE_SHORT4N*/   WINED3DFMT_R16G16B16A16_SNORM,
 221     /*WINED3DDECLTYPE_USHORT2N*/  WINED3DFMT_R16G16_UNORM,
 222     /*WINED3DDECLTYPE_USHORT4N*/  WINED3DFMT_R16G16B16A16_UNORM,
 223     /*WINED3DDECLTYPE_UDEC3*/     WINED3DFMT_R10G10B10A2_UINT,
 224     /*WINED3DDECLTYPE_DEC3N*/     WINED3DFMT_R10G10B10A2_SNORM,
 225     /*WINED3DDECLTYPE_FLOAT16_2*/ WINED3DFMT_R16G16_FLOAT,
 226     /*WINED3DDECLTYPE_FLOAT16_4*/ WINED3DFMT_R16G16B16A16_FLOAT,
 227 };
 228
 229 static const struct
 230 {
 231     BYTE usage;
 232     BYTE usage_idx;
 233 }
 234 wined3d_usage_lookup[] =
 235 {
 236     /* D3DVSDE_POSITION */      {WINED3D_DECL_USAGE_POSITION,      0},
 237     /* D3DVSDE_BLENDWEIGHT */   {WINED3D_DECL_USAGE_BLEND_WEIGHT,  0},
 238     /* D3DVSDE_BLENDINDICES */  {WINED3D_DECL_USAGE_BLEND_INDICES, 0},
 239     /* D3DVSDE_NORMAL */        {WINED3D_DECL_USAGE_NORMAL,        0},
 240     /* D3DVSDE_PSIZE */         {WINED3D_DECL_USAGE_PSIZE,         0},
 241     /* D3DVSDE_DIFFUSE */       {WINED3D_DECL_USAGE_COLOR,         0},
 242     /* D3DVSDE_SPECULAR */      {WINED3D_DECL_USAGE_COLOR,         1},
 243     /* D3DVSDE_TEXCOORD0 */     {WINED3D_DECL_USAGE_TEXCOORD,      0},
 244     /* D3DVSDE_TEXCOORD1 */     {WINED3D_DECL_USAGE_TEXCOORD,      1},
 245     /* D3DVSDE_TEXCOORD2 */     {WINED3D_DECL_USAGE_TEXCOORD,      2},
 246     /* D3DVSDE_TEXCOORD3 */     {WINED3D_DECL_USAGE_TEXCOORD,      3},
 247     /* D3DVSDE_TEXCOORD4 */     {WINED3D_DECL_USAGE_TEXCOORD,      4},
 248     /* D3DVSDE_TEXCOORD5 */     {WINED3D_DECL_USAGE_TEXCOORD,      5},
 249     /* D3DVSDE_TEXCOORD6 */     {WINED3D_DECL_USAGE_TEXCOORD,      6},
 250     /* D3DVSDE_TEXCOORD7 */     {WINED3D_DECL_USAGE_TEXCOORD,      7},
 251     /* D3DVSDE_POSITION2 */     {WINED3D_DECL_USAGE_POSITION,      1},
 252     /* D3DVSDE_NORMAL2 */       {WINED3D_DECL_USAGE_NORMAL,        1},
 253 };
 254
 255 /* TODO: find out where rhw (or positionT) is for declaration8 */
 256 static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3d8_elements_size,
 257         struct wined3d_vertex_element **wined3d_elements)
 258 {
 259     struct wined3d_vertex_element *element;
 260     const DWORD *token = d3d8_elements;
 261     D3DVSD_TOKENTYPE token_type;
 262     unsigned int element_count = 0;
 263     WORD stream = 0;
 264     int offset = 0;
 265
 266     TRACE("d3d8_elements %p, wined3d_elements %p\n", d3d8_elements, wined3d_elements);
 267
 268     /* 128 should be enough for anyone... */
 269     *wined3d_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 128 * sizeof(**wined3d_elements));
 270     while (D3DVSD_END() != *token)
 271     {
 272         token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
 273
 274         if (token_type == D3DVSD_TOKEN_STREAM && !(*token & D3DVSD_STREAMTESSMASK))
 275         {
 276             stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
 277             offset = 0;
 278         } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(token_type & 0x10000000)) {
 279             DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
 280             DWORD reg  = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 281
 282             TRACE("Adding element %d:\n", element_count);
 283
 284             element = *wined3d_elements + element_count++;
 285             element->format = wined3d_format_lookup[type];
 286             element->input_slot = stream;
 287             element->offset = offset;
 288             element->output_slot = reg;
 289             element->method = WINED3D_DECL_METHOD_DEFAULT;
 290             element->usage = wined3d_usage_lookup[reg].usage;
 291             element->usage_idx = wined3d_usage_lookup[reg].usage_idx;
 292
 293             offset += wined3d_type_sizes[type];
 294         } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (token_type & 0x10000000)) {
 295             TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
 296             offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
 297         }
 298
 299         if (element_count >= 127) {
 300             ERR("More than 127 elements?\n");
 301             break;
 302         }
 303
 304         token += parse_token(token);
 305     }
 306
 307     *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD);
 308
 309     return element_count;
 310 }
 311
 312 static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed(void *parent)
 313 {
 314     struct d3d8_vertex_declaration *declaration = parent;
 315     HeapFree(GetProcessHeap(), 0, declaration->elements);
 316     HeapFree(GetProcessHeap(), 0, declaration);
 317 }
 318
 319 void d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration *declaration)
 320 {
 321     TRACE("declaration %p.\n", declaration);
 322
 323     wined3d_mutex_lock();
 324     wined3d_vertex_declaration_decref(declaration->wined3d_vertex_declaration);
 325     wined3d_mutex_unlock();
 326 }
 327
 328 static const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops =
 329 {
 330     d3d8_vertexdeclaration_wined3d_object_destroyed,
 331 };
 332
 333 HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration,
 334         struct d3d8_device *device, const DWORD *elements, DWORD shader_handle)
 335 {
 336     struct wined3d_vertex_element *wined3d_elements;
 337     UINT wined3d_element_count;
 338     HRESULT hr;
 339
 340     declaration->shader_handle = shader_handle;
 341
 342     wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements);
 343     declaration->elements = HeapAlloc(GetProcessHeap(), 0, declaration->elements_size);
 344     if (!declaration->elements)
 345     {
 346         ERR("Failed to allocate vertex declaration elements memory.\n");
 347         HeapFree(GetProcessHeap(), 0, wined3d_elements);
 348         return E_OUTOFMEMORY;
 349     }
 350
 351     memcpy(declaration->elements, elements, declaration->elements_size);
 352
 353     wined3d_mutex_lock();
 354     hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
 355             declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
 356     wined3d_mutex_unlock();
 357     HeapFree(GetProcessHeap(), 0, wined3d_elements);
 358     if (FAILED(hr))
 359     {
 360         WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
 361         HeapFree(GetProcessHeap(), 0, declaration->elements);
 362         return hr;
 363     }
 364
 365     return D3D_OK;
 366 }
 367
 368 HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declaration,
 369         struct d3d8_device *device, DWORD fvf)
 370 {
 371     HRESULT hr;
 372
 373     declaration->elements = NULL;
 374     declaration->elements_size = 0;
 375     declaration->shader_handle = fvf;
 376
 377     hr = wined3d_vertex_declaration_create_from_fvf(device->wined3d_device, fvf, declaration,
 378             &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
 379     if (FAILED(hr))
 380     {
 381         WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
 382         return hr;
 383     }
 384
 385     return D3D_OK;
 386 }