2 * IDirect3DVertexDeclaration9 implementation
4 * Copyright 2002-2003 Raphael Junqueira
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.
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.
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
22 #include "d3d9_private.h"
26 enum wined3d_format_id format
;
27 unsigned int component_count
;
28 unsigned int component_size
;
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_R10G10B10X2_UINT
, 3, sizeof(short int)},
46 /* D3DDECLTYPE_DEC3N */ {WINED3DFMT_R10G10B10X2_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)}
51 static inline struct d3d9_vertex_declaration
*impl_from_IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9
*iface
)
53 return CONTAINING_RECORD(iface
, struct d3d9_vertex_declaration
, IDirect3DVertexDeclaration9_iface
);
56 HRESULT
vdecl_convert_fvf(
58 D3DVERTEXELEMENT9
** ppVertexElements
) {
60 unsigned int idx
, idx2
;
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;
71 BOOL has_diffuse
= (fvf
& D3DFVF_DIFFUSE
) != 0;
72 BOOL has_specular
= (fvf
& D3DFVF_SPECULAR
) !=0;
74 DWORD num_textures
= (fvf
& D3DFVF_TEXCOUNT_MASK
) >> D3DFVF_TEXCOUNT_SHIFT
;
75 DWORD texcoords
= (fvf
& 0xFFFF0000) >> 16;
77 D3DVERTEXELEMENT9 end_element
= D3DDECL_END();
78 D3DVERTEXELEMENT9
*elements
= NULL
;
81 DWORD num_blends
= 1 + (((fvf
& D3DFVF_XYZB5
) - D3DFVF_XYZB1
) >> 1);
82 if (has_blend_idx
) num_blends
--;
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;
88 /* convert the declaration */
89 elements
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(D3DVERTEXELEMENT9
));
90 if (!elements
) return D3DERR_OUTOFVIDEOMEMORY
;
92 elements
[size
-1] = end_element
;
95 if (!has_blend
&& (fvf
& D3DFVF_XYZRHW
)) {
96 elements
[idx
].Type
= D3DDECLTYPE_FLOAT4
;
97 elements
[idx
].Usage
= D3DDECLUSAGE_POSITIONT
;
99 else if (!has_blend
&& (fvf
& D3DFVF_XYZW
) == D3DFVF_XYZW
) {
100 elements
[idx
].Type
= D3DDECLTYPE_FLOAT4
;
101 elements
[idx
].Usage
= D3DDECLUSAGE_POSITION
;
104 elements
[idx
].Type
= D3DDECLTYPE_FLOAT3
;
105 elements
[idx
].Usage
= D3DDECLUSAGE_POSITION
;
107 elements
[idx
].UsageIndex
= 0;
110 if (has_blend
&& (num_blends
> 0)) {
111 if (((fvf
& D3DFVF_XYZB5
) == D3DFVF_XYZB2
) && (fvf
& D3DFVF_LASTBETA_D3DCOLOR
))
112 elements
[idx
].Type
= D3DDECLTYPE_D3DCOLOR
;
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;
120 ERR("Unexpected amount of blend values: %u\n", num_blends
);
123 elements
[idx
].Usage
= D3DDECLUSAGE_BLENDWEIGHT
;
124 elements
[idx
].UsageIndex
= 0;
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
;
134 elements
[idx
].Type
= D3DDECLTYPE_FLOAT1
;
135 elements
[idx
].Usage
= D3DDECLUSAGE_BLENDINDICES
;
136 elements
[idx
].UsageIndex
= 0;
140 elements
[idx
].Type
= D3DDECLTYPE_FLOAT3
;
141 elements
[idx
].Usage
= D3DDECLUSAGE_NORMAL
;
142 elements
[idx
].UsageIndex
= 0;
146 elements
[idx
].Type
= D3DDECLTYPE_FLOAT1
;
147 elements
[idx
].Usage
= D3DDECLUSAGE_PSIZE
;
148 elements
[idx
].UsageIndex
= 0;
152 elements
[idx
].Type
= D3DDECLTYPE_D3DCOLOR
;
153 elements
[idx
].Usage
= D3DDECLUSAGE_COLOR
;
154 elements
[idx
].UsageIndex
= 0;
158 elements
[idx
].Type
= D3DDECLTYPE_D3DCOLOR
;
159 elements
[idx
].Usage
= D3DDECLUSAGE_COLOR
;
160 elements
[idx
].UsageIndex
= 1;
163 for (idx2
= 0; idx2
< num_textures
; idx2
++) {
164 unsigned int numcoords
= (texcoords
>> (idx2
*2)) & 0x03;
166 case D3DFVF_TEXTUREFORMAT1
:
167 elements
[idx
].Type
= D3DDECLTYPE_FLOAT1
;
169 case D3DFVF_TEXTUREFORMAT2
:
170 elements
[idx
].Type
= D3DDECLTYPE_FLOAT2
;
172 case D3DFVF_TEXTUREFORMAT3
:
173 elements
[idx
].Type
= D3DDECLTYPE_FLOAT3
;
175 case D3DFVF_TEXTUREFORMAT4
:
176 elements
[idx
].Type
= D3DDECLTYPE_FLOAT4
;
179 elements
[idx
].Usage
= D3DDECLUSAGE_TEXCOORD
;
180 elements
[idx
].UsageIndex
= idx2
;
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
;
193 *ppVertexElements
= elements
;
197 static HRESULT WINAPI
d3d9_vertex_declaration_QueryInterface(IDirect3DVertexDeclaration9
*iface
,
198 REFIID riid
, void **out
)
200 TRACE("iface %p, riid %s, out %p.\n", iface
, debugstr_guid(riid
), out
);
202 if (IsEqualGUID(riid
, &IID_IDirect3DVertexDeclaration9
)
203 || IsEqualGUID(riid
, &IID_IUnknown
))
205 IDirect3DVertexDeclaration9_AddRef(iface
);
210 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid
));
213 return E_NOINTERFACE
;
216 static ULONG WINAPI
d3d9_vertex_declaration_AddRef(IDirect3DVertexDeclaration9
*iface
)
218 struct d3d9_vertex_declaration
*declaration
= impl_from_IDirect3DVertexDeclaration9(iface
);
219 ULONG refcount
= InterlockedIncrement(&declaration
->refcount
);
221 TRACE("%p increasing refcount to %u.\n", iface
, refcount
);
225 IDirect3DDevice9Ex_AddRef(declaration
->parent_device
);
226 wined3d_mutex_lock();
227 wined3d_vertex_declaration_incref(declaration
->wined3d_declaration
);
228 wined3d_mutex_unlock();
234 static ULONG WINAPI
d3d9_vertex_declaration_Release(IDirect3DVertexDeclaration9
*iface
)
236 struct d3d9_vertex_declaration
*declaration
= impl_from_IDirect3DVertexDeclaration9(iface
);
237 ULONG refcount
= InterlockedDecrement(&declaration
->refcount
);
239 TRACE("%p decreasing refcount to %u.\n", iface
, refcount
);
243 IDirect3DDevice9Ex
*parent_device
= declaration
->parent_device
;
244 wined3d_mutex_lock();
245 wined3d_vertex_declaration_decref(declaration
->wined3d_declaration
);
246 wined3d_mutex_unlock();
248 /* Release the device last, as it may cause the device to be destroyed. */
249 IDirect3DDevice9Ex_Release(parent_device
);
255 static HRESULT WINAPI
d3d9_vertex_declaration_GetDevice(IDirect3DVertexDeclaration9
*iface
, IDirect3DDevice9
**device
)
257 struct d3d9_vertex_declaration
*declaration
= impl_from_IDirect3DVertexDeclaration9(iface
);
259 TRACE("iface %p, device %p.\n", iface
, device
);
261 *device
= (IDirect3DDevice9
*)declaration
->parent_device
;
262 IDirect3DDevice9_AddRef(*device
);
264 TRACE("Returning device %p.\n", *device
);
269 static HRESULT WINAPI
d3d9_vertex_declaration_GetDeclaration(IDirect3DVertexDeclaration9
*iface
,
270 D3DVERTEXELEMENT9
*elements
, UINT
*element_count
)
272 struct d3d9_vertex_declaration
*declaration
= impl_from_IDirect3DVertexDeclaration9(iface
);
274 TRACE("iface %p, elements %p, element_count %p.\n", iface
, elements
, element_count
);
276 *element_count
= declaration
->element_count
;
278 /* Passing a NULL elements is used to just retrieve the number of elements */
282 TRACE("Copying %p to %p.\n", declaration
->elements
, elements
);
283 memcpy(elements
, declaration
->elements
, sizeof(*declaration
->elements
) * declaration
->element_count
);
288 static const struct IDirect3DVertexDeclaration9Vtbl d3d9_vertex_declaration_vtbl
=
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
,
299 struct d3d9_vertex_declaration
*unsafe_impl_from_IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9
*iface
)
303 assert(iface
->lpVtbl
== &d3d9_vertex_declaration_vtbl
);
304 return CONTAINING_RECORD(iface
, struct d3d9_vertex_declaration
, IDirect3DVertexDeclaration9_iface
);
307 static void STDMETHODCALLTYPE
d3d9_vertexdeclaration_wined3d_object_destroyed(void *parent
)
309 struct d3d9_vertex_declaration
*declaration
= parent
;
310 HeapFree(GetProcessHeap(), 0, declaration
->elements
);
311 HeapFree(GetProcessHeap(), 0, declaration
);
314 static const struct wined3d_parent_ops d3d9_vertexdeclaration_wined3d_parent_ops
=
316 d3d9_vertexdeclaration_wined3d_object_destroyed
,
319 static HRESULT
convert_to_wined3d_declaration(const D3DVERTEXELEMENT9
*d3d9_elements
,
320 struct wined3d_vertex_element
**wined3d_elements
, UINT
*element_count
)
322 const D3DVERTEXELEMENT9
* element
;
326 TRACE("d3d9_elements %p, wined3d_elements %p, element_count %p\n", d3d9_elements
, wined3d_elements
, element_count
);
328 element
= d3d9_elements
;
329 while (element
++->Stream
!= 0xff && count
++ < 128);
331 if (count
== 128) return E_FAIL
;
333 /* Skip the END element */
336 *wined3d_elements
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(**wined3d_elements
));
337 if (!*wined3d_elements
) {
338 FIXME("Memory allocation failed\n");
339 return D3DERR_OUTOFVIDEOMEMORY
;
342 for (i
= 0; i
< count
; ++i
)
344 if (d3d9_elements
[i
].Type
>= (sizeof(d3d_dtype_lookup
) / sizeof(*d3d_dtype_lookup
)))
346 WARN("Invalid element type %#x.\n", d3d9_elements
[i
].Type
);
347 HeapFree(GetProcessHeap(), 0, *wined3d_elements
);
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
= WINED3D_OUTPUT_SLOT_SEMANTIC
;
354 (*wined3d_elements
)[i
].input_slot_class
= WINED3D_INPUT_PER_VERTEX_DATA
;
355 (*wined3d_elements
)[i
].instance_data_step_rate
= 0;
356 (*wined3d_elements
)[i
].method
= d3d9_elements
[i
].Method
;
357 (*wined3d_elements
)[i
].usage
= d3d9_elements
[i
].Usage
;
358 (*wined3d_elements
)[i
].usage_idx
= d3d9_elements
[i
].UsageIndex
;
361 *element_count
= count
;
366 static HRESULT
vertexdeclaration_init(struct d3d9_vertex_declaration
*declaration
,
367 struct d3d9_device
*device
, const D3DVERTEXELEMENT9
*elements
)
369 struct wined3d_vertex_element
*wined3d_elements
;
370 UINT wined3d_element_count
;
374 hr
= convert_to_wined3d_declaration(elements
, &wined3d_elements
, &wined3d_element_count
);
377 WARN("Failed to create wined3d vertex declaration elements, hr %#x.\n", hr
);
381 declaration
->IDirect3DVertexDeclaration9_iface
.lpVtbl
= &d3d9_vertex_declaration_vtbl
;
382 declaration
->refcount
= 1;
384 element_count
= wined3d_element_count
+ 1;
385 declaration
->elements
= HeapAlloc(GetProcessHeap(), 0, element_count
* sizeof(*declaration
->elements
));
386 if (!declaration
->elements
)
388 HeapFree(GetProcessHeap(), 0, wined3d_elements
);
389 ERR("Failed to allocate vertex declaration elements memory.\n");
390 return D3DERR_OUTOFVIDEOMEMORY
;
392 memcpy(declaration
->elements
, elements
, element_count
* sizeof(*elements
));
393 declaration
->element_count
= element_count
;
395 wined3d_mutex_lock();
396 hr
= wined3d_vertex_declaration_create(device
->wined3d_device
, wined3d_elements
, wined3d_element_count
,
397 declaration
, &d3d9_vertexdeclaration_wined3d_parent_ops
, &declaration
->wined3d_declaration
);
398 wined3d_mutex_unlock();
399 HeapFree(GetProcessHeap(), 0, wined3d_elements
);
402 HeapFree(GetProcessHeap(), 0, declaration
->elements
);
403 WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr
);
407 declaration
->parent_device
= &device
->IDirect3DDevice9Ex_iface
;
408 IDirect3DDevice9Ex_AddRef(declaration
->parent_device
);
413 HRESULT
d3d9_vertex_declaration_create(struct d3d9_device
*device
,
414 const D3DVERTEXELEMENT9
*elements
, struct d3d9_vertex_declaration
**declaration
)
416 struct d3d9_vertex_declaration
*object
;
419 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
421 return E_OUTOFMEMORY
;
423 hr
= vertexdeclaration_init(object
, device
, elements
);
426 WARN("Failed to initialize vertex declaration, hr %#x.\n", hr
);
427 HeapFree(GetProcessHeap(), 0, object
);
431 TRACE("Created vertex declaration %p.\n", object
);
432 *declaration
= object
;