2 * vertex declaration implementation
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
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.
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.
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
26 #include "wine/port.h"
27 #include "wined3d_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d_decl
);
31 static void dump_wined3d_vertex_element(const struct wined3d_vertex_element
*element
)
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
);
44 ULONG CDECL
wined3d_vertex_declaration_incref(struct wined3d_vertex_declaration
*declaration
)
46 ULONG refcount
= InterlockedIncrement(&declaration
->ref
);
48 TRACE("%p increasing refcount to %u.\n", declaration
, refcount
);
53 static void wined3d_vertex_declaration_destroy_object(void *object
)
55 struct wined3d_vertex_declaration
*declaration
= object
;
57 HeapFree(GetProcessHeap(), 0, declaration
->elements
);
58 HeapFree(GetProcessHeap(), 0, declaration
);
61 ULONG CDECL
wined3d_vertex_declaration_decref(struct wined3d_vertex_declaration
*declaration
)
63 ULONG refcount
= InterlockedDecrement(&declaration
->ref
);
65 TRACE("%p decreasing refcount to %u.\n", declaration
, refcount
);
69 declaration
->parent_ops
->wined3d_object_destroyed(declaration
->parent
);
70 wined3d_cs_destroy_object(declaration
->device
->cs
,
71 wined3d_vertex_declaration_destroy_object
, declaration
);
77 void * CDECL
wined3d_vertex_declaration_get_parent(const struct wined3d_vertex_declaration
*declaration
)
79 TRACE("declaration %p.\n", declaration
);
81 return declaration
->parent
;
84 static BOOL
declaration_element_valid_ffp(const struct wined3d_vertex_element
*element
)
86 switch(element
->usage
)
88 case WINED3D_DECL_USAGE_POSITION
:
89 case WINED3D_DECL_USAGE_POSITIONT
:
90 switch(element
->format
)
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
:
104 case WINED3D_DECL_USAGE_BLEND_WEIGHT
:
105 switch(element
->format
)
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
:
122 case WINED3D_DECL_USAGE_NORMAL
:
123 switch(element
->format
)
125 case WINED3DFMT_R32G32B32_FLOAT
:
126 case WINED3DFMT_R32G32B32A32_FLOAT
:
127 case WINED3DFMT_R16G16B16A16_SINT
:
128 case WINED3DFMT_R16G16B16A16_FLOAT
:
134 case WINED3D_DECL_USAGE_TEXCOORD
:
135 switch(element
->format
)
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
:
150 case WINED3D_DECL_USAGE_COLOR
:
151 switch(element
->format
)
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
:
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
)
176 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
179 if (TRACE_ON(d3d_decl
))
181 for (i
= 0; i
< element_count
; ++i
)
183 dump_wined3d_vertex_element(elements
+ i
);
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
))))
193 ERR("Failed to allocate elements memory.\n");
194 return E_OUTOFMEMORY
;
196 declaration
->element_count
= element_count
;
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
)
202 struct wined3d_vertex_declaration_element
*e
= &declaration
->elements
[i
];
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
;
215 if (e
->usage
== WINED3D_DECL_USAGE_POSITIONT
)
216 declaration
->position_transformed
= TRUE
;
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;
222 if (!e
->format
->gl_vtx_format
)
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
);
230 if (e
->offset
== WINED3D_APPEND_ALIGNED_ELEMENT
)
232 const struct wined3d_vertex_declaration_element
*prev
;
236 for (j
= 1; j
<= i
; ++j
)
238 prev
= &declaration
->elements
[i
- j
];
239 if (prev
->input_slot
== e
->input_slot
)
241 e
->offset
= (prev
->offset
+ prev
->format
->byte_count
+ 3) & ~3;
249 WARN("Declaration element %u is not 4 byte aligned(%u), returning E_FAIL.\n", i
, e
->offset
);
250 HeapFree(GetProcessHeap(), 0, declaration
->elements
);
254 if (elements
[i
].format
== WINED3DFMT_R16G16_FLOAT
|| elements
[i
].format
== WINED3DFMT_R16G16B16A16_FLOAT
)
256 if (!gl_info
->supported
[ARB_HALF_FLOAT_VERTEX
]) declaration
->half_float_conv_needed
= TRUE
;
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
)
267 struct wined3d_vertex_declaration
*object
;
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
);
273 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
275 return E_OUTOFMEMORY
;
277 hr
= vertexdeclaration_init(object
, device
, elements
, element_count
, parent
, parent_ops
);
280 WARN("Failed to initialize vertex declaration, hr %#x.\n", hr
);
281 HeapFree(GetProcessHeap(), 0, object
);
285 TRACE("Created vertex declaration %p.\n", object
);
286 *declaration
= object
;
291 struct wined3d_fvf_convert_state
293 const struct wined3d_gl_info
*gl_info
;
294 struct wined3d_vertex_element
*elements
;
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
)
302 struct wined3d_vertex_element
*elements
= state
->elements
;
303 const struct wined3d_format
*format
;
304 UINT offset
= state
->offset
;
305 UINT idx
= state
->idx
;
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
;
317 format
= wined3d_get_format(state
->gl_info
, format_id
, 0);
318 state
->offset
+= format
->attribute_size
;
322 static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info
*gl_info
,
323 DWORD fvf
, struct wined3d_vertex_element
**elements
)
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
);
336 DWORD num_textures
= (fvf
& WINED3DFVF_TEXCOUNT_MASK
) >> WINED3DFVF_TEXCOUNT_SHIFT
;
337 DWORD texcoords
= (fvf
& 0xffff0000) >> 16;
338 struct wined3d_fvf_convert_state state
;
341 DWORD num_blends
= 1 + (((fvf
& WINED3DFVF_XYZB5
) - WINED3DFVF_XYZB1
) >> 1);
342 if (has_blend_idx
) num_blends
--;
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
;
348 state
.gl_info
= gl_info
;
349 if (!(state
.elements
= wined3d_calloc(size
, sizeof(*state
.elements
))))
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);
361 append_decl_element(&state
, WINED3DFMT_R32G32B32_FLOAT
, WINED3D_DECL_USAGE_POSITION
, 0);
364 if (has_blend
&& (num_blends
> 0))
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);
373 append_decl_element(&state
, WINED3DFMT_R32_FLOAT
, WINED3D_DECL_USAGE_BLEND_WEIGHT
, 0);
376 append_decl_element(&state
, WINED3DFMT_R32G32_FLOAT
, WINED3D_DECL_USAGE_BLEND_WEIGHT
, 0);
379 append_decl_element(&state
, WINED3DFMT_R32G32B32_FLOAT
, WINED3D_DECL_USAGE_BLEND_WEIGHT
, 0);
382 append_decl_element(&state
, WINED3DFMT_R32G32B32A32_FLOAT
, WINED3D_DECL_USAGE_BLEND_WEIGHT
, 0);
385 ERR("Unexpected amount of blend values: %u\n", num_blends
);
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);
398 append_decl_element(&state
, WINED3DFMT_R32_FLOAT
, WINED3D_DECL_USAGE_BLEND_INDICES
, 0);
402 append_decl_element(&state
, WINED3DFMT_R32G32B32_FLOAT
, WINED3D_DECL_USAGE_NORMAL
, 0);
404 append_decl_element(&state
, WINED3DFMT_R32_FLOAT
, WINED3D_DECL_USAGE_PSIZE
, 0);
406 append_decl_element(&state
, WINED3DFMT_B8G8R8A8_UNORM
, WINED3D_DECL_USAGE_COLOR
, 0);
408 append_decl_element(&state
, WINED3DFMT_B8G8R8A8_UNORM
, WINED3D_DECL_USAGE_COLOR
, 1);
410 for (idx
= 0; idx
< num_textures
; ++idx
)
412 switch ((texcoords
>> (idx
* 2)) & 0x03)
414 case WINED3DFVF_TEXTUREFORMAT1
:
415 append_decl_element(&state
, WINED3DFMT_R32_FLOAT
, WINED3D_DECL_USAGE_TEXCOORD
, idx
);
417 case WINED3DFVF_TEXTUREFORMAT2
:
418 append_decl_element(&state
, WINED3DFMT_R32G32_FLOAT
, WINED3D_DECL_USAGE_TEXCOORD
, idx
);
420 case WINED3DFVF_TEXTUREFORMAT3
:
421 append_decl_element(&state
, WINED3DFMT_R32G32B32_FLOAT
, WINED3D_DECL_USAGE_TEXCOORD
, idx
);
423 case WINED3DFVF_TEXTUREFORMAT4
:
424 append_decl_element(&state
, WINED3DFMT_R32G32B32A32_FLOAT
, WINED3D_DECL_USAGE_TEXCOORD
, idx
);
429 *elements
= state
.elements
;
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
)
437 struct wined3d_vertex_element
*elements
;
441 TRACE("device %p, fvf %#x, parent %p, parent_ops %p, declaration %p.\n",
442 device
, fvf
, parent
, parent_ops
, declaration
);
444 size
= convert_fvf_to_declaration(&device
->adapter
->gl_info
, fvf
, &elements
);
445 if (size
== ~0U) return E_OUTOFMEMORY
;
447 hr
= wined3d_vertex_declaration_create(device
, elements
, size
, parent
, parent_ops
, declaration
);
448 HeapFree(GetProcessHeap(), 0, elements
);