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_R10G10B10X2_UINT, 224 /*WINED3DDECLTYPE_DEC3N*/ WINED3DFMT_R10G10B10X2_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, d3d8_elements_size %p, wined3d_elements %p\n", d3d8_elements, d3d8_elements_size, wined3d_elements); 267 268 /* 128 should be enough for anyone... */ 269 *wined3d_elements = heap_alloc_zero(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 & D3DVSD_DATALOADTYPEMASK)) { 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->input_slot_class = WINED3D_INPUT_PER_VERTEX_DATA; 290 element->instance_data_step_rate = 0; 291 element->method = WINED3D_DECL_METHOD_DEFAULT; 292 element->usage = wined3d_usage_lookup[reg].usage; 293 element->usage_idx = wined3d_usage_lookup[reg].usage_idx; 294 295 offset += wined3d_type_sizes[type]; 296 } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (*token & D3DVSD_DATALOADTYPEMASK)) { 297 TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT)); 298 offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT); 299 } 300 301 if (element_count >= 127) { 302 ERR("More than 127 elements?\n"); 303 break; 304 } 305 306 token += parse_token(token); 307 } 308 309 *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD); 310 311 return element_count; 312 } 313 314 static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed(void *parent) 315 { 316 struct d3d8_vertex_declaration *declaration = parent; 317 heap_free(declaration->elements); 318 heap_free(declaration); 319 } 320 321 void d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration *declaration) 322 { 323 TRACE("declaration %p.\n", declaration); 324 325 wined3d_mutex_lock(); 326 wined3d_vertex_declaration_decref(declaration->wined3d_vertex_declaration); 327 wined3d_mutex_unlock(); 328 } 329 330 static const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops = 331 { 332 d3d8_vertexdeclaration_wined3d_object_destroyed, 333 }; 334 335 HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration, 336 struct d3d8_device *device, const DWORD *elements, DWORD shader_handle) 337 { 338 struct wined3d_vertex_element *wined3d_elements; 339 UINT wined3d_element_count; 340 HRESULT hr; 341 342 declaration->shader_handle = shader_handle; 343 344 wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements); 345 if (!(declaration->elements = heap_alloc(declaration->elements_size))) 346 { 347 ERR("Failed to allocate vertex declaration elements memory.\n"); 348 heap_free(wined3d_elements); 349 return E_OUTOFMEMORY; 350 } 351 352 memcpy(declaration->elements, elements, declaration->elements_size); 353 354 wined3d_mutex_lock(); 355 hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count, 356 declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration); 357 wined3d_mutex_unlock(); 358 heap_free(wined3d_elements); 359 if (FAILED(hr)) 360 { 361 WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); 362 heap_free(declaration->elements); 363 return hr; 364 } 365 366 return D3D_OK; 367 } 368 369 HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declaration, 370 struct d3d8_device *device, DWORD fvf) 371 { 372 HRESULT hr; 373 374 declaration->elements = NULL; 375 declaration->elements_size = 0; 376 declaration->shader_handle = fvf; 377 378 hr = wined3d_vertex_declaration_create_from_fvf(device->wined3d_device, fvf, declaration, 379 &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration); 380 if (FAILED(hr)) 381 { 382 WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); 383 return hr; 384 } 385 386 return D3D_OK; 387 } 388