user32: Don't try to alpha blend icons when drawing to a monochrome device.
[wine] / dlls / d3d8 / vertexdeclaration.c
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 /* IUnknown */
30 static HRESULT WINAPI IDirect3DVertexDeclaration8Impl_QueryInterface(IDirect3DVertexDeclaration8 *iface, REFIID riid, void **obj_ptr)
31 {
32     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), obj_ptr);
33
34     if (IsEqualGUID(riid, &IID_IUnknown)
35             || IsEqualGUID(riid, &IID_IDirect3DVertexDeclaration8))
36     {
37         IUnknown_AddRef(iface);
38         *obj_ptr = iface;
39         return S_OK;
40     }
41
42     *obj_ptr = NULL;
43     return E_NOINTERFACE;
44 }
45
46 static ULONG WINAPI IDirect3DVertexDeclaration8Impl_AddRef(IDirect3DVertexDeclaration8 *iface)
47 {
48     IDirect3DVertexDeclaration8Impl *This = (IDirect3DVertexDeclaration8Impl *)iface;
49     ULONG ref_count = InterlockedIncrement(&This->ref_count);
50
51     TRACE("%p increasing refcount to %u.\n", iface, ref_count);
52
53     if (ref_count == 1)
54     {
55         wined3d_mutex_lock();
56         IWineD3DVertexDeclaration_AddRef(This->wined3d_vertex_declaration);
57         wined3d_mutex_unlock();
58     }
59
60     return ref_count;
61 }
62
63 static ULONG WINAPI IDirect3DVertexDeclaration8Impl_Release(IDirect3DVertexDeclaration8 *iface)
64 {
65     IDirect3DVertexDeclaration8Impl *This = (IDirect3DVertexDeclaration8Impl *)iface;
66     ULONG ref_count = InterlockedDecrement(&This->ref_count);
67
68     TRACE("%p decreasing refcount to %u.\n", iface, ref_count);
69
70     if (!ref_count) {
71         wined3d_mutex_lock();
72         IWineD3DVertexDeclaration_Release(This->wined3d_vertex_declaration);
73         wined3d_mutex_unlock();
74     }
75
76     return ref_count;
77 }
78
79 static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type)
80 {
81     switch (d3dvsdt_type)
82     {
83 #define D3DVSDT_TYPE_TO_STR(u) case u: return #u
84         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1);
85         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2);
86         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3);
87         D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4);
88         D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR);
89         D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4);
90         D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2);
91         D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4);
92 #undef D3DVSDT_TYPE_TO_STR
93         default:
94             FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type);
95             return "unrecognized";
96     }
97 }
98
99 static const char *debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register)
100 {
101     switch (d3dvsde_register)
102     {
103 #define D3DVSDE_REGISTER_TO_STR(u) case u: return #u
104         D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION);
105         D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT);
106         D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES);
107         D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL);
108         D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE);
109         D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE);
110         D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR);
111         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0);
112         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1);
113         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2);
114         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3);
115         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4);
116         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5);
117         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6);
118         D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7);
119         D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2);
120         D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2);
121 #undef D3DVSDE_REGISTER_TO_STR
122         default:
123             FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register);
124             return "unrecognized";
125     }
126 }
127
128 size_t parse_token(const DWORD* pToken)
129 {
130     const DWORD token = *pToken;
131     size_t tokenlen = 1;
132
133     switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
134         case D3DVSD_TOKEN_NOP:
135             TRACE(" 0x%08x NOP()\n", token);
136             break;
137
138         case D3DVSD_TOKEN_STREAM:
139             if (token & D3DVSD_STREAMTESSMASK)
140             {
141                 TRACE(" 0x%08x STREAM_TESS()\n", token);
142             } else {
143                 TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
144             }
145             break;
146
147         case D3DVSD_TOKEN_STREAMDATA:
148             if (token & 0x10000000)
149             {
150                 TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
151             } else {
152                 DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
153                 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
154                 TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
155             }
156             break;
157
158         case D3DVSD_TOKEN_TESSELLATOR:
159             if (token & 0x10000000)
160             {
161                 DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
162                 DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
163                 TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
164             } else {
165                 DWORD type = ((token & D3DVSD_DATATYPEMASK)    >> D3DVSD_DATATYPESHIFT);
166                 DWORD regout = ((token & D3DVSD_VERTEXREGMASK)   >> D3DVSD_VERTEXREGSHIFT);
167                 DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
168                 TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
169                         debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
170             }
171             break;
172
173         case D3DVSD_TOKEN_CONSTMEM:
174             {
175                 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK)   >> D3DVSD_CONSTCOUNTSHIFT);
176                 tokenlen = (4 * count) + 1;
177             }
178             break;
179
180         case D3DVSD_TOKEN_EXT:
181             {
182                 DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
183                 DWORD extinfo = ((token & D3DVSD_EXTINFOMASK)    >> D3DVSD_EXTINFOSHIFT);
184                 TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo);
185                 /* todo ... print extension */
186                 tokenlen = count + 1;
187             }
188             break;
189
190         case D3DVSD_TOKEN_END:
191             TRACE(" 0x%08x END()\n", token);
192             break;
193
194         default:
195             TRACE(" 0x%08x UNKNOWN\n", token);
196             /* argg error */
197     }
198
199     return tokenlen;
200 }
201
202 void load_local_constants(const DWORD *d3d8_elements, IWineD3DVertexShader *wined3d_vertex_shader)
203 {
204     const DWORD *token = d3d8_elements;
205
206     while (*token != D3DVSD_END())
207     {
208         if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM)
209         {
210             DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
211             DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
212             HRESULT hr;
213
214             if (TRACE_ON(d3d8))
215             {
216                 DWORD i;
217                 for (i = 0; i < count; ++i)
218                 {
219                     TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n",
220                             constant_idx,
221                             *(const float *)(token + i * 4 + 1),
222                             *(const float *)(token + i * 4 + 2),
223                             *(const float *)(token + i * 4 + 3),
224                             *(const float *)(token + i * 4 + 4));
225                 }
226             }
227             hr = IWineD3DVertexShader_SetLocalConstantsF(wined3d_vertex_shader, constant_idx, (const float *)token+1, count);
228             if (FAILED(hr)) ERR("Failed setting shader constants\n");
229         }
230
231         token += parse_token(token);
232     }
233 }
234
235 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
236 static const size_t wined3d_type_sizes[] =
237 {
238     /*WINED3DDECLTYPE_FLOAT1*/    1 * sizeof(float),
239     /*WINED3DDECLTYPE_FLOAT2*/    2 * sizeof(float),
240     /*WINED3DDECLTYPE_FLOAT3*/    3 * sizeof(float),
241     /*WINED3DDECLTYPE_FLOAT4*/    4 * sizeof(float),
242     /*WINED3DDECLTYPE_D3DCOLOR*/  4 * sizeof(BYTE),
243     /*WINED3DDECLTYPE_UBYTE4*/    4 * sizeof(BYTE),
244     /*WINED3DDECLTYPE_SHORT2*/    2 * sizeof(short int),
245     /*WINED3DDECLTYPE_SHORT4*/    4 * sizeof(short int),
246     /*WINED3DDECLTYPE_UBYTE4N*/   4 * sizeof(BYTE),
247     /*WINED3DDECLTYPE_SHORT2N*/   2 * sizeof(short int),
248     /*WINED3DDECLTYPE_SHORT4N*/   4 * sizeof(short int),
249     /*WINED3DDECLTYPE_USHORT2N*/  2 * sizeof(short int),
250     /*WINED3DDECLTYPE_USHORT4N*/  4 * sizeof(short int),
251     /*WINED3DDECLTYPE_UDEC3*/     3 * sizeof(short int),
252     /*WINED3DDECLTYPE_DEC3N*/     3 * sizeof(short int),
253     /*WINED3DDECLTYPE_FLOAT16_2*/ 2 * sizeof(short int),
254     /*WINED3DDECLTYPE_FLOAT16_4*/ 4 * sizeof(short int)
255 };
256
257 static const WINED3DFORMAT wined3d_format_lookup[] =
258 {
259     /*WINED3DDECLTYPE_FLOAT1*/    WINED3DFMT_R32_FLOAT,
260     /*WINED3DDECLTYPE_FLOAT2*/    WINED3DFMT_R32G32_FLOAT,
261     /*WINED3DDECLTYPE_FLOAT3*/    WINED3DFMT_R32G32B32_FLOAT,
262     /*WINED3DDECLTYPE_FLOAT4*/    WINED3DFMT_R32G32B32A32_FLOAT,
263     /*WINED3DDECLTYPE_D3DCOLOR*/  WINED3DFMT_B8G8R8A8_UNORM,
264     /*WINED3DDECLTYPE_UBYTE4*/    WINED3DFMT_R8G8B8A8_UINT,
265     /*WINED3DDECLTYPE_SHORT2*/    WINED3DFMT_R16G16_SINT,
266     /*WINED3DDECLTYPE_SHORT4*/    WINED3DFMT_R16G16B16A16_SINT,
267     /*WINED3DDECLTYPE_UBYTE4N*/   WINED3DFMT_R8G8B8A8_UNORM,
268     /*WINED3DDECLTYPE_SHORT2N*/   WINED3DFMT_R16G16_SNORM,
269     /*WINED3DDECLTYPE_SHORT4N*/   WINED3DFMT_R16G16B16A16_SNORM,
270     /*WINED3DDECLTYPE_USHORT2N*/  WINED3DFMT_R16G16_UNORM,
271     /*WINED3DDECLTYPE_USHORT4N*/  WINED3DFMT_R16G16B16A16_UNORM,
272     /*WINED3DDECLTYPE_UDEC3*/     WINED3DFMT_R10G10B10A2_UINT,
273     /*WINED3DDECLTYPE_DEC3N*/     WINED3DFMT_R10G10B10A2_SNORM,
274     /*WINED3DDECLTYPE_FLOAT16_2*/ WINED3DFMT_R16G16_FLOAT,
275     /*WINED3DDECLTYPE_FLOAT16_4*/ WINED3DFMT_R16G16B16A16_FLOAT,
276 };
277
278 typedef struct {
279     BYTE usage;
280     BYTE usage_idx;
281 } wined3d_usage_t;
282
283 static const wined3d_usage_t wined3d_usage_lookup[] = {
284     /*D3DVSDE_POSITION*/     {WINED3DDECLUSAGE_POSITION,     0},
285     /*D3DVSDE_BLENDWEIGHT*/  {WINED3DDECLUSAGE_BLENDWEIGHT,  0},
286     /*D3DVSDE_BLENDINDICES*/ {WINED3DDECLUSAGE_BLENDINDICES, 0},
287     /*D3DVSDE_NORMAL*/       {WINED3DDECLUSAGE_NORMAL,       0},
288     /*D3DVSDE_PSIZE*/        {WINED3DDECLUSAGE_PSIZE,        0},
289     /*D3DVSDE_DIFFUSE*/      {WINED3DDECLUSAGE_COLOR,        0},
290     /*D3DVSDE_SPECULAR*/     {WINED3DDECLUSAGE_COLOR,        1},
291     /*D3DVSDE_TEXCOORD0*/    {WINED3DDECLUSAGE_TEXCOORD,     0},
292     /*D3DVSDE_TEXCOORD1*/    {WINED3DDECLUSAGE_TEXCOORD,     1},
293     /*D3DVSDE_TEXCOORD2*/    {WINED3DDECLUSAGE_TEXCOORD,     2},
294     /*D3DVSDE_TEXCOORD3*/    {WINED3DDECLUSAGE_TEXCOORD,     3},
295     /*D3DVSDE_TEXCOORD4*/    {WINED3DDECLUSAGE_TEXCOORD,     4},
296     /*D3DVSDE_TEXCOORD5*/    {WINED3DDECLUSAGE_TEXCOORD,     5},
297     /*D3DVSDE_TEXCOORD6*/    {WINED3DDECLUSAGE_TEXCOORD,     6},
298     /*D3DVSDE_TEXCOORD7*/    {WINED3DDECLUSAGE_TEXCOORD,     7},
299     /*D3DVSDE_POSITION2*/    {WINED3DDECLUSAGE_POSITION,     1},
300     /*D3DVSDE_NORMAL2*/      {WINED3DDECLUSAGE_NORMAL,       1},
301 };
302
303 /* TODO: find out where rhw (or positionT) is for declaration8 */
304 static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3d8_elements_size,
305         WINED3DVERTEXELEMENT **wined3d_elements)
306 {
307     const DWORD *token = d3d8_elements;
308     WINED3DVERTEXELEMENT *element;
309     D3DVSD_TOKENTYPE token_type;
310     unsigned int element_count = 0;
311     DWORD stream = 0;
312     int offset = 0;
313
314     TRACE("d3d8_elements %p, wined3d_elements %p\n", d3d8_elements, wined3d_elements);
315
316     /* 128 should be enough for anyone... */
317     *wined3d_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 128 * sizeof(WINED3DVERTEXELEMENT));
318     while (D3DVSD_END() != *token)
319     {
320         token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
321
322         if (token_type == D3DVSD_TOKEN_STREAM && !(*token & D3DVSD_STREAMTESSMASK))
323         {
324             stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
325             offset = 0;
326         } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(token_type & 0x10000000)) {
327             DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
328             DWORD reg  = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
329
330             TRACE("Adding element %d:\n", element_count);
331
332             element = *wined3d_elements + element_count++;
333             element->format = wined3d_format_lookup[type];
334             element->input_slot = stream;
335             element->offset = offset;
336             element->output_slot = reg;
337             element->method = WINED3DDECLMETHOD_DEFAULT;
338             element->usage = wined3d_usage_lookup[reg].usage;
339             element->usage_idx = wined3d_usage_lookup[reg].usage_idx;
340
341             offset += wined3d_type_sizes[type];
342         } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (token_type & 0x10000000)) {
343             TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
344             offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
345         }
346
347         if (element_count >= 127) {
348             ERR("More than 127 elements?\n");
349             break;
350         }
351
352         token += parse_token(token);
353     }
354
355     *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD);
356
357     return element_count;
358 }
359
360 static const IDirect3DVertexDeclaration8Vtbl Direct3DVertexDeclaration8_Vtbl =
361 {
362     IDirect3DVertexDeclaration8Impl_QueryInterface,
363     IDirect3DVertexDeclaration8Impl_AddRef,
364     IDirect3DVertexDeclaration8Impl_Release
365 };
366
367 static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed(void *parent)
368 {
369     IDirect3DVertexDeclaration8Impl *declaration = parent;
370     HeapFree(GetProcessHeap(), 0, declaration->elements);
371     HeapFree(GetProcessHeap(), 0, declaration);
372 }
373
374 static const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops =
375 {
376     d3d8_vertexdeclaration_wined3d_object_destroyed,
377 };
378
379 HRESULT vertexdeclaration_init(IDirect3DVertexDeclaration8Impl *declaration,
380         IDirect3DDevice8Impl *device, const DWORD *elements, DWORD shader_handle)
381 {
382     WINED3DVERTEXELEMENT *wined3d_elements;
383     UINT wined3d_element_count;
384     HRESULT hr;
385
386     declaration->lpVtbl = &Direct3DVertexDeclaration8_Vtbl;
387     declaration->ref_count = 1;
388     declaration->shader_handle = shader_handle;
389
390     wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements);
391     declaration->elements = HeapAlloc(GetProcessHeap(), 0, declaration->elements_size);
392     if (!declaration->elements)
393     {
394         ERR("Failed to allocate vertex declaration elements memory.\n");
395         HeapFree(GetProcessHeap(), 0, wined3d_elements);
396         return E_OUTOFMEMORY;
397     }
398
399     memcpy(declaration->elements, elements, declaration->elements_size);
400
401     wined3d_mutex_lock();
402     hr = IWineD3DDevice_CreateVertexDeclaration(device->WineD3DDevice, &declaration->wined3d_vertex_declaration,
403             (IUnknown *)declaration, &d3d8_vertexdeclaration_wined3d_parent_ops,
404             wined3d_elements, wined3d_element_count);
405     wined3d_mutex_unlock();
406     HeapFree(GetProcessHeap(), 0, wined3d_elements);
407     if (FAILED(hr))
408     {
409         WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
410         HeapFree(GetProcessHeap(), 0, declaration->elements);
411         return hr;
412     }
413
414     return D3D_OK;
415 }
416
417 HRESULT vertexdeclaration_init_fvf(IDirect3DVertexDeclaration8Impl *declaration,
418         IDirect3DDevice8Impl *device, DWORD fvf)
419 {
420     HRESULT hr;
421
422     declaration->ref_count = 1;
423     declaration->lpVtbl = &Direct3DVertexDeclaration8_Vtbl;
424     declaration->elements = NULL;
425     declaration->elements_size = 0;
426     declaration->shader_handle = fvf;
427
428     hr = IWineD3DDevice_CreateVertexDeclarationFromFVF(device->WineD3DDevice,
429             &declaration->wined3d_vertex_declaration, (IUnknown *)declaration,
430             &d3d8_vertexdeclaration_wined3d_parent_ops, fvf);
431     if (FAILED(hr))
432     {
433         WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
434         return hr;
435     }
436
437     return D3D_OK;
438 }