2 * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
23 #include "vertexdeclaration9.h"
24 #include "vertexbuffer9.h"
26 #include "nine_helpers.h"
28 #include "pipe/p_format.h"
29 #include "pipe/p_context.h"
30 #include "util/u_math.h"
31 #include "util/u_format.h"
32 #include "util/u_box.h"
33 #include "translate/translate.h"
35 #define DBG_CHANNEL DBG_VERTEXDECLARATION
37 static INLINE
enum pipe_format
decltype_format(BYTE type
)
40 case D3DDECLTYPE_FLOAT1
: return PIPE_FORMAT_R32_FLOAT
;
41 case D3DDECLTYPE_FLOAT2
: return PIPE_FORMAT_R32G32_FLOAT
;
42 case D3DDECLTYPE_FLOAT3
: return PIPE_FORMAT_R32G32B32_FLOAT
;
43 case D3DDECLTYPE_FLOAT4
: return PIPE_FORMAT_R32G32B32A32_FLOAT
;
44 case D3DDECLTYPE_D3DCOLOR
: return PIPE_FORMAT_B8G8R8A8_UNORM
;
45 case D3DDECLTYPE_UBYTE4
: return PIPE_FORMAT_R8G8B8A8_USCALED
;
46 case D3DDECLTYPE_SHORT2
: return PIPE_FORMAT_R16G16_SSCALED
;
47 case D3DDECLTYPE_SHORT4
: return PIPE_FORMAT_R16G16B16A16_SSCALED
;
48 case D3DDECLTYPE_UBYTE4N
: return PIPE_FORMAT_R8G8B8A8_UNORM
;
49 case D3DDECLTYPE_SHORT2N
: return PIPE_FORMAT_R16G16_SNORM
;
50 case D3DDECLTYPE_SHORT4N
: return PIPE_FORMAT_R16G16B16A16_SNORM
;
51 case D3DDECLTYPE_USHORT2N
: return PIPE_FORMAT_R16G16_UNORM
;
52 case D3DDECLTYPE_USHORT4N
: return PIPE_FORMAT_R16G16B16A16_UNORM
;
53 case D3DDECLTYPE_UDEC3
: return PIPE_FORMAT_R10G10B10X2_USCALED
;
54 case D3DDECLTYPE_DEC3N
: return PIPE_FORMAT_R10G10B10X2_SNORM
;
55 case D3DDECLTYPE_FLOAT16_2
: return PIPE_FORMAT_R16G16_FLOAT
;
56 case D3DDECLTYPE_FLOAT16_4
: return PIPE_FORMAT_R16G16B16A16_FLOAT
;
58 assert(!"Implementation error !");
60 return PIPE_FORMAT_NONE
;
63 static INLINE
unsigned decltype_size(BYTE type
)
66 case D3DDECLTYPE_FLOAT1
: return 1 * sizeof(float);
67 case D3DDECLTYPE_FLOAT2
: return 2 * sizeof(float);
68 case D3DDECLTYPE_FLOAT3
: return 3 * sizeof(float);
69 case D3DDECLTYPE_FLOAT4
: return 4 * sizeof(float);
70 case D3DDECLTYPE_D3DCOLOR
: return 1 * sizeof(DWORD
);
71 case D3DDECLTYPE_UBYTE4
: return 4 * sizeof(BYTE
);
72 case D3DDECLTYPE_SHORT2
: return 2 * sizeof(short);
73 case D3DDECLTYPE_SHORT4
: return 4 * sizeof(short);
74 case D3DDECLTYPE_UBYTE4N
: return 4 * sizeof(BYTE
);
75 case D3DDECLTYPE_SHORT2N
: return 2 * sizeof(short);
76 case D3DDECLTYPE_SHORT4N
: return 4 * sizeof(short);
77 case D3DDECLTYPE_USHORT2N
: return 2 * sizeof(short);
78 case D3DDECLTYPE_USHORT4N
: return 4 * sizeof(short);
79 case D3DDECLTYPE_UDEC3
: return 4;
80 case D3DDECLTYPE_DEC3N
: return 4;
81 case D3DDECLTYPE_FLOAT16_2
: return 2 * 2;
82 case D3DDECLTYPE_FLOAT16_4
: return 4 * 2;
84 assert(!"Implementation error !");
89 /* Actually, arbitrary usage index values are permitted, but a
90 * simple lookup table won't work in that case. Let's just wait
91 * with making this more generic until we need it.
94 nine_d3ddeclusage_check(unsigned usage
, unsigned usage_idx
)
97 case D3DDECLUSAGE_POSITIONT
:
98 case D3DDECLUSAGE_TESSFACTOR
:
99 case D3DDECLUSAGE_DEPTH
:
100 case D3DDECLUSAGE_NORMAL
:
101 case D3DDECLUSAGE_TANGENT
:
102 case D3DDECLUSAGE_BINORMAL
:
103 case D3DDECLUSAGE_POSITION
:
104 case D3DDECLUSAGE_BLENDWEIGHT
:
105 case D3DDECLUSAGE_BLENDINDICES
:
106 case D3DDECLUSAGE_COLOR
:
108 case D3DDECLUSAGE_PSIZE
:
109 case D3DDECLUSAGE_FOG
:
110 case D3DDECLUSAGE_SAMPLE
:
111 return usage_idx
<= 0;
112 case D3DDECLUSAGE_TEXCOORD
:
113 return usage_idx
<= 15;
119 #define NINE_DECLUSAGE_CASE0(n) case D3DDECLUSAGE_##n: return NINE_DECLUSAGE_##n
120 #define NINE_DECLUSAGE_CASEi(n) case D3DDECLUSAGE_##n: return NINE_DECLUSAGE_i(n, usage_idx)
122 nine_d3d9_to_nine_declusage(unsigned usage
, unsigned usage_idx
)
124 if (!nine_d3ddeclusage_check(usage
, usage_idx
))
125 ERR("D3DDECLUSAGE_%u[%u]\n",usage
,usage_idx
);
126 assert(nine_d3ddeclusage_check(usage
, usage_idx
));
128 NINE_DECLUSAGE_CASEi(POSITION
);
129 NINE_DECLUSAGE_CASEi(BLENDWEIGHT
);
130 NINE_DECLUSAGE_CASEi(BLENDINDICES
);
131 NINE_DECLUSAGE_CASEi(NORMAL
);
132 NINE_DECLUSAGE_CASE0(PSIZE
);
133 NINE_DECLUSAGE_CASEi(TEXCOORD
);
134 NINE_DECLUSAGE_CASEi(TANGENT
);
135 NINE_DECLUSAGE_CASEi(BINORMAL
);
136 NINE_DECLUSAGE_CASE0(TESSFACTOR
);
137 NINE_DECLUSAGE_CASEi(POSITIONT
);
138 NINE_DECLUSAGE_CASEi(COLOR
);
139 NINE_DECLUSAGE_CASE0(DEPTH
);
140 NINE_DECLUSAGE_CASE0(FOG
);
141 NINE_DECLUSAGE_CASE0(SAMPLE
);
143 assert(!"Invalid DECLUSAGE.");
144 return NINE_DECLUSAGE_NONE
;
148 static const char *nine_declusage_names
[] =
150 [NINE_DECLUSAGE_POSITION
] = "POSITION",
151 [NINE_DECLUSAGE_BLENDWEIGHT
] = "BLENDWEIGHT",
152 [NINE_DECLUSAGE_BLENDINDICES
] = "BLENDINDICES",
153 [NINE_DECLUSAGE_NORMAL
] = "NORMAL",
154 [NINE_DECLUSAGE_PSIZE
] = "PSIZE",
155 [NINE_DECLUSAGE_TEXCOORD
] = "TEXCOORD",
156 [NINE_DECLUSAGE_TANGENT
] = "TANGENT",
157 [NINE_DECLUSAGE_BINORMAL
] = "BINORMAL",
158 [NINE_DECLUSAGE_TESSFACTOR
] = "TESSFACTOR",
159 [NINE_DECLUSAGE_POSITIONT
] = "POSITIONT",
160 [NINE_DECLUSAGE_COLOR
] = "DIFFUSE",
161 [NINE_DECLUSAGE_DEPTH
] = "DEPTH",
162 [NINE_DECLUSAGE_FOG
] = "FOG",
163 [NINE_DECLUSAGE_NONE
] = "(NONE)",
165 static INLINE
const char *
166 nine_declusage_name(unsigned ndcl
)
168 return nine_declusage_names
[ndcl
% NINE_DECLUSAGE_COUNT
];
172 NineVertexDeclaration9_ctor( struct NineVertexDeclaration9
*This
,
173 struct NineUnknownParams
*pParams
,
174 const D3DVERTEXELEMENT9
*pElements
)
176 const D3DCAPS9
*caps
;
179 DBG("This=%p pParams=%p pElements=%p\n", This
, pParams
, pElements
);
181 HRESULT hr
= NineUnknown_ctor(&This
->base
, pParams
);
182 if (FAILED(hr
)) { return hr
; }
184 for (This
->nelems
= 0;
185 pElements
[This
->nelems
].Type
!= D3DDECLTYPE_UNUSED
&&
186 pElements
[This
->nelems
].Stream
!= 0xFF; /* wine */
189 caps
= NineDevice9_GetCaps(This
->base
.device
);
190 user_assert(This
->nelems
<= caps
->MaxStreams
, D3DERR_INVALIDCALL
);
192 This
->decls
= CALLOC(This
->nelems
+1, sizeof(D3DVERTEXELEMENT9
));
193 This
->elems
= CALLOC(This
->nelems
, sizeof(struct pipe_vertex_element
));
194 This
->usage_map
= CALLOC(This
->nelems
, sizeof(uint16_t));
195 if (!This
->decls
|| !This
->elems
) { return E_OUTOFMEMORY
; }
196 memcpy(This
->decls
, pElements
, sizeof(D3DVERTEXELEMENT9
)*(This
->nelems
+1));
198 for (i
= 0; i
< This
->nelems
; ++i
) {
199 uint16_t usage
= nine_d3d9_to_nine_declusage(This
->decls
[i
].Usage
,
200 This
->decls
[i
].UsageIndex
);
201 This
->usage_map
[i
] = usage
;
203 This
->elems
[i
].src_offset
= This
->decls
[i
].Offset
;
204 This
->elems
[i
].instance_divisor
= 0;
205 This
->elems
[i
].vertex_buffer_index
= This
->decls
[i
].Stream
;
206 This
->elems
[i
].src_format
= decltype_format(This
->decls
[i
].Type
);
207 /* XXX Remember Method (tesselation), Usage, UsageIndex */
209 DBG("VERTEXELEMENT[%u]: Stream=%u Offset=%u Type=%s DeclUsage=%s%d\n", i
,
210 This
->decls
[i
].Stream
,
211 This
->decls
[i
].Offset
,
212 util_format_name(This
->elems
[i
].src_format
),
213 nine_declusage_name(usage
),
214 usage
/ NINE_DECLUSAGE_COUNT
);
221 NineVertexDeclaration9_dtor( struct NineVertexDeclaration9
*This
)
225 FREE(This
->usage_map
);
227 NineUnknown_dtor(&This
->base
);
231 NineVertexDeclaration9_GetDeclaration( struct NineVertexDeclaration9
*This
,
232 D3DVERTEXELEMENT9
*pElement
,
236 user_assert(pNumElements
, D3DERR_INVALIDCALL
);
237 *pNumElements
= This
->nelems
+1;
240 if (pNumElements
) { *pNumElements
= This
->nelems
+1; }
241 memcpy(pElement
, This
->decls
, sizeof(D3DVERTEXELEMENT9
)*(This
->nelems
+1));
245 IDirect3DVertexDeclaration9Vtbl NineVertexDeclaration9_vtable
= {
246 (void *)NineUnknown_QueryInterface
,
247 (void *)NineUnknown_AddRef
,
248 (void *)NineUnknown_Release
,
249 (void *)NineUnknown_GetDevice
, /* actually part of VertexDecl9 iface */
250 (void *)NineVertexDeclaration9_GetDeclaration
253 static const GUID
*NineVertexDeclaration9_IIDs
[] = {
254 &IID_IDirect3DVertexDeclaration9
,
260 NineVertexDeclaration9_new( struct NineDevice9
*pDevice
,
261 const D3DVERTEXELEMENT9
*pElements
,
262 struct NineVertexDeclaration9
**ppOut
)
264 NINE_DEVICE_CHILD_NEW(VertexDeclaration9
, ppOut
, /* args */ pDevice
, pElements
);
268 NineVertexDeclaration9_new_from_fvf( struct NineDevice9
*pDevice
,
270 struct NineVertexDeclaration9
**ppOut
)
272 D3DVERTEXELEMENT9 elems
[16], decl_end
= D3DDECL_END();
273 unsigned texcount
, i
, betas
, nelems
= 0;
274 BYTE beta_index
= 0xFF;
276 switch (FVF
& D3DFVF_POSITION_MASK
) {
277 case D3DFVF_XYZ
: /* simple XYZ */
282 case D3DFVF_XYZB5
: /* XYZ with beta values */
283 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
;
284 elems
[nelems
].Usage
= D3DDECLUSAGE_POSITION
;
285 elems
[nelems
].UsageIndex
= 0;
287 /* simple XYZ has no beta values. break. */
288 if ((FVF
& D3DFVF_POSITION_MASK
) == D3DFVF_XYZ
) { break; }
290 betas
= (((FVF
& D3DFVF_XYZB5
)-D3DFVF_XYZB1
)>>1)+1;
291 if (FVF
& D3DFVF_LASTBETA_D3DCOLOR
) {
292 beta_index
= D3DDECLTYPE_D3DCOLOR
;
293 } else if (FVF
& D3DFVF_LASTBETA_UBYTE4
) {
294 beta_index
= D3DDECLTYPE_UBYTE4
;
295 } else if ((FVF
& D3DFVF_XYZB5
) == D3DFVF_XYZB5
) {
296 beta_index
= D3DDECLTYPE_FLOAT1
;
298 if (beta_index
!= 0xFF) { --betas
; }
302 case 1: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT1
; break;
303 case 2: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT2
; break;
304 case 3: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
; break;
305 case 4: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT4
; break;
307 assert(!"Implementation error!");
309 elems
[nelems
].Usage
= D3DDECLUSAGE_BLENDWEIGHT
;
310 elems
[nelems
].UsageIndex
= 0;
314 if (beta_index
!= 0xFF) {
315 elems
[nelems
].Type
= beta_index
;
316 elems
[nelems
].Usage
= D3DDECLUSAGE_BLENDINDICES
;
317 elems
[nelems
].UsageIndex
= 0;
322 case D3DFVF_XYZW
: /* simple XYZW */
323 case D3DFVF_XYZRHW
: /* pretransformed XYZW */
324 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT4
;
325 elems
[nelems
].Usage
=
326 ((FVF
& D3DFVF_POSITION_MASK
) == D3DFVF_XYZW
) ?
327 D3DDECLUSAGE_POSITION
: D3DDECLUSAGE_POSITIONT
;
328 elems
[nelems
].UsageIndex
= 0;
333 (void)user_error(!"Position doesn't match any known combination");
336 /* normals, psize and colors */
337 if (FVF
& D3DFVF_NORMAL
) {
338 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
;
339 elems
[nelems
].Usage
= D3DDECLUSAGE_NORMAL
;
340 elems
[nelems
].UsageIndex
= 0;
343 if (FVF
& D3DFVF_PSIZE
) {
344 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT1
;
345 elems
[nelems
].Usage
= D3DDECLUSAGE_PSIZE
;
346 elems
[nelems
].UsageIndex
= 0;
349 if (FVF
& D3DFVF_DIFFUSE
) {
350 elems
[nelems
].Type
= D3DDECLTYPE_D3DCOLOR
;
351 elems
[nelems
].Usage
= D3DDECLUSAGE_COLOR
;
352 elems
[nelems
].UsageIndex
= 0;
355 if (FVF
& D3DFVF_SPECULAR
) {
356 elems
[nelems
].Type
= D3DDECLTYPE_D3DCOLOR
;
357 elems
[nelems
].Usage
= D3DDECLUSAGE_COLOR
;
358 elems
[nelems
].UsageIndex
= 1;
363 texcount
= (FVF
& D3DFVF_TEXCOUNT_MASK
) >> D3DFVF_TEXCOUNT_SHIFT
;
364 if (user_error(texcount
<= 8)) { texcount
= 8; }
366 for (i
= 0; i
< texcount
; ++i
) {
367 switch ((FVF
>> (16+i
*2)) & 0x3) {
368 case D3DFVF_TEXTUREFORMAT1
:
369 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT1
;
372 case D3DFVF_TEXTUREFORMAT2
:
373 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT2
;
376 case D3DFVF_TEXTUREFORMAT3
:
377 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
;
380 case D3DFVF_TEXTUREFORMAT4
:
381 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT4
;
385 assert(!"Implementation error!");
387 elems
[nelems
].Usage
= D3DDECLUSAGE_TEXCOORD
;
388 elems
[nelems
].UsageIndex
= i
;
392 /* fill out remaining data */
393 for (i
= 0; i
< nelems
; ++i
) {
395 elems
[i
].Offset
= (i
== 0) ? 0 : (elems
[i
-1].Offset
+
396 decltype_size(elems
[i
-1].Type
));
397 elems
[i
].Method
= D3DDECLMETHOD_DEFAULT
;
399 elems
[nelems
++] = decl_end
;
401 NINE_DEVICE_CHILD_NEW(VertexDeclaration9
, ppOut
, /* args */ pDevice
, elems
);
404 /* ProcessVertices runs stream output into a temporary buffer to capture
406 * Now we have to convert them to the format and order set by the vertex
407 * declaration, for which we use u_translate.
408 * This is necessary if the vertex declaration contains elements using a
409 * non float32 format, because stream output only supports f32/u32/s32.
412 NineVertexDeclaration9_ConvertStreamOutput(
413 struct NineVertexDeclaration9
*This
,
414 struct NineVertexBuffer9
*pDstBuf
,
417 struct pipe_resource
*pSrcBuf
,
418 const struct pipe_stream_output_info
*so
)
420 struct pipe_context
*pipe
= This
->base
.device
->pipe
;
421 struct pipe_transfer
*transfer
= NULL
;
422 struct translate
*translate
;
423 struct translate_key transkey
;
430 DBG("This=%p pDstBuf=%p DestIndex=%u VertexCount=%u pSrcBuf=%p so=%p\n",
431 This
, pDstBuf
, DestIndex
, VertexCount
, pSrcBuf
, so
);
433 transkey
.output_stride
= 0;
434 for (i
= 0; i
< This
->nelems
; ++i
) {
435 enum pipe_format format
;
437 switch (so
->output
[i
].num_components
) {
438 case 1: format
= PIPE_FORMAT_R32_FLOAT
; break;
439 case 2: format
= PIPE_FORMAT_R32G32_FLOAT
; break;
440 case 3: format
= PIPE_FORMAT_R32G32B32_FLOAT
; break;
442 assert(so
->output
[i
].num_components
== 4);
443 format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
446 transkey
.element
[i
].type
= TRANSLATE_ELEMENT_NORMAL
;
447 transkey
.element
[i
].input_format
= format
;
448 transkey
.element
[i
].input_buffer
= 0;
449 transkey
.element
[i
].input_offset
= so
->output
[i
].dst_offset
* 4;
450 transkey
.element
[i
].instance_divisor
= 0;
452 transkey
.element
[i
].output_format
= This
->elems
[i
].src_format
;
453 transkey
.element
[i
].output_offset
= This
->elems
[i
].src_offset
;
454 transkey
.output_stride
+=
455 util_format_get_blocksize(This
->elems
[i
].src_format
);
457 assert(!(transkey
.output_stride
& 3));
459 transkey
.nr_elements
= This
->nelems
;
461 translate
= translate_create(&transkey
);
463 return E_OUTOFMEMORY
;
465 hr
= NineVertexBuffer9_Lock(pDstBuf
,
466 transkey
.output_stride
* DestIndex
,
467 transkey
.output_stride
* VertexCount
,
468 &dst_map
, D3DLOCK_DISCARD
);
472 src_map
= pipe
->transfer_map(pipe
, pSrcBuf
, 0, PIPE_TRANSFER_READ
, &box
,
475 hr
= D3DERR_DRIVERINTERNALERROR
;
478 translate
->set_buffer(translate
, 0, src_map
, so
->stride
[0], ~0);
480 translate
->run(translate
, 0, VertexCount
, 0, 0, dst_map
);
482 NineVertexBuffer9_Unlock(pDstBuf
);
485 pipe
->transfer_unmap(pipe
, transfer
);
486 translate
->release(translate
); /* TODO: cache these */