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
;
178 DBG("This=%p pParams=%p pElements=%p\n", This
, pParams
, pElements
);
182 pElements
[nelems
].Stream
!= 0xFF;
184 user_assert(pElements
[nelems
].Type
!= D3DDECLTYPE_UNUSED
, E_FAIL
);
185 user_assert(!(pElements
[nelems
].Offset
& 3), E_FAIL
);
188 caps
= NineDevice9_GetCaps(pParams
->device
);
189 user_assert(nelems
<= caps
->MaxStreams
, D3DERR_INVALIDCALL
);
191 HRESULT hr
= NineUnknown_ctor(&This
->base
, pParams
);
192 if (FAILED(hr
)) { return hr
; }
194 This
->nelems
= nelems
;
195 This
->decls
= CALLOC(This
->nelems
+1, sizeof(D3DVERTEXELEMENT9
));
196 This
->elems
= CALLOC(This
->nelems
, sizeof(struct pipe_vertex_element
));
197 This
->usage_map
= CALLOC(This
->nelems
, sizeof(uint16_t));
198 if (!This
->decls
|| !This
->elems
|| !This
->usage_map
) { return E_OUTOFMEMORY
; }
199 memcpy(This
->decls
, pElements
, sizeof(D3DVERTEXELEMENT9
)*(This
->nelems
+1));
201 for (i
= 0; i
< This
->nelems
; ++i
) {
202 uint16_t usage
= nine_d3d9_to_nine_declusage(This
->decls
[i
].Usage
,
203 This
->decls
[i
].UsageIndex
);
204 This
->usage_map
[i
] = usage
;
206 if (This
->decls
[i
].Usage
== D3DDECLUSAGE_POSITIONT
)
207 This
->position_t
= TRUE
;
209 This
->elems
[i
].src_offset
= This
->decls
[i
].Offset
;
210 This
->elems
[i
].instance_divisor
= 0;
211 This
->elems
[i
].vertex_buffer_index
= This
->decls
[i
].Stream
;
212 This
->elems
[i
].src_format
= decltype_format(This
->decls
[i
].Type
);
213 /* XXX Remember Method (tesselation), Usage, UsageIndex */
215 DBG("VERTEXELEMENT[%u]: Stream=%u Offset=%u Type=%s DeclUsage=%s%d\n", i
,
216 This
->decls
[i
].Stream
,
217 This
->decls
[i
].Offset
,
218 util_format_name(This
->elems
[i
].src_format
),
219 nine_declusage_name(usage
),
220 usage
/ NINE_DECLUSAGE_COUNT
);
227 NineVertexDeclaration9_dtor( struct NineVertexDeclaration9
*This
)
231 FREE(This
->usage_map
);
233 NineUnknown_dtor(&This
->base
);
237 NineVertexDeclaration9_GetDeclaration( struct NineVertexDeclaration9
*This
,
238 D3DVERTEXELEMENT9
*pElement
,
242 user_assert(pNumElements
, D3DERR_INVALIDCALL
);
243 *pNumElements
= This
->nelems
+1;
246 if (pNumElements
) { *pNumElements
= This
->nelems
+1; }
247 memcpy(pElement
, This
->decls
, sizeof(D3DVERTEXELEMENT9
)*(This
->nelems
+1));
251 IDirect3DVertexDeclaration9Vtbl NineVertexDeclaration9_vtable
= {
252 (void *)NineUnknown_QueryInterface
,
253 (void *)NineUnknown_AddRef
,
254 (void *)NineUnknown_Release
,
255 (void *)NineUnknown_GetDevice
, /* actually part of VertexDecl9 iface */
256 (void *)NineVertexDeclaration9_GetDeclaration
259 static const GUID
*NineVertexDeclaration9_IIDs
[] = {
260 &IID_IDirect3DVertexDeclaration9
,
266 NineVertexDeclaration9_new( struct NineDevice9
*pDevice
,
267 const D3DVERTEXELEMENT9
*pElements
,
268 struct NineVertexDeclaration9
**ppOut
)
270 NINE_DEVICE_CHILD_NEW(VertexDeclaration9
, ppOut
, /* args */ pDevice
, pElements
);
274 NineVertexDeclaration9_new_from_fvf( struct NineDevice9
*pDevice
,
276 struct NineVertexDeclaration9
**ppOut
)
278 D3DVERTEXELEMENT9 elems
[16], decl_end
= D3DDECL_END();
279 unsigned texcount
, i
, betas
, nelems
= 0;
280 BYTE beta_index
= 0xFF;
282 switch (FVF
& D3DFVF_POSITION_MASK
) {
283 case D3DFVF_XYZ
: /* simple XYZ */
288 case D3DFVF_XYZB5
: /* XYZ with beta values */
289 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
;
290 elems
[nelems
].Usage
= D3DDECLUSAGE_POSITION
;
291 elems
[nelems
].UsageIndex
= 0;
293 /* simple XYZ has no beta values. break. */
294 if ((FVF
& D3DFVF_POSITION_MASK
) == D3DFVF_XYZ
) { break; }
296 betas
= (((FVF
& D3DFVF_XYZB5
)-D3DFVF_XYZB1
)>>1)+1;
297 if (FVF
& D3DFVF_LASTBETA_D3DCOLOR
) {
298 beta_index
= D3DDECLTYPE_D3DCOLOR
;
299 } else if (FVF
& D3DFVF_LASTBETA_UBYTE4
) {
300 beta_index
= D3DDECLTYPE_UBYTE4
;
301 } else if ((FVF
& D3DFVF_XYZB5
) == D3DFVF_XYZB5
) {
302 beta_index
= D3DDECLTYPE_FLOAT1
;
304 if (beta_index
!= 0xFF) { --betas
; }
308 case 1: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT1
; break;
309 case 2: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT2
; break;
310 case 3: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
; break;
311 case 4: elems
[nelems
].Type
= D3DDECLTYPE_FLOAT4
; break;
313 assert(!"Implementation error!");
315 elems
[nelems
].Usage
= D3DDECLUSAGE_BLENDWEIGHT
;
316 elems
[nelems
].UsageIndex
= 0;
320 if (beta_index
!= 0xFF) {
321 elems
[nelems
].Type
= beta_index
;
322 elems
[nelems
].Usage
= D3DDECLUSAGE_BLENDINDICES
;
323 elems
[nelems
].UsageIndex
= 0;
328 case D3DFVF_XYZW
: /* simple XYZW */
329 case D3DFVF_XYZRHW
: /* pretransformed XYZW */
330 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT4
;
331 elems
[nelems
].Usage
=
332 ((FVF
& D3DFVF_POSITION_MASK
) == D3DFVF_XYZW
) ?
333 D3DDECLUSAGE_POSITION
: D3DDECLUSAGE_POSITIONT
;
334 elems
[nelems
].UsageIndex
= 0;
339 (void)user_error(!"Position doesn't match any known combination");
342 /* normals, psize and colors */
343 if (FVF
& D3DFVF_NORMAL
) {
344 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
;
345 elems
[nelems
].Usage
= D3DDECLUSAGE_NORMAL
;
346 elems
[nelems
].UsageIndex
= 0;
349 if (FVF
& D3DFVF_PSIZE
) {
350 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT1
;
351 elems
[nelems
].Usage
= D3DDECLUSAGE_PSIZE
;
352 elems
[nelems
].UsageIndex
= 0;
355 if (FVF
& D3DFVF_DIFFUSE
) {
356 elems
[nelems
].Type
= D3DDECLTYPE_D3DCOLOR
;
357 elems
[nelems
].Usage
= D3DDECLUSAGE_COLOR
;
358 elems
[nelems
].UsageIndex
= 0;
361 if (FVF
& D3DFVF_SPECULAR
) {
362 elems
[nelems
].Type
= D3DDECLTYPE_D3DCOLOR
;
363 elems
[nelems
].Usage
= D3DDECLUSAGE_COLOR
;
364 elems
[nelems
].UsageIndex
= 1;
369 texcount
= (FVF
& D3DFVF_TEXCOUNT_MASK
) >> D3DFVF_TEXCOUNT_SHIFT
;
370 if (user_error(texcount
<= 8)) { texcount
= 8; }
372 for (i
= 0; i
< texcount
; ++i
) {
373 switch ((FVF
>> (16+i
*2)) & 0x3) {
374 case D3DFVF_TEXTUREFORMAT1
:
375 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT1
;
378 case D3DFVF_TEXTUREFORMAT2
:
379 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT2
;
382 case D3DFVF_TEXTUREFORMAT3
:
383 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT3
;
386 case D3DFVF_TEXTUREFORMAT4
:
387 elems
[nelems
].Type
= D3DDECLTYPE_FLOAT4
;
391 assert(!"Implementation error!");
393 elems
[nelems
].Usage
= D3DDECLUSAGE_TEXCOORD
;
394 elems
[nelems
].UsageIndex
= i
;
398 /* fill out remaining data */
399 for (i
= 0; i
< nelems
; ++i
) {
401 elems
[i
].Offset
= (i
== 0) ? 0 : (elems
[i
-1].Offset
+
402 decltype_size(elems
[i
-1].Type
));
403 elems
[i
].Method
= D3DDECLMETHOD_DEFAULT
;
405 elems
[nelems
++] = decl_end
;
407 NINE_DEVICE_CHILD_NEW(VertexDeclaration9
, ppOut
, /* args */ pDevice
, elems
);
410 /* ProcessVertices runs stream output into a temporary buffer to capture
412 * Now we have to convert them to the format and order set by the vertex
413 * declaration, for which we use u_translate.
414 * This is necessary if the vertex declaration contains elements using a
415 * non float32 format, because stream output only supports f32/u32/s32.
418 NineVertexDeclaration9_ConvertStreamOutput(
419 struct NineVertexDeclaration9
*This
,
420 struct NineVertexBuffer9
*pDstBuf
,
423 struct pipe_resource
*pSrcBuf
,
424 const struct pipe_stream_output_info
*so
)
426 struct pipe_context
*pipe
= This
->base
.device
->pipe
;
427 struct pipe_transfer
*transfer
= NULL
;
428 struct translate
*translate
;
429 struct translate_key transkey
;
436 DBG("This=%p pDstBuf=%p DestIndex=%u VertexCount=%u pSrcBuf=%p so=%p\n",
437 This
, pDstBuf
, DestIndex
, VertexCount
, pSrcBuf
, so
);
439 transkey
.output_stride
= 0;
440 for (i
= 0; i
< This
->nelems
; ++i
) {
441 enum pipe_format format
;
443 switch (so
->output
[i
].num_components
) {
444 case 1: format
= PIPE_FORMAT_R32_FLOAT
; break;
445 case 2: format
= PIPE_FORMAT_R32G32_FLOAT
; break;
446 case 3: format
= PIPE_FORMAT_R32G32B32_FLOAT
; break;
448 assert(so
->output
[i
].num_components
== 4);
449 format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
452 transkey
.element
[i
].type
= TRANSLATE_ELEMENT_NORMAL
;
453 transkey
.element
[i
].input_format
= format
;
454 transkey
.element
[i
].input_buffer
= 0;
455 transkey
.element
[i
].input_offset
= so
->output
[i
].dst_offset
* 4;
456 transkey
.element
[i
].instance_divisor
= 0;
458 transkey
.element
[i
].output_format
= This
->elems
[i
].src_format
;
459 transkey
.element
[i
].output_offset
= This
->elems
[i
].src_offset
;
460 transkey
.output_stride
+=
461 util_format_get_blocksize(This
->elems
[i
].src_format
);
463 assert(!(transkey
.output_stride
& 3));
465 transkey
.nr_elements
= This
->nelems
;
467 translate
= translate_create(&transkey
);
469 return E_OUTOFMEMORY
;
471 hr
= NineVertexBuffer9_Lock(pDstBuf
,
472 transkey
.output_stride
* DestIndex
,
473 transkey
.output_stride
* VertexCount
,
474 &dst_map
, D3DLOCK_DISCARD
);
478 src_map
= pipe
->transfer_map(pipe
, pSrcBuf
, 0, PIPE_TRANSFER_READ
, &box
,
481 hr
= D3DERR_DRIVERINTERNALERROR
;
484 translate
->set_buffer(translate
, 0, src_map
, so
->stride
[0], ~0);
486 translate
->run(translate
, 0, VertexCount
, 0, 0, dst_map
);
488 NineVertexBuffer9_Unlock(pDstBuf
);
491 pipe
->transfer_unmap(pipe
, transfer
);
492 translate
->release(translate
); /* TODO: cache these */