device.c@ 33085

Last change on this file since 33085 was 32622, checked in by vboxsync, 14 years ago
wddm: VBOXWDDM->VBOX_WITH_WDDM
Property svn:eol-style set to `native`
File size: 270.8 KB

Line
1	/*
2	* IWineD3DDevice implementation
3	*
4	* Copyright 2002 Lionel Ulmer
5	* Copyright 2002-2005 Jason Edmeades
6	* Copyright 2003-2004 Raphael Junqueira
7	* Copyright 2004 Christian Costa
8	* Copyright 2005 Oliver Stieber
9	* Copyright 2006-2008 Stefan Dösinger for CodeWeavers
10	* Copyright 2006-2008 Henri Verbeet
11	* Copyright 2007 Andrew Riedi
12	* Copyright 2009 Henri Verbeet for CodeWeavers
13	*
14	* This library is free software; you can redistribute it and/or
15	* modify it under the terms of the GNU Lesser General Public
16	* License as published by the Free Software Foundation; either
17	* version 2.1 of the License, or (at your option) any later version.
18	*
19	* This library is distributed in the hope that it will be useful,
20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22	* Lesser General Public License for more details.
23	*
24	* You should have received a copy of the GNU Lesser General Public
25	* License along with this library; if not, write to the Free Software
26	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27	*/
28
29	/*
30	* Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
31	* other than GPL or LGPL is available it will apply instead, Sun elects to use only
32	* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
33	* a choice of LGPL license versions is made available with the language indicating
34	* that LGPLv2 or any later version may be used, or where a choice of which version
35	* of the LGPL is applied is otherwise unspecified.
36	*/
37
38	#include "config.h"
39	#include <stdio.h>
40	#ifdef HAVE_FLOAT_H
41	# include <float.h>
42	#endif
43	#include "wined3d_private.h"
44
45	WINE_DEFAULT_DEBUG_CHANNEL(d3d);
46	#define GLINFO_LOCATION This->adapter->gl_info
47
48	/* Define the default light parameters as specified by MSDN */
49	const WINED3DLIGHT WINED3D_default_light = {
50
51	WINED3DLIGHT_DIRECTIONAL, /* Type */
52	{ 1.0f, 1.0f, 1.0f, 0.0f }, /* Diffuse r,g,b,a */
53	{ 0.0f, 0.0f, 0.0f, 0.0f }, /* Specular r,g,b,a */
54	{ 0.0f, 0.0f, 0.0f, 0.0f }, /* Ambient r,g,b,a, */
55	{ 0.0f, 0.0f, 0.0f }, /* Position x,y,z */
56	{ 0.0f, 0.0f, 1.0f }, /* Direction x,y,z */
57	0.0f, /* Range */
58	0.0f, /* Falloff */
59	0.0f, 0.0f, 0.0f, /* Attenuation 0,1,2 */
60	0.0f, /* Theta */
61	0.0f /* Phi */
62	};
63
64	/**********************************************************
65	* Global variable / Constants follow
66	**********************************************************/
67	const float identity[] =
68	{
69	1.0f, 0.0f, 0.0f, 0.0f,
70	0.0f, 1.0f, 0.0f, 0.0f,
71	0.0f, 0.0f, 1.0f, 0.0f,
72	0.0f, 0.0f, 0.0f, 1.0f,
73	}; /* When needed for comparisons */
74
75	/* Note that except for WINED3DPT_POINTLIST and WINED3DPT_LINELIST these
76	* actually have the same values in GL and D3D. */
77	static GLenum gl_primitive_type_from_d3d(WINED3DPRIMITIVETYPE primitive_type)
78	{
79	switch(primitive_type)
80	{
81	case WINED3DPT_POINTLIST:
82	return GL_POINTS;
83
84	case WINED3DPT_LINELIST:
85	return GL_LINES;
86
87	case WINED3DPT_LINESTRIP:
88	return GL_LINE_STRIP;
89
90	case WINED3DPT_TRIANGLELIST:
91	return GL_TRIANGLES;
92
93	case WINED3DPT_TRIANGLESTRIP:
94	return GL_TRIANGLE_STRIP;
95
96	case WINED3DPT_TRIANGLEFAN:
97	return GL_TRIANGLE_FAN;
98
99	case WINED3DPT_LINELIST_ADJ:
100	return GL_LINES_ADJACENCY_ARB;
101
102	case WINED3DPT_LINESTRIP_ADJ:
103	return GL_LINE_STRIP_ADJACENCY_ARB;
104
105	case WINED3DPT_TRIANGLELIST_ADJ:
106	return GL_TRIANGLES_ADJACENCY_ARB;
107
108	case WINED3DPT_TRIANGLESTRIP_ADJ:
109	return GL_TRIANGLE_STRIP_ADJACENCY_ARB;
110
111	default:
112	FIXME("Unhandled primitive type %s\n", debug_d3dprimitivetype(primitive_type));
113	return GL_NONE;
114	}
115	}
116
117	static WINED3DPRIMITIVETYPE d3d_primitive_type_from_gl(GLenum primitive_type)
118	{
119	switch(primitive_type)
120	{
121	case GL_POINTS:
122	return WINED3DPT_POINTLIST;
123
124	case GL_LINES:
125	return WINED3DPT_LINELIST;
126
127	case GL_LINE_STRIP:
128	return WINED3DPT_LINESTRIP;
129
130	case GL_TRIANGLES:
131	return WINED3DPT_TRIANGLELIST;
132
133	case GL_TRIANGLE_STRIP:
134	return WINED3DPT_TRIANGLESTRIP;
135
136	case GL_TRIANGLE_FAN:
137	return WINED3DPT_TRIANGLEFAN;
138
139	case GL_LINES_ADJACENCY_ARB:
140	return WINED3DPT_LINELIST_ADJ;
141
142	case GL_LINE_STRIP_ADJACENCY_ARB:
143	return WINED3DPT_LINESTRIP_ADJ;
144
145	case GL_TRIANGLES_ADJACENCY_ARB:
146	return WINED3DPT_TRIANGLELIST_ADJ;
147
148	case GL_TRIANGLE_STRIP_ADJACENCY_ARB:
149	return WINED3DPT_TRIANGLESTRIP_ADJ;
150
151	default:
152	FIXME("Unhandled primitive type %s\n", debug_d3dprimitivetype(primitive_type));
153	return WINED3DPT_UNDEFINED;
154	}
155	}
156
157	static BOOL fixed_get_input(BYTE usage, BYTE usage_idx, unsigned int *regnum)
158	{
159	if ((usage == WINED3DDECLUSAGE_POSITION \|\| usage == WINED3DDECLUSAGE_POSITIONT) && usage_idx == 0)
160	*regnum = WINED3D_FFP_POSITION;
161	else if (usage == WINED3DDECLUSAGE_BLENDWEIGHT && usage_idx == 0)
162	*regnum = WINED3D_FFP_BLENDWEIGHT;
163	else if (usage == WINED3DDECLUSAGE_BLENDINDICES && usage_idx == 0)
164	*regnum = WINED3D_FFP_BLENDINDICES;
165	else if (usage == WINED3DDECLUSAGE_NORMAL && usage_idx == 0)
166	*regnum = WINED3D_FFP_NORMAL;
167	else if (usage == WINED3DDECLUSAGE_PSIZE && usage_idx == 0)
168	*regnum = WINED3D_FFP_PSIZE;
169	else if (usage == WINED3DDECLUSAGE_COLOR && usage_idx == 0)
170	*regnum = WINED3D_FFP_DIFFUSE;
171	else if (usage == WINED3DDECLUSAGE_COLOR && usage_idx == 1)
172	*regnum = WINED3D_FFP_SPECULAR;
173	else if (usage == WINED3DDECLUSAGE_TEXCOORD && usage_idx < WINED3DDP_MAXTEXCOORD)
174	*regnum = WINED3D_FFP_TEXCOORD0 + usage_idx;
175	else
176	{
177	FIXME("Unsupported input stream [usage=%s, usage_idx=%u]\n", debug_d3ddeclusage(usage), usage_idx);
178	*regnum = ~0U;
179	return FALSE;
180	}
181
182	return TRUE;
183	}
184
185	/* Context activation is done by the caller. */
186	void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
187	BOOL use_vshader, struct wined3d_stream_info stream_info, BOOL fixup)
188	{
189	/* We need to deal with frequency data! */
190	IWineD3DVertexDeclarationImpl declaration = (IWineD3DVertexDeclarationImpl )This->stateBlock->vertexDecl;
191	unsigned int i;
192
193	stream_info->use_map = 0;
194	stream_info->swizzle_map = 0;
195
196	/* Check for transformed vertices, disable vertex shader if present. */
197	stream_info->position_transformed = declaration->position_transformed;
198	if (declaration->position_transformed) use_vshader = FALSE;
199
200	/* Translate the declaration into strided data. */
201	for (i = 0; i < declaration->element_count; ++i)
202	{
203	const struct wined3d_vertex_declaration_element *element = &declaration->elements[i];
204	GLuint buffer_object = 0;
205	const BYTE *data = NULL;
206	BOOL stride_used;
207	unsigned int idx;
208	DWORD stride;
209
210	TRACE("%p Element %p (%u of %u)\n", declaration->elements,
211	element, i + 1, declaration->element_count);
212
213	if (!This->stateBlock->streamSource[element->input_slot]) continue;
214
215	stride = This->stateBlock->streamStride[element->input_slot];
216	if (This->stateBlock->streamIsUP)
217	{
218	TRACE("Stream %u is UP, %p\n", element->input_slot, This->stateBlock->streamSource[element->input_slot]);
219	buffer_object = 0;
220	data = (BYTE *)This->stateBlock->streamSource[element->input_slot];
221	}
222	else
223	{
224	TRACE("Stream %u isn't UP, %p\n", element->input_slot, This->stateBlock->streamSource[element->input_slot]);
225	data = buffer_get_memory(This->stateBlock->streamSource[element->input_slot], &buffer_object);
226
227	/* Can't use vbo's if the base vertex index is negative. OpenGL doesn't accept negative offsets
228	* (or rather offsets bigger than the vbo, because the pointer is unsigned), so use system memory
229	* sources. In most sane cases the pointer - offset will still be > 0, otherwise it will wrap
230	* around to some big value. Hope that with the indices, the driver wraps it back internally. If
231	* not, drawStridedSlow is needed, including a vertex buffer path. */
232	if (This->stateBlock->loadBaseVertexIndex < 0)
233	{
234	WARN("loadBaseVertexIndex is < 0 (%d), not using vbos\n", This->stateBlock->loadBaseVertexIndex);
235	buffer_object = 0;
236	data = buffer_get_sysmem((struct wined3d_buffer *)This->stateBlock->streamSource[element->input_slot]);
237	if ((UINT_PTR)data < -This->stateBlock->loadBaseVertexIndex * stride)
238	{
239	FIXME("System memory vertex data load offset is negative!\n");
240	}
241	}
242
243	if (fixup)
244	{
245	if (buffer_object) *fixup = TRUE;
246	else if (*fixup && !use_vshader
247	&& (element->usage == WINED3DDECLUSAGE_COLOR
248	\|\| element->usage == WINED3DDECLUSAGE_POSITIONT))
249	{
250	static BOOL warned = FALSE;
251	if (!warned)
252	{
253	/* This may be bad with the fixed function pipeline. */
254	FIXME("Missing vbo streams with unfixed colors or transformed position, expect problems\n");
255	warned = TRUE;
256	}
257	}
258	}
259	}
260	data += element->offset;
261
262	TRACE("offset %u input_slot %u usage_idx %d\n", element->offset, element->input_slot, element->usage_idx);
263
264	if (use_vshader)
265	{
266	if (element->output_slot == ~0U)
267	{
268	/* TODO: Assuming vertexdeclarations are usually used with the
269	* same or a similar shader, it might be worth it to store the
270	* last used output slot and try that one first. */
271	stride_used = vshader_get_input(This->stateBlock->vertexShader,
272	element->usage, element->usage_idx, &idx);
273	}
274	else
275	{
276	idx = element->output_slot;
277	stride_used = TRUE;
278	}
279	}
280	else
281	{
282	if (!element->ffp_valid)
283	{
284	WARN("Skipping unsupported fixed function element of format %s and usage %s\n",
285	debug_d3dformat(element->format_desc->format), debug_d3ddeclusage(element->usage));
286	stride_used = FALSE;
287	}
288	else
289	{
290	stride_used = fixed_get_input(element->usage, element->usage_idx, &idx);
291	}
292	}
293
294	if (stride_used)
295	{
296	TRACE("Load %s array %u [usage %s, usage_idx %u, "
297	"input_slot %u, offset %u, stride %u, format %s, buffer_object %u]\n",
298	use_vshader ? "shader": "fixed function", idx,
299	debug_d3ddeclusage(element->usage), element->usage_idx, element->input_slot,
300	element->offset, stride, debug_d3dformat(element->format_desc->format), buffer_object);
301
302	stream_info->elements[idx].format_desc = element->format_desc;
303	stream_info->elements[idx].stride = stride;
304	stream_info->elements[idx].data = data;
305	stream_info->elements[idx].stream_idx = element->input_slot;
306	stream_info->elements[idx].buffer_object = buffer_object;
307
308	if (!This->adapter->gl_info.supported[ARB_VERTEX_ARRAY_BGRA]
309	&& element->format_desc->format == WINED3DFMT_B8G8R8A8_UNORM)
310	{
311	stream_info->swizzle_map \|= 1 << idx;
312	}
313	stream_info->use_map \|= 1 << idx;
314	}
315	}
316
317	This->num_buffer_queries = 0;
318	if (!This->stateBlock->streamIsUP)
319	{
320	WORD map = stream_info->use_map;
321
322	/* PreLoad all the vertex buffers. */
323	for (i = 0; map; map >>= 1, ++i)
324	{
325	struct wined3d_stream_info_element *element;
326	struct wined3d_buffer *buffer;
327	struct wined3d_event_query *query;
328
329	if (!(map & 1)) continue;
330
331	element = &stream_info->elements[i];
332	buffer = (struct wined3d_buffer *)This->stateBlock->streamSource[element->stream_idx];
333	IWineD3DBuffer_PreLoad((IWineD3DBuffer *)buffer);
334
335	/* If PreLoad dropped the buffer object, update the stream info. */
336	if (buffer->buffer_object != element->buffer_object)
337	{
338	element->buffer_object = 0;
339	element->data = buffer_get_sysmem(buffer) + (ptrdiff_t)element->data;
340	}
341
342	query = ((struct wined3d_buffer *) buffer)->query;
343	if(query)
344	{
345	This->buffer_queries[This->num_buffer_queries++] = query;
346	}
347	}
348	}
349	}
350
351	static void stream_info_element_from_strided(const struct wined3d_gl_info *gl_info,
352	const struct WineDirect3DStridedData strided, struct wined3d_stream_info_element e)
353	{
354	const struct wined3d_format_desc *format_desc = getFormatDescEntry(strided->format, gl_info);
355	e->format_desc = format_desc;
356	e->stride = strided->dwStride;
357	e->data = strided->lpData;
358	e->stream_idx = 0;
359	e->buffer_object = 0;
360	}
361
362	static void device_stream_info_from_strided(const struct wined3d_gl_info *gl_info,
363	const struct WineDirect3DVertexStridedData strided, struct wined3d_stream_info stream_info)
364	{
365	unsigned int i;
366
367	memset(stream_info, 0, sizeof(*stream_info));
368
369	if (strided->position.lpData)
370	stream_info_element_from_strided(gl_info, &strided->position, &stream_info->elements[WINED3D_FFP_POSITION]);
371	if (strided->normal.lpData)
372	stream_info_element_from_strided(gl_info, &strided->normal, &stream_info->elements[WINED3D_FFP_NORMAL]);
373	if (strided->diffuse.lpData)
374	stream_info_element_from_strided(gl_info, &strided->diffuse, &stream_info->elements[WINED3D_FFP_DIFFUSE]);
375	if (strided->specular.lpData)
376	stream_info_element_from_strided(gl_info, &strided->specular, &stream_info->elements[WINED3D_FFP_SPECULAR]);
377
378	for (i = 0; i < WINED3DDP_MAXTEXCOORD; ++i)
379	{
380	if (strided->texCoords[i].lpData)
381	stream_info_element_from_strided(gl_info, &strided->texCoords[i],
382	&stream_info->elements[WINED3D_FFP_TEXCOORD0 + i]);
383	}
384
385	stream_info->position_transformed = strided->position_transformed;
386
387	for (i = 0; i < sizeof(stream_info->elements) / sizeof(*stream_info->elements); ++i)
388	{
389	if (!stream_info->elements[i].format_desc) continue;
390
391	if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
392	&& stream_info->elements[i].format_desc->format == WINED3DFMT_B8G8R8A8_UNORM)
393	{
394	stream_info->swizzle_map \|= 1 << i;
395	}
396	stream_info->use_map \|= 1 << i;
397	}
398	}
399
400	static void device_trace_strided_stream_info(const struct wined3d_stream_info *stream_info)
401	{
402	TRACE("Strided Data:\n");
403	TRACE_STRIDED(stream_info, WINED3D_FFP_POSITION);
404	TRACE_STRIDED(stream_info, WINED3D_FFP_BLENDWEIGHT);
405	TRACE_STRIDED(stream_info, WINED3D_FFP_BLENDINDICES);
406	TRACE_STRIDED(stream_info, WINED3D_FFP_NORMAL);
407	TRACE_STRIDED(stream_info, WINED3D_FFP_PSIZE);
408	TRACE_STRIDED(stream_info, WINED3D_FFP_DIFFUSE);
409	TRACE_STRIDED(stream_info, WINED3D_FFP_SPECULAR);
410	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD0);
411	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD1);
412	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD2);
413	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD3);
414	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD4);
415	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD5);
416	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD6);
417	TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD7);
418	}
419
420	/* Context activation is done by the caller. */
421	void device_update_stream_info(IWineD3DDeviceImpl device, const struct wined3d_gl_info gl_info)
422	{
423	struct wined3d_stream_info *stream_info = &device->strided_streams;
424	IWineD3DStateBlockImpl *stateblock = device->stateBlock;
425	BOOL vs = stateblock->vertexShader && device->vs_selected_mode != SHADER_NONE;
426	BOOL fixup = FALSE;
427
428	if (device->up_strided)
429	{
430	/* Note: this is a ddraw fixed-function code path. */
431	TRACE("=============================== Strided Input ================================\n");
432	device_stream_info_from_strided(gl_info, device->up_strided, stream_info);
433	if (TRACE_ON(d3d)) device_trace_strided_stream_info(stream_info);
434	}
435	else
436	{
437	TRACE("============================= Vertex Declaration =============================\n");
438	device_stream_info_from_declaration(device, vs, stream_info, &fixup);
439	}
440
441	if (vs && !stream_info->position_transformed)
442	{
443	if (((IWineD3DVertexDeclarationImpl *)stateblock->vertexDecl)->half_float_conv_needed && !fixup)
444	{
445	TRACE("Using drawStridedSlow with vertex shaders for FLOAT16 conversion.\n");
446	device->useDrawStridedSlow = TRUE;
447	}
448	else
449	{
450	device->useDrawStridedSlow = FALSE;
451	}
452	}
453	else
454	{
455	WORD slow_mask = (1 << WINED3D_FFP_PSIZE);
456	slow_mask \|= -!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
457	& ((1 << WINED3D_FFP_DIFFUSE) \| (1 << WINED3D_FFP_SPECULAR));
458
459	if ((stream_info->position_transformed \|\| (stream_info->use_map & slow_mask)) && !fixup)
460	{
461	device->useDrawStridedSlow = TRUE;
462	}
463	else
464	{
465	device->useDrawStridedSlow = FALSE;
466	}
467	}
468	}
469
470	static void device_preload_texture(IWineD3DStateBlockImpl *stateblock, unsigned int idx)
471	{
472	IWineD3DBaseTextureImpl *texture;
473	enum WINED3DSRGB srgb;
474
475	if (!(texture = (IWineD3DBaseTextureImpl *)stateblock->textures[idx])) return;
476	srgb = stateblock->samplerState[idx][WINED3DSAMP_SRGBTEXTURE] ? SRGB_SRGB : SRGB_RGB;
477	texture->baseTexture.internal_preload((IWineD3DBaseTexture *)texture, srgb);
478	}
479
480	void device_preload_textures(IWineD3DDeviceImpl *device)
481	{
482	IWineD3DStateBlockImpl *stateblock = device->stateBlock;
483	unsigned int i;
484
485	if (use_vs(stateblock))
486	{
487	for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i)
488	{
489	if (((IWineD3DBaseShaderImpl *)stateblock->vertexShader)->baseShader.reg_maps.sampler_type[i])
490	device_preload_texture(stateblock, MAX_FRAGMENT_SAMPLERS + i);
491	}
492	}
493
494	if (use_ps(stateblock))
495	{
496	for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
497	{
498	if (((IWineD3DBaseShaderImpl *)stateblock->pixelShader)->baseShader.reg_maps.sampler_type[i])
499	device_preload_texture(stateblock, i);
500	}
501	}
502	else
503	{
504	WORD ffu_map = device->fixed_function_usage_map;
505
506	for (i = 0; ffu_map; ffu_map >>= 1, ++i)
507	{
508	if (ffu_map & 1)
509	device_preload_texture(stateblock, i);
510	}
511	}
512	}
513
514	BOOL device_context_add(IWineD3DDeviceImpl device, struct wined3d_context context)
515	{
516	struct wined3d_context **new_array;
517
518	TRACE("Adding context %p.\n", context);
519
520	if (!device->contexts) new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
521	else new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts, sizeof(new_array) (device->numContexts + 1));
522
523	if (!new_array)
524	{
525	ERR("Failed to grow the context array.\n");
526	return FALSE;
527	}
528
529	new_array[device->numContexts++] = context;
530	device->contexts = new_array;
531	return TRUE;
532	}
533
534	void device_context_remove(IWineD3DDeviceImpl device, struct wined3d_context context)
535	{
536	struct wined3d_context **new_array;
537	BOOL found = FALSE;
538	UINT i;
539
540	TRACE("Removing context %p.\n", context);
541
542	for (i = 0; i < device->numContexts; ++i)
543	{
544	if (device->contexts[i] == context)
545	{
546	found = TRUE;
547	break;
548	}
549	}
550
551	if (!found)
552	{
553	ERR("Context %p doesn't exist in context array.\n", context);
554	return;
555	}
556
557	if (!--device->numContexts)
558	{
559	HeapFree(GetProcessHeap(), 0, device->contexts);
560	device->contexts = NULL;
561	return;
562	}
563
564	memmove(&device->contexts[i], &device->contexts[i + 1], (device->numContexts - i) * sizeof(*device->contexts));
565	new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts, device->numContexts * sizeof(*device->contexts));
566	if (!new_array)
567	{
568	ERR("Failed to shrink context array. Oh well.\n");
569	return;
570	}
571
572	device->contexts = new_array;
573	}
574
575
576	/**********************************************************
577	* IUnknown parts follows
578	**********************************************************/
579
580	static HRESULT WINAPI IWineD3DDeviceImpl_QueryInterface(IWineD3DDevice iface,REFIID riid,LPVOID ppobj)
581	{
582	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
583
584	TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
585	if (IsEqualGUID(riid, &IID_IUnknown)
586	\|\| IsEqualGUID(riid, &IID_IWineD3DBase)
587	\|\| IsEqualGUID(riid, &IID_IWineD3DDevice)) {
588	IUnknown_AddRef(iface);
589	*ppobj = This;
590	return S_OK;
591	}
592	*ppobj = NULL;
593	return E_NOINTERFACE;
594	}
595
596	static ULONG WINAPI IWineD3DDeviceImpl_AddRef(IWineD3DDevice *iface) {
597	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
598	ULONG refCount = InterlockedIncrement(&This->ref);
599
600	TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
601	return refCount;
602	}
603
604	static ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
605	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
606	ULONG refCount = InterlockedDecrement(&This->ref);
607
608	TRACE("(%p) : Releasing from %d\n", This, refCount + 1);
609
610	if (!refCount) {
611	UINT i;
612
613	for (i = 0; i < sizeof(This->multistate_funcs)/sizeof(This->multistate_funcs[0]); ++i) {
614	HeapFree(GetProcessHeap(), 0, This->multistate_funcs[i]);
615	This->multistate_funcs[i] = NULL;
616	}
617
618	/* TODO: Clean up all the surfaces and textures! */
619	/* NOTE: You must release the parent if the object was created via a callback
620	*************************/
621
622	if (!list_empty(&This->resources))
623	{
624	IWineD3DResourceImpl *resource;
625	FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
626
627	LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry)
628	{
629	WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource);
630	FIXME("Leftover resource %p with type %s (%#x).\n",
631	resource, debug_d3dresourcetype(type), type);
632	}
633	}
634
635	if(This->contexts) ERR("Context array not freed!\n");
636	if (This->hardwareCursor) DestroyCursor(This->hardwareCursor);
637	This->haveHardwareCursor = FALSE;
638
639	IWineD3D_Release(This->wined3d);
640	This->wined3d = NULL;
641	HeapFree(GetProcessHeap(), 0, This);
642	TRACE("Freed device %p\n", This);
643	This = NULL;
644	}
645	return refCount;
646	}
647
648	/**********************************************************
649	* IWineD3DDevice implementation follows
650	**********************************************************/
651	static HRESULT WINAPI IWineD3DDeviceImpl_GetParent(IWineD3DDevice iface, IUnknown *pParent) {
652	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
653	*pParent = This->parent;
654	IUnknown_AddRef(This->parent);
655	return WINED3D_OK;
656	}
657
658	static HRESULT WINAPI IWineD3DDeviceImpl_CreateBuffer(IWineD3DDevice iface, struct wined3d_buffer_desc desc,
659	const void data, IUnknown parent, const struct wined3d_parent_ops parent_ops, IWineD3DBuffer *buffer)
660	{
661	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
662	struct wined3d_buffer *object;
663	HRESULT hr;
664
665	TRACE("iface %p, desc %p, data %p, parent %p, buffer %p\n", iface, desc, data, parent, buffer);
666
667	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
668	if (!object)
669	{
670	ERR("Failed to allocate memory\n");
671	return E_OUTOFMEMORY;
672	}
673
674	FIXME("Ignoring access flags (pool)\n");
675
676	hr = buffer_init(object, This, desc->byte_width, desc->usage, WINED3DFMT_UNKNOWN,
677	WINED3DPOOL_MANAGED, GL_ARRAY_BUFFER_ARB, data, parent, parent_ops);
678	if (FAILED(hr))
679	{
680	WARN("Failed to initialize buffer, hr %#x.\n", hr);
681	HeapFree(GetProcessHeap(), 0, object);
682	return hr;
683	}
684	object->desc = *desc;
685
686	TRACE("Created buffer %p.\n", object);
687
688	buffer = (IWineD3DBuffer )object;
689
690	return WINED3D_OK;
691	}
692
693	static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface,
694	UINT Size, DWORD Usage, WINED3DPOOL Pool, IWineD3DBuffer **ppVertexBuffer,
695	IUnknown parent, const struct wined3d_parent_ops parent_ops)
696	{
697	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
698	struct wined3d_buffer *object;
699	HRESULT hr;
700
701	TRACE("iface %p, size %u, usage %#x, pool %#x, buffer %p, parent %p, parent_ops %p.\n",
702	iface, Size, Usage, Pool, ppVertexBuffer, parent, parent_ops);
703
704	if (Pool == WINED3DPOOL_SCRATCH)
705	{
706	/* The d3d9 testsuit shows that this is not allowed. It doesn't make much sense
707	* anyway, SCRATCH vertex buffers aren't usable anywhere
708	*/
709	WARN("Vertex buffer in D3DPOOL_SCRATCH requested, returning WINED3DERR_INVALIDCALL\n");
710	*ppVertexBuffer = NULL;
711	return WINED3DERR_INVALIDCALL;
712	}
713
714	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
715	if (!object)
716	{
717	ERR("Out of memory\n");
718	*ppVertexBuffer = NULL;
719	return WINED3DERR_OUTOFVIDEOMEMORY;
720	}
721
722	hr = buffer_init(object, This, Size, Usage, WINED3DFMT_VERTEXDATA,
723	Pool, GL_ARRAY_BUFFER_ARB, NULL, parent, parent_ops);
724	if (FAILED(hr))
725	{
726	WARN("Failed to initialize buffer, hr %#x.\n", hr);
727	HeapFree(GetProcessHeap(), 0, object);
728	return hr;
729	}
730
731	TRACE("Created buffer %p.\n", object);
732	ppVertexBuffer = (IWineD3DBuffer )object;
733
734	return WINED3D_OK;
735	}
736
737	static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface,
738	UINT Length, DWORD Usage, WINED3DPOOL Pool, IWineD3DBuffer **ppIndexBuffer,
739	IUnknown parent, const struct wined3d_parent_ops parent_ops)
740	{
741	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
742	struct wined3d_buffer *object;
743	HRESULT hr;
744
745	TRACE("(%p) Creating index buffer\n", This);
746
747	/* Allocate the storage for the device */
748	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
749	if (!object)
750	{
751	ERR("Out of memory\n");
752	*ppIndexBuffer = NULL;
753	return WINED3DERR_OUTOFVIDEOMEMORY;
754	}
755
756	hr = buffer_init(object, This, Length, Usage \| WINED3DUSAGE_STATICDECL,
757	WINED3DFMT_UNKNOWN, Pool, GL_ELEMENT_ARRAY_BUFFER_ARB, NULL,
758	parent, parent_ops);
759	if (FAILED(hr))
760	{
761	WARN("Failed to initialize buffer, hr %#x\n", hr);
762	HeapFree(GetProcessHeap(), 0, object);
763	return hr;
764	}
765
766	TRACE("Created buffer %p.\n", object);
767
768	ppIndexBuffer = (IWineD3DBuffer ) object;
769
770	return WINED3D_OK;
771	}
772
773	static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice *iface,
774	WINED3DSTATEBLOCKTYPE type, IWineD3DStateBlock *stateblock, IUnknown parent)
775	{
776	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
777	IWineD3DStateBlockImpl *object;
778	HRESULT hr;
779
780	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
781	if(!object)
782	{
783	ERR("Failed to allocate stateblock memory.\n");
784	return E_OUTOFMEMORY;
785	}
786
787	hr = stateblock_init(object, This, type);
788	if (FAILED(hr))
789	{
790	WARN("Failed to initialize stateblock, hr %#x.\n", hr);
791	HeapFree(GetProcessHeap(), 0, object);
792	return hr;
793	}
794
795	TRACE("Created stateblock %p.\n", object);
796	stateblock = (IWineD3DStateBlock )object;
797
798	return WINED3D_OK;
799	}
800
801	static HRESULT WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UINT Width, UINT Height,
802	WINED3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IWineD3DSurface **ppSurface,
803	DWORD Usage, WINED3DPOOL Pool, WINED3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality,
804	WINED3DSURFTYPE Impl, IUnknown parent, const struct wined3d_parent_ops parent_ops
805	#ifdef VBOX_WITH_WDDM
806	, HANDLE *shared_handle
807	, void *pvClientMem
808	#endif
809	)
810	{
811	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
812	IWineD3DSurfaceImpl *object;
813	HRESULT hr;
814
815	TRACE("iface %p, width %u, height %u, format %s (%#x), lockable %#x, discard %#x, level %u\n",
816	iface, Width, Height, debug_d3dformat(Format), Format, Lockable, Discard, Level);
817	TRACE("surface %p, usage %s (%#x), pool %s (%#x), multisample_type %#x, multisample_quality %u\n",
818	ppSurface, debug_d3dusage(Usage), Usage, debug_d3dpool(Pool), Pool, MultiSample, MultisampleQuality);
819	TRACE("surface_type %#x, parent %p, parent_ops %p.\n", Impl, parent, parent_ops);
820
821	if (Impl == SURFACE_OPENGL && !This->adapter)
822	{
823	ERR("OpenGL surfaces are not available without OpenGL.\n");
824	return WINED3DERR_NOTAVAILABLE;
825	}
826
827	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
828	if (!object)
829	{
830	ERR("Failed to allocate surface memory.\n");
831	return WINED3DERR_OUTOFVIDEOMEMORY;
832	}
833
834	hr = surface_init(object, Impl, This->surface_alignment, Width, Height, Level, Lockable,
835	Discard, MultiSample, MultisampleQuality, This, Usage, Format, Pool, parent, parent_ops
836	#ifdef VBOX_WITH_WDDM
837	, shared_handle
838	, pvClientMem
839	#endif
840	);
841	if (FAILED(hr))
842	{
843	WARN("Failed to initialize surface, returning %#x.\n", hr);
844	HeapFree(GetProcessHeap(), 0, object);
845	return hr;
846	}
847
848	TRACE("(%p) : Created surface %p\n", This, object);
849
850	ppSurface = (IWineD3DSurface )object;
851
852	return hr;
853	}
854
855	static HRESULT WINAPI IWineD3DDeviceImpl_CreateRendertargetView(IWineD3DDevice *iface,
856	IWineD3DResource resource, IUnknown parent, IWineD3DRendertargetView **rendertarget_view)
857	{
858	struct wined3d_rendertarget_view *object;
859
860	TRACE("iface %p, resource %p, parent %p, rendertarget_view %p.\n",
861	iface, resource, parent, rendertarget_view);
862
863	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
864	if (!object)
865	{
866	ERR("Failed to allocate memory\n");
867	return E_OUTOFMEMORY;
868	}
869
870	wined3d_rendertarget_view_init(object, resource, parent);
871
872	TRACE("Created render target view %p.\n", object);
873	rendertarget_view = (IWineD3DRendertargetView )object;
874
875	return WINED3D_OK;
876	}
877
878	static HRESULT WINAPI IWineD3DDeviceImpl_CreateTexture(IWineD3DDevice *iface,
879	UINT Width, UINT Height, UINT Levels, DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool,
880	IWineD3DTexture *ppTexture, IUnknown parent, const struct wined3d_parent_ops *parent_ops
881	#ifdef VBOX_WITH_WDDM
882	, HANDLE *shared_handle
883	, void *pvClientMem
884	#endif
885	)
886	{
887	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
888	IWineD3DTextureImpl *object;
889	HRESULT hr;
890
891	TRACE("(%p) : Width %d, Height %d, Levels %d, Usage %#x\n", This, Width, Height, Levels, Usage);
892	TRACE("Format %#x (%s), Pool %#x, ppTexture %p, parent %p\n",
893	Format, debug_d3dformat(Format), Pool, ppTexture, parent);
894
895	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
896	if (!object)
897	{
898	ERR("Out of memory\n");
899	*ppTexture = NULL;
900	return WINED3DERR_OUTOFVIDEOMEMORY;
901	}
902
903	hr = texture_init(object, Width, Height, Levels, This, Usage, Format, Pool, parent, parent_ops
904	#ifdef VBOX_WITH_WDDM
905	, shared_handle
906	, pvClientMem
907	#endif
908	);
909	if (FAILED(hr))
910	{
911	WARN("Failed to initialize texture, returning %#x\n", hr);
912	HeapFree(GetProcessHeap(), 0, object);
913	*ppTexture = NULL;
914	return hr;
915	}
916
917	ppTexture = (IWineD3DTexture )object;
918
919	TRACE("(%p) : Created texture %p\n", This, object);
920
921	return WINED3D_OK;
922	}
923
924	static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *iface,
925	UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool,
926	IWineD3DVolumeTexture *ppVolumeTexture, IUnknown parent, const struct wined3d_parent_ops *parent_ops)
927	{
928	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
929	IWineD3DVolumeTextureImpl *object;
930	HRESULT hr;
931
932	TRACE("(%p) : W(%u) H(%u) D(%u), Lvl(%u) Usage(%#x), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
933	Depth, Levels, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
934
935	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
936	if (!object)
937	{
938	ERR("Out of memory\n");
939	*ppVolumeTexture = NULL;
940	return WINED3DERR_OUTOFVIDEOMEMORY;
941	}
942
943	hr = volumetexture_init(object, Width, Height, Depth, Levels, This, Usage, Format, Pool, parent, parent_ops);
944	if (FAILED(hr))
945	{
946	WARN("Failed to initialize volumetexture, returning %#x\n", hr);
947	HeapFree(GetProcessHeap(), 0, object);
948	*ppVolumeTexture = NULL;
949	return hr;
950	}
951
952	TRACE("(%p) : Created volume texture %p.\n", This, object);
953	ppVolumeTexture = (IWineD3DVolumeTexture )object;
954
955	return WINED3D_OK;
956	}
957
958	static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolume(IWineD3DDevice *iface, UINT Width, UINT Height,
959	UINT Depth, DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DVolume **ppVolume,
960	IUnknown parent, const struct wined3d_parent_ops parent_ops)
961	{
962	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
963	IWineD3DVolumeImpl *object;
964	HRESULT hr;
965
966	TRACE("(%p) : W(%d) H(%d) D(%d), Usage(%d), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
967	Depth, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
968
969	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
970	if (!object)
971	{
972	ERR("Out of memory\n");
973	*ppVolume = NULL;
974	return WINED3DERR_OUTOFVIDEOMEMORY;
975	}
976
977	hr = volume_init(object, This, Width, Height, Depth, Usage, Format, Pool, parent, parent_ops);
978	if (FAILED(hr))
979	{
980	WARN("Failed to initialize volume, returning %#x.\n", hr);
981	HeapFree(GetProcessHeap(), 0, object);
982	return hr;
983	}
984
985	TRACE("(%p) : Created volume %p.\n", This, object);
986	ppVolume = (IWineD3DVolume )object;
987
988	return WINED3D_OK;
989	}
990
991	static HRESULT WINAPI IWineD3DDeviceImpl_CreateCubeTexture(IWineD3DDevice *iface, UINT EdgeLength, UINT Levels,
992	DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DCubeTexture **ppCubeTexture,
993	IUnknown parent, const struct wined3d_parent_ops parent_ops)
994	{
995	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
996	IWineD3DCubeTextureImpl object; /* NOTE: impl ref allowed since this is a create function **/
997	HRESULT hr;
998
999	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1000	if (!object)
1001	{
1002	ERR("Out of memory\n");
1003	*ppCubeTexture = NULL;
1004	return WINED3DERR_OUTOFVIDEOMEMORY;
1005	}
1006
1007	hr = cubetexture_init(object, EdgeLength, Levels, This, Usage, Format, Pool, parent, parent_ops);
1008	if (FAILED(hr))
1009	{
1010	WARN("Failed to initialize cubetexture, returning %#x\n", hr);
1011	HeapFree(GetProcessHeap(), 0, object);
1012	*ppCubeTexture = NULL;
1013	return hr;
1014	}
1015
1016	TRACE("(%p) : Created Cube Texture %p\n", This, object);
1017	ppCubeTexture = (IWineD3DCubeTexture )object;
1018
1019	return WINED3D_OK;
1020	}
1021
1022	static HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface,
1023	WINED3DQUERYTYPE type, IWineD3DQuery *query, IUnknown parent)
1024	{
1025	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1026	IWineD3DQueryImpl *object;
1027	HRESULT hr;
1028
1029	TRACE("iface %p, type %#x, query %p, parent %p.\n", iface, type, query, parent);
1030
1031	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1032	if (!object)
1033	{
1034	ERR("Failed to allocate query memory.\n");
1035	return E_OUTOFMEMORY;
1036	}
1037
1038	hr = query_init(object, This, type, parent);
1039	if (FAILED(hr))
1040	{
1041	WARN("Failed to initialize query, hr %#x.\n", hr);
1042	HeapFree(GetProcessHeap(), 0, object);
1043	return hr;
1044	}
1045
1046	TRACE("Created query %p.\n", object);
1047	query = (IWineD3DQuery )object;
1048
1049	return WINED3D_OK;
1050	}
1051
1052	static HRESULT WINAPI IWineD3DDeviceImpl_CreateSwapChain(IWineD3DDevice *iface,
1053	WINED3DPRESENT_PARAMETERS present_parameters, IWineD3DSwapChain *swapchain,
1054	IUnknown *parent, WINED3DSURFTYPE surface_type)
1055	{
1056	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1057	IWineD3DSwapChainImpl *object;
1058	HRESULT hr;
1059
1060	TRACE("iface %p, present_parameters %p, swapchain %p, parent %p, surface_type %#x.\n",
1061	iface, present_parameters, swapchain, parent, surface_type);
1062
1063	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1064	if (!object)
1065	{
1066	ERR("Failed to allocate swapchain memory.\n");
1067	return E_OUTOFMEMORY;
1068	}
1069
1070	hr = swapchain_init(object, surface_type, This, present_parameters, parent);
1071	if (FAILED(hr))
1072	{
1073	WARN("Failed to initialize swapchain, hr %#x.\n", hr);
1074	HeapFree(GetProcessHeap(), 0, object);
1075	return hr;
1076	}
1077
1078	TRACE("Created swapchain %p.\n", object);
1079	swapchain = (IWineD3DSwapChain )object;
1080
1081	return WINED3D_OK;
1082	}
1083
1084	/ NOTE: These are ahead of the other getters and setters to save using a forward declaration /
1085	static UINT WINAPI IWineD3DDeviceImpl_GetNumberOfSwapChains(IWineD3DDevice *iface) {
1086	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1087	TRACE("(%p)\n", This);
1088
1089	return This->NumberOfSwapChains;
1090	}
1091
1092	static HRESULT WINAPI IWineD3DDeviceImpl_GetSwapChain(IWineD3DDevice iface, UINT iSwapChain, IWineD3DSwapChain *pSwapChain) {
1093	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1094	TRACE("(%p) : swapchain %d\n", This, iSwapChain);
1095
1096	if(iSwapChain < This->NumberOfSwapChains) {
1097	*pSwapChain = This->swapchains[iSwapChain];
1098	IWineD3DSwapChain_AddRef(*pSwapChain);
1099	TRACE("(%p) returning %p\n", This, *pSwapChain);
1100	return WINED3D_OK;
1101	} else {
1102	TRACE("Swapchain out of range\n");
1103	*pSwapChain = NULL;
1104	return WINED3DERR_INVALIDCALL;
1105	}
1106	}
1107
1108	static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclaration(IWineD3DDevice *iface,
1109	IWineD3DVertexDeclaration *declaration, IUnknown parent, const struct wined3d_parent_ops *parent_ops,
1110	const WINED3DVERTEXELEMENT *elements, UINT element_count)
1111	{
1112	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1113	IWineD3DVertexDeclarationImpl *object = NULL;
1114	HRESULT hr;
1115
1116	TRACE("iface %p, declaration %p, parent %p, elements %p, element_count %u.\n",
1117	iface, declaration, parent, elements, element_count);
1118
1119	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1120	if(!object)
1121	{
1122	ERR("Failed to allocate vertex declaration memory.\n");
1123	return E_OUTOFMEMORY;
1124	}
1125
1126	hr = vertexdeclaration_init(object, This, elements, element_count, parent, parent_ops);
1127	if (FAILED(hr))
1128	{
1129	WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
1130	HeapFree(GetProcessHeap(), 0, object);
1131	return hr;
1132	}
1133
1134	TRACE("Created vertex declaration %p.\n", object);
1135	declaration = (IWineD3DVertexDeclaration )object;
1136
1137	return WINED3D_OK;
1138	}
1139
1140	struct wined3d_fvf_convert_state
1141	{
1142	const struct wined3d_gl_info *gl_info;
1143	WINED3DVERTEXELEMENT *elements;
1144	UINT offset;
1145	UINT idx;
1146	};
1147
1148	static void append_decl_element(struct wined3d_fvf_convert_state *state,
1149	WINED3DFORMAT format, WINED3DDECLUSAGE usage, UINT usage_idx)
1150	{
1151	WINED3DVERTEXELEMENT *elements = state->elements;
1152	const struct wined3d_format_desc *format_desc;
1153	UINT offset = state->offset;
1154	UINT idx = state->idx;
1155
1156	elements[idx].format = format;
1157	elements[idx].input_slot = 0;
1158	elements[idx].offset = offset;
1159	elements[idx].output_slot = 0;
1160	elements[idx].method = WINED3DDECLMETHOD_DEFAULT;
1161	elements[idx].usage = usage;
1162	elements[idx].usage_idx = usage_idx;
1163
1164	format_desc = getFormatDescEntry(format, state->gl_info);
1165	state->offset += format_desc->component_count * format_desc->component_size;
1166	++state->idx;
1167	}
1168
1169	static unsigned int ConvertFvfToDeclaration(IWineD3DDeviceImpl This, / For the GL info, which has the type table */
1170	DWORD fvf, WINED3DVERTEXELEMENT **ppVertexElements)
1171	{
1172	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
1173	BOOL has_pos = (fvf & WINED3DFVF_POSITION_MASK) != 0;
1174	BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
1175	BOOL has_blend_idx = has_blend &&
1176	(((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB5) \|\|
1177	(fvf & WINED3DFVF_LASTBETA_D3DCOLOR) \|\|
1178	(fvf & WINED3DFVF_LASTBETA_UBYTE4));
1179	BOOL has_normal = (fvf & WINED3DFVF_NORMAL) != 0;
1180	BOOL has_psize = (fvf & WINED3DFVF_PSIZE) != 0;
1181	BOOL has_diffuse = (fvf & WINED3DFVF_DIFFUSE) != 0;
1182	BOOL has_specular = (fvf & WINED3DFVF_SPECULAR) !=0;
1183
1184	DWORD num_textures = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1185	DWORD texcoords = (fvf & 0xFFFF0000) >> 16;
1186	struct wined3d_fvf_convert_state state;
1187	unsigned int size;
1188	unsigned int idx;
1189	DWORD num_blends = 1 + (((fvf & WINED3DFVF_XYZB5) - WINED3DFVF_XYZB1) >> 1);
1190	if (has_blend_idx) num_blends--;
1191
1192	/* Compute declaration size */
1193	size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
1194	has_psize + has_diffuse + has_specular + num_textures;
1195
1196	state.gl_info = gl_info;
1197	state.elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*state.elements));
1198	if (!state.elements) return ~0U;
1199	state.offset = 0;
1200	state.idx = 0;
1201
1202	if (has_pos)
1203	{
1204	if (!has_blend && (fvf & WINED3DFVF_XYZRHW))
1205	append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_POSITIONT, 0);
1206	else if ((fvf & WINED3DFVF_XYZW) == WINED3DFVF_XYZW)
1207	append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_POSITION, 0);
1208	else
1209	append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_POSITION, 0);
1210	}
1211
1212	if (has_blend && (num_blends > 0))
1213	{
1214	if ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
1215	append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
1216	else
1217	{
1218	switch (num_blends)
1219	{
1220	case 1:
1221	append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
1222	break;
1223	case 2:
1224	append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
1225	break;
1226	case 3:
1227	append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
1228	break;
1229	case 4:
1230	append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
1231	break;
1232	default:
1233	ERR("Unexpected amount of blend values: %u\n", num_blends);
1234	}
1235	}
1236	}
1237
1238	if (has_blend_idx)
1239	{
1240	if ((fvf & WINED3DFVF_LASTBETA_UBYTE4)
1241	\|\| ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
1242	append_decl_element(&state, WINED3DFMT_R8G8B8A8_UINT, WINED3DDECLUSAGE_BLENDINDICES, 0);
1243	else if (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)
1244	append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_BLENDINDICES, 0);
1245	else
1246	append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_BLENDINDICES, 0);
1247	}
1248
1249	if (has_normal) append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_NORMAL, 0);
1250	if (has_psize) append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_PSIZE, 0);
1251	if (has_diffuse) append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_COLOR, 0);
1252	if (has_specular) append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_COLOR, 1);
1253
1254	for (idx = 0; idx < num_textures; ++idx)
1255	{
1256	switch ((texcoords >> (idx * 2)) & 0x03)
1257	{
1258	case WINED3DFVF_TEXTUREFORMAT1:
1259	append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
1260	break;
1261	case WINED3DFVF_TEXTUREFORMAT2:
1262	append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
1263	break;
1264	case WINED3DFVF_TEXTUREFORMAT3:
1265	append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
1266	break;
1267	case WINED3DFVF_TEXTUREFORMAT4:
1268	append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
1269	break;
1270	}
1271	}
1272
1273	*ppVertexElements = state.elements;
1274	return size;
1275	}
1276
1277	static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF(IWineD3DDevice *iface,
1278	IWineD3DVertexDeclaration *declaration, IUnknown parent,
1279	const struct wined3d_parent_ops *parent_ops, DWORD fvf)
1280	{
1281	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1282	WINED3DVERTEXELEMENT *elements;
1283	unsigned int size;
1284	DWORD hr;
1285
1286	TRACE("iface %p, declaration %p, parent %p, fvf %#x.\n", iface, declaration, parent, fvf);
1287
1288	size = ConvertFvfToDeclaration(This, fvf, &elements);
1289	if (size == ~0U) return E_OUTOFMEMORY;
1290
1291	hr = IWineD3DDevice_CreateVertexDeclaration(iface, declaration, parent, parent_ops, elements, size);
1292	HeapFree(GetProcessHeap(), 0, elements);
1293	return hr;
1294	}
1295
1296	static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexShader(IWineD3DDevice *iface,
1297	const DWORD pFunction, const struct wined3d_shader_signature output_signature,
1298	IWineD3DVertexShader *ppVertexShader, IUnknown parent,
1299	const struct wined3d_parent_ops *parent_ops)
1300	{
1301	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1302	IWineD3DVertexShaderImpl *object;
1303	HRESULT hr;
1304
1305	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1306	if (!object)
1307	{
1308	ERR("Failed to allocate shader memory.\n");
1309	return E_OUTOFMEMORY;
1310	}
1311
1312	hr = vertexshader_init(object, This, pFunction, output_signature, parent, parent_ops);
1313	if (FAILED(hr))
1314	{
1315	WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
1316	HeapFree(GetProcessHeap(), 0, object);
1317	return hr;
1318	}
1319
1320	TRACE("Created vertex shader %p.\n", object);
1321	ppVertexShader = (IWineD3DVertexShader )object;
1322
1323	return WINED3D_OK;
1324	}
1325
1326	static HRESULT WINAPI IWineD3DDeviceImpl_CreateGeometryShader(IWineD3DDevice *iface,
1327	const DWORD byte_code, const struct wined3d_shader_signature output_signature,
1328	IWineD3DGeometryShader *shader, IUnknown parent,
1329	const struct wined3d_parent_ops *parent_ops)
1330	{
1331	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1332	struct wined3d_geometryshader *object;
1333	HRESULT hr;
1334
1335	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1336	if (!object)
1337	{
1338	ERR("Failed to allocate shader memory.\n");
1339	return E_OUTOFMEMORY;
1340	}
1341
1342	hr = geometryshader_init(object, This, byte_code, output_signature, parent, parent_ops);
1343	if (FAILED(hr))
1344	{
1345	WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
1346	HeapFree(GetProcessHeap(), 0, object);
1347	return hr;
1348	}
1349
1350	TRACE("Created geometry shader %p.\n", object);
1351	shader = (IWineD3DGeometryShader )object;
1352
1353	return WINED3D_OK;
1354	}
1355
1356	static HRESULT WINAPI IWineD3DDeviceImpl_CreatePixelShader(IWineD3DDevice *iface,
1357	const DWORD pFunction, const struct wined3d_shader_signature output_signature,
1358	IWineD3DPixelShader *ppPixelShader, IUnknown parent,
1359	const struct wined3d_parent_ops *parent_ops)
1360	{
1361	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1362	IWineD3DPixelShaderImpl *object;
1363	HRESULT hr;
1364
1365	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1366	if (!object)
1367	{
1368	ERR("Failed to allocate shader memory.\n");
1369	return E_OUTOFMEMORY;
1370	}
1371
1372	hr = pixelshader_init(object, This, pFunction, output_signature, parent, parent_ops);
1373	if (FAILED(hr))
1374	{
1375	WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
1376	HeapFree(GetProcessHeap(), 0, object);
1377	return hr;
1378	}
1379
1380	TRACE("Created pixel shader %p.\n", object);
1381	ppPixelShader = (IWineD3DPixelShader )object;
1382
1383	return WINED3D_OK;
1384	}
1385
1386	static HRESULT WINAPI IWineD3DDeviceImpl_CreatePalette(IWineD3DDevice *iface, DWORD Flags,
1387	const PALETTEENTRY PalEnt, IWineD3DPalette Palette, IUnknown Parent)
1388	{
1389	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1390	IWineD3DPaletteImpl *object;
1391	HRESULT hr;
1392
1393	TRACE("iface %p, flags %#x, entries %p, palette %p, parent %p.\n",
1394	iface, Flags, PalEnt, Palette, Parent);
1395
1396	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1397	if (!object)
1398	{
1399	ERR("Failed to allocate palette memory.\n");
1400	return E_OUTOFMEMORY;
1401	}
1402
1403	hr = wined3d_palette_init(object, This, Flags, PalEnt, Parent);
1404	if (FAILED(hr))
1405	{
1406	WARN("Failed to initialize palette, hr %#x.\n", hr);
1407	HeapFree(GetProcessHeap(), 0, object);
1408	return hr;
1409	}
1410
1411	TRACE("Created palette %p.\n", object);
1412	Palette = (IWineD3DPalette )object;
1413
1414	return WINED3D_OK;
1415	}
1416
1417	static void IWineD3DDeviceImpl_LoadLogo(IWineD3DDeviceImpl This, const char filename) {
1418	HBITMAP hbm;
1419	BITMAP bm;
1420	HRESULT hr;
1421	HDC dcb = NULL, dcs = NULL;
1422	WINEDDCOLORKEY colorkey;
1423
1424	hbm = LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);
1425	if(hbm)
1426	{
1427	GetObjectA(hbm, sizeof(BITMAP), &bm);
1428	dcb = CreateCompatibleDC(NULL);
1429	if(!dcb) goto out;
1430	SelectObject(dcb, hbm);
1431	}
1432	else
1433	{
1434	/* Create a 32x32 white surface to indicate that wined3d is used, but the specified image
1435	* couldn't be loaded
1436	*/
1437	memset(&bm, 0, sizeof(bm));
1438	bm.bmWidth = 32;
1439	bm.bmHeight = 32;
1440	}
1441
1442	#ifdef VBOX_WITH_WDDM
1443	hr = IWineD3DDevice_CreateSurface((IWineD3DDevice *)This, bm.bmWidth, bm.bmHeight, WINED3DFMT_B5G6R5_UNORM, TRUE,
1444	FALSE, 0, &This->logo_surface, 0, WINED3DPOOL_DEFAULT, WINED3DMULTISAMPLE_NONE, 0, SURFACE_OPENGL,
1445	NULL, &wined3d_null_parent_ops, NULL, NULL);
1446	#else
1447	hr = IWineD3DDevice_CreateSurface((IWineD3DDevice *)This, bm.bmWidth, bm.bmHeight, WINED3DFMT_B5G6R5_UNORM, TRUE,
1448	FALSE, 0, &This->logo_surface, 0, WINED3DPOOL_DEFAULT, WINED3DMULTISAMPLE_NONE, 0, SURFACE_OPENGL,
1449	NULL, &wined3d_null_parent_ops);
1450	#endif
1451	if(FAILED(hr)) {
1452	ERR("Wine logo requested, but failed to create surface\n");
1453	goto out;
1454	}
1455
1456	if(dcb) {
1457	hr = IWineD3DSurface_GetDC(This->logo_surface, &dcs);
1458	if(FAILED(hr)) goto out;
1459	BitBlt(dcs, 0, 0, bm.bmWidth, bm.bmHeight, dcb, 0, 0, SRCCOPY);
1460	IWineD3DSurface_ReleaseDC(This->logo_surface, dcs);
1461
1462	colorkey.dwColorSpaceLowValue = 0;
1463	colorkey.dwColorSpaceHighValue = 0;
1464	IWineD3DSurface_SetColorKey(This->logo_surface, WINEDDCKEY_SRCBLT, &colorkey);
1465	} else {
1466	/* Fill the surface with a white color to show that wined3d is there */
1467	IWineD3DDevice_ColorFill((IWineD3DDevice *) This, This->logo_surface, NULL, 0xffffffff);
1468	}
1469
1470	out:
1471	if (dcb) DeleteDC(dcb);
1472	if (hbm) DeleteObject(hbm);
1473	}
1474
1475	/* Context activation is done by the caller. */
1476	static void create_dummy_textures(IWineD3DDeviceImpl *This)
1477	{
1478	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
1479	unsigned int i;
1480	/* Under DirectX you can have texture stage operations even if no texture is
1481	bound, whereas opengl will only do texture operations when a valid texture is
1482	bound. We emulate this by creating dummy textures and binding them to each
1483	texture stage, but disable all stages by default. Hence if a stage is enabled
1484	then the default texture will kick in until replaced by a SetTexture call */
1485	ENTER_GL();
1486
1487	if (gl_info->supported[APPLE_CLIENT_STORAGE])
1488	{
1489	/* The dummy texture does not have client storage backing */
1490	glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
1491	checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
1492	}
1493
1494	for (i = 0; i < gl_info->limits.textures; ++i)
1495	{
1496	GLubyte white = 255;
1497
1498	/* Make appropriate texture active */
1499	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1500	checkGLcall("glActiveTextureARB");
1501
1502	/* Generate an opengl texture name */
1503	glGenTextures(1, &This->dummyTextureName[i]);
1504	checkGLcall("glGenTextures");
1505	TRACE("Dummy Texture %d given name %d\n", i, This->dummyTextureName[i]);
1506
1507	/* Generate a dummy 2d texture (not using 1d because they cause many
1508	* DRI drivers fall back to sw) */
1509	glBindTexture(GL_TEXTURE_2D, This->dummyTextureName[i]);
1510	checkGLcall("glBindTexture");
1511
1512	glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &white);
1513	checkGLcall("glTexImage2D");
1514	}
1515
1516	if (gl_info->supported[APPLE_CLIENT_STORAGE])
1517	{
1518	/* Reenable because if supported it is enabled by default */
1519	glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
1520	checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
1521	}
1522
1523	LEAVE_GL();
1524	}
1525
1526	/* Context activation is done by the caller. */
1527	static void destroy_dummy_textures(IWineD3DDeviceImpl device, const struct wined3d_gl_info gl_info)
1528	{
1529	ENTER_GL();
1530	glDeleteTextures(gl_info->limits.textures, device->dummyTextureName);
1531	checkGLcall("glDeleteTextures(gl_info->limits.textures, device->dummyTextureName)");
1532	LEAVE_GL();
1533
1534	memset(device->dummyTextureName, 0, gl_info->limits.textures * sizeof(*device->dummyTextureName));
1535	}
1536
1537	static HRESULT WINAPI IWineD3DDeviceImpl_AcquireFocusWindow(IWineD3DDevice *iface, HWND window)
1538	{
1539	IWineD3DDeviceImpl device = (IWineD3DDeviceImpl )iface;
1540
1541	if (!wined3d_register_window(window, device))
1542	{
1543	ERR("Failed to register window %p.\n", window);
1544	return E_FAIL;
1545	}
1546
1547	device->focus_window = window;
1548	SetForegroundWindow(window);
1549
1550	return WINED3D_OK;
1551	}
1552
1553	static void WINAPI IWineD3DDeviceImpl_ReleaseFocusWindow(IWineD3DDevice *iface)
1554	{
1555	IWineD3DDeviceImpl device = (IWineD3DDeviceImpl )iface;
1556
1557	if (device->focus_window) wined3d_unregister_window(device->focus_window);
1558	device->focus_window = NULL;
1559	}
1560
1561	static HRESULT WINAPI IWineD3DDeviceImpl_Init3D(IWineD3DDevice *iface,
1562	WINED3DPRESENT_PARAMETERS *pPresentationParameters)
1563	{
1564	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1565	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
1566	IWineD3DSwapChainImpl *swapchain = NULL;
1567	struct wined3d_context *context;
1568	HRESULT hr;
1569	DWORD state;
1570	unsigned int i;
1571
1572	TRACE("(%p)->(%p)\n", This, pPresentationParameters);
1573
1574	if(This->d3d_initialized) return WINED3DERR_INVALIDCALL;
1575	if(!This->adapter->opengl) return WINED3DERR_INVALIDCALL;
1576
1577	TRACE("(%p) : Creating stateblock\n", This);
1578	/* Creating the startup stateBlock - Note Special Case: 0 => Don't fill in yet! */
1579	hr = IWineD3DDevice_CreateStateBlock(iface,
1580	WINED3DSBT_INIT,
1581	(IWineD3DStateBlock **)&This->stateBlock,
1582	NULL);
1583	if (WINED3D_OK != hr) { /* Note: No parent needed for initial internal stateblock */
1584	WARN("Failed to create stateblock\n");
1585	goto err_out;
1586	}
1587	TRACE("(%p) : Created stateblock (%p)\n", This, This->stateBlock);
1588	This->updateStateBlock = This->stateBlock;
1589	IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
1590
1591	This->render_targets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1592	sizeof(IWineD3DSurface ) gl_info->limits.buffers);
1593	This->draw_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1594	sizeof(GLenum) * gl_info->limits.buffers);
1595
1596	This->NumberOfPalettes = 1;
1597	This->palettes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PALETTEENTRY*));
1598	if(!This->palettes \|\| !This->render_targets \|\| !This->draw_buffers) {
1599	ERR("Out of memory!\n");
1600	hr = E_OUTOFMEMORY;
1601	goto err_out;
1602	}
1603	This->palettes[0] = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
1604	if(!This->palettes[0]) {
1605	ERR("Out of memory!\n");
1606	hr = E_OUTOFMEMORY;
1607	goto err_out;
1608	}
1609	for (i = 0; i < 256; ++i) {
1610	This->palettes[0][i].peRed = 0xFF;
1611	This->palettes[0][i].peGreen = 0xFF;
1612	This->palettes[0][i].peBlue = 0xFF;
1613	This->palettes[0][i].peFlags = 0xFF;
1614	}
1615	This->currentPalette = 0;
1616
1617	/* Initialize the texture unit mapping to a 1:1 mapping */
1618	for (state = 0; state < MAX_COMBINED_SAMPLERS; ++state)
1619	{
1620	if (state < gl_info->limits.fragment_samplers)
1621	{
1622	This->texUnitMap[state] = state;
1623	This->rev_tex_unit_map[state] = state;
1624	} else {
1625	This->texUnitMap[state] = WINED3D_UNMAPPED_STAGE;
1626	This->rev_tex_unit_map[state] = WINED3D_UNMAPPED_STAGE;
1627	}
1628	}
1629
1630	/* Setup the implicit swapchain. This also initializes a context. */
1631	TRACE("Creating implicit swapchain\n");
1632	hr = IWineD3DDeviceParent_CreateSwapChain(This->device_parent,
1633	pPresentationParameters, (IWineD3DSwapChain **)&swapchain);
1634	if (FAILED(hr))
1635	{
1636	WARN("Failed to create implicit swapchain\n");
1637	goto err_out;
1638	}
1639
1640	This->NumberOfSwapChains = 1;
1641	This->swapchains = HeapAlloc(GetProcessHeap(), 0, This->NumberOfSwapChains * sizeof(IWineD3DSwapChain *));
1642	if(!This->swapchains) {
1643	ERR("Out of memory!\n");
1644	goto err_out;
1645	}
1646	This->swapchains[0] = (IWineD3DSwapChain *) swapchain;
1647
1648	if(swapchain->backBuffer && swapchain->backBuffer[0]) {
1649	TRACE("Setting rendertarget to %p\n", swapchain->backBuffer);
1650	This->render_targets[0] = swapchain->backBuffer[0];
1651	}
1652	else {
1653	TRACE("Setting rendertarget to %p\n", swapchain->frontBuffer);
1654	This->render_targets[0] = swapchain->frontBuffer;
1655	}
1656	IWineD3DSurface_AddRef(This->render_targets[0]);
1657
1658	/* Depth Stencil support */
1659	This->stencilBufferTarget = This->auto_depth_stencil_buffer;
1660	if (NULL != This->stencilBufferTarget) {
1661	IWineD3DSurface_AddRef(This->stencilBufferTarget);
1662	}
1663
1664	hr = This->shader_backend->shader_alloc_private(iface);
1665	if(FAILED(hr)) {
1666	TRACE("Shader private data couldn't be allocated\n");
1667	goto err_out;
1668	}
1669	hr = This->frag_pipe->alloc_private(iface);
1670	if(FAILED(hr)) {
1671	TRACE("Fragment pipeline private data couldn't be allocated\n");
1672	goto err_out;
1673	}
1674	hr = This->blitter->alloc_private(iface);
1675	if(FAILED(hr)) {
1676	TRACE("Blitter private data couldn't be allocated\n");
1677	goto err_out;
1678	}
1679
1680	/* Set up some starting GL setup */
1681
1682	/* Setup all the devices defaults */
1683	IWineD3DStateBlock_InitStartupStateBlock((IWineD3DStateBlock *)This->stateBlock);
1684
1685	context = context_acquire(This, swapchain->frontBuffer, CTXUSAGE_RESOURCELOAD);
1686
1687	create_dummy_textures(This);
1688
1689	ENTER_GL();
1690
1691	/* Initialize the current view state */
1692	This->view_ident = 1;
1693	This->contexts[0]->last_was_rhw = 0;
1694	glGetIntegerv(GL_MAX_LIGHTS, &This->maxConcurrentLights);
1695	checkGLcall("glGetIntegerv(GL_MAX_LIGHTS, &This->maxConcurrentLights)");
1696
1697	switch(wined3d_settings.offscreen_rendering_mode) {
1698	case ORM_FBO:
1699	This->offscreenBuffer = GL_COLOR_ATTACHMENT0;
1700	break;
1701
1702	case ORM_BACKBUFFER:
1703	{
1704	if (context_get_current()->aux_buffers > 0)
1705	{
1706	TRACE("Using auxilliary buffer for offscreen rendering\n");
1707	This->offscreenBuffer = GL_AUX0;
1708	} else {
1709	TRACE("Using back buffer for offscreen rendering\n");
1710	This->offscreenBuffer = GL_BACK;
1711	}
1712	}
1713	}
1714
1715	TRACE("(%p) All defaults now set up, leaving Init3D with %p\n", This, This);
1716	LEAVE_GL();
1717
1718	context_release(context);
1719
1720	/* Clear the screen */
1721	IWineD3DDevice_Clear((IWineD3DDevice *) This, 0, NULL,
1722	WINED3DCLEAR_TARGET \| pPresentationParameters->EnableAutoDepthStencil ? WINED3DCLEAR_ZBUFFER \| WINED3DCLEAR_STENCIL : 0,
1723	0x00, 1.0f, 0);
1724
1725	This->d3d_initialized = TRUE;
1726
1727	if(wined3d_settings.logo) {
1728	IWineD3DDeviceImpl_LoadLogo(This, wined3d_settings.logo);
1729	}
1730	This->highest_dirty_ps_const = 0;
1731	This->highest_dirty_vs_const = 0;
1732	return WINED3D_OK;
1733
1734	err_out:
1735	HeapFree(GetProcessHeap(), 0, This->render_targets);
1736	HeapFree(GetProcessHeap(), 0, This->draw_buffers);
1737	HeapFree(GetProcessHeap(), 0, This->swapchains);
1738	This->NumberOfSwapChains = 0;
1739	if(This->palettes) {
1740	HeapFree(GetProcessHeap(), 0, This->palettes[0]);
1741	HeapFree(GetProcessHeap(), 0, This->palettes);
1742	}
1743	This->NumberOfPalettes = 0;
1744	if(swapchain) {
1745	IWineD3DSwapChain_Release( (IWineD3DSwapChain *) swapchain);
1746	}
1747	if(This->stateBlock) {
1748	IWineD3DStateBlock_Release((IWineD3DStateBlock *) This->stateBlock);
1749	This->stateBlock = NULL;
1750	}
1751	if (This->blit_priv) {
1752	This->blitter->free_private(iface);
1753	}
1754	if (This->fragment_priv) {
1755	This->frag_pipe->free_private(iface);
1756	}
1757	if (This->shader_priv) {
1758	This->shader_backend->shader_free_private(iface);
1759	}
1760	return hr;
1761	}
1762
1763	static HRESULT WINAPI IWineD3DDeviceImpl_InitGDI(IWineD3DDevice *iface,
1764	WINED3DPRESENT_PARAMETERS *pPresentationParameters)
1765	{
1766	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1767	IWineD3DSwapChainImpl *swapchain = NULL;
1768	HRESULT hr;
1769
1770	/* Setup the implicit swapchain */
1771	TRACE("Creating implicit swapchain\n");
1772	hr = IWineD3DDeviceParent_CreateSwapChain(This->device_parent,
1773	pPresentationParameters, (IWineD3DSwapChain **)&swapchain);
1774	if (FAILED(hr))
1775	{
1776	WARN("Failed to create implicit swapchain\n");
1777	goto err_out;
1778	}
1779
1780	This->NumberOfSwapChains = 1;
1781	This->swapchains = HeapAlloc(GetProcessHeap(), 0, This->NumberOfSwapChains * sizeof(IWineD3DSwapChain *));
1782	if(!This->swapchains) {
1783	ERR("Out of memory!\n");
1784	goto err_out;
1785	}
1786	This->swapchains[0] = (IWineD3DSwapChain *) swapchain;
1787	return WINED3D_OK;
1788
1789	err_out:
1790	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
1791	return hr;
1792	}
1793
1794	static HRESULT WINAPI device_unload_resource(IWineD3DResource resource, void ctx)
1795	{
1796	IWineD3DResource_UnLoad(resource);
1797	IWineD3DResource_Release(resource);
1798	return WINED3D_OK;
1799	}
1800
1801	static HRESULT WINAPI IWineD3DDeviceImpl_Uninit3D(IWineD3DDevice *iface,
1802	D3DCB_DESTROYSWAPCHAINFN D3DCB_DestroySwapChain)
1803	{
1804	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1805	const struct wined3d_gl_info *gl_info;
1806	struct wined3d_context *context;
1807	int sampler;
1808	UINT i;
1809	TRACE("(%p)\n", This);
1810
1811	if(!This->d3d_initialized) return WINED3DERR_INVALIDCALL;
1812
1813	/* I don't think that the interface guarantees that the device is destroyed from the same thread
1814	* it was created. Thus make sure a context is active for the glDelete* calls
1815	*/
1816	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
1817	gl_info = context->gl_info;
1818
1819	if(This->logo_surface) IWineD3DSurface_Release(This->logo_surface);
1820
1821	/* Unload resources */
1822	IWineD3DDevice_EnumResources(iface, device_unload_resource, NULL);
1823
1824	TRACE("Deleting high order patches\n");
1825	for(i = 0; i < PATCHMAP_SIZE; i++) {
1826	struct list e1, e2;
1827	struct WineD3DRectPatch *patch;
1828	LIST_FOR_EACH_SAFE(e1, e2, &This->patches[i]) {
1829	patch = LIST_ENTRY(e1, struct WineD3DRectPatch, entry);
1830	IWineD3DDevice_DeletePatch(iface, patch->Handle);
1831	}
1832	}
1833
1834	/* Delete the mouse cursor texture */
1835	if(This->cursorTexture) {
1836	ENTER_GL();
1837	glDeleteTextures(1, &This->cursorTexture);
1838	LEAVE_GL();
1839	This->cursorTexture = 0;
1840	}
1841
1842	for (sampler = 0; sampler < MAX_FRAGMENT_SAMPLERS; ++sampler) {
1843	IWineD3DDevice_SetTexture(iface, sampler, NULL);
1844	}
1845	for (sampler = 0; sampler < MAX_VERTEX_SAMPLERS; ++sampler) {
1846	IWineD3DDevice_SetTexture(iface, WINED3DVERTEXTEXTURESAMPLER0 + sampler, NULL);
1847	}
1848
1849	/* Destroy the depth blt resources, they will be invalid after the reset. Also free shader
1850	* private data, it might contain opengl pointers
1851	*/
1852	if(This->depth_blt_texture) {
1853	ENTER_GL();
1854	glDeleteTextures(1, &This->depth_blt_texture);
1855	LEAVE_GL();
1856	This->depth_blt_texture = 0;
1857	}
1858	if (This->depth_blt_rb) {
1859	ENTER_GL();
1860	gl_info->fbo_ops.glDeleteRenderbuffers(1, &This->depth_blt_rb);
1861	LEAVE_GL();
1862	This->depth_blt_rb = 0;
1863	This->depth_blt_rb_w = 0;
1864	This->depth_blt_rb_h = 0;
1865	}
1866
1867	/* Release the update stateblock */
1868	if(IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->updateStateBlock) > 0){
1869	if(This->updateStateBlock != This->stateBlock)
1870	FIXME("(%p) Something's still holding the Update stateblock\n",This);
1871	}
1872	This->updateStateBlock = NULL;
1873
1874	{ /* because were not doing proper internal refcounts releasing the primary state block
1875	causes recursion with the extra checks in ResourceReleased, to avoid this we have
1876	to set this->stateBlock = NULL; first */
1877	IWineD3DStateBlock stateBlock = (IWineD3DStateBlock )This->stateBlock;
1878	This->stateBlock = NULL;
1879
1880	/* Release the stateblock */
1881	if(IWineD3DStateBlock_Release(stateBlock) > 0){
1882	FIXME("(%p) Something's still holding the Update stateblock\n",This);
1883	}
1884	}
1885
1886	/* Destroy the shader backend. Note that this has to happen after all shaders are destroyed. */
1887	This->blitter->free_private(iface);
1888	This->frag_pipe->free_private(iface);
1889	This->shader_backend->shader_free_private(iface);
1890
1891	/* Release the buffers (with sanity checks)*/
1892	TRACE("Releasing the depth stencil buffer at %p\n", This->stencilBufferTarget);
1893	if(This->stencilBufferTarget != NULL && (IWineD3DSurface_Release(This->stencilBufferTarget) >0)){
1894	if(This->auto_depth_stencil_buffer != This->stencilBufferTarget)
1895	FIXME("(%p) Something's still holding the stencilBufferTarget\n",This);
1896	}
1897	This->stencilBufferTarget = NULL;
1898
1899	TRACE("Releasing the render target at %p\n", This->render_targets[0]);
1900	IWineD3DSurface_Release(This->render_targets[0]);
1901
1902	TRACE("Setting rendertarget to NULL\n");
1903	This->render_targets[0] = NULL;
1904
1905	if (This->auto_depth_stencil_buffer) {
1906	if (IWineD3DSurface_Release(This->auto_depth_stencil_buffer) > 0)
1907	{
1908	FIXME("(%p) Something's still holding the auto depth stencil buffer\n", This);
1909	}
1910	This->auto_depth_stencil_buffer = NULL;
1911	}
1912
1913	context_release(context);
1914
1915	for(i=0; i < This->NumberOfSwapChains; i++) {
1916	TRACE("Releasing the implicit swapchain %d\n", i);
1917	if (D3DCB_DestroySwapChain(This->swapchains[i]) > 0) {
1918	FIXME("(%p) Something's still holding the implicit swapchain\n", This);
1919	}
1920	}
1921
1922	HeapFree(GetProcessHeap(), 0, This->swapchains);
1923	This->swapchains = NULL;
1924	This->NumberOfSwapChains = 0;
1925
1926	for (i = 0; i < This->NumberOfPalettes; i++) HeapFree(GetProcessHeap(), 0, This->palettes[i]);
1927	HeapFree(GetProcessHeap(), 0, This->palettes);
1928	This->palettes = NULL;
1929	This->NumberOfPalettes = 0;
1930
1931	HeapFree(GetProcessHeap(), 0, This->render_targets);
1932	HeapFree(GetProcessHeap(), 0, This->draw_buffers);
1933	This->render_targets = NULL;
1934	This->draw_buffers = NULL;
1935
1936	This->d3d_initialized = FALSE;
1937
1938	return WINED3D_OK;
1939	}
1940
1941	static HRESULT WINAPI IWineD3DDeviceImpl_UninitGDI(IWineD3DDevice *iface, D3DCB_DESTROYSWAPCHAINFN D3DCB_DestroySwapChain) {
1942	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1943	unsigned int i;
1944
1945	for(i=0; i < This->NumberOfSwapChains; i++) {
1946	TRACE("Releasing the implicit swapchain %d\n", i);
1947	if (D3DCB_DestroySwapChain(This->swapchains[i]) > 0) {
1948	FIXME("(%p) Something's still holding the implicit swapchain\n", This);
1949	}
1950	}
1951
1952	HeapFree(GetProcessHeap(), 0, This->swapchains);
1953	This->swapchains = NULL;
1954	This->NumberOfSwapChains = 0;
1955	return WINED3D_OK;
1956	}
1957
1958	/* Enables thread safety in the wined3d device and its resources. Called by DirectDraw
1959	* from SetCooperativeLevel if DDSCL_MULTITHREADED is specified, and by d3d8/9 from
1960	* CreateDevice if D3DCREATE_MULTITHREADED is passed.
1961	*
1962	* There is no way to deactivate thread safety once it is enabled.
1963	*/
1964	static void WINAPI IWineD3DDeviceImpl_SetMultithreaded(IWineD3DDevice *iface) {
1965	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
1966
1967	/For now just store the flag(needed in case of ddraw) /
1968	This->createParms.BehaviorFlags \|= WINED3DCREATE_MULTITHREADED;
1969	}
1970
1971	static HRESULT WINAPI IWineD3DDeviceImpl_SetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain,
1972	const WINED3DDISPLAYMODE* pMode) {
1973	DEVMODEW devmode;
1974	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1975	const struct wined3d_format_desc *format_desc = getFormatDescEntry(pMode->Format, &This->adapter->gl_info);
1976	LONG ret;
1977	RECT clip_rc;
1978
1979	TRACE("(%p)->(%d,%p) Mode=%dx%dx@%d, %s\n", This, iSwapChain, pMode, pMode->Width, pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1980
1981	/* Resize the screen even without a window:
1982	* The app could have unset it with SetCooperativeLevel, but not called
1983	* RestoreDisplayMode first. Then the release will call RestoreDisplayMode,
1984	* but we don't have any hwnd
1985	*/
1986
1987	memset(&devmode, 0, sizeof(devmode));
1988	devmode.dmSize = sizeof(devmode);
1989	devmode.dmFields = DM_BITSPERPEL \| DM_PELSWIDTH \| DM_PELSHEIGHT;
1990	devmode.dmBitsPerPel = format_desc->byte_count * 8;
1991	devmode.dmPelsWidth = pMode->Width;
1992	devmode.dmPelsHeight = pMode->Height;
1993
1994	devmode.dmDisplayFrequency = pMode->RefreshRate;
1995	if (pMode->RefreshRate != 0) {
1996	devmode.dmFields \|= DM_DISPLAYFREQUENCY;
1997	}
1998
1999	/* Only change the mode if necessary */
2000	if( (This->ddraw_width == pMode->Width) &&
2001	(This->ddraw_height == pMode->Height) &&
2002	(This->ddraw_format == pMode->Format) &&
2003	(pMode->RefreshRate == 0) ) {
2004	return WINED3D_OK;
2005	}
2006
2007	ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL);
2008	if (ret != DISP_CHANGE_SUCCESSFUL) {
2009	if(devmode.dmDisplayFrequency != 0) {
2010	WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate\n");
2011	devmode.dmFields &= ~DM_DISPLAYFREQUENCY;
2012	devmode.dmDisplayFrequency = 0;
2013	ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL;
2014	}
2015	if(ret != DISP_CHANGE_SUCCESSFUL) {
2016	return WINED3DERR_NOTAVAILABLE;
2017	}
2018	}
2019
2020	/* Store the new values */
2021	This->ddraw_width = pMode->Width;
2022	This->ddraw_height = pMode->Height;
2023	This->ddraw_format = pMode->Format;
2024
2025	/* And finally clip mouse to our screen */
2026	SetRect(&clip_rc, 0, 0, pMode->Width, pMode->Height);
2027	ClipCursor(&clip_rc);
2028
2029	return WINED3D_OK;
2030	}
2031
2032	static HRESULT WINAPI IWineD3DDeviceImpl_GetDirect3D(IWineD3DDevice iface, IWineD3D *ppD3D) {
2033	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2034	*ppD3D = This->wined3d;
2035	TRACE("Returning %p.\n", *ppD3D);
2036	IWineD3D_AddRef(*ppD3D);
2037	return WINED3D_OK;
2038	}
2039
2040	static UINT WINAPI IWineD3DDeviceImpl_GetAvailableTextureMem(IWineD3DDevice *iface) {
2041	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2042
2043	TRACE("(%p) : simulating %dMB, returning %dMB left\n", This,
2044	(This->adapter->TextureRam/(1024*1024)),
2045	((This->adapter->TextureRam - This->adapter->UsedTextureRam) / (1024*1024)));
2046	/* return simulated texture memory left */
2047	return (This->adapter->TextureRam - This->adapter->UsedTextureRam);
2048	}
2049
2050	/*****
2051	* Get / Set Stream Source
2052	*****/
2053	static HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,
2054	IWineD3DBuffer *pStreamData, UINT OffsetInBytes, UINT Stride)
2055	{
2056	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2057	IWineD3DBuffer *oldSrc;
2058
2059	if (StreamNumber >= MAX_STREAMS) {
2060	WARN("Stream out of range %d\n", StreamNumber);
2061	return WINED3DERR_INVALIDCALL;
2062	} else if(OffsetInBytes & 0x3) {
2063	WARN("OffsetInBytes is not 4 byte aligned: %d\n", OffsetInBytes);
2064	return WINED3DERR_INVALIDCALL;
2065	}
2066
2067	oldSrc = This->updateStateBlock->streamSource[StreamNumber];
2068	TRACE("(%p) : StreamNo: %u, OldStream (%p), NewStream (%p), OffsetInBytes %u, NewStride %u\n", This, StreamNumber, oldSrc, pStreamData, OffsetInBytes, Stride);
2069
2070	This->updateStateBlock->changed.streamSource \|= 1 << StreamNumber;
2071
2072	if(oldSrc == pStreamData &&
2073	This->updateStateBlock->streamStride[StreamNumber] == Stride &&
2074	This->updateStateBlock->streamOffset[StreamNumber] == OffsetInBytes) {
2075	TRACE("Application is setting the old values over, nothing to do\n");
2076	return WINED3D_OK;
2077	}
2078
2079	This->updateStateBlock->streamSource[StreamNumber] = pStreamData;
2080	if (pStreamData) {
2081	This->updateStateBlock->streamStride[StreamNumber] = Stride;
2082	This->updateStateBlock->streamOffset[StreamNumber] = OffsetInBytes;
2083	}
2084
2085	/* Handle recording of state blocks */
2086	if (This->isRecordingState) {
2087	TRACE("Recording... not performing anything\n");
2088	if (pStreamData) IWineD3DBuffer_AddRef(pStreamData);
2089	if (oldSrc) IWineD3DBuffer_Release(oldSrc);
2090	return WINED3D_OK;
2091	}
2092
2093	if (pStreamData != NULL) {
2094	InterlockedIncrement(&((struct wined3d_buffer *)pStreamData)->bind_count);
2095	IWineD3DBuffer_AddRef(pStreamData);
2096	}
2097	if (oldSrc != NULL) {
2098	InterlockedDecrement(&((struct wined3d_buffer *)oldSrc)->bind_count);
2099	IWineD3DBuffer_Release(oldSrc);
2100	}
2101
2102	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2103
2104	return WINED3D_OK;
2105	}
2106
2107	static HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSource(IWineD3DDevice *iface,
2108	UINT StreamNumber, IWineD3DBuffer *pStream, UINT pOffset, UINT *pStride)
2109	{
2110	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2111
2112	TRACE("(%p) : StreamNo: %u, Stream (%p), Offset %u, Stride %u\n", This, StreamNumber,
2113	This->stateBlock->streamSource[StreamNumber],
2114	This->stateBlock->streamOffset[StreamNumber],
2115	This->stateBlock->streamStride[StreamNumber]);
2116
2117	if (StreamNumber >= MAX_STREAMS) {
2118	WARN("Stream out of range %d\n", StreamNumber);
2119	return WINED3DERR_INVALIDCALL;
2120	}
2121	*pStream = This->stateBlock->streamSource[StreamNumber];
2122	*pStride = This->stateBlock->streamStride[StreamNumber];
2123	if (pOffset) {
2124	*pOffset = This->stateBlock->streamOffset[StreamNumber];
2125	}
2126
2127	if (*pStream != NULL) {
2128	IWineD3DBuffer_AddRef(pStream); / We have created a new reference to the VB */
2129	}
2130	return WINED3D_OK;
2131	}
2132
2133	static HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT Divider) {
2134	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2135	UINT oldFlags = This->updateStateBlock->streamFlags[StreamNumber];
2136	UINT oldFreq = This->updateStateBlock->streamFreq[StreamNumber];
2137
2138	/* Verify input at least in d3d9 this is invalid*/
2139	if( (Divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && (Divider & WINED3DSTREAMSOURCE_INDEXEDDATA)){
2140	WARN("INSTANCEDATA and INDEXEDDATA were set, returning D3DERR_INVALIDCALL\n");
2141	return WINED3DERR_INVALIDCALL;
2142	}
2143	if( (Divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && StreamNumber == 0 ){
2144	WARN("INSTANCEDATA used on stream 0, returning D3DERR_INVALIDCALL\n");
2145	return WINED3DERR_INVALIDCALL;
2146	}
2147	if( Divider == 0 ){
2148	WARN("Divider is 0, returning D3DERR_INVALIDCALL\n");
2149	return WINED3DERR_INVALIDCALL;
2150	}
2151
2152	TRACE("(%p) StreamNumber(%d), Divider(%d)\n", This, StreamNumber, Divider);
2153	This->updateStateBlock->streamFlags[StreamNumber] = Divider & (WINED3DSTREAMSOURCE_INSTANCEDATA \| WINED3DSTREAMSOURCE_INDEXEDDATA );
2154
2155	This->updateStateBlock->changed.streamFreq \|= 1 << StreamNumber;
2156	This->updateStateBlock->streamFreq[StreamNumber] = Divider & 0x7FFFFF;
2157
2158	if(This->updateStateBlock->streamFreq[StreamNumber] != oldFreq \|\|
2159	This->updateStateBlock->streamFlags[StreamNumber] != oldFlags) {
2160	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2161	}
2162
2163	return WINED3D_OK;
2164	}
2165
2166	static HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSourceFreq(IWineD3DDevice iface, UINT StreamNumber, UINT Divider) {
2167	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2168
2169	TRACE("(%p) StreamNumber(%d), Divider(%p)\n", This, StreamNumber, Divider);
2170	*Divider = This->updateStateBlock->streamFreq[StreamNumber] \| This->updateStateBlock->streamFlags[StreamNumber];
2171
2172	TRACE("(%p) : returning %d\n", This, *Divider);
2173
2174	return WINED3D_OK;
2175	}
2176
2177	/*****
2178	* Get / Set & Multiply Transform
2179	*****/
2180	static HRESULT WINAPI IWineD3DDeviceImpl_SetTransform(IWineD3DDevice iface, WINED3DTRANSFORMSTATETYPE d3dts, CONST WINED3DMATRIX lpmatrix) {
2181	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2182
2183	/* Most of this routine, comments included copied from ddraw tree initially: */
2184	TRACE("(%p) : Transform State=%s\n", This, debug_d3dtstype(d3dts));
2185
2186	/* Handle recording of state blocks */
2187	if (This->isRecordingState) {
2188	TRACE("Recording... not performing anything\n");
2189	This->updateStateBlock->changed.transform[d3dts >> 5] \|= 1 << (d3dts & 0x1f);
2190	This->updateStateBlock->transforms[d3dts] = *lpmatrix;
2191	return WINED3D_OK;
2192	}
2193
2194	/*
2195	* If the new matrix is the same as the current one,
2196	* we cut off any further processing. this seems to be a reasonable
2197	* optimization because as was noticed, some apps (warcraft3 for example)
2198	* tend towards setting the same matrix repeatedly for some reason.
2199	*
2200	* From here on we assume that the new matrix is different, wherever it matters.
2201	*/
2202	if (!memcmp(&This->stateBlock->transforms[d3dts].u.m[0][0], lpmatrix, sizeof(WINED3DMATRIX))) {
2203	TRACE("The app is setting the same matrix over again\n");
2204	return WINED3D_OK;
2205	} else {
2206	conv_mat(lpmatrix, &This->stateBlock->transforms[d3dts].u.m[0][0]);
2207	}
2208
2209	/*
2210	ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
2211	where ViewMat = Camera space, WorldMat = world space.
2212
2213	In OpenGL, camera and world space is combined into GL_MODELVIEW
2214	matrix. The Projection matrix stay projection matrix.
2215	*/
2216
2217	/* Capture the times we can just ignore the change for now */
2218	if (d3dts == WINED3DTS_VIEW) { /* handle the VIEW matrix */
2219	This->view_ident = !memcmp(lpmatrix, identity, 16 * sizeof(float));
2220	/* Handled by the state manager */
2221	}
2222
2223	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TRANSFORM(d3dts));
2224	return WINED3D_OK;
2225
2226	}
2227	static HRESULT WINAPI IWineD3DDeviceImpl_GetTransform(IWineD3DDevice iface, WINED3DTRANSFORMSTATETYPE State, WINED3DMATRIX pMatrix) {
2228	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2229	TRACE("(%p) : for Transform State %s\n", This, debug_d3dtstype(State));
2230	*pMatrix = This->stateBlock->transforms[State];
2231	return WINED3D_OK;
2232	}
2233
2234	static HRESULT WINAPI IWineD3DDeviceImpl_MultiplyTransform(IWineD3DDevice iface, WINED3DTRANSFORMSTATETYPE State, CONST WINED3DMATRIX pMatrix) {
2235	const WINED3DMATRIX *mat = NULL;
2236	WINED3DMATRIX temp;
2237
2238	/* Note: Using 'updateStateBlock' rather than 'stateblock' in the code
2239	* below means it will be recorded in a state block change, but it
2240	* works regardless where it is recorded.
2241	* If this is found to be wrong, change to StateBlock.
2242	*/
2243	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2244	TRACE("(%p) : For state %s\n", This, debug_d3dtstype(State));
2245
2246	if (State <= HIGHEST_TRANSFORMSTATE)
2247	{
2248	mat = &This->updateStateBlock->transforms[State];
2249	} else {
2250	FIXME("Unhandled transform state!!\n");
2251	}
2252
2253	multiply_matrix(&temp, mat, pMatrix);
2254
2255	/* Apply change via set transform - will reapply to eg. lights this way */
2256	return IWineD3DDeviceImpl_SetTransform(iface, State, &temp);
2257	}
2258
2259	/*****
2260	* Get / Set Light
2261	*****/
2262	/* Note lights are real special cases. Although the device caps state only eg. 8 are supported,
2263	you can reference any indexes you want as long as that number max are enabled at any
2264	one point in time! Therefore since the indexes can be anything, we need a hashmap of them.
2265	However, this causes stateblock problems. When capturing the state block, I duplicate the hashmap,
2266	but when recording, just build a chain pretty much of commands to be replayed. */
2267
2268	static HRESULT WINAPI IWineD3DDeviceImpl_SetLight(IWineD3DDevice iface, DWORD Index, CONST WINED3DLIGHT pLight) {
2269	float rho;
2270	struct wined3d_light_info *object = NULL;
2271	UINT Hi = LIGHTMAP_HASHFUNC(Index);
2272	struct list *e;
2273
2274	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2275	TRACE("(%p) : Idx(%d), pLight(%p). Hash index is %d\n", This, Index, pLight, Hi);
2276
2277	/* Check the parameter range. Need for speed most wanted sets junk lights which confuse
2278	* the gl driver.
2279	*/
2280	if(!pLight) {
2281	WARN("Light pointer = NULL, returning WINED3DERR_INVALIDCALL\n");
2282	return WINED3DERR_INVALIDCALL;
2283	}
2284
2285	switch(pLight->Type) {
2286	case WINED3DLIGHT_POINT:
2287	case WINED3DLIGHT_SPOT:
2288	case WINED3DLIGHT_PARALLELPOINT:
2289	case WINED3DLIGHT_GLSPOT:
2290	/* Incorrect attenuation values can cause the gl driver to crash. Happens with Need for speed
2291	* most wanted
2292	*/
2293	if (pLight->Attenuation0 < 0.0f \|\| pLight->Attenuation1 < 0.0f \|\| pLight->Attenuation2 < 0.0f)
2294	{
2295	WARN("Attenuation is negative, returning WINED3DERR_INVALIDCALL\n");
2296	return WINED3DERR_INVALIDCALL;
2297	}
2298	break;
2299
2300	case WINED3DLIGHT_DIRECTIONAL:
2301	/* Ignores attenuation */
2302	break;
2303
2304	default:
2305	WARN("Light type out of range, returning WINED3DERR_INVALIDCALL\n");
2306	return WINED3DERR_INVALIDCALL;
2307	}
2308
2309	LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi])
2310	{
2311	object = LIST_ENTRY(e, struct wined3d_light_info, entry);
2312	if(object->OriginalIndex == Index) break;
2313	object = NULL;
2314	}
2315
2316	if(!object) {
2317	TRACE("Adding new light\n");
2318	object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2319	if(!object) {
2320	ERR("Out of memory error when allocating a light\n");
2321	return E_OUTOFMEMORY;
2322	}
2323	list_add_head(&This->updateStateBlock->lightMap[Hi], &object->entry);
2324	object->glIndex = -1;
2325	object->OriginalIndex = Index;
2326	}
2327
2328	/* Initialize the object */
2329	TRACE("Light %d setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n", Index, pLight->Type,
2330	pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a,
2331	pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a,
2332	pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a);
2333	TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z,
2334	pLight->Direction.x, pLight->Direction.y, pLight->Direction.z);
2335	TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi);
2336
2337	/* Save away the information */
2338	object->OriginalParms = *pLight;
2339
2340	switch (pLight->Type) {
2341	case WINED3DLIGHT_POINT:
2342	/* Position */
2343	object->lightPosn[0] = pLight->Position.x;
2344	object->lightPosn[1] = pLight->Position.y;
2345	object->lightPosn[2] = pLight->Position.z;
2346	object->lightPosn[3] = 1.0f;
2347	object->cutoff = 180.0f;
2348	/* FIXME: Range */
2349	break;
2350
2351	case WINED3DLIGHT_DIRECTIONAL:
2352	/* Direction */
2353	object->lightPosn[0] = -pLight->Direction.x;
2354	object->lightPosn[1] = -pLight->Direction.y;
2355	object->lightPosn[2] = -pLight->Direction.z;
2356	object->lightPosn[3] = 0.0f;
2357	object->exponent = 0.0f;
2358	object->cutoff = 180.0f;
2359	break;
2360
2361	case WINED3DLIGHT_SPOT:
2362	/* Position */
2363	object->lightPosn[0] = pLight->Position.x;
2364	object->lightPosn[1] = pLight->Position.y;
2365	object->lightPosn[2] = pLight->Position.z;
2366	object->lightPosn[3] = 1.0f;
2367
2368	/* Direction */
2369	object->lightDirn[0] = pLight->Direction.x;
2370	object->lightDirn[1] = pLight->Direction.y;
2371	object->lightDirn[2] = pLight->Direction.z;
2372	object->lightDirn[3] = 1.0f;
2373
2374	/*
2375	* opengl-ish and d3d-ish spot lights use too different models for the
2376	* light "intensity" as a function of the angle towards the main light direction,
2377	* so we only can approximate very roughly.
2378	* however spot lights are rather rarely used in games (if ever used at all).
2379	* furthermore if still used, probably nobody pays attention to such details.
2380	*/
2381	if (pLight->Falloff == 0) {
2382	/* Falloff = 0 is easy, because d3d's and opengl's spot light equations have the
2383	* falloff resp. exponent parameter as an exponent, so the spot light lighting
2384	* will always be 1.0 for both of them, and we don't have to care for the
2385	* rest of the rather complex calculation
2386	*/
2387	object->exponent = 0.0f;
2388	} else {
2389	rho = pLight->Theta + (pLight->Phi - pLight->Theta)/(2*pLight->Falloff);
2390	if (rho < 0.0001f) rho = 0.0001f;
2391	object->exponent = -0.3f/log(cos(rho/2));
2392	}
2393	if (object->exponent > 128.0f)
2394	{
2395	object->exponent = 128.0f;
2396	}
2397	object->cutoff = pLight->Phi*90/M_PI;
2398
2399	/* FIXME: Range */
2400	break;
2401
2402	default:
2403	FIXME("Unrecognized light type %d\n", pLight->Type);
2404	}
2405
2406	/* Update the live definitions if the light is currently assigned a glIndex */
2407	if (object->glIndex != -1 && !This->isRecordingState) {
2408	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(object->glIndex));
2409	}
2410	return WINED3D_OK;
2411	}
2412
2413	static HRESULT WINAPI IWineD3DDeviceImpl_GetLight(IWineD3DDevice iface, DWORD Index, WINED3DLIGHT pLight)
2414	{
2415	struct wined3d_light_info *lightInfo = NULL;
2416	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2417	DWORD Hi = LIGHTMAP_HASHFUNC(Index);
2418	struct list *e;
2419	TRACE("(%p) : Idx(%d), pLight(%p)\n", This, Index, pLight);
2420
2421	LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi])
2422	{
2423	lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
2424	if(lightInfo->OriginalIndex == Index) break;
2425	lightInfo = NULL;
2426	}
2427
2428	if (lightInfo == NULL) {
2429	TRACE("Light information requested but light not defined\n");
2430	return WINED3DERR_INVALIDCALL;
2431	}
2432
2433	*pLight = lightInfo->OriginalParms;
2434	return WINED3D_OK;
2435	}
2436
2437	/*****
2438	* Get / Set Light Enable
2439	* (Note for consistency, renamed d3dx function by adding the 'set' prefix)
2440	*****/
2441	static HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, DWORD Index, BOOL Enable)
2442	{
2443	struct wined3d_light_info *lightInfo = NULL;
2444	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2445	UINT Hi = LIGHTMAP_HASHFUNC(Index);
2446	struct list *e;
2447	TRACE("(%p) : Idx(%d), enable? %d\n", This, Index, Enable);
2448
2449	LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi])
2450	{
2451	lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
2452	if(lightInfo->OriginalIndex == Index) break;
2453	lightInfo = NULL;
2454	}
2455	TRACE("Found light: %p\n", lightInfo);
2456
2457	/* Special case - enabling an undefined light creates one with a strict set of parms! */
2458	if (lightInfo == NULL) {
2459
2460	TRACE("Light enabled requested but light not defined, so defining one!\n");
2461	IWineD3DDeviceImpl_SetLight(iface, Index, &WINED3D_default_light);
2462
2463	/* Search for it again! Should be fairly quick as near head of list */
2464	LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi])
2465	{
2466	lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
2467	if(lightInfo->OriginalIndex == Index) break;
2468	lightInfo = NULL;
2469	}
2470	if (lightInfo == NULL) {
2471	FIXME("Adding default lights has failed dismally\n");
2472	return WINED3DERR_INVALIDCALL;
2473	}
2474	}
2475
2476	if(!Enable) {
2477	if(lightInfo->glIndex != -1) {
2478	if(!This->isRecordingState) {
2479	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(lightInfo->glIndex));
2480	}
2481
2482	This->updateStateBlock->activeLights[lightInfo->glIndex] = NULL;
2483	lightInfo->glIndex = -1;
2484	} else {
2485	TRACE("Light already disabled, nothing to do\n");
2486	}
2487	lightInfo->enabled = FALSE;
2488	} else {
2489	lightInfo->enabled = TRUE;
2490	if (lightInfo->glIndex != -1) {
2491	/* nop */
2492	TRACE("Nothing to do as light was enabled\n");
2493	} else {
2494	int i;
2495	/* Find a free gl light */
2496	for(i = 0; i < This->maxConcurrentLights; i++) {
2497	if(This->updateStateBlock->activeLights[i] == NULL) {
2498	This->updateStateBlock->activeLights[i] = lightInfo;
2499	lightInfo->glIndex = i;
2500	break;
2501	}
2502	}
2503	if(lightInfo->glIndex == -1) {
2504	/* Our tests show that Windows returns D3D_OK in this situation, even with
2505	* D3DCREATE_HARDWARE_VERTEXPROCESSING \| D3DCREATE_PUREDEVICE devices. This
2506	* is consistent among ddraw, d3d8 and d3d9. GetLightEnable returns TRUE
2507	* as well for those lights.
2508	*
2509	* TODO: Test how this affects rendering
2510	*/
2511	WARN("Too many concurrently active lights\n");
2512	return WINED3D_OK;
2513	}
2514
2515	/* i == lightInfo->glIndex */
2516	if(!This->isRecordingState) {
2517	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(i));
2518	}
2519	}
2520	}
2521
2522	return WINED3D_OK;
2523	}
2524
2525	static HRESULT WINAPI IWineD3DDeviceImpl_GetLightEnable(IWineD3DDevice iface, DWORD Index,BOOL pEnable)
2526	{
2527	struct wined3d_light_info *lightInfo = NULL;
2528	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2529	struct list *e;
2530	UINT Hi = LIGHTMAP_HASHFUNC(Index);
2531	TRACE("(%p) : for idx(%d)\n", This, Index);
2532
2533	LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi])
2534	{
2535	lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
2536	if(lightInfo->OriginalIndex == Index) break;
2537	lightInfo = NULL;
2538	}
2539
2540	if (lightInfo == NULL) {
2541	TRACE("Light enabled state requested but light not defined\n");
2542	return WINED3DERR_INVALIDCALL;
2543	}
2544	/* true is 128 according to SetLightEnable */
2545	*pEnable = lightInfo->enabled ? 128 : 0;
2546	return WINED3D_OK;
2547	}
2548
2549	/*****
2550	* Get / Set Clip Planes
2551	*****/
2552	static HRESULT WINAPI IWineD3DDeviceImpl_SetClipPlane(IWineD3DDevice iface, DWORD Index, CONST float pPlane) {
2553	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2554	TRACE("(%p) : for idx %d, %p\n", This, Index, pPlane);
2555
2556	/* Validate Index */
2557	if (Index >= This->adapter->gl_info.limits.clipplanes)
2558	{
2559	TRACE("Application has requested clipplane this device doesn't support\n");
2560	return WINED3DERR_INVALIDCALL;
2561	}
2562
2563	This->updateStateBlock->changed.clipplane \|= 1 << Index;
2564
2565	if(This->updateStateBlock->clipplane[Index][0] == pPlane[0] &&
2566	This->updateStateBlock->clipplane[Index][1] == pPlane[1] &&
2567	This->updateStateBlock->clipplane[Index][2] == pPlane[2] &&
2568	This->updateStateBlock->clipplane[Index][3] == pPlane[3]) {
2569	TRACE("Application is setting old values over, nothing to do\n");
2570	return WINED3D_OK;
2571	}
2572
2573	This->updateStateBlock->clipplane[Index][0] = pPlane[0];
2574	This->updateStateBlock->clipplane[Index][1] = pPlane[1];
2575	This->updateStateBlock->clipplane[Index][2] = pPlane[2];
2576	This->updateStateBlock->clipplane[Index][3] = pPlane[3];
2577
2578	/* Handle recording of state blocks */
2579	if (This->isRecordingState) {
2580	TRACE("Recording... not performing anything\n");
2581	return WINED3D_OK;
2582	}
2583
2584	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_CLIPPLANE(Index));
2585
2586	return WINED3D_OK;
2587	}
2588
2589	static HRESULT WINAPI IWineD3DDeviceImpl_GetClipPlane(IWineD3DDevice iface, DWORD Index, float pPlane) {
2590	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2591	TRACE("(%p) : for idx %d\n", This, Index);
2592
2593	/* Validate Index */
2594	if (Index >= This->adapter->gl_info.limits.clipplanes)
2595	{
2596	TRACE("Application has requested clipplane this device doesn't support\n");
2597	return WINED3DERR_INVALIDCALL;
2598	}
2599
2600	pPlane[0] = This->stateBlock->clipplane[Index][0];
2601	pPlane[1] = This->stateBlock->clipplane[Index][1];
2602	pPlane[2] = This->stateBlock->clipplane[Index][2];
2603	pPlane[3] = This->stateBlock->clipplane[Index][3];
2604	return WINED3D_OK;
2605	}
2606
2607	/*****
2608	* Get / Set Clip Plane Status
2609	* WARNING: This code relies on the fact that D3DCLIPSTATUS8 == D3DCLIPSTATUS9
2610	*****/
2611	static HRESULT WINAPI IWineD3DDeviceImpl_SetClipStatus(IWineD3DDevice iface, CONST WINED3DCLIPSTATUS pClipStatus) {
2612	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2613	FIXME("(%p) : stub\n", This);
2614	if (NULL == pClipStatus) {
2615	return WINED3DERR_INVALIDCALL;
2616	}
2617	This->updateStateBlock->clip_status.ClipUnion = pClipStatus->ClipUnion;
2618	This->updateStateBlock->clip_status.ClipIntersection = pClipStatus->ClipIntersection;
2619	return WINED3D_OK;
2620	}
2621
2622	static HRESULT WINAPI IWineD3DDeviceImpl_GetClipStatus(IWineD3DDevice iface, WINED3DCLIPSTATUS pClipStatus) {
2623	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2624	FIXME("(%p) : stub\n", This);
2625	if (NULL == pClipStatus) {
2626	return WINED3DERR_INVALIDCALL;
2627	}
2628	pClipStatus->ClipUnion = This->updateStateBlock->clip_status.ClipUnion;
2629	pClipStatus->ClipIntersection = This->updateStateBlock->clip_status.ClipIntersection;
2630	return WINED3D_OK;
2631	}
2632
2633	/*****
2634	* Get / Set Material
2635	*****/
2636	static HRESULT WINAPI IWineD3DDeviceImpl_SetMaterial(IWineD3DDevice iface, CONST WINED3DMATERIAL pMaterial) {
2637	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2638
2639	This->updateStateBlock->changed.material = TRUE;
2640	This->updateStateBlock->material = *pMaterial;
2641
2642	/* Handle recording of state blocks */
2643	if (This->isRecordingState) {
2644	TRACE("Recording... not performing anything\n");
2645	return WINED3D_OK;
2646	}
2647
2648	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_MATERIAL);
2649	return WINED3D_OK;
2650	}
2651
2652	static HRESULT WINAPI IWineD3DDeviceImpl_GetMaterial(IWineD3DDevice iface, WINED3DMATERIAL pMaterial) {
2653	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2654	*pMaterial = This->updateStateBlock->material;
2655	TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g,
2656	pMaterial->Diffuse.b, pMaterial->Diffuse.a);
2657	TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g,
2658	pMaterial->Ambient.b, pMaterial->Ambient.a);
2659	TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g,
2660	pMaterial->Specular.b, pMaterial->Specular.a);
2661	TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g,
2662	pMaterial->Emissive.b, pMaterial->Emissive.a);
2663	TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
2664
2665	return WINED3D_OK;
2666	}
2667
2668	/*****
2669	* Get / Set Indices
2670	*****/
2671	static HRESULT WINAPI IWineD3DDeviceImpl_SetIndexBuffer(IWineD3DDevice *iface,
2672	IWineD3DBuffer *pIndexData, WINED3DFORMAT fmt)
2673	{
2674	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2675	IWineD3DBuffer *oldIdxs;
2676
2677	TRACE("(%p) : Setting to %p\n", This, pIndexData);
2678	oldIdxs = This->updateStateBlock->pIndexData;
2679
2680	This->updateStateBlock->changed.indices = TRUE;
2681	This->updateStateBlock->pIndexData = pIndexData;
2682	This->updateStateBlock->IndexFmt = fmt;
2683
2684	/* Handle recording of state blocks */
2685	if (This->isRecordingState) {
2686	TRACE("Recording... not performing anything\n");
2687	if(pIndexData) IWineD3DBuffer_AddRef(pIndexData);
2688	if(oldIdxs) IWineD3DBuffer_Release(oldIdxs);
2689	return WINED3D_OK;
2690	}
2691
2692	if(oldIdxs != pIndexData) {
2693	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
2694	if(pIndexData) {
2695	InterlockedIncrement(&((struct wined3d_buffer *)pIndexData)->bind_count);
2696	IWineD3DBuffer_AddRef(pIndexData);
2697	}
2698	if(oldIdxs) {
2699	InterlockedDecrement(&((struct wined3d_buffer *)oldIdxs)->bind_count);
2700	IWineD3DBuffer_Release(oldIdxs);
2701	}
2702	}
2703
2704	return WINED3D_OK;
2705	}
2706
2707	static HRESULT WINAPI IWineD3DDeviceImpl_GetIndexBuffer(IWineD3DDevice iface, IWineD3DBuffer *ppIndexData)
2708	{
2709	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2710
2711	*ppIndexData = This->stateBlock->pIndexData;
2712
2713	/* up ref count on ppindexdata */
2714	if (*ppIndexData) {
2715	IWineD3DBuffer_AddRef(*ppIndexData);
2716	TRACE("(%p) index data set to %p\n", This, ppIndexData);
2717	}else{
2718	TRACE("(%p) No index data set\n", This);
2719	}
2720	TRACE("Returning %p\n", *ppIndexData);
2721
2722	return WINED3D_OK;
2723	}
2724
2725	/* Method to offer d3d9 a simple way to set the base vertex index without messing with the index buffer */
2726	static HRESULT WINAPI IWineD3DDeviceImpl_SetBaseVertexIndex(IWineD3DDevice *iface, INT BaseIndex) {
2727	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2728	TRACE("(%p)->(%d)\n", This, BaseIndex);
2729
2730	if(This->updateStateBlock->baseVertexIndex == BaseIndex) {
2731	TRACE("Application is setting the old value over, nothing to do\n");
2732	return WINED3D_OK;
2733	}
2734
2735	This->updateStateBlock->baseVertexIndex = BaseIndex;
2736
2737	if (This->isRecordingState) {
2738	TRACE("Recording... not performing anything\n");
2739	return WINED3D_OK;
2740	}
2741	/* The base vertex index affects the stream sources */
2742	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2743	return WINED3D_OK;
2744	}
2745
2746	static HRESULT WINAPI IWineD3DDeviceImpl_GetBaseVertexIndex(IWineD3DDevice iface, INT base_index) {
2747	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2748	TRACE("(%p) : base_index %p\n", This, base_index);
2749
2750	*base_index = This->stateBlock->baseVertexIndex;
2751
2752	TRACE("Returning %u\n", *base_index);
2753
2754	return WINED3D_OK;
2755	}
2756
2757	/*****
2758	* Get / Set Viewports
2759	*****/
2760	static HRESULT WINAPI IWineD3DDeviceImpl_SetViewport(IWineD3DDevice iface, CONST WINED3DVIEWPORT pViewport) {
2761	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2762
2763	TRACE("(%p)\n", This);
2764	This->updateStateBlock->changed.viewport = TRUE;
2765	This->updateStateBlock->viewport = *pViewport;
2766
2767	/* Handle recording of state blocks */
2768	if (This->isRecordingState) {
2769	TRACE("Recording... not performing anything\n");
2770	return WINED3D_OK;
2771	}
2772
2773	TRACE("(%p) : x=%d, y=%d, wid=%d, hei=%d, minz=%f, maxz=%f\n", This,
2774	pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ);
2775
2776	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VIEWPORT);
2777	return WINED3D_OK;
2778
2779	}
2780
2781	static HRESULT WINAPI IWineD3DDeviceImpl_GetViewport(IWineD3DDevice iface, WINED3DVIEWPORT pViewport) {
2782	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2783	TRACE("(%p)\n", This);
2784	*pViewport = This->stateBlock->viewport;
2785	return WINED3D_OK;
2786	}
2787
2788	/*****
2789	* Get / Set Render States
2790	* TODO: Verify against dx9 definitions
2791	*****/
2792	static HRESULT WINAPI IWineD3DDeviceImpl_SetRenderState(IWineD3DDevice *iface, WINED3DRENDERSTATETYPE State, DWORD Value) {
2793
2794	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2795	DWORD oldValue = This->stateBlock->renderState[State];
2796
2797	TRACE("(%p)->state = %s(%d), value = %d\n", This, debug_d3drenderstate(State), State, Value);
2798
2799	This->updateStateBlock->changed.renderState[State >> 5] \|= 1 << (State & 0x1f);
2800	This->updateStateBlock->renderState[State] = Value;
2801
2802	/* Handle recording of state blocks */
2803	if (This->isRecordingState) {
2804	TRACE("Recording... not performing anything\n");
2805	return WINED3D_OK;
2806	}
2807
2808	/* Compared here and not before the assignment to allow proper stateblock recording */
2809	if(Value == oldValue) {
2810	TRACE("Application is setting the old value over, nothing to do\n");
2811	} else {
2812	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(State));
2813	}
2814
2815	return WINED3D_OK;
2816	}
2817
2818	static HRESULT WINAPI IWineD3DDeviceImpl_GetRenderState(IWineD3DDevice iface, WINED3DRENDERSTATETYPE State, DWORD pValue) {
2819	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2820	TRACE("(%p) for State %d = %d\n", This, State, This->stateBlock->renderState[State]);
2821	*pValue = This->stateBlock->renderState[State];
2822	return WINED3D_OK;
2823	}
2824
2825	/*****
2826	* Get / Set Sampler States
2827	* TODO: Verify against dx9 definitions
2828	*****/
2829
2830	static HRESULT WINAPI IWineD3DDeviceImpl_SetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD Value) {
2831	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2832	DWORD oldValue;
2833
2834	TRACE("(%p) : Sampler %#x, Type %s (%#x), Value %#x\n",
2835	This, Sampler, debug_d3dsamplerstate(Type), Type, Value);
2836
2837	if (Sampler >= WINED3DVERTEXTEXTURESAMPLER0 && Sampler <= WINED3DVERTEXTEXTURESAMPLER3) {
2838	Sampler -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
2839	}
2840
2841	if (Sampler >= sizeof(This->stateBlock->samplerState)/sizeof(This->stateBlock->samplerState[0])) {
2842	ERR("Current Sampler overflows sampleState0 array (sampler %d)\n", Sampler);
2843	return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
2844	}
2845	/**
2846	* SetSampler is designed to allow for more than the standard up to 8 textures
2847	* and Geforce has stopped supporting more than 6 standard textures in openGL.
2848	* So I have to use ARB for Gforce. (maybe if the sampler > 4 then use ARB?)
2849	*
2850	* http://developer.nvidia.com/object/General_FAQ.html#t6
2851	*
2852	* There are two new settings for GForce
2853	* the sampler one:
2854	* GL_MAX_TEXTURE_IMAGE_UNITS_ARB
2855	* and the texture one:
2856	* GL_MAX_TEXTURE_COORDS_ARB.
2857	* Ok GForce say it's ok to use glTexParameter/glGetTexParameter(...).
2858	******************/
2859
2860	oldValue = This->stateBlock->samplerState[Sampler][Type];
2861	This->updateStateBlock->samplerState[Sampler][Type] = Value;
2862	This->updateStateBlock->changed.samplerState[Sampler] \|= 1 << Type;
2863
2864	/* Handle recording of state blocks */
2865	if (This->isRecordingState) {
2866	TRACE("Recording... not performing anything\n");
2867	return WINED3D_OK;
2868	}
2869
2870	if(oldValue == Value) {
2871	TRACE("Application is setting the old value over, nothing to do\n");
2872	return WINED3D_OK;
2873	}
2874
2875	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(Sampler));
2876
2877	return WINED3D_OK;
2878	}
2879
2880	static HRESULT WINAPI IWineD3DDeviceImpl_GetSamplerState(IWineD3DDevice iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD Value) {
2881	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2882
2883	TRACE("(%p) : Sampler %#x, Type %s (%#x)\n",
2884	This, Sampler, debug_d3dsamplerstate(Type), Type);
2885
2886	if (Sampler >= WINED3DVERTEXTEXTURESAMPLER0 && Sampler <= WINED3DVERTEXTEXTURESAMPLER3) {
2887	Sampler -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
2888	}
2889
2890	if (Sampler >= sizeof(This->stateBlock->samplerState)/sizeof(This->stateBlock->samplerState[0])) {
2891	ERR("Current Sampler overflows sampleState0 array (sampler %d)\n", Sampler);
2892	return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
2893	}
2894	*Value = This->stateBlock->samplerState[Sampler][Type];
2895	TRACE("(%p) : Returning %#x\n", This, *Value);
2896
2897	return WINED3D_OK;
2898	}
2899
2900	static HRESULT WINAPI IWineD3DDeviceImpl_SetScissorRect(IWineD3DDevice iface, CONST RECT pRect) {
2901	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2902
2903	This->updateStateBlock->changed.scissorRect = TRUE;
2904	if(EqualRect(&This->updateStateBlock->scissorRect, pRect)) {
2905	TRACE("App is setting the old scissor rectangle over, nothing to do\n");
2906	return WINED3D_OK;
2907	}
2908	CopyRect(&This->updateStateBlock->scissorRect, pRect);
2909
2910	if(This->isRecordingState) {
2911	TRACE("Recording... not performing anything\n");
2912	return WINED3D_OK;
2913	}
2914
2915	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SCISSORRECT);
2916
2917	return WINED3D_OK;
2918	}
2919
2920	static HRESULT WINAPI IWineD3DDeviceImpl_GetScissorRect(IWineD3DDevice iface, RECT pRect) {
2921	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2922
2923	*pRect = This->updateStateBlock->scissorRect;
2924	TRACE("(%p)Returning a Scissor Rect of %d:%d-%d:%d\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom);
2925	return WINED3D_OK;
2926	}
2927
2928	static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration* pDecl) {
2929	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
2930	IWineD3DVertexDeclaration *oldDecl = This->updateStateBlock->vertexDecl;
2931
2932	TRACE("(%p) : pDecl=%p\n", This, pDecl);
2933
2934	if (pDecl) IWineD3DVertexDeclaration_AddRef(pDecl);
2935	if (oldDecl) IWineD3DVertexDeclaration_Release(oldDecl);
2936
2937	This->updateStateBlock->vertexDecl = pDecl;
2938	This->updateStateBlock->changed.vertexDecl = TRUE;
2939
2940	if (This->isRecordingState) {
2941	TRACE("Recording... not performing anything\n");
2942	return WINED3D_OK;
2943	} else if(pDecl == oldDecl) {
2944	/* Checked after the assignment to allow proper stateblock recording */
2945	TRACE("Application is setting the old declaration over, nothing to do\n");
2946	return WINED3D_OK;
2947	}
2948
2949	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
2950	return WINED3D_OK;
2951	}
2952
2953	static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppDecl) {
2954	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2955
2956	TRACE("(%p) : ppDecl=%p\n", This, ppDecl);
2957
2958	*ppDecl = This->stateBlock->vertexDecl;
2959	if (NULL != ppDecl) IWineD3DVertexDeclaration_AddRef(ppDecl);
2960	return WINED3D_OK;
2961	}
2962
2963	static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice iface, IWineD3DVertexShader pShader) {
2964	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2965	IWineD3DVertexShader* oldShader = This->updateStateBlock->vertexShader;
2966
2967	This->updateStateBlock->vertexShader = pShader;
2968	This->updateStateBlock->changed.vertexShader = TRUE;
2969
2970	if (This->isRecordingState) {
2971	if(pShader) IWineD3DVertexShader_AddRef(pShader);
2972	if(oldShader) IWineD3DVertexShader_Release(oldShader);
2973	TRACE("Recording... not performing anything\n");
2974	return WINED3D_OK;
2975	} else if(oldShader == pShader) {
2976	/* Checked here to allow proper stateblock recording */
2977	TRACE("App is setting the old shader over, nothing to do\n");
2978	return WINED3D_OK;
2979	}
2980
2981	TRACE("(%p) : setting pShader(%p)\n", This, pShader);
2982	if(pShader) IWineD3DVertexShader_AddRef(pShader);
2983	if(oldShader) IWineD3DVertexShader_Release(oldShader);
2984
2985	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VSHADER);
2986
2987	return WINED3D_OK;
2988	}
2989
2990	static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShader(IWineD3DDevice iface, IWineD3DVertexShader* ppShader) {
2991	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
2992
2993	if (NULL == ppShader) {
2994	return WINED3DERR_INVALIDCALL;
2995	}
2996	*ppShader = This->stateBlock->vertexShader;
2997	if( NULL != *ppShader)
2998	IWineD3DVertexShader_AddRef(*ppShader);
2999
3000	TRACE("(%p) : returning %p\n", This, *ppShader);
3001	return WINED3D_OK;
3002	}
3003
3004	static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(
3005	IWineD3DDevice *iface,
3006	UINT start,
3007	CONST BOOL *srcData,
3008	UINT count) {
3009
3010	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3011	unsigned int i, cnt = min(count, MAX_CONST_B - start);
3012
3013	TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3014	iface, srcData, start, count);
3015
3016	if (!srcData \|\| start >= MAX_CONST_B) return WINED3DERR_INVALIDCALL;
3017
3018	memcpy(&This->updateStateBlock->vertexShaderConstantB[start], srcData, cnt * sizeof(BOOL));
3019	for (i = 0; i < cnt; i++)
3020	TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
3021
3022	for (i = start; i < cnt + start; ++i) {
3023	This->updateStateBlock->changed.vertexShaderConstantsB \|= (1 << i);
3024	}
3025
3026	if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3027
3028	return WINED3D_OK;
3029	}
3030
3031	static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(
3032	IWineD3DDevice *iface,
3033	UINT start,
3034	BOOL *dstData,
3035	UINT count) {
3036
3037	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3038	int cnt = min(count, MAX_CONST_B - start);
3039
3040	TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3041	iface, dstData, start, count);
3042
3043	if (dstData == NULL \|\| cnt < 0)
3044	return WINED3DERR_INVALIDCALL;
3045
3046	memcpy(dstData, &This->stateBlock->vertexShaderConstantB[start], cnt * sizeof(BOOL));
3047	return WINED3D_OK;
3048	}
3049
3050	static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(
3051	IWineD3DDevice *iface,
3052	UINT start,
3053	CONST int *srcData,
3054	UINT count) {
3055
3056	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3057	unsigned int i, cnt = min(count, MAX_CONST_I - start);
3058
3059	TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3060	iface, srcData, start, count);
3061
3062	if (!srcData \|\| start >= MAX_CONST_I) return WINED3DERR_INVALIDCALL;
3063
3064	memcpy(&This->updateStateBlock->vertexShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
3065	for (i = 0; i < cnt; i++)
3066	TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
3067	srcData[i4], srcData[i4+1], srcData[i4+2], srcData[i4+3]);
3068
3069	for (i = start; i < cnt + start; ++i) {
3070	This->updateStateBlock->changed.vertexShaderConstantsI \|= (1 << i);
3071	}
3072
3073	if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3074
3075	return WINED3D_OK;
3076	}
3077
3078	static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(
3079	IWineD3DDevice *iface,
3080	UINT start,
3081	int *dstData,
3082	UINT count) {
3083
3084	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3085	int cnt = min(count, MAX_CONST_I - start);
3086
3087	TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3088	iface, dstData, start, count);
3089
3090	if (dstData == NULL \|\| ((signed int) MAX_CONST_I - (signed int) start) <= 0)
3091	return WINED3DERR_INVALIDCALL;
3092
3093	memcpy(dstData, &This->stateBlock->vertexShaderConstantI[start * 4], cnt * sizeof(int) * 4);
3094	return WINED3D_OK;
3095	}
3096
3097	static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(
3098	IWineD3DDevice *iface,
3099	UINT start,
3100	CONST float *srcData,
3101	UINT count) {
3102
3103	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3104	UINT i;
3105
3106	TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3107	iface, srcData, start, count);
3108
3109	/* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3110	if (srcData == NULL \|\| start + count > This->d3d_vshader_constantF \|\| start > This->d3d_vshader_constantF)
3111	return WINED3DERR_INVALIDCALL;
3112
3113	memcpy(&This->updateStateBlock->vertexShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3114	if(TRACE_ON(d3d)) {
3115	for (i = 0; i < count; i++)
3116	TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3117	srcData[i4], srcData[i4+1], srcData[i4+2], srcData[i4+3]);
3118	}
3119
3120	if (!This->isRecordingState)
3121	{
3122	This->shader_backend->shader_update_float_vertex_constants(iface, start, count);
3123	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3124	}
3125
3126	memset(This->updateStateBlock->changed.vertexShaderConstantsF + start, 1,
3127	sizeof(This->updateStateBlock->changed.vertexShaderConstantsF) count);
3128
3129	return WINED3D_OK;
3130	}
3131
3132	static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(
3133	IWineD3DDevice *iface,
3134	UINT start,
3135	float *dstData,
3136	UINT count) {
3137
3138	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3139	int cnt = min(count, This->d3d_vshader_constantF - start);
3140
3141	TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3142	iface, dstData, start, count);
3143
3144	if (dstData == NULL \|\| cnt < 0)
3145	return WINED3DERR_INVALIDCALL;
3146
3147	memcpy(dstData, &This->stateBlock->vertexShaderConstantF[start * 4], cnt * sizeof(float) * 4);
3148	return WINED3D_OK;
3149	}
3150
3151	static inline void markTextureStagesDirty(IWineD3DDeviceImpl *This, DWORD stage) {
3152	DWORD i;
3153	for(i = 0; i <= WINED3D_HIGHEST_TEXTURE_STATE; ++i)
3154	{
3155	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, i));
3156	}
3157	}
3158
3159	static void device_map_stage(IWineD3DDeviceImpl *This, DWORD stage, DWORD unit)
3160	{
3161	DWORD i = This->rev_tex_unit_map[unit];
3162	DWORD j = This->texUnitMap[stage];
3163
3164	This->texUnitMap[stage] = unit;
3165	if (i != WINED3D_UNMAPPED_STAGE && i != stage)
3166	{
3167	This->texUnitMap[i] = WINED3D_UNMAPPED_STAGE;
3168	}
3169
3170	This->rev_tex_unit_map[unit] = stage;
3171	if (j != WINED3D_UNMAPPED_STAGE && j != unit)
3172	{
3173	This->rev_tex_unit_map[j] = WINED3D_UNMAPPED_STAGE;
3174	}
3175	}
3176
3177	static void device_update_fixed_function_usage_map(IWineD3DDeviceImpl *This) {
3178	int i;
3179
3180	This->fixed_function_usage_map = 0;
3181	for (i = 0; i < MAX_TEXTURES; ++i) {
3182	WINED3DTEXTUREOP color_op = This->stateBlock->textureState[i][WINED3DTSS_COLOROP];
3183	WINED3DTEXTUREOP alpha_op = This->stateBlock->textureState[i][WINED3DTSS_ALPHAOP];
3184	DWORD color_arg1 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG1] & WINED3DTA_SELECTMASK;
3185	DWORD color_arg2 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG2] & WINED3DTA_SELECTMASK;
3186	DWORD color_arg3 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG0] & WINED3DTA_SELECTMASK;
3187	DWORD alpha_arg1 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG1] & WINED3DTA_SELECTMASK;
3188	DWORD alpha_arg2 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG2] & WINED3DTA_SELECTMASK;
3189	DWORD alpha_arg3 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG0] & WINED3DTA_SELECTMASK;
3190
3191	if (color_op == WINED3DTOP_DISABLE) {
3192	/* Not used, and disable higher stages */
3193	break;
3194	}
3195
3196	if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG2)
3197	\|\| ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG1)
3198	\|\| ((color_arg3 == WINED3DTA_TEXTURE) && (color_op == WINED3DTOP_MULTIPLYADD \|\| color_op == WINED3DTOP_LERP))
3199	\|\| ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG2)
3200	\|\| ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG1)
3201	\|\| ((alpha_arg3 == WINED3DTA_TEXTURE) && (alpha_op == WINED3DTOP_MULTIPLYADD \|\| alpha_op == WINED3DTOP_LERP))) {
3202	This->fixed_function_usage_map \|= (1 << i);
3203	}
3204
3205	if ((color_op == WINED3DTOP_BUMPENVMAP \|\| color_op == WINED3DTOP_BUMPENVMAPLUMINANCE) && i < MAX_TEXTURES - 1) {
3206	This->fixed_function_usage_map \|= (1 << (i + 1));
3207	}
3208	}
3209	}
3210
3211	static void device_map_fixed_function_samplers(IWineD3DDeviceImpl This, const struct wined3d_gl_info gl_info)
3212	{
3213	unsigned int i, tex;
3214	WORD ffu_map;
3215
3216	device_update_fixed_function_usage_map(This);
3217	ffu_map = This->fixed_function_usage_map;
3218
3219	if (This->max_ffp_textures == gl_info->limits.texture_stages
3220	\|\| This->stateBlock->lowest_disabled_stage <= This->max_ffp_textures)
3221	{
3222	for (i = 0; ffu_map; ffu_map >>= 1, ++i)
3223	{
3224	if (!(ffu_map & 1)) continue;
3225
3226	if (This->texUnitMap[i] != i) {
3227	device_map_stage(This, i, i);
3228	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3229	markTextureStagesDirty(This, i);
3230	}
3231	}
3232	return;
3233	}
3234
3235	/* Now work out the mapping */
3236	tex = 0;
3237	for (i = 0; ffu_map; ffu_map >>= 1, ++i)
3238	{
3239	if (!(ffu_map & 1)) continue;
3240
3241	if (This->texUnitMap[i] != tex) {
3242	device_map_stage(This, i, tex);
3243	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3244	markTextureStagesDirty(This, i);
3245	}
3246
3247	++tex;
3248	}
3249	}
3250
3251	static void device_map_psamplers(IWineD3DDeviceImpl This, const struct wined3d_gl_info gl_info)
3252	{
3253	const WINED3DSAMPLER_TEXTURE_TYPE *sampler_type =
3254	((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.reg_maps.sampler_type;
3255	unsigned int i;
3256
3257	for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
3258	if (sampler_type[i] && This->texUnitMap[i] != i)
3259	{
3260	device_map_stage(This, i, i);
3261	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3262	if (i < gl_info->limits.texture_stages)
3263	{
3264	markTextureStagesDirty(This, i);
3265	}
3266	}
3267	}
3268	}
3269
3270	static BOOL device_unit_free_for_vs(IWineD3DDeviceImpl This, const DWORD pshader_sampler_tokens,
3271	const DWORD *vshader_sampler_tokens, DWORD unit)
3272	{
3273	DWORD current_mapping = This->rev_tex_unit_map[unit];
3274
3275	/* Not currently used */
3276	if (current_mapping == WINED3D_UNMAPPED_STAGE) return TRUE;
3277
3278	if (current_mapping < MAX_FRAGMENT_SAMPLERS) {
3279	/* Used by a fragment sampler */
3280
3281	if (!pshader_sampler_tokens) {
3282	/* No pixel shader, check fixed function */
3283	return current_mapping >= MAX_TEXTURES \|\| !(This->fixed_function_usage_map & (1 << current_mapping));
3284	}
3285
3286	/* Pixel shader, check the shader's sampler map */
3287	return !pshader_sampler_tokens[current_mapping];
3288	}
3289
3290	/* Used by a vertex sampler */
3291	return !vshader_sampler_tokens[current_mapping - MAX_FRAGMENT_SAMPLERS];
3292	}
3293
3294	static void device_map_vsamplers(IWineD3DDeviceImpl This, BOOL ps, const struct wined3d_gl_info gl_info)
3295	{
3296	const WINED3DSAMPLER_TEXTURE_TYPE *vshader_sampler_type =
3297	((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.reg_maps.sampler_type;
3298	const WINED3DSAMPLER_TEXTURE_TYPE *pshader_sampler_type = NULL;
3299	int start = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers) - 1;
3300	int i;
3301
3302	if (ps) {
3303	IWineD3DPixelShaderImpl pshader = (IWineD3DPixelShaderImpl )This->stateBlock->pixelShader;
3304
3305	/* Note that we only care if a sampler is sampled or not, not the sampler's specific type.
3306	* Otherwise we'd need to call shader_update_samplers() here for 1.x pixelshaders. */
3307	pshader_sampler_type = pshader->baseShader.reg_maps.sampler_type;
3308	}
3309
3310	for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
3311	DWORD vsampler_idx = i + MAX_FRAGMENT_SAMPLERS;
3312	if (vshader_sampler_type[i])
3313	{
3314	if (This->texUnitMap[vsampler_idx] != WINED3D_UNMAPPED_STAGE)
3315	{
3316	/* Already mapped somewhere */
3317	continue;
3318	}
3319
3320	while (start >= 0) {
3321	if (device_unit_free_for_vs(This, pshader_sampler_type, vshader_sampler_type, start))
3322	{
3323	device_map_stage(This, vsampler_idx, start);
3324	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(vsampler_idx));
3325
3326	--start;
3327	break;
3328	}
3329
3330	--start;
3331	}
3332	}
3333	}
3334	}
3335
3336	void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This)
3337	{
3338	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3339	BOOL vs = use_vs(This->stateBlock);
3340	BOOL ps = use_ps(This->stateBlock);
3341	/*
3342	* Rules are:
3343	* -> Pixel shaders need a 1:1 map. In theory the shader input could be mapped too, but
3344	* that would be really messy and require shader recompilation
3345	* -> When the mapping of a stage is changed, sampler and ALL texture stage states have
3346	* to be reset. Because of that try to work with a 1:1 mapping as much as possible
3347	*/
3348	if (ps) device_map_psamplers(This, gl_info);
3349	else device_map_fixed_function_samplers(This, gl_info);
3350
3351	if (vs) device_map_vsamplers(This, ps, gl_info);
3352	}
3353
3354	static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice iface, IWineD3DPixelShader pShader) {
3355	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3356	IWineD3DPixelShader *oldShader = This->updateStateBlock->pixelShader;
3357	This->updateStateBlock->pixelShader = pShader;
3358	This->updateStateBlock->changed.pixelShader = TRUE;
3359
3360	/* Handle recording of state blocks */
3361	if (This->isRecordingState) {
3362	TRACE("Recording... not performing anything\n");
3363	}
3364
3365	if (This->isRecordingState) {
3366	TRACE("Recording... not performing anything\n");
3367	if(pShader) IWineD3DPixelShader_AddRef(pShader);
3368	if(oldShader) IWineD3DPixelShader_Release(oldShader);
3369	return WINED3D_OK;
3370	}
3371
3372	if(pShader == oldShader) {
3373	TRACE("App is setting the old pixel shader over, nothing to do\n");
3374	return WINED3D_OK;
3375	}
3376
3377	if(pShader) IWineD3DPixelShader_AddRef(pShader);
3378	if(oldShader) IWineD3DPixelShader_Release(oldShader);
3379
3380	TRACE("(%p) : setting pShader(%p)\n", This, pShader);
3381	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADER);
3382
3383	return WINED3D_OK;
3384	}
3385
3386	static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShader(IWineD3DDevice iface, IWineD3DPixelShader *ppShader) {
3387	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3388
3389	if (NULL == ppShader) {
3390	WARN("(%p) : PShader is NULL, returning INVALIDCALL\n", This);
3391	return WINED3DERR_INVALIDCALL;
3392	}
3393
3394	*ppShader = This->stateBlock->pixelShader;
3395	if (NULL != *ppShader) {
3396	IWineD3DPixelShader_AddRef(*ppShader);
3397	}
3398	TRACE("(%p) : returning %p\n", This, *ppShader);
3399	return WINED3D_OK;
3400	}
3401
3402	static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(
3403	IWineD3DDevice *iface,
3404	UINT start,
3405	CONST BOOL *srcData,
3406	UINT count) {
3407
3408	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3409	unsigned int i, cnt = min(count, MAX_CONST_B - start);
3410
3411	TRACE("(iface %p, srcData %p, start %u, count %u)\n",
3412	iface, srcData, start, count);
3413
3414	if (!srcData \|\| start >= MAX_CONST_B) return WINED3DERR_INVALIDCALL;
3415
3416	memcpy(&This->updateStateBlock->pixelShaderConstantB[start], srcData, cnt * sizeof(BOOL));
3417	for (i = 0; i < cnt; i++)
3418	TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
3419
3420	for (i = start; i < cnt + start; ++i) {
3421	This->updateStateBlock->changed.pixelShaderConstantsB \|= (1 << i);
3422	}
3423
3424	if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3425
3426	return WINED3D_OK;
3427	}
3428
3429	static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(
3430	IWineD3DDevice *iface,
3431	UINT start,
3432	BOOL *dstData,
3433	UINT count) {
3434
3435	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3436	int cnt = min(count, MAX_CONST_B - start);
3437
3438	TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3439	iface, dstData, start, count);
3440
3441	if (dstData == NULL \|\| cnt < 0)
3442	return WINED3DERR_INVALIDCALL;
3443
3444	memcpy(dstData, &This->stateBlock->pixelShaderConstantB[start], cnt * sizeof(BOOL));
3445	return WINED3D_OK;
3446	}
3447
3448	static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(
3449	IWineD3DDevice *iface,
3450	UINT start,
3451	CONST int *srcData,
3452	UINT count) {
3453
3454	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3455	unsigned int i, cnt = min(count, MAX_CONST_I - start);
3456
3457	TRACE("(iface %p, srcData %p, start %u, count %u)\n",
3458	iface, srcData, start, count);
3459
3460	if (!srcData \|\| start >= MAX_CONST_I) return WINED3DERR_INVALIDCALL;
3461
3462	memcpy(&This->updateStateBlock->pixelShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
3463	for (i = 0; i < cnt; i++)
3464	TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
3465	srcData[i4], srcData[i4+1], srcData[i4+2], srcData[i4+3]);
3466
3467	for (i = start; i < cnt + start; ++i) {
3468	This->updateStateBlock->changed.pixelShaderConstantsI \|= (1 << i);
3469	}
3470
3471	if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3472
3473	return WINED3D_OK;
3474	}
3475
3476	static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(
3477	IWineD3DDevice *iface,
3478	UINT start,
3479	int *dstData,
3480	UINT count) {
3481
3482	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3483	int cnt = min(count, MAX_CONST_I - start);
3484
3485	TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3486	iface, dstData, start, count);
3487
3488	if (dstData == NULL \|\| cnt < 0)
3489	return WINED3DERR_INVALIDCALL;
3490
3491	memcpy(dstData, &This->stateBlock->pixelShaderConstantI[start * 4], cnt * sizeof(int) * 4);
3492	return WINED3D_OK;
3493	}
3494
3495	static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(
3496	IWineD3DDevice *iface,
3497	UINT start,
3498	CONST float *srcData,
3499	UINT count) {
3500
3501	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3502	UINT i;
3503
3504	TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3505	iface, srcData, start, count);
3506
3507	/* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3508	if (srcData == NULL \|\| start + count > This->d3d_pshader_constantF \|\| start > This->d3d_pshader_constantF)
3509	return WINED3DERR_INVALIDCALL;
3510
3511	memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3512	if(TRACE_ON(d3d)) {
3513	for (i = 0; i < count; i++)
3514	TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3515	srcData[i4], srcData[i4+1], srcData[i4+2], srcData[i4+3]);
3516	}
3517
3518	if (!This->isRecordingState)
3519	{
3520	This->shader_backend->shader_update_float_pixel_constants(iface, start, count);
3521	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3522	}
3523
3524	memset(This->updateStateBlock->changed.pixelShaderConstantsF + start, 1,
3525	sizeof(This->updateStateBlock->changed.pixelShaderConstantsF) count);
3526
3527	return WINED3D_OK;
3528	}
3529
3530	static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(
3531	IWineD3DDevice *iface,
3532	UINT start,
3533	float *dstData,
3534	UINT count) {
3535
3536	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3537	int cnt = min(count, This->d3d_pshader_constantF - start);
3538
3539	TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3540	iface, dstData, start, count);
3541
3542	if (dstData == NULL \|\| cnt < 0)
3543	return WINED3DERR_INVALIDCALL;
3544
3545	memcpy(dstData, &This->stateBlock->pixelShaderConstantF[start * 4], cnt * sizeof(float) * 4);
3546	return WINED3D_OK;
3547	}
3548
3549	/* Context activation is done by the caller. */
3550	#define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)
3551	static HRESULT process_vertices_strided(IWineD3DDeviceImpl *This, DWORD dwDestIndex, DWORD dwCount,
3552	const struct wined3d_stream_info stream_info, struct wined3d_buffer dest, DWORD dwFlags,
3553	DWORD DestFVF)
3554	{
3555	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3556	char dest_ptr, dest_conv = NULL, *dest_conv_addr = NULL;
3557	unsigned int i;
3558	WINED3DVIEWPORT vp;
3559	WINED3DMATRIX mat, proj_mat, view_mat, world_mat;
3560	BOOL doClip;
3561	DWORD numTextures;
3562
3563	if (stream_info->use_map & (1 << WINED3D_FFP_NORMAL))
3564	{
3565	WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
3566	}
3567
3568	if (!(stream_info->use_map & (1 << WINED3D_FFP_POSITION)))
3569	{
3570	ERR("Source has no position mask\n");
3571	return WINED3DERR_INVALIDCALL;
3572	}
3573
3574	/* We might access VBOs from this code, so hold the lock */
3575	ENTER_GL();
3576
3577	if (dest->resource.allocatedMemory == NULL) {
3578	buffer_get_sysmem(dest);
3579	}
3580
3581	/* Get a pointer into the destination vbo(create one if none exists) and
3582	* write correct opengl data into it. It's cheap and allows us to run drawStridedFast
3583	*/
3584	if (!dest->buffer_object && gl_info->supported[ARB_VERTEX_BUFFER_OBJECT])
3585	{
3586	dest->flags \|= WINED3D_BUFFER_CREATEBO;
3587	IWineD3DBuffer_PreLoad((IWineD3DBuffer *)dest);
3588	}
3589
3590	if (dest->buffer_object)
3591	{
3592	unsigned char extrabytes = 0;
3593	/* If the destination vertex buffer has D3DFVF_XYZ position(non-rhw), native d3d writes RHW position, where the RHW
3594	* gets written into the 4 bytes after the Z position. In the case of a dest buffer that only has D3DFVF_XYZ data,
3595	* this may write 4 extra bytes beyond the area that should be written
3596	*/
3597	if(DestFVF == WINED3DFVF_XYZ) extrabytes = 4;
3598	dest_conv_addr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCount * get_flexible_vertex_size(DestFVF) + extrabytes);
3599	if(!dest_conv_addr) {
3600	ERR("Out of memory\n");
3601	/* Continue without storing converted vertices */
3602	}
3603	dest_conv = dest_conv_addr;
3604	}
3605
3606	/* Should I clip?
3607	* a) WINED3DRS_CLIPPING is enabled
3608	* b) WINED3DVOP_CLIP is passed
3609	*/
3610	if(This->stateBlock->renderState[WINED3DRS_CLIPPING]) {
3611	static BOOL warned = FALSE;
3612	/*
3613	* The clipping code is not quite correct. Some things need
3614	* to be checked against IDirect3DDevice3 (!), d3d8 and d3d9,
3615	* so disable clipping for now.
3616	* (The graphics in Half-Life are broken, and my processvertices
3617	* test crashes with IDirect3DDevice3)
3618	doClip = TRUE;
3619	*/
3620	doClip = FALSE;
3621	if(!warned) {
3622	warned = TRUE;
3623	FIXME("Clipping is broken and disabled for now\n");
3624	}
3625	} else doClip = FALSE;
3626	dest_ptr = ((char ) buffer_get_sysmem(dest)) + dwDestIndex get_flexible_vertex_size(DestFVF);
3627
3628	IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
3629	WINED3DTS_VIEW,
3630	&view_mat);
3631	IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
3632	WINED3DTS_PROJECTION,
3633	&proj_mat);
3634	IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
3635	WINED3DTS_WORLDMATRIX(0),
3636	&world_mat);
3637
3638	TRACE("View mat:\n");
3639	TRACE("%f %f %f %f\n", view_mat.u.s._11, view_mat.u.s._12, view_mat.u.s._13, view_mat.u.s._14);
3640	TRACE("%f %f %f %f\n", view_mat.u.s._21, view_mat.u.s._22, view_mat.u.s._23, view_mat.u.s._24);
3641	TRACE("%f %f %f %f\n", view_mat.u.s._31, view_mat.u.s._32, view_mat.u.s._33, view_mat.u.s._34);
3642	TRACE("%f %f %f %f\n", view_mat.u.s._41, view_mat.u.s._42, view_mat.u.s._43, view_mat.u.s._44);
3643
3644	TRACE("Proj mat:\n");
3645	TRACE("%f %f %f %f\n", proj_mat.u.s._11, proj_mat.u.s._12, proj_mat.u.s._13, proj_mat.u.s._14);
3646	TRACE("%f %f %f %f\n", proj_mat.u.s._21, proj_mat.u.s._22, proj_mat.u.s._23, proj_mat.u.s._24);
3647	TRACE("%f %f %f %f\n", proj_mat.u.s._31, proj_mat.u.s._32, proj_mat.u.s._33, proj_mat.u.s._34);
3648	TRACE("%f %f %f %f\n", proj_mat.u.s._41, proj_mat.u.s._42, proj_mat.u.s._43, proj_mat.u.s._44);
3649
3650	TRACE("World mat:\n");
3651	TRACE("%f %f %f %f\n", world_mat.u.s._11, world_mat.u.s._12, world_mat.u.s._13, world_mat.u.s._14);
3652	TRACE("%f %f %f %f\n", world_mat.u.s._21, world_mat.u.s._22, world_mat.u.s._23, world_mat.u.s._24);
3653	TRACE("%f %f %f %f\n", world_mat.u.s._31, world_mat.u.s._32, world_mat.u.s._33, world_mat.u.s._34);
3654	TRACE("%f %f %f %f\n", world_mat.u.s._41, world_mat.u.s._42, world_mat.u.s._43, world_mat.u.s._44);
3655
3656	/* Get the viewport */
3657	IWineD3DDevice_GetViewport( (IWineD3DDevice *) This, &vp);
3658	TRACE("Viewport: X=%d, Y=%d, Width=%d, Height=%d, MinZ=%f, MaxZ=%f\n",
3659	vp.X, vp.Y, vp.Width, vp.Height, vp.MinZ, vp.MaxZ);
3660
3661	multiply_matrix(&mat,&view_mat,&world_mat);
3662	multiply_matrix(&mat,&proj_mat,&mat);
3663
3664	numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
3665
3666	for (i = 0; i < dwCount; i+= 1) {
3667	unsigned int tex_index;
3668
3669	if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) \|\|
3670	((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) {
3671	/* The position first */
3672	const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_POSITION];
3673	const float p = (const float )(element->data + i * element->stride);
3674	float x, y, z, rhw;
3675	TRACE("In: ( %06.2f %06.2f %06.2f )\n", p[0], p[1], p[2]);
3676
3677	/* Multiplication with world, view and projection matrix */
3678	x = (p[0] * mat.u.s._11) + (p[1] * mat.u.s._21) + (p[2] * mat.u.s._31) + (1.0f * mat.u.s._41);
3679	y = (p[0] * mat.u.s._12) + (p[1] * mat.u.s._22) + (p[2] * mat.u.s._32) + (1.0f * mat.u.s._42);
3680	z = (p[0] * mat.u.s._13) + (p[1] * mat.u.s._23) + (p[2] * mat.u.s._33) + (1.0f * mat.u.s._43);
3681	rhw = (p[0] * mat.u.s._14) + (p[1] * mat.u.s._24) + (p[2] * mat.u.s._34) + (1.0f * mat.u.s._44);
3682
3683	TRACE("x=%f y=%f z=%f rhw=%f\n", x, y, z, rhw);
3684
3685	/* WARNING: The following things are taken from d3d7 and were not yet checked
3686	* against d3d8 or d3d9!
3687	*/
3688
3689	/* Clipping conditions: From msdn
3690	*
3691	* A vertex is clipped if it does not match the following requirements
3692	* -rhw < x <= rhw
3693	* -rhw < y <= rhw
3694	* 0 < z <= rhw
3695	* 0 < rhw ( Not in d3d7, but tested in d3d7)
3696	*
3697	* If clipping is on is determined by the D3DVOP_CLIP flag in D3D7, and
3698	* by the D3DRS_CLIPPING in D3D9(according to the msdn, not checked)
3699	*
3700	*/
3701
3702	if( !doClip \|\|
3703	( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) &&
3704	(x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) &&
3705	( rhw > eps ) ) ) {
3706
3707	/* "Normal" viewport transformation (not clipped)
3708	* 1) The values are divided by rhw
3709	* 2) The y axis is negative, so multiply it with -1
3710	* 3) Screen coordinates go from -(Width/2) to +(Width/2) and
3711	* -(Height/2) to +(Height/2). The z range is MinZ to MaxZ
3712	* 4) Multiply x with Width/2 and add Width/2
3713	* 5) The same for the height
3714	* 6) Add the viewpoint X and Y to the 2D coordinates and
3715	* The minimum Z value to z
3716	* 7) rhw = 1 / rhw Reciprocal of Homogeneous W....
3717	*
3718	* Well, basically it's simply a linear transformation into viewport
3719	* coordinates
3720	*/
3721
3722	x /= rhw;
3723	y /= rhw;
3724	z /= rhw;
3725
3726	y *= -1;
3727
3728	x *= vp.Width / 2;
3729	y *= vp.Height / 2;
3730	z *= vp.MaxZ - vp.MinZ;
3731
3732	x += vp.Width / 2 + vp.X;
3733	y += vp.Height / 2 + vp.Y;
3734	z += vp.MinZ;
3735
3736	rhw = 1 / rhw;
3737	} else {
3738	/* That vertex got clipped
3739	* Contrary to OpenGL it is not dropped completely, it just
3740	* undergoes a different calculation.
3741	*/
3742	TRACE("Vertex got clipped\n");
3743	x += rhw;
3744	y += rhw;
3745
3746	x /= 2;
3747	y /= 2;
3748
3749	/* Msdn mentions that Direct3D9 keeps a list of clipped vertices
3750	* outside of the main vertex buffer memory. That needs some more
3751	* investigation...
3752	*/
3753	}
3754
3755	TRACE("Writing (%f %f %f) %f\n", x, y, z, rhw);
3756
3757
3758	( (float *) dest_ptr)[0] = x;
3759	( (float *) dest_ptr)[1] = y;
3760	( (float *) dest_ptr)[2] = z;
3761	( (float ) dest_ptr)[3] = rhw; / SIC, see ddraw test! */
3762
3763	dest_ptr += 3 * sizeof(float);
3764
3765	if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
3766	dest_ptr += sizeof(float);
3767	}
3768
3769	if(dest_conv) {
3770	float w = 1 / rhw;
3771	( (float ) dest_conv)[0] = x w;
3772	( (float ) dest_conv)[1] = y w;
3773	( (float ) dest_conv)[2] = z w;
3774	( (float *) dest_conv)[3] = w;
3775
3776	dest_conv += 3 * sizeof(float);
3777
3778	if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
3779	dest_conv += sizeof(float);
3780	}
3781	}
3782	}
3783	if (DestFVF & WINED3DFVF_PSIZE) {
3784	dest_ptr += sizeof(DWORD);
3785	if(dest_conv) dest_conv += sizeof(DWORD);
3786	}
3787	if (DestFVF & WINED3DFVF_NORMAL) {
3788	const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_NORMAL];
3789	const float normal = (const float )(element->data + i * element->stride);
3790	/* AFAIK this should go into the lighting information */
3791	FIXME("Didn't expect the destination to have a normal\n");
3792	copy_and_next(dest_ptr, normal, 3 * sizeof(float));
3793	if(dest_conv) {
3794	copy_and_next(dest_conv, normal, 3 * sizeof(float));
3795	}
3796	}
3797
3798	if (DestFVF & WINED3DFVF_DIFFUSE) {
3799	const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_DIFFUSE];
3800	const DWORD color_d = (const DWORD )(element->data + i * element->stride);
3801	if (!(stream_info->use_map & (1 << WINED3D_FFP_DIFFUSE)))
3802	{
3803	static BOOL warned = FALSE;
3804
3805	if(!warned) {
3806	ERR("No diffuse color in source, but destination has one\n");
3807	warned = TRUE;
3808	}
3809
3810	( (DWORD ) dest_ptr) = 0xffffffff;
3811	dest_ptr += sizeof(DWORD);
3812
3813	if(dest_conv) {
3814	( (DWORD ) dest_conv) = 0xffffffff;
3815	dest_conv += sizeof(DWORD);
3816	}
3817	}
3818	else {
3819	copy_and_next(dest_ptr, color_d, sizeof(DWORD));
3820	if(dest_conv) {
3821	( (DWORD ) dest_conv) = (color_d & 0xff00ff00) ; / Alpha + green */
3822	( (DWORD ) dest_conv) \|= (color_d & 0x00ff0000) >> 16; / Red */
3823	( (DWORD ) dest_conv) \|= (color_d & 0xff0000ff) << 16; / Blue */
3824	dest_conv += sizeof(DWORD);
3825	}
3826	}
3827	}
3828
3829	if (DestFVF & WINED3DFVF_SPECULAR)
3830	{
3831	/* What's the color value in the feedback buffer? */
3832	const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_SPECULAR];
3833	const DWORD color_s = (const DWORD )(element->data + i * element->stride);
3834	if (!(stream_info->use_map & (1 << WINED3D_FFP_SPECULAR)))
3835	{
3836	static BOOL warned = FALSE;
3837
3838	if(!warned) {
3839	ERR("No specular color in source, but destination has one\n");
3840	warned = TRUE;
3841	}
3842
3843	( (DWORD ) dest_ptr) = 0xFF000000;
3844	dest_ptr += sizeof(DWORD);
3845
3846	if(dest_conv) {
3847	( (DWORD ) dest_conv) = 0xFF000000;
3848	dest_conv += sizeof(DWORD);
3849	}
3850	}
3851	else {
3852	copy_and_next(dest_ptr, color_s, sizeof(DWORD));
3853	if(dest_conv) {
3854	( (DWORD ) dest_conv) = (color_s & 0xff00ff00) ; / Alpha + green */
3855	( (DWORD ) dest_conv) \|= (color_s & 0x00ff0000) >> 16; / Red */
3856	( (DWORD ) dest_conv) \|= (color_s & 0xff0000ff) << 16; / Blue */
3857	dest_conv += sizeof(DWORD);
3858	}
3859	}
3860	}
3861
3862	for (tex_index = 0; tex_index < numTextures; tex_index++) {
3863	const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_TEXCOORD0 + tex_index];
3864	const float tex_coord = (const float )(element->data + i * element->stride);
3865	if (!(stream_info->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + tex_index))))
3866	{
3867	ERR("No source texture, but destination requests one\n");
3868	dest_ptr+=GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
3869	if(dest_conv) dest_conv += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
3870	}
3871	else {
3872	copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
3873	if(dest_conv) {
3874	copy_and_next(dest_conv, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
3875	}
3876	}
3877	}
3878	}
3879
3880	if(dest_conv) {
3881	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, dest->buffer_object));
3882	checkGLcall("glBindBufferARB(GL_ARRAY_BUFFER_ARB)");
3883	GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, dwDestIndex * get_flexible_vertex_size(DestFVF),
3884	dwCount * get_flexible_vertex_size(DestFVF),
3885	dest_conv_addr));
3886	checkGLcall("glBufferSubDataARB(GL_ARRAY_BUFFER_ARB)");
3887	HeapFree(GetProcessHeap(), 0, dest_conv_addr);
3888	}
3889
3890	LEAVE_GL();
3891
3892	return WINED3D_OK;
3893	}
3894	#undef copy_and_next
3895
3896	static HRESULT WINAPI IWineD3DDeviceImpl_ProcessVertices(IWineD3DDevice *iface, UINT SrcStartIndex, UINT DestIndex,
3897	UINT VertexCount, IWineD3DBuffer pDestBuffer, IWineD3DVertexDeclaration pVertexDecl, DWORD Flags,
3898	DWORD DestFVF)
3899	{
3900	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3901	struct wined3d_stream_info stream_info;
3902	struct wined3d_context *context;
3903	BOOL vbo = FALSE, streamWasUP = This->stateBlock->streamIsUP;
3904	HRESULT hr;
3905
3906	TRACE("(%p)->(%d,%d,%d,%p,%p,%d\n", This, SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags);
3907
3908	if(pVertexDecl) {
3909	ERR("Output vertex declaration not implemented yet\n");
3910	}
3911
3912	/* Need any context to write to the vbo. */
3913	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
3914
3915	/* ProcessVertices reads from vertex buffers, which have to be assigned. DrawPrimitive and DrawPrimitiveUP
3916	* control the streamIsUP flag, thus restore it afterwards.
3917	*/
3918	This->stateBlock->streamIsUP = FALSE;
3919	device_stream_info_from_declaration(This, FALSE, &stream_info, &vbo);
3920	This->stateBlock->streamIsUP = streamWasUP;
3921
3922	if(vbo \|\| SrcStartIndex) {
3923	unsigned int i;
3924	/* ProcessVertices can't convert FROM a vbo, and vertex buffers used to source into ProcessVertices are
3925	* unlikely to ever be used for drawing. Release vbos in those buffers and fix up the stream_info structure
3926	*
3927	* Also get the start index in, but only loop over all elements if there's something to add at all.
3928	*/
3929	for (i = 0; i < (sizeof(stream_info.elements) / sizeof(*stream_info.elements)); ++i)
3930	{
3931	struct wined3d_stream_info_element *e;
3932
3933	if (!(stream_info.use_map & (1 << i))) continue;
3934
3935	e = &stream_info.elements[i];
3936	if (e->buffer_object)
3937	{
3938	struct wined3d_buffer vb = (struct wined3d_buffer )This->stateBlock->streamSource[e->stream_idx];
3939	e->buffer_object = 0;
3940	e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
3941	ENTER_GL();
3942	GL_EXTCALL(glDeleteBuffersARB(1, &vb->buffer_object));
3943	vb->buffer_object = 0;
3944	LEAVE_GL();
3945	}
3946	if (e->data) e->data += e->stride * SrcStartIndex;
3947	}
3948	}
3949
3950	hr = process_vertices_strided(This, DestIndex, VertexCount, &stream_info,
3951	(struct wined3d_buffer *)pDestBuffer, Flags, DestFVF);
3952
3953	context_release(context);
3954
3955	return hr;
3956	}
3957
3958	/*****
3959	* Get / Set Texture Stage States
3960	* TODO: Verify against dx9 definitions
3961	*****/
3962	static HRESULT WINAPI IWineD3DDeviceImpl_SetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
3963	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
3964	DWORD oldValue = This->updateStateBlock->textureState[Stage][Type];
3965	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3966
3967	TRACE("(%p) : Stage=%d, Type=%s(%d), Value=%d\n", This, Stage, debug_d3dtexturestate(Type), Type, Value);
3968
3969	if (Stage >= gl_info->limits.texture_stages)
3970	{
3971	WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring.\n",
3972	Stage, gl_info->limits.texture_stages - 1);
3973	return WINED3D_OK;
3974	}
3975
3976	This->updateStateBlock->changed.textureState[Stage] \|= 1 << Type;
3977	This->updateStateBlock->textureState[Stage][Type] = Value;
3978
3979	if (This->isRecordingState) {
3980	TRACE("Recording... not performing anything\n");
3981	return WINED3D_OK;
3982	}
3983
3984	/* Checked after the assignments to allow proper stateblock recording */
3985	if(oldValue == Value) {
3986	TRACE("App is setting the old value over, nothing to do\n");
3987	return WINED3D_OK;
3988	}
3989
3990	if(Stage > This->stateBlock->lowest_disabled_stage &&
3991	This->StateTable[STATE_TEXTURESTAGE(0, Type)].representative == STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP)) {
3992	/* Colorop change above lowest disabled stage? That won't change anything in the gl setup
3993	* Changes in other states are important on disabled stages too
3994	*/
3995	return WINED3D_OK;
3996	}
3997
3998	if(Type == WINED3DTSS_COLOROP) {
3999	unsigned int i;
4000
4001	if(Value == WINED3DTOP_DISABLE && oldValue != WINED3DTOP_DISABLE) {
4002	/* Previously enabled stage disabled now. Make sure to dirtify all enabled stages above Stage,
4003	* they have to be disabled
4004	*
4005	* The current stage is dirtified below.
4006	*/
4007	for(i = Stage + 1; i < This->stateBlock->lowest_disabled_stage; i++) {
4008	TRACE("Additionally dirtifying stage %u\n", i);
4009	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
4010	}
4011	This->stateBlock->lowest_disabled_stage = Stage;
4012	TRACE("New lowest disabled: %u\n", Stage);
4013	} else if(Value != WINED3DTOP_DISABLE && oldValue == WINED3DTOP_DISABLE) {
4014	/* Previously disabled stage enabled. Stages above it may need enabling
4015	* stage must be lowest_disabled_stage here, if it's bigger success is returned above,
4016	* and stages below the lowest disabled stage can't be enabled(because they are enabled already).
4017	*
4018	* Again stage Stage doesn't need to be dirtified here, it is handled below.
4019	*/
4020
4021	for (i = Stage + 1; i < This->adapter->gl_info.limits.texture_stages; ++i)
4022	{
4023	if(This->updateStateBlock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
4024	break;
4025	}
4026	TRACE("Additionally dirtifying stage %u due to enable\n", i);
4027	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
4028	}
4029	This->stateBlock->lowest_disabled_stage = i;
4030	TRACE("New lowest disabled: %u\n", i);
4031	}
4032	}
4033
4034	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, Type));
4035
4036	return WINED3D_OK;
4037	}
4038
4039	static HRESULT WINAPI IWineD3DDeviceImpl_GetTextureStageState(IWineD3DDevice iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD pValue) {
4040	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4041	TRACE("(%p) : requesting Stage %d, Type %d getting %d\n", This, Stage, Type, This->updateStateBlock->textureState[Stage][Type]);
4042	*pValue = This->updateStateBlock->textureState[Stage][Type];
4043	return WINED3D_OK;
4044	}
4045
4046	/*****
4047	* Get / Set Texture
4048	*****/
4049	static HRESULT WINAPI IWineD3DDeviceImpl_SetTexture(IWineD3DDevice *iface,
4050	DWORD stage, IWineD3DBaseTexture *texture)
4051	{
4052	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4053	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
4054	IWineD3DBaseTexture *prev;
4055
4056	TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
4057
4058	if (stage >= WINED3DVERTEXTEXTURESAMPLER0 && stage <= WINED3DVERTEXTEXTURESAMPLER3)
4059	stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
4060
4061	/* Windows accepts overflowing this array... we do not. */
4062	if (stage >= sizeof(This->stateBlock->textures) / sizeof(*This->stateBlock->textures))
4063	{
4064	WARN("Ignoring invalid stage %u.\n", stage);
4065	return WINED3D_OK;
4066	}
4067
4068	/* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH */
4069	if (texture && ((IWineD3DTextureImpl *)texture)->resource.pool == WINED3DPOOL_SCRATCH)
4070	{
4071	WARN("Rejecting attempt to set scratch texture.\n");
4072	return WINED3DERR_INVALIDCALL;
4073	}
4074
4075	This->updateStateBlock->changed.textures \|= 1 << stage;
4076
4077	prev = This->updateStateBlock->textures[stage];
4078	TRACE("Previous texture %p.\n", prev);
4079
4080	if (texture == prev)
4081	{
4082	TRACE("App is setting the same texture again, nothing to do.\n");
4083	return WINED3D_OK;
4084	}
4085
4086	TRACE("Setting new texture to %p.\n", texture);
4087	This->updateStateBlock->textures[stage] = texture;
4088
4089	if (This->isRecordingState)
4090	{
4091	TRACE("Recording... not performing anything\n");
4092
4093	if (texture) IWineD3DBaseTexture_AddRef(texture);
4094	if (prev) IWineD3DBaseTexture_Release(prev);
4095
4096	return WINED3D_OK;
4097	}
4098
4099	if (texture)
4100	{
4101	IWineD3DBaseTextureImpl t = (IWineD3DBaseTextureImpl )texture;
4102	LONG bind_count = InterlockedIncrement(&t->baseTexture.bindCount);
4103	UINT dimensions = IWineD3DBaseTexture_GetTextureDimensions(texture);
4104
4105	IWineD3DBaseTexture_AddRef(texture);
4106
4107	if (!prev \|\| dimensions != IWineD3DBaseTexture_GetTextureDimensions(prev))
4108	{
4109	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADER);
4110	}
4111
4112	if (!prev && stage < gl_info->limits.texture_stages)
4113	{
4114	/* The source arguments for color and alpha ops have different
4115	* meanings when a NULL texture is bound, so the COLOROP and
4116	* ALPHAOP have to be dirtified. */
4117	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, WINED3DTSS_COLOROP));
4118	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, WINED3DTSS_ALPHAOP));
4119	}
4120
4121	if (bind_count == 1) t->baseTexture.sampler = stage;
4122	}
4123
4124	if (prev)
4125	{
4126	IWineD3DBaseTextureImpl t = (IWineD3DBaseTextureImpl )prev;
4127	LONG bind_count = InterlockedDecrement(&t->baseTexture.bindCount);
4128
4129	IWineD3DBaseTexture_Release(prev);
4130
4131	if (!texture && stage < gl_info->limits.texture_stages)
4132	{
4133	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, WINED3DTSS_COLOROP));
4134	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, WINED3DTSS_ALPHAOP));
4135	}
4136
4137	if (bind_count && t->baseTexture.sampler == stage)
4138	{
4139	unsigned int i;
4140
4141	/* Search for other stages the texture is bound to. Shouldn't
4142	* happen if applications bind textures to a single stage only. */
4143	TRACE("Searching for other stages the texture is bound to.\n");
4144	for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
4145	{
4146	if (This->updateStateBlock->textures[i] == prev)
4147	{
4148	TRACE("Texture is also bound to stage %u.\n", i);
4149	t->baseTexture.sampler = i;
4150	break;
4151	}
4152	}
4153	}
4154	}
4155
4156	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(stage));
4157
4158	return WINED3D_OK;
4159	}
4160
4161	static HRESULT WINAPI IWineD3DDeviceImpl_GetTexture(IWineD3DDevice iface, DWORD Stage, IWineD3DBaseTexture* ppTexture) {
4162	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4163
4164	TRACE("(%p) : Stage %#x, ppTexture %p\n", This, Stage, ppTexture);
4165
4166	if (Stage >= WINED3DVERTEXTEXTURESAMPLER0 && Stage <= WINED3DVERTEXTEXTURESAMPLER3) {
4167	Stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
4168	}
4169
4170	if (Stage >= sizeof(This->stateBlock->textures)/sizeof(This->stateBlock->textures[0])) {
4171	ERR("Current stage overflows textures array (stage %d)\n", Stage);
4172	return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
4173	}
4174
4175	*ppTexture=This->stateBlock->textures[Stage];
4176	if (*ppTexture)
4177	IWineD3DBaseTexture_AddRef(*ppTexture);
4178
4179	TRACE("(%p) : Returning %p\n", This, *ppTexture);
4180
4181	return WINED3D_OK;
4182	}
4183
4184	/*****
4185	* Get Back Buffer
4186	*****/
4187	static HRESULT WINAPI IWineD3DDeviceImpl_GetBackBuffer(IWineD3DDevice *iface, UINT swapchain_idx,
4188	UINT backbuffer_idx, WINED3DBACKBUFFER_TYPE backbuffer_type, IWineD3DSurface **backbuffer)
4189	{
4190	IWineD3DSwapChain *swapchain;
4191	HRESULT hr;
4192
4193	TRACE("iface %p, swapchain_idx %u, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
4194	iface, swapchain_idx, backbuffer_idx, backbuffer_type, backbuffer);
4195
4196	hr = IWineD3DDeviceImpl_GetSwapChain(iface, swapchain_idx, &swapchain);
4197	if (FAILED(hr))
4198	{
4199	WARN("Failed to get swapchain %u, hr %#x.\n", swapchain_idx, hr);
4200	return hr;
4201	}
4202
4203	hr = IWineD3DSwapChain_GetBackBuffer(swapchain, backbuffer_idx, backbuffer_type, backbuffer);
4204	IWineD3DSwapChain_Release(swapchain);
4205	if (FAILED(hr))
4206	{
4207	WARN("Failed to get backbuffer %u, hr %#x.\n", backbuffer_idx, hr);
4208	return hr;
4209	}
4210
4211	return WINED3D_OK;
4212	}
4213
4214	static HRESULT WINAPI IWineD3DDeviceImpl_GetDeviceCaps(IWineD3DDevice iface, WINED3DCAPS pCaps) {
4215	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4216	WARN("(%p) : stub, calling idirect3d for now\n", This);
4217	return IWineD3D_GetDeviceCaps(This->wined3d, This->adapter->ordinal, This->devType, pCaps);
4218	}
4219
4220	static HRESULT WINAPI IWineD3DDeviceImpl_GetDisplayMode(IWineD3DDevice iface, UINT iSwapChain, WINED3DDISPLAYMODE pMode) {
4221	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4222	IWineD3DSwapChain *swapChain;
4223	HRESULT hr;
4224
4225	if(iSwapChain > 0) {
4226	hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
4227	if (hr == WINED3D_OK) {
4228	hr = IWineD3DSwapChain_GetDisplayMode(swapChain, pMode);
4229	IWineD3DSwapChain_Release(swapChain);
4230	} else {
4231	FIXME("(%p) Error getting display mode\n", This);
4232	}
4233	} else {
4234	/* Don't read the real display mode,
4235	but return the stored mode instead. X11 can't change the color
4236	depth, and some apps are pretty angry if they SetDisplayMode from
4237	24 to 16 bpp and find out that GetDisplayMode still returns 24 bpp
4238
4239	Also don't relay to the swapchain because with ddraw it's possible
4240	that there isn't a swapchain at all */
4241	pMode->Width = This->ddraw_width;
4242	pMode->Height = This->ddraw_height;
4243	pMode->Format = This->ddraw_format;
4244	pMode->RefreshRate = 0;
4245	hr = WINED3D_OK;
4246	}
4247
4248	return hr;
4249	}
4250
4251	/*****
4252	* Stateblock related functions
4253	*****/
4254
4255	static HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface) {
4256	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4257	IWineD3DStateBlock *stateblock;
4258	HRESULT hr;
4259
4260	TRACE("(%p)\n", This);
4261
4262	if (This->isRecordingState) return WINED3DERR_INVALIDCALL;
4263
4264	hr = IWineD3DDeviceImpl_CreateStateBlock(iface, WINED3DSBT_RECORDED, &stateblock, NULL);
4265	if (FAILED(hr)) return hr;
4266
4267	IWineD3DStateBlock_Release((IWineD3DStateBlock*)This->updateStateBlock);
4268	This->updateStateBlock = (IWineD3DStateBlockImpl *)stateblock;
4269	This->isRecordingState = TRUE;
4270
4271	TRACE("(%p) recording stateblock %p\n", This, stateblock);
4272
4273	return WINED3D_OK;
4274	}
4275
4276	static HRESULT WINAPI IWineD3DDeviceImpl_EndStateBlock(IWineD3DDevice iface, IWineD3DStateBlock* ppStateBlock) {
4277	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4278	IWineD3DStateBlockImpl *object = This->updateStateBlock;
4279
4280	if (!This->isRecordingState) {
4281	WARN("(%p) not recording! returning error\n", This);
4282	*ppStateBlock = NULL;
4283	return WINED3DERR_INVALIDCALL;
4284	}
4285
4286	stateblock_init_contained_states(object);
4287
4288	ppStateBlock = (IWineD3DStateBlock) object;
4289	This->isRecordingState = FALSE;
4290	This->updateStateBlock = This->stateBlock;
4291	IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
4292	/* IWineD3DStateBlock_AddRef(ppStateBlock); don't need to do this, since we should really just release UpdateStateBlock first /
4293	TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, *ppStateBlock);
4294	return WINED3D_OK;
4295	}
4296
4297	/*****
4298	* Scene related functions
4299	*****/
4300	static HRESULT WINAPI IWineD3DDeviceImpl_BeginScene(IWineD3DDevice *iface) {
4301	/* At the moment we have no need for any functionality at the beginning
4302	of a scene */
4303	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4304	TRACE("(%p)\n", This);
4305
4306	if(This->inScene) {
4307	TRACE("Already in Scene, returning WINED3DERR_INVALIDCALL\n");
4308	return WINED3DERR_INVALIDCALL;
4309	}
4310	This->inScene = TRUE;
4311	return WINED3D_OK;
4312	}
4313
4314	static HRESULT WINAPI IWineD3DDeviceImpl_EndScene(IWineD3DDevice *iface)
4315	{
4316	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4317	struct wined3d_context *context;
4318
4319	TRACE("(%p)\n", This);
4320
4321	if(!This->inScene) {
4322	TRACE("Not in scene, returning WINED3DERR_INVALIDCALL\n");
4323	return WINED3DERR_INVALIDCALL;
4324	}
4325
4326	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
4327	/* We only have to do this if we need to read the, swapbuffers performs a flush for us */
4328	wglFlush();
4329	/* No checkGLcall here to avoid locking the lock just for checking a call that hardly ever
4330	* fails. */
4331	context_release(context);
4332
4333	This->inScene = FALSE;
4334	return WINED3D_OK;
4335	}
4336
4337	static HRESULT WINAPI IWineD3DDeviceImpl_Present(IWineD3DDevice *iface,
4338	const RECT pSourceRect, const RECT pDestRect,
4339	HWND hDestWindowOverride, const RGNDATA *pDirtyRegion)
4340	{
4341	IWineD3DSwapChain *swapChain = NULL;
4342	int i;
4343	int swapchains = IWineD3DDeviceImpl_GetNumberOfSwapChains(iface);
4344
4345	TRACE("iface %p.\n", iface);
4346
4347	for(i = 0 ; i < swapchains ; i ++) {
4348
4349	IWineD3DDeviceImpl_GetSwapChain(iface, i, &swapChain);
4350	TRACE("presentinng chain %d, %p\n", i, swapChain);
4351	IWineD3DSwapChain_Present(swapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, 0);
4352	IWineD3DSwapChain_Release(swapChain);
4353	}
4354
4355	return WINED3D_OK;
4356	}
4357
4358	static BOOL is_full_clear(IWineD3DSurfaceImpl target, const WINED3DVIEWPORT viewport,
4359	const RECT scissor_rect, const WINED3DRECT clear_rect)
4360	{
4361	/* partial viewport*/
4362	if (viewport->X != 0 \|\| viewport->Y != 0
4363	\|\| viewport->Width < target->currentDesc.Width
4364	\|\| viewport->Height < target->currentDesc.Height)
4365	return FALSE;
4366
4367	/* partial scissor rect */
4368	if (scissor_rect && (scissor_rect->left > 0 \|\| scissor_rect->top > 0
4369	\|\| scissor_rect->right < target->currentDesc.Width
4370	\|\| scissor_rect->bottom < target->currentDesc.Height))
4371	return FALSE;
4372
4373	/* partial clear rect */
4374	if (clear_rect && (clear_rect->x1 > 0 \|\| clear_rect->y1 > 0
4375	\|\| clear_rect->x2 < target->currentDesc.Width
4376	\|\| clear_rect->y2 < target->currentDesc.Height))
4377	return FALSE;
4378
4379	return TRUE;
4380	}
4381
4382	/* Not called from the VTable (internal subroutine) */
4383	HRESULT IWineD3DDeviceImpl_ClearSurface(IWineD3DDeviceImpl This, IWineD3DSurfaceImpl target, DWORD Count,
4384	const WINED3DRECT *pRects, DWORD Flags, WINED3DCOLOR Color, float Z, DWORD Stencil)
4385	{
4386	IWineD3DStateBlockImpl *stateblock = This->stateBlock;
4387	const RECT *scissor_rect = stateblock->renderState[WINED3DRS_SCISSORTESTENABLE] ? &stateblock->scissorRect : NULL;
4388	const WINED3DRECT *clear_rect = (Count > 0 && pRects) ? pRects : NULL;
4389	const WINED3DVIEWPORT *vp = &stateblock->viewport;
4390	GLbitfield glMask = 0;
4391	unsigned int i;
4392	WINED3DRECT curRect;
4393	RECT vp_rect;
4394	UINT drawable_width, drawable_height;
4395	IWineD3DSurfaceImpl depth_stencil = (IWineD3DSurfaceImpl ) This->stencilBufferTarget;
4396	struct wined3d_context *context;
4397
4398	/* When we're clearing parts of the drawable, make sure that the target surface is well up to date in the
4399	* drawable. After the clear we'll mark the drawable up to date, so we have to make sure that this is true
4400	* for the cleared parts, and the untouched parts.
4401	*
4402	* If we're clearing the whole target there is no need to copy it into the drawable, it will be overwritten
4403	* anyway. If we're not clearing the color buffer we don't have to copy either since we're not going to set
4404	* the drawable up to date. We have to check all settings that limit the clear area though. Do not bother
4405	* checking all this if the dest surface is in the drawable anyway.
4406	*/
4407	if (Flags & WINED3DCLEAR_TARGET && !(target->Flags & SFLAG_INDRAWABLE))
4408	{
4409	if (!is_full_clear(target, vp, scissor_rect, clear_rect))
4410	IWineD3DSurface_LoadLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, NULL);
4411	}
4412
4413	context = context_acquire(This, (IWineD3DSurface *)target, CTXUSAGE_CLEAR);
4414	if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
4415	{
4416	if (!surface_is_offscreen((IWineD3DSurface *)target))
4417	{
4418	TRACE("Surface %p is onscreen\n", target);
4419
4420	ENTER_GL();
4421	context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4422	context_set_draw_buffer(context, surface_get_gl_buffer((IWineD3DSurface *)target));
4423	LEAVE_GL();
4424	}
4425	else
4426	{
4427	TRACE("Surface %p is offscreen\n", target);
4428
4429	ENTER_GL();
4430	context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
4431	context_attach_surface_fbo(context, GL_FRAMEBUFFER, 0, target);
4432	context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, depth_stencil, TRUE);
4433	LEAVE_GL();
4434	}
4435	}
4436
4437	if (!context->valid)
4438	{
4439	context_release(context);
4440	WARN("Invalid context, skipping clear.\n");
4441	return WINED3D_OK;
4442	}
4443
4444	target->get_drawable_size(context, &drawable_width, &drawable_height);
4445
4446	ENTER_GL();
4447
4448	/* Only set the values up once, as they are not changing */
4449	if (Flags & WINED3DCLEAR_STENCIL)
4450	{
4451	if (context->gl_info->supported[EXT_STENCIL_TWO_SIDE])
4452	{
4453	glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
4454	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE));
4455	}
4456	glStencilMask(~0U);
4457	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
4458	glClearStencil(Stencil);
4459	checkGLcall("glClearStencil");
4460	glMask = glMask \| GL_STENCIL_BUFFER_BIT;
4461	}
4462
4463	if (Flags & WINED3DCLEAR_ZBUFFER)
4464	{
4465	DWORD location = context->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
4466	if (!(depth_stencil->Flags & location) && !is_full_clear(depth_stencil, vp, scissor_rect, clear_rect))
4467	surface_load_ds_location(This->stencilBufferTarget, context, location);
4468
4469	glDepthMask(GL_TRUE);
4470	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
4471	glClearDepth(Z);
4472	checkGLcall("glClearDepth");
4473	glMask = glMask \| GL_DEPTH_BUFFER_BIT;
4474	}
4475
4476	if (Flags & WINED3DCLEAR_TARGET)
4477	{
4478	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
4479	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
4480	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
4481	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
4482	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
4483	glClearColor(D3DCOLOR_R(Color), D3DCOLOR_G(Color), D3DCOLOR_B(Color), D3DCOLOR_A(Color));
4484	checkGLcall("glClearColor");
4485	glMask = glMask \| GL_COLOR_BUFFER_BIT;
4486	}
4487
4488	vp_rect.left = vp->X;
4489	vp_rect.top = vp->Y;
4490	vp_rect.right = vp->X + vp->Width;
4491	vp_rect.bottom = vp->Y + vp->Height;
4492	if (!(Count > 0 && pRects)) {
4493	if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
4494	IntersectRect(&vp_rect, &vp_rect, &This->stateBlock->scissorRect);
4495	}
4496	if (context->render_offscreen)
4497	{
4498	glScissor(vp_rect.left, vp_rect.top,
4499	vp_rect.right - vp_rect.left, vp_rect.bottom - vp_rect.top);
4500	} else {
4501	glScissor(vp_rect.left, drawable_height - vp_rect.bottom,
4502	vp_rect.right - vp_rect.left, vp_rect.bottom - vp_rect.top);
4503	}
4504	checkGLcall("glScissor");
4505	glClear(glMask);
4506	checkGLcall("glClear");
4507	} else {
4508	/* Now process each rect in turn */
4509	for (i = 0; i < Count; i++) {
4510	/* Note gl uses lower left, width/height */
4511	IntersectRect((RECT )&curRect, &vp_rect, (const RECT )&pRects[i]);
4512	if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
4513	IntersectRect((RECT ) &curRect, (RECT ) &curRect, &This->stateBlock->scissorRect);
4514	}
4515	TRACE("(%p) Rect=(%d,%d)->(%d,%d) glRect=(%d,%d), len=%d, hei=%d\n", This,
4516	pRects[i].x1, pRects[i].y1, pRects[i].x2, pRects[i].y2,
4517	curRect.x1, (target->currentDesc.Height - curRect.y2),
4518	curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
4519
4520	/* Tests show that rectangles where x1 > x2 or y1 > y2 are ignored silently.
4521	* The rectangle is not cleared, no error is returned, but further rectanlges are
4522	* still cleared if they are valid
4523	*/
4524	if(curRect.x1 > curRect.x2 \|\| curRect.y1 > curRect.y2) {
4525	TRACE("Rectangle with negative dimensions, ignoring\n");
4526	continue;
4527	}
4528
4529	if (context->render_offscreen)
4530	{
4531	glScissor(curRect.x1, curRect.y1,
4532	curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
4533	} else {
4534	glScissor(curRect.x1, drawable_height - curRect.y2,
4535	curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
4536	}
4537	checkGLcall("glScissor");
4538
4539	glClear(glMask);
4540	checkGLcall("glClear");
4541	}
4542	}
4543
4544	if (Flags & WINED3DCLEAR_TARGET)
4545	{
4546	IWineD3DSurface_ModifyLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, TRUE);
4547	}
4548	if (Flags & WINED3DCLEAR_ZBUFFER) {
4549	/* Note that WINED3DCLEAR_ZBUFFER implies a depth stencil exists on the device */
4550	DWORD location = context->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
4551	surface_modify_ds_location(This->stencilBufferTarget, location);
4552	}
4553
4554	LEAVE_GL();
4555
4556	if (wined3d_settings.strict_draw_ordering \|\| ((target->Flags & SFLAG_SWAPCHAIN)
4557	&& ((IWineD3DSwapChainImpl )target->container)->frontBuffer == (IWineD3DSurface )target))
4558	wglFlush(); /* Flush to ensure ordering across contexts. */
4559
4560	context_release(context);
4561
4562	return WINED3D_OK;
4563	}
4564
4565	static HRESULT WINAPI IWineD3DDeviceImpl_Clear(IWineD3DDevice iface, DWORD Count, CONST WINED3DRECT pRects,
4566	DWORD Flags, WINED3DCOLOR Color, float Z, DWORD Stencil) {
4567	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4568	IWineD3DSurfaceImpl target = (IWineD3DSurfaceImpl )This->render_targets[0];
4569
4570	TRACE("(%p) Count (%d), pRects (%p), Flags (%x), Color (0x%08x), Z (%f), Stencil (%d)\n", This,
4571	Count, pRects, Flags, Color, Z, Stencil);
4572
4573	if(Flags & (WINED3DCLEAR_ZBUFFER \| WINED3DCLEAR_STENCIL) && This->stencilBufferTarget == NULL) {
4574	WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
4575	/* TODO: What about depth stencil buffers without stencil bits? */
4576	return WINED3DERR_INVALIDCALL;
4577	}
4578
4579	return IWineD3DDeviceImpl_ClearSurface(This, target, Count, pRects, Flags, Color, Z, Stencil);
4580	}
4581
4582	/*****
4583	* Drawing functions
4584	*****/
4585
4586	static void WINAPI IWineD3DDeviceImpl_SetPrimitiveType(IWineD3DDevice *iface,
4587	WINED3DPRIMITIVETYPE primitive_type)
4588	{
4589	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4590
4591	TRACE("iface %p, primitive_type %s\n", iface, debug_d3dprimitivetype(primitive_type));
4592
4593	This->updateStateBlock->changed.primitive_type = TRUE;
4594	This->updateStateBlock->gl_primitive_type = gl_primitive_type_from_d3d(primitive_type);
4595	}
4596
4597	static void WINAPI IWineD3DDeviceImpl_GetPrimitiveType(IWineD3DDevice *iface,
4598	WINED3DPRIMITIVETYPE *primitive_type)
4599	{
4600	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4601
4602	TRACE("iface %p, primitive_type %p\n", iface, primitive_type);
4603
4604	*primitive_type = d3d_primitive_type_from_gl(This->stateBlock->gl_primitive_type);
4605
4606	TRACE("Returning %s\n", debug_d3dprimitivetype(*primitive_type));
4607	}
4608
4609	static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitive(IWineD3DDevice *iface, UINT StartVertex, UINT vertex_count)
4610	{
4611	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4612
4613	TRACE("(%p) : start %u, count %u\n", This, StartVertex, vertex_count);
4614
4615	if(!This->stateBlock->vertexDecl) {
4616	WARN("(%p) : Called without a valid vertex declaration set\n", This);
4617	return WINED3DERR_INVALIDCALL;
4618	}
4619
4620	/* The index buffer is not needed here, but restore it, otherwise it is hell to keep track of */
4621	if(This->stateBlock->streamIsUP) {
4622	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
4623	This->stateBlock->streamIsUP = FALSE;
4624	}
4625
4626	if(This->stateBlock->loadBaseVertexIndex != 0) {
4627	This->stateBlock->loadBaseVertexIndex = 0;
4628	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
4629	}
4630	/* Account for the loading offset due to index buffers. Instead of reloading all sources correct it with the startvertex parameter */
4631	drawPrimitive(iface, vertex_count, StartVertex /* start_idx /, 0 / indxSize /, NULL / indxData */);
4632	return WINED3D_OK;
4633	}
4634
4635	static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitive(IWineD3DDevice *iface, UINT startIndex, UINT index_count)
4636	{
4637	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4638	UINT idxStride = 2;
4639	IWineD3DBuffer *pIB;
4640	GLuint vbo;
4641
4642	pIB = This->stateBlock->pIndexData;
4643	if (!pIB) {
4644	/* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
4645	* without an index buffer set. (The first time at least...)
4646	* D3D8 simply dies, but I doubt it can do much harm to return
4647	* D3DERR_INVALIDCALL there as well. */
4648	WARN("(%p) : Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL\n", This);
4649	return WINED3DERR_INVALIDCALL;
4650	}
4651
4652	if(!This->stateBlock->vertexDecl) {
4653	WARN("(%p) : Called without a valid vertex declaration set\n", This);
4654	return WINED3DERR_INVALIDCALL;
4655	}
4656
4657	if(This->stateBlock->streamIsUP) {
4658	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
4659	This->stateBlock->streamIsUP = FALSE;
4660	}
4661	vbo = ((struct wined3d_buffer *) pIB)->buffer_object;
4662
4663	TRACE("(%p) : startIndex %u, index count %u.\n", This, startIndex, index_count);
4664
4665	if (This->stateBlock->IndexFmt == WINED3DFMT_R16_UINT) {
4666	idxStride = 2;
4667	} else {
4668	idxStride = 4;
4669	}
4670
4671	if(This->stateBlock->loadBaseVertexIndex != This->stateBlock->baseVertexIndex) {
4672	This->stateBlock->loadBaseVertexIndex = This->stateBlock->baseVertexIndex;
4673	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
4674	}
4675
4676	drawPrimitive(iface, index_count, startIndex, idxStride,
4677	vbo ? NULL : ((struct wined3d_buffer *)pIB)->resource.allocatedMemory);
4678
4679	return WINED3D_OK;
4680	}
4681
4682	static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveUP(IWineD3DDevice *iface, UINT vertex_count,
4683	const void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
4684	{
4685	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4686	IWineD3DBuffer *vb;
4687
4688	TRACE("(%p) : vertex count %u, pVtxData %p, stride %u\n",
4689	This, vertex_count, pVertexStreamZeroData, VertexStreamZeroStride);
4690
4691	if(!This->stateBlock->vertexDecl) {
4692	WARN("(%p) : Called without a valid vertex declaration set\n", This);
4693	return WINED3DERR_INVALIDCALL;
4694	}
4695
4696	/* Note in the following, it's not this type, but that's the purpose of streamIsUP */
4697	vb = This->stateBlock->streamSource[0];
4698	This->stateBlock->streamSource[0] = (IWineD3DBuffer *)pVertexStreamZeroData;
4699	if (vb) IWineD3DBuffer_Release(vb);
4700	This->stateBlock->streamOffset[0] = 0;
4701	This->stateBlock->streamStride[0] = VertexStreamZeroStride;
4702	This->stateBlock->streamIsUP = TRUE;
4703	This->stateBlock->loadBaseVertexIndex = 0;
4704
4705	/* TODO: Only mark dirty if drawing from a different UP address */
4706	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
4707
4708	drawPrimitive(iface, vertex_count, 0 /* start_idx /, 0 / indxSize/, NULL / indxData */);
4709
4710	/* MSDN specifies stream zero settings must be set to NULL */
4711	This->stateBlock->streamStride[0] = 0;
4712	This->stateBlock->streamSource[0] = NULL;
4713
4714	/* stream zero settings set to null at end, as per the msdn. No need to mark dirty here, the app has to set
4715	* the new stream sources or use UP drawing again
4716	*/
4717	return WINED3D_OK;
4718	}
4719
4720	static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveUP(IWineD3DDevice *iface,
4721	UINT index_count, const void *pIndexData, WINED3DFORMAT IndexDataFormat,
4722	const void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
4723	{
4724	int idxStride;
4725	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4726	IWineD3DBuffer *vb;
4727	IWineD3DBuffer *ib;
4728
4729	TRACE("(%p) : index count %u, pidxdata %p, IdxFmt %u, pVtxdata %p, stride=%u.\n",
4730	This, index_count, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
4731
4732	if(!This->stateBlock->vertexDecl) {
4733	WARN("(%p) : Called without a valid vertex declaration set\n", This);
4734	return WINED3DERR_INVALIDCALL;
4735	}
4736
4737	if (IndexDataFormat == WINED3DFMT_R16_UINT) {
4738	idxStride = 2;
4739	} else {
4740	idxStride = 4;
4741	}
4742
4743	/* Note in the following, it's not this type, but that's the purpose of streamIsUP */
4744	vb = This->stateBlock->streamSource[0];
4745	This->stateBlock->streamSource[0] = (IWineD3DBuffer *)pVertexStreamZeroData;
4746	if (vb) IWineD3DBuffer_Release(vb);
4747	This->stateBlock->streamIsUP = TRUE;
4748	This->stateBlock->streamOffset[0] = 0;
4749	This->stateBlock->streamStride[0] = VertexStreamZeroStride;
4750
4751	/* Set to 0 as per msdn. Do it now due to the stream source loading during drawPrimitive */
4752	This->stateBlock->baseVertexIndex = 0;
4753	This->stateBlock->loadBaseVertexIndex = 0;
4754	/* Mark the state dirty until we have nicer tracking of the stream source pointers */
4755	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
4756	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
4757
4758	drawPrimitive(iface, index_count, 0 /* start_idx */, idxStride, pIndexData);
4759
4760	/* MSDN specifies stream zero settings and index buffer must be set to NULL */
4761	This->stateBlock->streamSource[0] = NULL;
4762	This->stateBlock->streamStride[0] = 0;
4763	ib = This->stateBlock->pIndexData;
4764	if(ib) {
4765	IWineD3DBuffer_Release(ib);
4766	This->stateBlock->pIndexData = NULL;
4767	}
4768	/* No need to mark the stream source state dirty here. Either the app calls UP drawing again, or it has to call
4769	* SetStreamSource to specify a vertex buffer
4770	*/
4771
4772	return WINED3D_OK;
4773	}
4774
4775	static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveStrided(IWineD3DDevice *iface,
4776	UINT vertex_count, const WineDirect3DVertexStridedData *DrawPrimStrideData)
4777	{
4778	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
4779
4780	/* Mark the state dirty until we have nicer tracking
4781	* its fine to change baseVertexIndex because that call is only called by ddraw which does not need
4782	* that value.
4783	*/
4784	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
4785	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
4786	This->stateBlock->baseVertexIndex = 0;
4787	This->up_strided = DrawPrimStrideData;
4788	drawPrimitive(iface, vertex_count, 0, 0, NULL);
4789	This->up_strided = NULL;
4790	return WINED3D_OK;
4791	}
4792
4793	static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided(IWineD3DDevice *iface,
4794	UINT vertex_count, const WineDirect3DVertexStridedData *DrawPrimStrideData,
4795	UINT NumVertices, const void *pIndexData, WINED3DFORMAT IndexDataFormat)
4796	{
4797	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
4798	DWORD idxSize = (IndexDataFormat == WINED3DFMT_R32_UINT ? 4 : 2);
4799
4800	/* Mark the state dirty until we have nicer tracking
4801	* its fine to change baseVertexIndex because that call is only called by ddraw which does not need
4802	* that value.
4803	*/
4804	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
4805	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
4806	This->stateBlock->streamIsUP = TRUE;
4807	This->stateBlock->baseVertexIndex = 0;
4808	This->up_strided = DrawPrimStrideData;
4809	drawPrimitive(iface, vertex_count, 0 /* start_idx */, idxSize, pIndexData);
4810	This->up_strided = NULL;
4811	return WINED3D_OK;
4812	}
4813
4814	/* This is a helper function for UpdateTexture, there is no UpdateVolume method in D3D. */
4815	static HRESULT IWineD3DDeviceImpl_UpdateVolume(IWineD3DDevice *iface,
4816	IWineD3DVolume pSourceVolume, IWineD3DVolume pDestinationVolume)
4817	{
4818	WINED3DLOCKED_BOX src;
4819	WINED3DLOCKED_BOX dst;
4820	HRESULT hr;
4821
4822	TRACE("iface %p, src_volume %p, dst_volume %p.\n",
4823	iface, pSourceVolume, pDestinationVolume);
4824
4825	/* TODO: Implement direct loading into the gl volume instead of using memcpy and
4826	* dirtification to improve loading performance.
4827	*/
4828	hr = IWineD3DVolume_LockBox(pSourceVolume, &src, NULL, WINED3DLOCK_READONLY);
4829	if(FAILED(hr)) return hr;
4830	hr = IWineD3DVolume_LockBox(pDestinationVolume, &dst, NULL, WINED3DLOCK_DISCARD);
4831	if(FAILED(hr)) {
4832	IWineD3DVolume_UnlockBox(pSourceVolume);
4833	return hr;
4834	}
4835
4836	memcpy(dst.pBits, src.pBits, ((IWineD3DVolumeImpl *) pDestinationVolume)->resource.size);
4837
4838	hr = IWineD3DVolume_UnlockBox(pDestinationVolume);
4839	if(FAILED(hr)) {
4840	IWineD3DVolume_UnlockBox(pSourceVolume);
4841	} else {
4842	hr = IWineD3DVolume_UnlockBox(pSourceVolume);
4843	}
4844	return hr;
4845	}
4846
4847	static HRESULT WINAPI IWineD3DDeviceImpl_UpdateTexture(IWineD3DDevice *iface,
4848	IWineD3DBaseTexture src_texture, IWineD3DBaseTexture dst_texture)
4849	{
4850	unsigned int level_count, i;
4851	WINED3DRESOURCETYPE type;
4852	HRESULT hr;
4853
4854	TRACE("iface %p, src_texture %p, dst_texture %p.\n", iface, src_texture, dst_texture);
4855
4856	/* Verify that the source and destination textures are non-NULL. */
4857	if (!src_texture \|\| !dst_texture)
4858	{
4859	WARN("Source and destination textures must be non-NULL, returning WINED3DERR_INVALIDCALL.\n");
4860	return WINED3DERR_INVALIDCALL;
4861	}
4862
4863	if (src_texture == dst_texture)
4864	{
4865	WARN("Source and destination are the same object, returning WINED3DERR_INVALIDCALL.\n");
4866	return WINED3DERR_INVALIDCALL;
4867	}
4868
4869	/* Verify that the source and destination textures are the same type. */
4870	type = IWineD3DBaseTexture_GetType(src_texture);
4871	if (IWineD3DBaseTexture_GetType(dst_texture) != type)
4872	{
4873	WARN("Source and destination have different types, returning WINED3DERR_INVALIDCALL.\n");
4874	return WINED3DERR_INVALIDCALL;
4875	}
4876
4877	/* Check that both textures have the identical numbers of levels. */
4878	level_count = IWineD3DBaseTexture_GetLevelCount(src_texture);
4879	if (IWineD3DBaseTexture_GetLevelCount(dst_texture) != level_count)
4880	{
4881	WARN("Source and destination have different level counts, returning WINED3DERR_INVALIDCALL.\n");
4882	return WINED3DERR_INVALIDCALL;
4883	}
4884
4885	/* Make sure that the destination texture is loaded. */
4886	((IWineD3DBaseTextureImpl *)dst_texture)->baseTexture.internal_preload(dst_texture, SRGB_RGB);
4887
4888	/* Update every surface level of the texture. */
4889	switch (type)
4890	{
4891	case WINED3DRTYPE_TEXTURE:
4892	{
4893	IWineD3DSurface *src_surface;
4894	IWineD3DSurface *dst_surface;
4895
4896	for (i = 0; i < level_count; ++i)
4897	{
4898	IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)src_texture, i, &src_surface);
4899	IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)dst_texture, i, &dst_surface);
4900	hr = IWineD3DDevice_UpdateSurface(iface, src_surface, NULL, dst_surface, NULL);
4901	IWineD3DSurface_Release(dst_surface);
4902	IWineD3DSurface_Release(src_surface);
4903	if (FAILED(hr))
4904	{
4905	WARN("IWineD3DDevice_UpdateSurface failed, hr %#x.\n", hr);
4906	return hr;
4907	}
4908	}
4909	break;
4910	}
4911
4912	case WINED3DRTYPE_CUBETEXTURE:
4913	{
4914	IWineD3DSurface *src_surface;
4915	IWineD3DSurface *dst_surface;
4916	WINED3DCUBEMAP_FACES face;
4917
4918	for (i = 0; i < level_count; ++i)
4919	{
4920	/* Update each cube face. */
4921	for (face = WINED3DCUBEMAP_FACE_POSITIVE_X; face <= WINED3DCUBEMAP_FACE_NEGATIVE_Z; ++face)
4922	{
4923	hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)src_texture,
4924	face, i, &src_surface);
4925	if (FAILED(hr)) ERR("Failed to get src cube surface face %u, level %u, hr %#x.\n", face, i, hr);
4926	hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)dst_texture,
4927	face, i, &dst_surface);
4928	if (FAILED(hr)) ERR("Failed to get dst cube surface face %u, level %u, hr %#x.\n", face, i, hr);
4929	hr = IWineD3DDevice_UpdateSurface(iface, src_surface, NULL, dst_surface, NULL);
4930	IWineD3DSurface_Release(dst_surface);
4931	IWineD3DSurface_Release(src_surface);
4932	if (FAILED(hr))
4933	{
4934	WARN("IWineD3DDevice_UpdateSurface failed, hr %#x.\n", hr);
4935	return hr;
4936	}
4937	}
4938	}
4939	break;
4940	}
4941
4942	case WINED3DRTYPE_VOLUMETEXTURE:
4943	{
4944	IWineD3DVolume *src_volume;
4945	IWineD3DVolume *dst_volume;
4946
4947	for (i = 0; i < level_count; ++i)
4948	{
4949	IWineD3DVolumeTexture_GetVolumeLevel((IWineD3DVolumeTexture *)src_texture, i, &src_volume);
4950	IWineD3DVolumeTexture_GetVolumeLevel((IWineD3DVolumeTexture *)dst_texture, i, &dst_volume);
4951	hr = IWineD3DDeviceImpl_UpdateVolume(iface, src_volume, dst_volume);
4952	IWineD3DVolume_Release(dst_volume);
4953	IWineD3DVolume_Release(src_volume);
4954	if (FAILED(hr))
4955	{
4956	WARN("IWineD3DDeviceImpl_UpdateVolume failed, hr %#x.\n", hr);
4957	return hr;
4958	}
4959	}
4960	break;
4961	}
4962
4963	default:
4964	FIXME("Unsupported texture type %#x.\n", type);
4965	return WINED3DERR_INVALIDCALL;
4966	}
4967
4968	return WINED3D_OK;
4969	}
4970
4971	static HRESULT WINAPI IWineD3DDeviceImpl_GetFrontBufferData(IWineD3DDevice iface,UINT iSwapChain, IWineD3DSurface pDestSurface) {
4972	IWineD3DSwapChain *swapChain;
4973	HRESULT hr;
4974	hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
4975	if(hr == WINED3D_OK) {
4976	hr = IWineD3DSwapChain_GetFrontBufferData(swapChain, pDestSurface);
4977	IWineD3DSwapChain_Release(swapChain);
4978	}
4979	return hr;
4980	}
4981
4982	static HRESULT WINAPI IWineD3DDeviceImpl_ValidateDevice(IWineD3DDevice iface, DWORD pNumPasses) {
4983	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
4984	IWineD3DBaseTextureImpl *texture;
4985	DWORD i;
4986
4987	TRACE("(%p) : %p\n", This, pNumPasses);
4988
4989	for(i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
4990	if(This->stateBlock->samplerState[i][WINED3DSAMP_MINFILTER] == WINED3DTEXF_NONE) {
4991	WARN("Sampler state %u has minfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
4992	return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
4993	}
4994	if(This->stateBlock->samplerState[i][WINED3DSAMP_MAGFILTER] == WINED3DTEXF_NONE) {
4995	WARN("Sampler state %u has magfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
4996	return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
4997	}
4998
4999	texture = (IWineD3DBaseTextureImpl *) This->stateBlock->textures[i];
5000	if (!texture \|\| texture->resource.format_desc->Flags & WINED3DFMT_FLAG_FILTERING) continue;
5001
5002	if(This->stateBlock->samplerState[i][WINED3DSAMP_MAGFILTER] != WINED3DTEXF_POINT) {
5003	WARN("Non-filterable texture and mag filter enabled on samper %u, returning E_FAIL\n", i);
5004	return E_FAIL;
5005	}
5006	if(This->stateBlock->samplerState[i][WINED3DSAMP_MINFILTER] != WINED3DTEXF_POINT) {
5007	WARN("Non-filterable texture and min filter enabled on samper %u, returning E_FAIL\n", i);
5008	return E_FAIL;
5009	}
5010	if(This->stateBlock->samplerState[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_NONE &&
5011	This->stateBlock->samplerState[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_POINT /* sic! */) {
5012	WARN("Non-filterable texture and mip filter enabled on samper %u, returning E_FAIL\n", i);
5013	return E_FAIL;
5014	}
5015	}
5016
5017	/* return a sensible default */
5018	*pNumPasses = 1;
5019
5020	TRACE("returning D3D_OK\n");
5021	return WINED3D_OK;
5022	}
5023
5024	static void dirtify_p8_texture_samplers(IWineD3DDeviceImpl *device)
5025	{
5026	int i;
5027
5028	for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
5029	{
5030	IWineD3DBaseTextureImpl texture = (IWineD3DBaseTextureImpl)device->stateBlock->textures[i];
5031	if (texture && (texture->resource.format_desc->format == WINED3DFMT_P8_UINT
5032	\|\| texture->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM))
5033	{
5034	IWineD3DDeviceImpl_MarkStateDirty(device, STATE_SAMPLER(i));
5035	}
5036	}
5037	}
5038
5039	static HRESULT WINAPI IWineD3DDeviceImpl_SetPaletteEntries(IWineD3DDevice iface, UINT PaletteNumber, CONST PALETTEENTRY pEntries) {
5040	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5041	int j;
5042	UINT NewSize;
5043	PALETTEENTRY **palettes;
5044
5045	TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5046
5047	if (PaletteNumber >= MAX_PALETTES) {
5048	ERR("(%p) : (%u) Out of range 0-%u, returning Invalid Call\n", This, PaletteNumber, MAX_PALETTES);
5049	return WINED3DERR_INVALIDCALL;
5050	}
5051
5052	if (PaletteNumber >= This->NumberOfPalettes) {
5053	NewSize = This->NumberOfPalettes;
5054	do {
5055	NewSize *= 2;
5056	} while(PaletteNumber >= NewSize);
5057	palettes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->palettes, sizeof(PALETTEENTRY) NewSize);
5058	if (!palettes) {
5059	ERR("Out of memory!\n");
5060	return E_OUTOFMEMORY;
5061	}
5062	This->palettes = palettes;
5063	This->NumberOfPalettes = NewSize;
5064	}
5065
5066	if (!This->palettes[PaletteNumber]) {
5067	This->palettes[PaletteNumber] = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
5068	if (!This->palettes[PaletteNumber]) {
5069	ERR("Out of memory!\n");
5070	return E_OUTOFMEMORY;
5071	}
5072	}
5073
5074	for (j = 0; j < 256; ++j) {
5075	This->palettes[PaletteNumber][j].peRed = pEntries[j].peRed;
5076	This->palettes[PaletteNumber][j].peGreen = pEntries[j].peGreen;
5077	This->palettes[PaletteNumber][j].peBlue = pEntries[j].peBlue;
5078	This->palettes[PaletteNumber][j].peFlags = pEntries[j].peFlags;
5079	}
5080	if (PaletteNumber == This->currentPalette) dirtify_p8_texture_samplers(This);
5081	TRACE("(%p) : returning\n", This);
5082	return WINED3D_OK;
5083	}
5084
5085	static HRESULT WINAPI IWineD3DDeviceImpl_GetPaletteEntries(IWineD3DDevice iface, UINT PaletteNumber, PALETTEENTRY pEntries) {
5086	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5087	int j;
5088	TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5089	if (PaletteNumber >= This->NumberOfPalettes \|\| !This->palettes[PaletteNumber]) {
5090	/* What happens in such situation isn't documented; Native seems to silently abort
5091	on such conditions. Return Invalid Call. */
5092	ERR("(%p) : (%u) Nonexistent palette. NumberOfPalettes %u\n", This, PaletteNumber, This->NumberOfPalettes);
5093	return WINED3DERR_INVALIDCALL;
5094	}
5095	for (j = 0; j < 256; ++j) {
5096	pEntries[j].peRed = This->palettes[PaletteNumber][j].peRed;
5097	pEntries[j].peGreen = This->palettes[PaletteNumber][j].peGreen;
5098	pEntries[j].peBlue = This->palettes[PaletteNumber][j].peBlue;
5099	pEntries[j].peFlags = This->palettes[PaletteNumber][j].peFlags;
5100	}
5101	TRACE("(%p) : returning\n", This);
5102	return WINED3D_OK;
5103	}
5104
5105	static HRESULT WINAPI IWineD3DDeviceImpl_SetCurrentTexturePalette(IWineD3DDevice *iface, UINT PaletteNumber) {
5106	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5107	TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5108	/* Native appears to silently abort on attempt to make an uninitialized palette current and render.
5109	(tested with reference rasterizer). Return Invalid Call. */
5110	if (PaletteNumber >= This->NumberOfPalettes \|\| !This->palettes[PaletteNumber]) {
5111	ERR("(%p) : (%u) Nonexistent palette. NumberOfPalettes %u\n", This, PaletteNumber, This->NumberOfPalettes);
5112	return WINED3DERR_INVALIDCALL;
5113	}
5114	/TODO: stateblocks /
5115	if (This->currentPalette != PaletteNumber) {
5116	This->currentPalette = PaletteNumber;
5117	dirtify_p8_texture_samplers(This);
5118	}
5119	TRACE("(%p) : returning\n", This);
5120	return WINED3D_OK;
5121	}
5122
5123	static HRESULT WINAPI IWineD3DDeviceImpl_GetCurrentTexturePalette(IWineD3DDevice iface, UINT PaletteNumber) {
5124	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5125	if (PaletteNumber == NULL) {
5126	WARN("(%p) : returning Invalid Call\n", This);
5127	return WINED3DERR_INVALIDCALL;
5128	}
5129	/TODO: stateblocks /
5130	*PaletteNumber = This->currentPalette;
5131	TRACE("(%p) : returning %u\n", This, *PaletteNumber);
5132	return WINED3D_OK;
5133	}
5134
5135	static HRESULT WINAPI IWineD3DDeviceImpl_SetSoftwareVertexProcessing(IWineD3DDevice *iface, BOOL bSoftware) {
5136	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5137	static BOOL warned;
5138	if (!warned)
5139	{
5140	FIXME("(%p) : stub\n", This);
5141	warned = TRUE;
5142	}
5143
5144	This->softwareVertexProcessing = bSoftware;
5145	return WINED3D_OK;
5146	}
5147
5148
5149	static BOOL WINAPI IWineD3DDeviceImpl_GetSoftwareVertexProcessing(IWineD3DDevice *iface) {
5150	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5151	static BOOL warned;
5152	if (!warned)
5153	{
5154	FIXME("(%p) : stub\n", This);
5155	warned = TRUE;
5156	}
5157	return This->softwareVertexProcessing;
5158	}
5159
5160	static HRESULT WINAPI IWineD3DDeviceImpl_GetRasterStatus(IWineD3DDevice *iface,
5161	UINT swapchain_idx, WINED3DRASTER_STATUS *raster_status)
5162	{
5163	IWineD3DSwapChain *swapchain;
5164	HRESULT hr;
5165
5166	TRACE("iface %p, swapchain_idx %u, raster_status %p.\n",
5167	iface, swapchain_idx, raster_status);
5168
5169	hr = IWineD3DDeviceImpl_GetSwapChain(iface, swapchain_idx, &swapchain);
5170	if (FAILED(hr))
5171	{
5172	WARN("Failed to get swapchain %u, hr %#x.\n", swapchain_idx, hr);
5173	return hr;
5174	}
5175
5176	hr = IWineD3DSwapChain_GetRasterStatus(swapchain, raster_status);
5177	IWineD3DSwapChain_Release(swapchain);
5178	if (FAILED(hr))
5179	{
5180	WARN("Failed to get raster status, hr %#x.\n", hr);
5181	return hr;
5182	}
5183
5184	return WINED3D_OK;
5185	}
5186
5187	static HRESULT WINAPI IWineD3DDeviceImpl_SetNPatchMode(IWineD3DDevice *iface, float nSegments)
5188	{
5189	static BOOL warned;
5190	if(nSegments != 0.0f) {
5191	if (!warned)
5192	{
5193	FIXME("iface %p, nSegments %.8e stub!\n", iface, nSegments);
5194	warned = TRUE;
5195	}
5196	}
5197	return WINED3D_OK;
5198	}
5199
5200	static float WINAPI IWineD3DDeviceImpl_GetNPatchMode(IWineD3DDevice *iface)
5201	{
5202	static BOOL warned;
5203	if (!warned)
5204	{
5205	FIXME("iface %p stub!\n", iface);
5206	warned = TRUE;
5207	}
5208	return 0.0f;
5209	}
5210
5211	static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface,
5212	IWineD3DSurface src_surface, const RECT src_rect,
5213	IWineD3DSurface dst_surface, const POINT dst_point)
5214	{
5215	IWineD3DSurfaceImpl src_impl = (IWineD3DSurfaceImpl )src_surface;
5216	IWineD3DSurfaceImpl dst_impl = (IWineD3DSurfaceImpl )dst_surface;
5217	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5218	const struct wined3d_format_desc *src_format;
5219	const struct wined3d_format_desc *dst_format;
5220	struct wined3d_context *context;
5221	const unsigned char *data;
5222	UINT update_w, update_h;
5223	CONVERT_TYPES convert;
5224	UINT src_w, src_h;
5225	UINT dst_x, dst_y;
5226	DWORD sampler;
5227	struct wined3d_format_desc dummy_desc;
5228
5229	TRACE("iface %p, src_surface %p, src_rect %s, dst_surface %p, dst_point %s",
5230	iface, src_surface, wine_dbgstr_rect(src_rect),
5231	dst_surface, wine_dbgstr_point(dst_point));
5232
5233	if (src_impl->resource.pool != WINED3DPOOL_SYSTEMMEM \|\| dst_impl->resource.pool != WINED3DPOOL_DEFAULT)
5234	{
5235	WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n",
5236	src_surface, dst_surface);
5237	return WINED3DERR_INVALIDCALL;
5238	}
5239
5240	src_format = src_impl->resource.format_desc;
5241	dst_format = dst_impl->resource.format_desc;
5242
5243	if (src_format->format != dst_format->format)
5244	{
5245	WARN("Source and destination surfaces should have the same format.\n");
5246	return WINED3DERR_INVALIDCALL;
5247	}
5248
5249	dst_x = dst_point ? dst_point->x : 0;
5250	dst_y = dst_point ? dst_point->y : 0;
5251
5252	/* This call loads the OpenGL surface directly, instead of copying the
5253	* surface to the destination's sysmem copy. If surface conversion is
5254	* needed, use BltFast instead to copy in sysmem and use regular surface
5255	* loading. */
5256	d3dfmt_get_conv(dst_impl, FALSE, TRUE, &dummy_desc, &convert);
5257	if (convert != NO_CONVERSION)
5258	return IWineD3DSurface_BltFast(dst_surface, dst_x, dst_y, src_surface, src_rect, 0);
5259
5260	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
5261
5262	ENTER_GL();
5263	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
5264	checkGLcall("glActiveTextureARB");
5265	LEAVE_GL();
5266
5267	/* Make sure the surface is loaded and up to date */
5268	surface_internal_preload(dst_surface, SRGB_RGB);
5269	IWineD3DSurface_BindTexture(dst_surface, FALSE);
5270
5271	src_w = src_impl->currentDesc.Width;
5272	src_h = src_impl->currentDesc.Height;
5273	update_w = src_rect ? src_rect->right - src_rect->left : src_w;
5274	update_h = src_rect ? src_rect->bottom - src_rect->top : src_h;
5275
5276	data = IWineD3DSurface_GetData(src_surface);
5277	if (!data) ERR("Source surface has no allocated memory, but should be a sysmem surface.\n");
5278
5279	ENTER_GL();
5280
5281	if (dst_format->Flags & WINED3DFMT_FLAG_COMPRESSED)
5282	{
5283	UINT row_length = (update_w / src_format->block_width) * src_format->block_byte_count;
5284	UINT row_count = update_h / src_format->block_height;
5285	UINT src_pitch = IWineD3DSurface_GetPitch(src_surface);
5286
5287	if (src_rect)
5288	{
5289	data += (src_rect->top / src_format->block_height) * src_pitch;
5290	data += (src_rect->left / src_format->block_width) * src_format->block_byte_count;
5291	}
5292
5293	TRACE("glCompressedTexSubImage2DARB, target %#x, level %d, x %d, y %d, w %d, h %d, "
5294	"format %#x, image_size %#x, data %p.\n", dst_impl->texture_target, dst_impl->texture_level,
5295	dst_x, dst_y, update_w, update_h, dst_format->glFormat, row_count * row_length, data);
5296
5297	if (row_length == src_pitch)
5298	{
5299	GL_EXTCALL(glCompressedTexSubImage2DARB(dst_impl->texture_target, dst_impl->texture_level,
5300	dst_x, dst_y, update_w, update_h, dst_format->glInternal, row_count * row_length, data));
5301	}
5302	else
5303	{
5304	UINT row, y;
5305
5306	/* glCompressedTexSubImage2DARB() ignores pixel store state, so we
5307	* can't use the unpack row length like below. */
5308	for (row = 0, y = dst_y; row < row_count; ++row)
5309	{
5310	GL_EXTCALL(glCompressedTexSubImage2DARB(dst_impl->texture_target, dst_impl->texture_level,
5311	dst_x, y, update_w, src_format->block_height, dst_format->glInternal, row_length, data));
5312	y += src_format->block_height;
5313	data += src_pitch;
5314	}
5315	}
5316	checkGLcall("glCompressedTexSubImage2DARB");
5317	}
5318	else
5319	{
5320	if (src_rect)
5321	{
5322	data += src_rect->top * src_w * src_format->byte_count;
5323	data += src_rect->left * src_format->byte_count;
5324	}
5325
5326	TRACE("glTexSubImage2D, target %#x, level %d, x %d, y %d, w %d, h %d, format %#x, type %#x, data %p.\n",
5327	dst_impl->texture_target, dst_impl->texture_level, dst_x, dst_y,
5328	update_w, update_h, dst_format->glFormat, dst_format->glType, data);
5329
5330	glPixelStorei(GL_UNPACK_ROW_LENGTH, src_w);
5331	glTexSubImage2D(dst_impl->texture_target, dst_impl->texture_level, dst_x, dst_y,
5332	update_w, update_h, dst_format->glFormat, dst_format->glType, data);
5333	glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
5334	checkGLcall("glTexSubImage2D");
5335	}
5336
5337	LEAVE_GL();
5338	context_release(context);
5339
5340	IWineD3DSurface_ModifyLocation(dst_surface, SFLAG_INTEXTURE, TRUE);
5341	sampler = This->rev_tex_unit_map[0];
5342	if (sampler != WINED3D_UNMAPPED_STAGE)
5343	{
5344	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(sampler));
5345	}
5346
5347	return WINED3D_OK;
5348	}
5349
5350	static HRESULT WINAPI IWineD3DDeviceImpl_DrawRectPatch(IWineD3DDevice iface, UINT Handle, CONST float pNumSegs, CONST WINED3DRECTPATCH_INFO* pRectPatchInfo) {
5351	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5352	struct WineD3DRectPatch *patch;
5353	GLenum old_primitive_type;
5354	unsigned int i;
5355	struct list *e;
5356	BOOL found;
5357	TRACE("(%p) Handle(%d) noSegs(%p) rectpatch(%p)\n", This, Handle, pNumSegs, pRectPatchInfo);
5358
5359	if(!(Handle \|\| pRectPatchInfo)) {
5360	/* TODO: Write a test for the return value, thus the FIXME */
5361	FIXME("Both Handle and pRectPatchInfo are NULL\n");
5362	return WINED3DERR_INVALIDCALL;
5363	}
5364
5365	if(Handle) {
5366	i = PATCHMAP_HASHFUNC(Handle);
5367	found = FALSE;
5368	LIST_FOR_EACH(e, &This->patches[i]) {
5369	patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5370	if(patch->Handle == Handle) {
5371	found = TRUE;
5372	break;
5373	}
5374	}
5375
5376	if(!found) {
5377	TRACE("Patch does not exist. Creating a new one\n");
5378	patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
5379	patch->Handle = Handle;
5380	list_add_head(&This->patches[i], &patch->entry);
5381	} else {
5382	TRACE("Found existing patch %p\n", patch);
5383	}
5384	} else {
5385	/* Since opengl does not load tesselated vertex attributes into numbered vertex
5386	* attributes we have to tesselate, read back, and draw. This needs a patch
5387	* management structure instance. Create one.
5388	*
5389	* A possible improvement is to check if a vertex shader is used, and if not directly
5390	* draw the patch.
5391	*/
5392	FIXME("Drawing an uncached patch. This is slow\n");
5393	patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
5394	}
5395
5396	if(pNumSegs[0] != patch->numSegs[0] \|\| pNumSegs[1] != patch->numSegs[1] \|\|
5397	pNumSegs[2] != patch->numSegs[2] \|\| pNumSegs[3] != patch->numSegs[3] \|\|
5398	(pRectPatchInfo && memcmp(pRectPatchInfo, &patch->RectPatchInfo, sizeof(*pRectPatchInfo)) != 0) ) {
5399	HRESULT hr;
5400	TRACE("Tesselation density or patch info changed, retesselating\n");
5401
5402	if(pRectPatchInfo) {
5403	patch->RectPatchInfo = *pRectPatchInfo;
5404	}
5405	patch->numSegs[0] = pNumSegs[0];
5406	patch->numSegs[1] = pNumSegs[1];
5407	patch->numSegs[2] = pNumSegs[2];
5408	patch->numSegs[3] = pNumSegs[3];
5409
5410	hr = tesselate_rectpatch(This, patch);
5411	if(FAILED(hr)) {
5412	WARN("Patch tesselation failed\n");
5413
5414	/* Do not release the handle to store the params of the patch */
5415	if(!Handle) {
5416	HeapFree(GetProcessHeap(), 0, patch);
5417	}
5418	return hr;
5419	}
5420	}
5421
5422	This->currentPatch = patch;
5423	old_primitive_type = This->stateBlock->gl_primitive_type;
5424	This->stateBlock->gl_primitive_type = GL_TRIANGLES;
5425	IWineD3DDevice_DrawPrimitiveStrided(iface, patch->numSegs[0] * patch->numSegs[1] * 2 * 3, &patch->strided);
5426	This->stateBlock->gl_primitive_type = old_primitive_type;
5427	This->currentPatch = NULL;
5428
5429	/* Destroy uncached patches */
5430	if(!Handle) {
5431	HeapFree(GetProcessHeap(), 0, patch->mem);
5432	HeapFree(GetProcessHeap(), 0, patch);
5433	}
5434	return WINED3D_OK;
5435	}
5436
5437	static HRESULT WINAPI IWineD3DDeviceImpl_DrawTriPatch(IWineD3DDevice *iface,
5438	UINT handle, const float segment_count, const WINED3DTRIPATCH_INFO patch_info)
5439	{
5440	FIXME("iface %p, handle %#x, segment_count %p, patch_info %p stub!\n",
5441	iface, handle, segment_count, patch_info);
5442
5443	return WINED3D_OK;
5444	}
5445
5446	static HRESULT WINAPI IWineD3DDeviceImpl_DeletePatch(IWineD3DDevice *iface, UINT Handle) {
5447	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5448	int i;
5449	struct WineD3DRectPatch *patch;
5450	struct list *e;
5451	TRACE("(%p) Handle(%d)\n", This, Handle);
5452
5453	i = PATCHMAP_HASHFUNC(Handle);
5454	LIST_FOR_EACH(e, &This->patches[i]) {
5455	patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5456	if(patch->Handle == Handle) {
5457	TRACE("Deleting patch %p\n", patch);
5458	list_remove(&patch->entry);
5459	HeapFree(GetProcessHeap(), 0, patch->mem);
5460	HeapFree(GetProcessHeap(), 0, patch);
5461	return WINED3D_OK;
5462	}
5463	}
5464
5465	/* TODO: Write a test for the return value */
5466	FIXME("Attempt to destroy nonexistent patch\n");
5467	return WINED3DERR_INVALIDCALL;
5468	}
5469
5470	static void color_fill_fbo(IWineD3DDevice iface, IWineD3DSurface surface,
5471	const WINED3DRECT *rect, const float color[4])
5472	{
5473	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
5474	struct wined3d_context *context;
5475
5476	if (rect) IWineD3DSurface_LoadLocation(surface, SFLAG_INDRAWABLE, NULL);
5477	IWineD3DSurface_ModifyLocation(surface, SFLAG_INDRAWABLE, TRUE);
5478
5479	if (!surface_is_offscreen(surface))
5480	{
5481	TRACE("Surface %p is onscreen\n", surface);
5482
5483	context = context_acquire(This, surface, CTXUSAGE_RESOURCELOAD);
5484	ENTER_GL();
5485	context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
5486	context_set_draw_buffer(context, surface_get_gl_buffer(surface));
5487	}
5488	else
5489	{
5490	TRACE("Surface %p is offscreen\n", surface);
5491
5492	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
5493	ENTER_GL();
5494	context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
5495	context_attach_surface_fbo(context, GL_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)surface);
5496	context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, NULL, FALSE);
5497	}
5498
5499	if (rect) {
5500	glEnable(GL_SCISSOR_TEST);
5501	if(surface_is_offscreen(surface)) {
5502	glScissor(rect->x1, rect->y1, rect->x2 - rect->x1, rect->y2 - rect->y1);
5503	} else {
5504	glScissor(rect->x1, ((IWineD3DSurfaceImpl *)surface)->currentDesc.Height - rect->y2,
5505	rect->x2 - rect->x1, rect->y2 - rect->y1);
5506	}
5507	checkGLcall("glScissor");
5508	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SCISSORRECT);
5509	} else {
5510	glDisable(GL_SCISSOR_TEST);
5511	}
5512	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
5513
5514	glDisable(GL_BLEND);
5515	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
5516
5517	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
5518	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
5519	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
5520	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
5521	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
5522
5523	glClearColor(color[0], color[1], color[2], color[3]);
5524	glClear(GL_COLOR_BUFFER_BIT);
5525	checkGLcall("glClear");
5526
5527	LEAVE_GL();
5528
5529	if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
5530
5531	context_release(context);
5532	}
5533
5534	static HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface,
5535	IWineD3DSurface pSurface, const WINED3DRECT pRect, WINED3DCOLOR color)
5536	{
5537	IWineD3DSurfaceImpl surface = (IWineD3DSurfaceImpl ) pSurface;
5538	WINEDDBLTFX BltFx;
5539
5540	TRACE("iface %p, surface %p, rect %p, color 0x%08x.\n", iface, pSurface, pRect, color);
5541
5542	if (surface->resource.pool != WINED3DPOOL_DEFAULT && surface->resource.pool != WINED3DPOOL_SYSTEMMEM) {
5543	FIXME("call to colorfill with non WINED3DPOOL_DEFAULT or WINED3DPOOL_SYSTEMMEM surface\n");
5544	return WINED3DERR_INVALIDCALL;
5545	}
5546
5547	if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
5548	const float c[4] = {D3DCOLOR_R(color), D3DCOLOR_G(color), D3DCOLOR_B(color), D3DCOLOR_A(color)};
5549	color_fill_fbo(iface, pSurface, pRect, c);
5550	return WINED3D_OK;
5551	} else {
5552	/* Just forward this to the DirectDraw blitting engine */
5553	memset(&BltFx, 0, sizeof(BltFx));
5554	BltFx.dwSize = sizeof(BltFx);
5555	BltFx.u5.dwFillColor = color_convert_argb_to_fmt(color, surface->resource.format_desc->format);
5556	return IWineD3DSurface_Blt(pSurface, (const RECT *)pRect, NULL, NULL,
5557	WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
5558	}
5559	}
5560
5561	static void WINAPI IWineD3DDeviceImpl_ClearRendertargetView(IWineD3DDevice *iface,
5562	IWineD3DRendertargetView *rendertarget_view, const float color[4])
5563	{
5564	IWineD3DResource *resource;
5565	IWineD3DSurface *surface;
5566	HRESULT hr;
5567
5568	hr = IWineD3DRendertargetView_GetResource(rendertarget_view, &resource);
5569	if (FAILED(hr))
5570	{
5571	ERR("Failed to get resource, hr %#x\n", hr);
5572	return;
5573	}
5574
5575	if (IWineD3DResource_GetType(resource) != WINED3DRTYPE_SURFACE)
5576	{
5577	FIXME("Only supported on surface resources\n");
5578	IWineD3DResource_Release(resource);
5579	return;
5580	}
5581
5582	surface = (IWineD3DSurface *)resource;
5583
5584	if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
5585	{
5586	color_fill_fbo(iface, surface, NULL, color);
5587	}
5588	else
5589	{
5590	WINEDDBLTFX BltFx;
5591	WINED3DCOLOR c;
5592
5593	WARN("Converting to WINED3DCOLOR, this might give incorrect results\n");
5594
5595	c = ((DWORD)(color[2] * 255.0f));
5596	c \|= ((DWORD)(color[1] * 255.0f)) << 8;
5597	c \|= ((DWORD)(color[0] * 255.0f)) << 16;
5598	c \|= ((DWORD)(color[3] * 255.0f)) << 24;
5599
5600	/* Just forward this to the DirectDraw blitting engine */
5601	memset(&BltFx, 0, sizeof(BltFx));
5602	BltFx.dwSize = sizeof(BltFx);
5603	BltFx.u5.dwFillColor = color_convert_argb_to_fmt(c, ((IWineD3DSurfaceImpl *)surface)->resource.format_desc->format);
5604	hr = IWineD3DSurface_Blt(surface, NULL, NULL, NULL, WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
5605	if (FAILED(hr))
5606	{
5607	ERR("Blt failed, hr %#x\n", hr);
5608	}
5609	}
5610
5611	IWineD3DResource_Release(resource);
5612	}
5613
5614	/* rendertarget and depth stencil functions */
5615	static HRESULT WINAPI IWineD3DDeviceImpl_GetRenderTarget(IWineD3DDevice* iface,DWORD RenderTargetIndex, IWineD3DSurface **ppRenderTarget) {
5616	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5617
5618	if (RenderTargetIndex >= This->adapter->gl_info.limits.buffers)
5619	{
5620	ERR("(%p) : Only %d render targets are supported.\n",
5621	This, This->adapter->gl_info.limits.buffers);
5622	return WINED3DERR_INVALIDCALL;
5623	}
5624
5625	*ppRenderTarget = This->render_targets[RenderTargetIndex];
5626	TRACE("(%p) : RenderTarget %d Index returning %p\n", This, RenderTargetIndex, *ppRenderTarget);
5627	/* Note inc ref on returned surface */
5628	if(*ppRenderTarget != NULL)
5629	IWineD3DSurface_AddRef(*ppRenderTarget);
5630	return WINED3D_OK;
5631	}
5632
5633	static HRESULT WINAPI IWineD3DDeviceImpl_SetFrontBackBuffers(IWineD3DDevice *iface,
5634	IWineD3DSurface front, IWineD3DSurface back)
5635	{
5636	IWineD3DSurfaceImpl front_impl = (IWineD3DSurfaceImpl )front;
5637	IWineD3DSurfaceImpl back_impl = (IWineD3DSurfaceImpl )back;
5638	IWineD3DSwapChainImpl *swapchain;
5639	HRESULT hr;
5640
5641	TRACE("iface %p, front %p, back %p.\n", iface, front, back);
5642
5643	if (FAILED(hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **)&swapchain)))
5644	{
5645	ERR("Failed to get the swapchain, hr %#x.\n", hr);
5646	return hr;
5647	}
5648
5649	if (front_impl && !(front_impl->resource.usage & WINED3DUSAGE_RENDERTARGET))
5650	{
5651	ERR("Trying to set a front buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage.\n");
5652	IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
5653	return WINED3DERR_INVALIDCALL;
5654	}
5655
5656	if (back_impl)
5657	{
5658	if (!(back_impl->resource.usage & WINED3DUSAGE_RENDERTARGET))
5659	{
5660	ERR("Trying to set a back buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage.\n");
5661	IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
5662	return WINED3DERR_INVALIDCALL;
5663	}
5664
5665	if (!swapchain->backBuffer)
5666	{
5667	swapchain->backBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*swapchain->backBuffer));
5668	if (!swapchain->backBuffer)
5669	{
5670	ERR("Failed to allocate back buffer array memory.\n");
5671	IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
5672	return E_OUTOFMEMORY;
5673	}
5674	}
5675	}
5676
5677	if (swapchain->frontBuffer != front)
5678	{
5679	TRACE("Changing the front buffer from %p to %p.\n", swapchain->frontBuffer, front);
5680
5681	if (swapchain->frontBuffer)
5682	{
5683	IWineD3DSurface_SetContainer(swapchain->frontBuffer, NULL);
5684	((IWineD3DSurfaceImpl *)swapchain->frontBuffer)->Flags &= ~SFLAG_SWAPCHAIN;
5685	}
5686	swapchain->frontBuffer = front;
5687
5688	if (front)
5689	{
5690	IWineD3DSurface_SetContainer(front, (IWineD3DBase *)swapchain);
5691	front_impl->Flags \|= SFLAG_SWAPCHAIN;
5692	}
5693	}
5694
5695	if (swapchain->backBuffer[0] != back)
5696	{
5697	TRACE("Changing the back buffer from %p to %p.\n", swapchain->backBuffer[0], back);
5698
5699	if (swapchain->backBuffer[0])
5700	{
5701	IWineD3DSurface_SetContainer(swapchain->backBuffer[0], NULL);
5702	((IWineD3DSurfaceImpl *)swapchain->backBuffer[0])->Flags &= ~SFLAG_SWAPCHAIN;
5703	}
5704	swapchain->backBuffer[0] = back;
5705
5706	if (back)
5707	{
5708	swapchain->presentParms.BackBufferWidth = back_impl->currentDesc.Width;
5709	swapchain->presentParms.BackBufferHeight = back_impl->currentDesc.Height;
5710	swapchain->presentParms.BackBufferFormat = back_impl->resource.format_desc->format;
5711	swapchain->presentParms.BackBufferCount = 1;
5712
5713	IWineD3DSurface_SetContainer(back, (IWineD3DBase *)swapchain);
5714	back_impl->Flags \|= SFLAG_SWAPCHAIN;
5715	}
5716	else
5717	{
5718	swapchain->presentParms.BackBufferCount = 0;
5719	HeapFree(GetProcessHeap(), 0, swapchain->backBuffer);
5720	swapchain->backBuffer = NULL;
5721	}
5722	}
5723
5724	IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
5725	return WINED3D_OK;
5726	}
5727
5728	static HRESULT WINAPI IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) {
5729	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5730	*ppZStencilSurface = This->stencilBufferTarget;
5731	TRACE("(%p) : zStencilSurface returning %p\n", This, *ppZStencilSurface);
5732
5733	if(*ppZStencilSurface != NULL) {
5734	/* Note inc ref on returned surface */
5735	IWineD3DSurface_AddRef(*ppZStencilSurface);
5736	return WINED3D_OK;
5737	} else {
5738	return WINED3DERR_NOTFOUND;
5739	}
5740	}
5741
5742	void stretch_rect_fbo(IWineD3DDevice iface, IWineD3DSurface src_surface, const RECT *src_rect_in,
5743	IWineD3DSurface dst_surface, const RECT dst_rect_in, const WINED3DTEXTUREFILTERTYPE filter)
5744	{
5745	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5746	GLbitfield mask = GL_COLOR_BUFFER_BIT; /* TODO: Support blitting depth/stencil surfaces */
5747	const struct wined3d_gl_info *gl_info;
5748	struct wined3d_context *context;
5749	GLenum gl_filter;
5750	POINT offset = {0, 0};
5751	RECT src_rect, dst_rect;
5752
5753	TRACE("(%p) : src_surface %p, src_rect_in %p, dst_surface %p, dst_rect_in %p, filter %s (0x%08x)\n",
5754	This, src_surface, src_rect_in, dst_surface, dst_rect_in, debug_d3dtexturefiltertype(filter), filter);
5755	TRACE("src_rect_in %s\n", wine_dbgstr_rect(src_rect_in));
5756	TRACE("dst_rect_in %s\n", wine_dbgstr_rect(dst_rect_in));
5757
5758	src_rect = *src_rect_in;
5759	dst_rect = *dst_rect_in;
5760
5761	switch (filter) {
5762	case WINED3DTEXF_LINEAR:
5763	gl_filter = GL_LINEAR;
5764	break;
5765
5766	default:
5767	FIXME("Unsupported filter mode %s (0x%08x)\n", debug_d3dtexturefiltertype(filter), filter);
5768	case WINED3DTEXF_NONE:
5769	case WINED3DTEXF_POINT:
5770	gl_filter = GL_NEAREST;
5771	break;
5772	}
5773
5774	/* Make sure the drawables are up-to-date. Note that loading the
5775	* destination surface isn't strictly required if we overwrite the
5776	* entire surface. */
5777	IWineD3DSurface_LoadLocation(src_surface, SFLAG_INDRAWABLE, NULL);
5778	IWineD3DSurface_LoadLocation(dst_surface, SFLAG_INDRAWABLE, NULL);
5779
5780	if (!surface_is_offscreen(src_surface)) context = context_acquire(This, src_surface, CTXUSAGE_RESOURCELOAD);
5781	else if (!surface_is_offscreen(dst_surface)) context = context_acquire(This, dst_surface, CTXUSAGE_RESOURCELOAD);
5782	else context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
5783
5784	if (!context->valid)
5785	{
5786	context_release(context);
5787	WARN("Invalid context, skipping blit.\n");
5788	return;
5789	}
5790
5791	gl_info = context->gl_info;
5792
5793	if (!surface_is_offscreen(src_surface))
5794	{
5795	GLenum buffer = surface_get_gl_buffer(src_surface);
5796
5797	TRACE("Source surface %p is onscreen\n", src_surface);
5798
5799	if(buffer == GL_FRONT) {
5800	RECT windowsize;
5801	UINT h;
5802	ClientToScreen(context->win_handle, &offset);
5803	GetClientRect(context->win_handle, &windowsize);
5804	h = windowsize.bottom - windowsize.top;
5805	src_rect.left -= offset.x; src_rect.right -=offset.x;
5806	src_rect.top = offset.y + h - src_rect.top;
5807	src_rect.bottom = offset.y + h - src_rect.bottom;
5808	} else {
5809	src_rect.top = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect.top;
5810	src_rect.bottom = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect.bottom;
5811	}
5812
5813	ENTER_GL();
5814	context_bind_fbo(context, GL_READ_FRAMEBUFFER, NULL);
5815	glReadBuffer(buffer);
5816	checkGLcall("glReadBuffer()");
5817	} else {
5818	TRACE("Source surface %p is offscreen\n", src_surface);
5819	ENTER_GL();
5820	context_bind_fbo(context, GL_READ_FRAMEBUFFER, &context->src_fbo);
5821	context_attach_surface_fbo(context, GL_READ_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)src_surface);
5822	glReadBuffer(GL_COLOR_ATTACHMENT0);
5823	checkGLcall("glReadBuffer()");
5824	context_attach_depth_stencil_fbo(context, GL_READ_FRAMEBUFFER, NULL, FALSE);
5825	}
5826	LEAVE_GL();
5827
5828	/* Attach dst surface to dst fbo */
5829	if (!surface_is_offscreen(dst_surface))
5830	{
5831	GLenum buffer = surface_get_gl_buffer(dst_surface);
5832
5833	TRACE("Destination surface %p is onscreen\n", dst_surface);
5834
5835	if(buffer == GL_FRONT) {
5836	RECT windowsize;
5837	UINT h;
5838	ClientToScreen(context->win_handle, &offset);
5839	GetClientRect(context->win_handle, &windowsize);
5840	h = windowsize.bottom - windowsize.top;
5841	dst_rect.left -= offset.x; dst_rect.right -=offset.x;
5842	dst_rect.top = offset.y + h - dst_rect.top;
5843	dst_rect.bottom = offset.y + h - dst_rect.bottom;
5844	} else {
5845	/* Screen coords = window coords, surface height = window height */
5846	dst_rect.top = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect.top;
5847	dst_rect.bottom = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect.bottom;
5848	}
5849
5850	ENTER_GL();
5851	context_bind_fbo(context, GL_DRAW_FRAMEBUFFER, NULL);
5852	context_set_draw_buffer(context, buffer);
5853	}
5854	else
5855	{
5856	TRACE("Destination surface %p is offscreen\n", dst_surface);
5857
5858	ENTER_GL();
5859	context_bind_fbo(context, GL_DRAW_FRAMEBUFFER, &context->dst_fbo);
5860	context_attach_surface_fbo(context, GL_DRAW_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)dst_surface);
5861	context_set_draw_buffer(context, GL_COLOR_ATTACHMENT0);
5862	context_attach_depth_stencil_fbo(context, GL_DRAW_FRAMEBUFFER, NULL, FALSE);
5863	}
5864	glDisable(GL_SCISSOR_TEST);
5865	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
5866
5867	gl_info->fbo_ops.glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom,
5868	dst_rect.left, dst_rect.top, dst_rect.right, dst_rect.bottom, mask, gl_filter);
5869	checkGLcall("glBlitFramebuffer()");
5870
5871	LEAVE_GL();
5872
5873	if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
5874
5875	context_release(context);
5876
5877	IWineD3DSurface_ModifyLocation(dst_surface, SFLAG_INDRAWABLE, TRUE);
5878	}
5879
5880	static HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice iface, DWORD RenderTargetIndex, IWineD3DSurface pRenderTarget,
5881	BOOL set_viewport) {
5882	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5883
5884	TRACE("(%p) : Setting rendertarget %d to %p\n", This, RenderTargetIndex, pRenderTarget);
5885
5886	if (RenderTargetIndex >= This->adapter->gl_info.limits.buffers)
5887	{
5888	WARN("(%p) : Unsupported target %u set, returning WINED3DERR_INVALIDCALL(only %u supported)\n",
5889	This, RenderTargetIndex, This->adapter->gl_info.limits.buffers);
5890	return WINED3DERR_INVALIDCALL;
5891	}
5892
5893	/* MSDN says that null disables the render target
5894	but a device must always be associated with a render target
5895	nope MSDN says that we return invalid call to a null rendertarget with an index of 0
5896	*/
5897	if (RenderTargetIndex == 0 && pRenderTarget == NULL) {
5898	FIXME("Trying to set render target 0 to NULL\n");
5899	return WINED3DERR_INVALIDCALL;
5900	}
5901	if (pRenderTarget && !(((IWineD3DSurfaceImpl *)pRenderTarget)->resource.usage & WINED3DUSAGE_RENDERTARGET)) {
5902	FIXME("(%p)Trying to set the render target to a surface(%p) that wasn't created with a usage of WINED3DUSAGE_RENDERTARGET\n",This ,pRenderTarget);
5903	return WINED3DERR_INVALIDCALL;
5904	}
5905
5906	/* If we are trying to set what we already have, don't bother */
5907	if (pRenderTarget == This->render_targets[RenderTargetIndex]) {
5908	TRACE("Trying to do a NOP SetRenderTarget operation\n");
5909	return WINED3D_OK;
5910	}
5911	if(pRenderTarget) IWineD3DSurface_AddRef(pRenderTarget);
5912	if(This->render_targets[RenderTargetIndex]) IWineD3DSurface_Release(This->render_targets[RenderTargetIndex]);
5913	This->render_targets[RenderTargetIndex] = pRenderTarget;
5914
5915	/* Render target 0 is special */
5916	if(RenderTargetIndex == 0 && set_viewport) {
5917	/* Finally, reset the viewport and scissor rect as the MSDN states.
5918	* Tests show that stateblock recording is ignored, the change goes
5919	* directly into the primary stateblock.
5920	*/
5921	This->stateBlock->viewport.Height = ((IWineD3DSurfaceImpl *)This->render_targets[0])->currentDesc.Height;
5922	This->stateBlock->viewport.Width = ((IWineD3DSurfaceImpl *)This->render_targets[0])->currentDesc.Width;
5923	This->stateBlock->viewport.X = 0;
5924	This->stateBlock->viewport.Y = 0;
5925	This->stateBlock->viewport.MaxZ = 1.0f;
5926	This->stateBlock->viewport.MinZ = 0.0f;
5927	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VIEWPORT);
5928
5929	This->stateBlock->scissorRect.top = 0;
5930	This->stateBlock->scissorRect.left = 0;
5931	This->stateBlock->scissorRect.right = This->stateBlock->viewport.Width;
5932	This->stateBlock->scissorRect.bottom = This->stateBlock->viewport.Height;
5933	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SCISSORRECT);
5934	}
5935	return WINED3D_OK;
5936	}
5937
5938	static HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice iface, IWineD3DSurface pNewZStencil) {
5939	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
5940	HRESULT hr = WINED3D_OK;
5941	IWineD3DSurface *tmp;
5942
5943	TRACE("(%p) Swapping z-buffer. Old = %p, new = %p\n",This, This->stencilBufferTarget, pNewZStencil);
5944
5945	if (pNewZStencil == This->stencilBufferTarget) {
5946	TRACE("Trying to do a NOP SetRenderTarget operation\n");
5947	} else {
5948	/** OpenGL doesn't support 'sharing' of the stencilBuffer so we may incur an extra memory overhead
5949	* depending on the renter target implementation being used.
5950	* A shared context implementation will share all buffers between all rendertargets (including swapchains),
5951	* implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
5952	* stencil buffer and incur an extra memory overhead
5953	******************************************************/
5954
5955	if (This->stencilBufferTarget) {
5956	if (((IWineD3DSwapChainImpl *)This->swapchains[0])->presentParms.Flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
5957	\|\| ((IWineD3DSurfaceImpl *)This->stencilBufferTarget)->Flags & SFLAG_DISCARD) {
5958	surface_modify_ds_location(This->stencilBufferTarget, SFLAG_DS_DISCARDED);
5959	} else {
5960	struct wined3d_context *context = context_acquire(This, This->render_targets[0], CTXUSAGE_RESOURCELOAD);
5961	surface_load_ds_location(This->stencilBufferTarget, context, SFLAG_DS_OFFSCREEN);
5962	surface_modify_ds_location(This->stencilBufferTarget, SFLAG_DS_OFFSCREEN);
5963	context_release(context);
5964	}
5965	}
5966
5967	tmp = This->stencilBufferTarget;
5968	This->stencilBufferTarget = pNewZStencil;
5969	/* should we be calling the parent or the wined3d surface? */
5970	if (NULL != This->stencilBufferTarget) IWineD3DSurface_AddRef(This->stencilBufferTarget);
5971	if (NULL != tmp) IWineD3DSurface_Release(tmp);
5972	hr = WINED3D_OK;
5973
5974	if((!tmp && pNewZStencil) \|\| (!pNewZStencil && tmp)) {
5975	/* Swapping NULL / non NULL depth stencil affects the depth and tests */
5976	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZENABLE));
5977	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILENABLE));
5978	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
5979	}
5980	}
5981
5982	return hr;
5983	}
5984
5985	static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice* iface, UINT XHotSpot,
5986	UINT YHotSpot, IWineD3DSurface *pCursorBitmap) {
5987	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
5988	/* TODO: the use of Impl is deprecated. */
5989	IWineD3DSurfaceImpl * pSur = (IWineD3DSurfaceImpl *) pCursorBitmap;
5990	WINED3DLOCKED_RECT lockedRect;
5991
5992	TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot);
5993
5994	/* some basic validation checks */
5995	if(This->cursorTexture) {
5996	struct wined3d_context *context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
5997	ENTER_GL();
5998	glDeleteTextures(1, &This->cursorTexture);
5999	LEAVE_GL();
6000	context_release(context);
6001	This->cursorTexture = 0;
6002	}
6003
6004	if ( (pSur->currentDesc.Width == 32) && (pSur->currentDesc.Height == 32) )
6005	This->haveHardwareCursor = TRUE;
6006	else
6007	This->haveHardwareCursor = FALSE;
6008
6009	if(pCursorBitmap) {
6010	WINED3DLOCKED_RECT rect;
6011
6012	/* MSDN: Cursor must be A8R8G8B8 */
6013	if (pSur->resource.format_desc->format != WINED3DFMT_B8G8R8A8_UNORM)
6014	{
6015	ERR("(%p) : surface(%p) has an invalid format\n", This, pCursorBitmap);
6016	return WINED3DERR_INVALIDCALL;
6017	}
6018
6019	/* MSDN: Cursor must be smaller than the display mode */
6020	if(pSur->currentDesc.Width > This->ddraw_width \|\|
6021	pSur->currentDesc.Height > This->ddraw_height) {
6022	ERR("(%p) : Surface(%p) is %dx%d pixels, but screen res is %dx%d\n", This, pSur, pSur->currentDesc.Width, pSur->currentDesc.Height, This->ddraw_width, This->ddraw_height);
6023	return WINED3DERR_INVALIDCALL;
6024	}
6025
6026	if (!This->haveHardwareCursor) {
6027	/* TODO: MSDN: Cursor sizes must be a power of 2 */
6028
6029	/* Do not store the surface's pointer because the application may
6030	* release it after setting the cursor image. Windows doesn't
6031	* addref the set surface, so we can't do this either without
6032	* creating circular refcount dependencies. Copy out the gl texture
6033	* instead.
6034	*/
6035	This->cursorWidth = pSur->currentDesc.Width;
6036	This->cursorHeight = pSur->currentDesc.Height;
6037	if (SUCCEEDED(IWineD3DSurface_LockRect(pCursorBitmap, &rect, NULL, WINED3DLOCK_READONLY)))
6038	{
6039	const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
6040	const struct wined3d_format_desc *format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
6041	struct wined3d_context *context;
6042	char mem, bits = rect.pBits;
6043	GLint intfmt = format_desc->glInternal;
6044	GLint format = format_desc->glFormat;
6045	GLint type = format_desc->glType;
6046	INT height = This->cursorHeight;
6047	INT width = This->cursorWidth;
6048	INT bpp = format_desc->byte_count;
6049	DWORD sampler;
6050	INT i;
6051
6052	/* Reformat the texture memory (pitch and width can be
6053	* different) */
6054	mem = HeapAlloc(GetProcessHeap(), 0, width * height * bpp);
6055	for(i = 0; i < height; i++)
6056	memcpy(&mem[width * bpp * i], &bits[rect.Pitch * i], width * bpp);
6057	IWineD3DSurface_UnlockRect(pCursorBitmap);
6058
6059	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
6060
6061	ENTER_GL();
6062
6063	if (gl_info->supported[APPLE_CLIENT_STORAGE])
6064	{
6065	glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
6066	checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
6067	}
6068
6069	/* Make sure that a proper texture unit is selected */
6070	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
6071	checkGLcall("glActiveTextureARB");
6072	sampler = This->rev_tex_unit_map[0];
6073	if (sampler != WINED3D_UNMAPPED_STAGE)
6074	{
6075	IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(sampler));
6076	}
6077	/* Create a new cursor texture */
6078	glGenTextures(1, &This->cursorTexture);
6079	checkGLcall("glGenTextures");
6080	glBindTexture(GL_TEXTURE_2D, This->cursorTexture);
6081	checkGLcall("glBindTexture");
6082	/* Copy the bitmap memory into the cursor texture */
6083	glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, format, type, mem);
6084	HeapFree(GetProcessHeap(), 0, mem);
6085	checkGLcall("glTexImage2D");
6086
6087	if (gl_info->supported[APPLE_CLIENT_STORAGE])
6088	{
6089	glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
6090	checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
6091	}
6092
6093	LEAVE_GL();
6094
6095	context_release(context);
6096	}
6097	else
6098	{
6099	FIXME("A cursor texture was not returned.\n");
6100	This->cursorTexture = 0;
6101	}
6102	}
6103	else
6104	{
6105	/* Draw a hardware cursor */
6106	ICONINFO cursorInfo;
6107	HCURSOR cursor;
6108	/* Create and clear maskBits because it is not needed for
6109	* 32-bit cursors. 32x32 bits split into 32-bit chunks == 32
6110	* chunks. */
6111	DWORD *maskBits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
6112	(pSur->currentDesc.Width * pSur->currentDesc.Height / 8));
6113	IWineD3DSurface_LockRect(pCursorBitmap, &lockedRect, NULL,
6114	WINED3DLOCK_NO_DIRTY_UPDATE \|
6115	WINED3DLOCK_READONLY
6116	);
6117	TRACE("width: %i height: %i\n", pSur->currentDesc.Width,
6118	pSur->currentDesc.Height);
6119
6120	cursorInfo.fIcon = FALSE;
6121	cursorInfo.xHotspot = XHotSpot;
6122	cursorInfo.yHotspot = YHotSpot;
6123	cursorInfo.hbmMask = CreateBitmap(pSur->currentDesc.Width, pSur->currentDesc.Height,
6124	1, 1, maskBits);
6125	cursorInfo.hbmColor = CreateBitmap(pSur->currentDesc.Width, pSur->currentDesc.Height,
6126	1, 32, lockedRect.pBits);
6127	IWineD3DSurface_UnlockRect(pCursorBitmap);
6128	/* Create our cursor and clean up. */
6129	cursor = CreateIconIndirect(&cursorInfo);
6130	SetCursor(cursor);
6131	if (cursorInfo.hbmMask) DeleteObject(cursorInfo.hbmMask);
6132	if (cursorInfo.hbmColor) DeleteObject(cursorInfo.hbmColor);
6133	if (This->hardwareCursor) DestroyCursor(This->hardwareCursor);
6134	This->hardwareCursor = cursor;
6135	HeapFree(GetProcessHeap(), 0, maskBits);
6136	}
6137	}
6138
6139	This->xHotSpot = XHotSpot;
6140	This->yHotSpot = YHotSpot;
6141	return WINED3D_OK;
6142	}
6143
6144	static void WINAPI IWineD3DDeviceImpl_SetCursorPosition(IWineD3DDevice* iface, int XScreenSpace, int YScreenSpace, DWORD Flags) {
6145	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6146	TRACE("(%p) : SetPos to (%u,%u)\n", This, XScreenSpace, YScreenSpace);
6147
6148	This->xScreenSpace = XScreenSpace;
6149	This->yScreenSpace = YScreenSpace;
6150
6151	return;
6152
6153	}
6154
6155	static BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOOL bShow) {
6156	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6157	BOOL oldVisible = This->bCursorVisible;
6158	POINT pt;
6159
6160	TRACE("(%p) : visible(%d)\n", This, bShow);
6161
6162	/*
6163	* When ShowCursor is first called it should make the cursor appear at the OS's last
6164	* known cursor position. Because of this, some applications just repetitively call
6165	* ShowCursor in order to update the cursor's position. This behavior is undocumented.
6166	*/
6167	GetCursorPos(&pt);
6168	This->xScreenSpace = pt.x;
6169	This->yScreenSpace = pt.y;
6170
6171	if (This->haveHardwareCursor) {
6172	This->bCursorVisible = bShow;
6173	if (bShow)
6174	SetCursor(This->hardwareCursor);
6175	else
6176	SetCursor(NULL);
6177	}
6178	else
6179	{
6180	if (This->cursorTexture)
6181	This->bCursorVisible = bShow;
6182	}
6183
6184	return oldVisible;
6185	}
6186
6187	static HRESULT WINAPI evict_managed_resource(IWineD3DResource resource, void data) {
6188	TRACE("checking resource %p for eviction\n", resource);
6189	if(((IWineD3DResourceImpl *) resource)->resource.pool == WINED3DPOOL_MANAGED) {
6190	TRACE("Evicting %p\n", resource);
6191	IWineD3DResource_UnLoad(resource);
6192	}
6193	IWineD3DResource_Release(resource);
6194	return S_OK;
6195	}
6196
6197	static HRESULT WINAPI IWineD3DDeviceImpl_EvictManagedResources(IWineD3DDevice *iface)
6198	{
6199	TRACE("iface %p.\n", iface);
6200
6201	IWineD3DDevice_EnumResources(iface, evict_managed_resource, NULL);
6202	return WINED3D_OK;
6203	}
6204
6205	static HRESULT updateSurfaceDesc(IWineD3DSurfaceImpl surface, const WINED3DPRESENT_PARAMETERS pPresentationParameters)
6206	{
6207	IWineD3DDeviceImpl *device = surface->resource.device;
6208	const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
6209
6210	/* Reallocate proper memory for the front and back buffer and adjust their sizes */
6211	if(surface->Flags & SFLAG_DIBSECTION) {
6212	/* Release the DC */
6213	SelectObject(surface->hDC, surface->dib.holdbitmap);
6214	DeleteDC(surface->hDC);
6215	/* Release the DIB section */
6216	DeleteObject(surface->dib.DIBsection);
6217	surface->dib.bitmap_data = NULL;
6218	surface->resource.allocatedMemory = NULL;
6219	surface->Flags &= ~SFLAG_DIBSECTION;
6220	}
6221	surface->currentDesc.Width = pPresentationParameters->BackBufferWidth;
6222	surface->currentDesc.Height = pPresentationParameters->BackBufferHeight;
6223	if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] \|\| gl_info->supported[ARB_TEXTURE_RECTANGLE]
6224	\|\| gl_info->supported[WINE_NORMALIZED_TEXRECT])
6225	{
6226	surface->pow2Width = pPresentationParameters->BackBufferWidth;
6227	surface->pow2Height = pPresentationParameters->BackBufferHeight;
6228	} else {
6229	surface->pow2Width = surface->pow2Height = 1;
6230	while (surface->pow2Width < pPresentationParameters->BackBufferWidth) surface->pow2Width <<= 1;
6231	while (surface->pow2Height < pPresentationParameters->BackBufferHeight) surface->pow2Height <<= 1;
6232	}
6233
6234	if (surface->texture_name)
6235	{
6236	struct wined3d_context *context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
6237	ENTER_GL();
6238	glDeleteTextures(1, &surface->texture_name);
6239	LEAVE_GL();
6240	context_release(context);
6241	surface->texture_name = 0;
6242	surface->Flags &= ~SFLAG_CLIENT;
6243	}
6244	if(surface->pow2Width != pPresentationParameters->BackBufferWidth \|\|
6245	surface->pow2Height != pPresentationParameters->BackBufferHeight) {
6246	surface->Flags \|= SFLAG_NONPOW2;
6247	} else {
6248	surface->Flags &= ~SFLAG_NONPOW2;
6249	}
6250	HeapFree(GetProcessHeap(), 0, surface->resource.heapMemory);
6251	surface->resource.allocatedMemory = NULL;
6252	surface->resource.heapMemory = NULL;
6253	surface->resource.size = IWineD3DSurface_GetPitch((IWineD3DSurface ) surface) surface->pow2Width;
6254
6255	/* Put all surfaces into sysmem - the drawable might disappear if the backbuffer was rendered
6256	* to a FBO */
6257	if(!surface_init_sysmem((IWineD3DSurface *) surface))
6258	{
6259	return E_OUTOFMEMORY;
6260	}
6261	return WINED3D_OK;
6262	}
6263
6264	static HRESULT WINAPI reset_unload_resources(IWineD3DResource resource, void data) {
6265	TRACE("Unloading resource %p\n", resource);
6266	IWineD3DResource_UnLoad(resource);
6267	IWineD3DResource_Release(resource);
6268	return S_OK;
6269	}
6270
6271	static BOOL is_display_mode_supported(IWineD3DDeviceImpl This, const WINED3DPRESENT_PARAMETERS pp)
6272	{
6273	UINT i, count;
6274	WINED3DDISPLAYMODE m;
6275	HRESULT hr;
6276
6277	/* All Windowed modes are supported, as is leaving the current mode */
6278	if(pp->Windowed) return TRUE;
6279	if(!pp->BackBufferWidth) return TRUE;
6280	if(!pp->BackBufferHeight) return TRUE;
6281
6282	count = IWineD3D_GetAdapterModeCount(This->wined3d, This->adapter->ordinal, WINED3DFMT_UNKNOWN);
6283	for(i = 0; i < count; i++) {
6284	memset(&m, 0, sizeof(m));
6285	hr = IWineD3D_EnumAdapterModes(This->wined3d, This->adapter->ordinal, WINED3DFMT_UNKNOWN, i, &m);
6286	if(FAILED(hr)) {
6287	ERR("EnumAdapterModes failed\n");
6288	}
6289	if(m.Width == pp->BackBufferWidth && m.Height == pp->BackBufferHeight) {
6290	/* Mode found, it is supported */
6291	return TRUE;
6292	}
6293	}
6294	/* Mode not found -> not supported */
6295	return FALSE;
6296	}
6297
6298	static void delete_opengl_contexts(IWineD3DDevice *iface
6299	#ifndef VBOX_WITH_WDDM
6300	, IWineD3DSwapChainImpl *swapchain
6301	#endif
6302	)
6303	{
6304	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6305	const struct wined3d_gl_info *gl_info;
6306	struct wined3d_context *context;
6307	IWineD3DBaseShaderImpl *shader;
6308
6309	context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
6310	gl_info = context->gl_info;
6311
6312	IWineD3DDevice_EnumResources(iface, reset_unload_resources, NULL);
6313	LIST_FOR_EACH_ENTRY(shader, &This->shaders, IWineD3DBaseShaderImpl, baseShader.shader_list_entry) {
6314	This->shader_backend->shader_destroy((IWineD3DBaseShader *) shader);
6315	}
6316
6317	ENTER_GL();
6318	if(This->depth_blt_texture) {
6319	glDeleteTextures(1, &This->depth_blt_texture);
6320	This->depth_blt_texture = 0;
6321	}
6322	if (This->depth_blt_rb) {
6323	gl_info->fbo_ops.glDeleteRenderbuffers(1, &This->depth_blt_rb);
6324	This->depth_blt_rb = 0;
6325	This->depth_blt_rb_w = 0;
6326	This->depth_blt_rb_h = 0;
6327	}
6328	LEAVE_GL();
6329
6330	This->blitter->free_private(iface);
6331	This->frag_pipe->free_private(iface);
6332	This->shader_backend->shader_free_private(iface);
6333	destroy_dummy_textures(This, gl_info);
6334
6335	context_release(context);
6336
6337	while (This->numContexts)
6338	{
6339	context_destroy(This, This->contexts[0]);
6340	}
6341	#ifndef VBOX_WITH_WDDM
6342	HeapFree(GetProcessHeap(), 0, swapchain->context);
6343	swapchain->context = NULL;
6344	swapchain->num_contexts = 0;
6345	#endif
6346	}
6347
6348	static HRESULT create_primary_opengl_context(IWineD3DDevice iface, IWineD3DSwapChainImpl swapchain)
6349	{
6350	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6351	struct wined3d_context *context;
6352	HRESULT hr;
6353	IWineD3DSurfaceImpl *target;
6354
6355	#ifndef VBOX_WITH_WDDM
6356	/* Recreate the primary swapchain's context */
6357	swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
6358	if (!swapchain->context)
6359	{
6360	ERR("Failed to allocate memory for swapchain context array.\n");
6361	return E_OUTOFMEMORY;
6362	}
6363	#endif
6364
6365	target = (IWineD3DSurfaceImpl *)(swapchain->backBuffer ? swapchain->backBuffer[0] : swapchain->frontBuffer);
6366	if (!(context = context_create(swapchain, target, swapchain->ds_format)))
6367	{
6368	WARN("Failed to create context.\n");
6369	#ifndef VBOX_WITH_WDDM
6370	HeapFree(GetProcessHeap(), 0, swapchain->context);
6371	#endif
6372	return E_FAIL;
6373	}
6374
6375	#ifndef VBOX_WITH_WDDM
6376	swapchain->context[0] = context;
6377	swapchain->num_contexts = 1;
6378	#endif
6379	create_dummy_textures(This);
6380	context_release(context);
6381
6382	hr = This->shader_backend->shader_alloc_private(iface);
6383	if (FAILED(hr))
6384	{
6385	ERR("Failed to allocate shader private data, hr %#x.\n", hr);
6386	goto err;
6387	}
6388
6389	hr = This->frag_pipe->alloc_private(iface);
6390	if (FAILED(hr))
6391	{
6392	ERR("Failed to allocate fragment pipe private data, hr %#x.\n", hr);
6393	This->shader_backend->shader_free_private(iface);
6394	goto err;
6395	}
6396
6397	hr = This->blitter->alloc_private(iface);
6398	if (FAILED(hr))
6399	{
6400	ERR("Failed to allocate blitter private data, hr %#x.\n", hr);
6401	This->frag_pipe->free_private(iface);
6402	This->shader_backend->shader_free_private(iface);
6403	goto err;
6404	}
6405
6406	return WINED3D_OK;
6407
6408	err:
6409	context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
6410	destroy_dummy_textures(This, context->gl_info);
6411	context_release(context);
6412	context_destroy(This, context);
6413	#ifndef VBOX_WITH_WDDM
6414	HeapFree(GetProcessHeap(), 0, swapchain->context);
6415	swapchain->num_contexts = 0;
6416	#endif
6417	return hr;
6418	}
6419
6420	static HRESULT WINAPI IWineD3DDeviceImpl_Reset(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters) {
6421	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6422	IWineD3DSwapChainImpl *swapchain;
6423	HRESULT hr;
6424	BOOL DisplayModeChanged = FALSE;
6425	WINED3DDISPLAYMODE mode;
6426	TRACE("(%p)\n", This);
6427
6428	#ifdef VBOX_WITH_WDDM
6429	/* todo: implement multi-swapchain handlling!!! */
6430	Assert(0);
6431	#endif
6432
6433	hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **) &swapchain);
6434	if(FAILED(hr)) {
6435	ERR("Failed to get the first implicit swapchain\n");
6436	return hr;
6437	}
6438
6439	if(!is_display_mode_supported(This, pPresentationParameters)) {
6440	WARN("Rejecting Reset() call because the requested display mode is not supported\n");
6441	WARN("Requested mode: %d, %d\n", pPresentationParameters->BackBufferWidth,
6442	pPresentationParameters->BackBufferHeight);
6443	IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
6444	return WINED3DERR_INVALIDCALL;
6445	}
6446
6447	/* Is it necessary to recreate the gl context? Actually every setting can be changed
6448	* on an existing gl context, so there's no real need for recreation.
6449	*
6450	* TODO: Figure out how Reset influences resources in D3DPOOL_DEFAULT, D3DPOOL_SYSTEMMEMORY and D3DPOOL_MANAGED
6451	*
6452	* TODO: Figure out what happens to explicit swapchains, or if we have more than one implicit swapchain
6453	*/
6454	TRACE("New params:\n");
6455	TRACE("BackBufferWidth = %d\n", pPresentationParameters->BackBufferWidth);
6456	TRACE("BackBufferHeight = %d\n", pPresentationParameters->BackBufferHeight);
6457	TRACE("BackBufferFormat = %s\n", debug_d3dformat(pPresentationParameters->BackBufferFormat));
6458	TRACE("BackBufferCount = %d\n", pPresentationParameters->BackBufferCount);
6459	TRACE("MultiSampleType = %d\n", pPresentationParameters->MultiSampleType);
6460	TRACE("MultiSampleQuality = %d\n", pPresentationParameters->MultiSampleQuality);
6461	TRACE("SwapEffect = %d\n", pPresentationParameters->SwapEffect);
6462	TRACE("hDeviceWindow = %p\n", pPresentationParameters->hDeviceWindow);
6463	TRACE("Windowed = %s\n", pPresentationParameters->Windowed ? "true" : "false");
6464	TRACE("EnableAutoDepthStencil = %s\n", pPresentationParameters->EnableAutoDepthStencil ? "true" : "false");
6465	TRACE("Flags = %08x\n", pPresentationParameters->Flags);
6466	TRACE("FullScreen_RefreshRateInHz = %d\n", pPresentationParameters->FullScreen_RefreshRateInHz);
6467	TRACE("PresentationInterval = %d\n", pPresentationParameters->PresentationInterval);
6468
6469	/* No special treatment of these parameters. Just store them */
6470	swapchain->presentParms.SwapEffect = pPresentationParameters->SwapEffect;
6471	swapchain->presentParms.Flags = pPresentationParameters->Flags;
6472	swapchain->presentParms.PresentationInterval = pPresentationParameters->PresentationInterval;
6473	swapchain->presentParms.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz;
6474
6475	/* What to do about these? */
6476	if(pPresentationParameters->BackBufferCount != 0 &&
6477	pPresentationParameters->BackBufferCount != swapchain->presentParms.BackBufferCount) {
6478	ERR("Cannot change the back buffer count yet\n");
6479	}
6480	if(pPresentationParameters->BackBufferFormat != WINED3DFMT_UNKNOWN &&
6481	pPresentationParameters->BackBufferFormat != swapchain->presentParms.BackBufferFormat) {
6482	ERR("Cannot change the back buffer format yet\n");
6483	}
6484	if(pPresentationParameters->hDeviceWindow != NULL &&
6485	pPresentationParameters->hDeviceWindow != swapchain->presentParms.hDeviceWindow) {
6486	ERR("Cannot change the device window yet\n");
6487	}
6488	if (pPresentationParameters->EnableAutoDepthStencil && !This->auto_depth_stencil_buffer) {
6489	HRESULT hrc;
6490
6491	TRACE("Creating the depth stencil buffer\n");
6492
6493	hrc = IWineD3DDeviceParent_CreateDepthStencilSurface(This->device_parent,
6494	This->parent,
6495	pPresentationParameters->BackBufferWidth,
6496	pPresentationParameters->BackBufferHeight,
6497	pPresentationParameters->AutoDepthStencilFormat,
6498	pPresentationParameters->MultiSampleType,
6499	pPresentationParameters->MultiSampleQuality,
6500	FALSE,
6501	&This->auto_depth_stencil_buffer);
6502
6503	if (FAILED(hrc)) {
6504	ERR("Failed to create the depth stencil buffer\n");
6505	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
6506	return WINED3DERR_INVALIDCALL;
6507	}
6508	}
6509
6510	/* Reset the depth stencil */
6511	if (pPresentationParameters->EnableAutoDepthStencil)
6512	IWineD3DDevice_SetDepthStencilSurface(iface, This->auto_depth_stencil_buffer);
6513	else
6514	IWineD3DDevice_SetDepthStencilSurface(iface, NULL);
6515
6516	TRACE("Resetting stateblock\n");
6517	IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->updateStateBlock);
6518	IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->stateBlock);
6519
6520	delete_opengl_contexts(iface
6521	#ifndef VBOX_WITH_WDDM
6522	, swapchain
6523	#endif
6524	);
6525
6526	if(pPresentationParameters->Windowed) {
6527	mode.Width = swapchain->orig_width;
6528	mode.Height = swapchain->orig_height;
6529	mode.RefreshRate = 0;
6530	mode.Format = swapchain->presentParms.BackBufferFormat;
6531	} else {
6532	mode.Width = pPresentationParameters->BackBufferWidth;
6533	mode.Height = pPresentationParameters->BackBufferHeight;
6534	mode.RefreshRate = pPresentationParameters->FullScreen_RefreshRateInHz;
6535	mode.Format = swapchain->presentParms.BackBufferFormat;
6536	}
6537
6538	/* Should Width == 800 && Height == 0 set 800x600? */
6539	if(pPresentationParameters->BackBufferWidth != 0 && pPresentationParameters->BackBufferHeight != 0 &&
6540	(pPresentationParameters->BackBufferWidth != swapchain->presentParms.BackBufferWidth \|\|
6541	pPresentationParameters->BackBufferHeight != swapchain->presentParms.BackBufferHeight))
6542	{
6543	UINT i;
6544
6545	if(!pPresentationParameters->Windowed) {
6546	DisplayModeChanged = TRUE;
6547	}
6548	swapchain->presentParms.BackBufferWidth = pPresentationParameters->BackBufferWidth;
6549	swapchain->presentParms.BackBufferHeight = pPresentationParameters->BackBufferHeight;
6550
6551	hr = updateSurfaceDesc((IWineD3DSurfaceImpl *)swapchain->frontBuffer, pPresentationParameters);
6552	if(FAILED(hr))
6553	{
6554	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
6555	return hr;
6556	}
6557
6558	for(i = 0; i < swapchain->presentParms.BackBufferCount; i++) {
6559	hr = updateSurfaceDesc((IWineD3DSurfaceImpl *)swapchain->backBuffer[i], pPresentationParameters);
6560	if(FAILED(hr))
6561	{
6562	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
6563	return hr;
6564	}
6565	}
6566	if(This->auto_depth_stencil_buffer) {
6567	hr = updateSurfaceDesc((IWineD3DSurfaceImpl *)This->auto_depth_stencil_buffer, pPresentationParameters);
6568	if(FAILED(hr))
6569	{
6570	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
6571	return hr;
6572	}
6573	}
6574	}
6575
6576	if (!pPresentationParameters->Windowed != !swapchain->presentParms.Windowed
6577	\|\| DisplayModeChanged)
6578	{
6579	IWineD3DDevice_SetDisplayMode(iface, 0, &mode);
6580
6581	if (!pPresentationParameters->Windowed)
6582	{
6583	if(swapchain->presentParms.Windowed) {
6584	/* switch from windowed to fs */
6585	swapchain_setup_fullscreen_window(swapchain, pPresentationParameters->BackBufferWidth,
6586	pPresentationParameters->BackBufferHeight);
6587	} else {
6588	/* Fullscreen -> fullscreen mode change */
6589	MoveWindow(swapchain->device_window, 0, 0,
6590	pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight,
6591	TRUE);
6592	}
6593	}
6594	else if (!swapchain->presentParms.Windowed)
6595	{
6596	/* Fullscreen -> windowed switch */
6597	swapchain_restore_fullscreen_window(swapchain);
6598	}
6599	swapchain->presentParms.Windowed = pPresentationParameters->Windowed;
6600	} else if(!pPresentationParameters->Windowed) {
6601	DWORD style = This->style, exStyle = This->exStyle;
6602	/* If we're in fullscreen, and the mode wasn't changed, we have to get the window back into
6603	* the right position. Some applications(Battlefield 2, Guild Wars) move it and then call
6604	* Reset to clear up their mess. Guild Wars also loses the device during that.
6605	*/
6606	This->style = 0;
6607	This->exStyle = 0;
6608	swapchain_setup_fullscreen_window(swapchain, pPresentationParameters->BackBufferWidth,
6609	pPresentationParameters->BackBufferHeight);
6610	This->style = style;
6611	This->exStyle = exStyle;
6612	}
6613
6614	/* Note: No parent needed for initial internal stateblock */
6615	hr = IWineD3DDevice_CreateStateBlock(iface, WINED3DSBT_INIT, (IWineD3DStateBlock **)&This->stateBlock, NULL);
6616	if (FAILED(hr)) ERR("Resetting the stateblock failed with error 0x%08x\n", hr);
6617	else TRACE("Created stateblock %p\n", This->stateBlock);
6618	This->updateStateBlock = This->stateBlock;
6619	IWineD3DStateBlock_AddRef((IWineD3DStateBlock *)This->updateStateBlock);
6620
6621	hr = IWineD3DStateBlock_InitStartupStateBlock((IWineD3DStateBlock *) This->stateBlock);
6622	if(FAILED(hr)) {
6623	ERR("Resetting the stateblock failed with error 0x%08x\n", hr);
6624	}
6625
6626	if(wined3d_settings.offscreen_rendering_mode == ORM_FBO)
6627	{
6628	RECT client_rect;
6629	GetClientRect(swapchain->win_handle, &client_rect);
6630
6631	if(!swapchain->presentParms.BackBufferCount)
6632	{
6633	TRACE("Single buffered rendering\n");
6634	swapchain->render_to_fbo = FALSE;
6635	}
6636	else if(swapchain->presentParms.BackBufferWidth != client_rect.right \|\|
6637	swapchain->presentParms.BackBufferHeight != client_rect.bottom )
6638	{
6639	TRACE("Rendering to FBO. Backbuffer %ux%u, window %ux%u\n",
6640	swapchain->presentParms.BackBufferWidth,
6641	swapchain->presentParms.BackBufferHeight,
6642	client_rect.right, client_rect.bottom);
6643	swapchain->render_to_fbo = TRUE;
6644	}
6645	else
6646	{
6647	TRACE("Rendering directly to GL_BACK\n");
6648	swapchain->render_to_fbo = FALSE;
6649	}
6650	}
6651
6652	hr = create_primary_opengl_context(iface, swapchain);
6653	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
6654
6655	/* All done. There is no need to reload resources or shaders, this will happen automatically on the
6656	* first use
6657	*/
6658	return hr;
6659	}
6660
6661	static HRESULT WINAPI IWineD3DDeviceImpl_SetDialogBoxMode(IWineD3DDevice *iface, BOOL enable_dialogs)
6662	{
6663	TRACE("iface %p, enable_dialogs %#x.\n", iface, enable_dialogs);
6664
6665	if (!enable_dialogs) FIXME("Dialogs cannot be disabled yet.\n");
6666
6667	return WINED3D_OK;
6668	}
6669
6670
6671	static HRESULT WINAPI IWineD3DDeviceImpl_GetCreationParameters(IWineD3DDevice iface, WINED3DDEVICE_CREATION_PARAMETERS pParameters) {
6672	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6673	TRACE("(%p) : pParameters %p\n", This, pParameters);
6674
6675	*pParameters = This->createParms;
6676	return WINED3D_OK;
6677	}
6678
6679	static void WINAPI IWineD3DDeviceImpl_SetGammaRamp(IWineD3DDevice * iface, UINT iSwapChain, DWORD Flags, CONST WINED3DGAMMARAMP* pRamp) {
6680	IWineD3DSwapChain *swapchain;
6681
6682	TRACE("Relaying to swapchain\n");
6683
6684	if (IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain) == WINED3D_OK) {
6685	IWineD3DSwapChain_SetGammaRamp(swapchain, Flags, pRamp);
6686	IWineD3DSwapChain_Release(swapchain);
6687	}
6688	}
6689
6690	static void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice iface, UINT iSwapChain, WINED3DGAMMARAMP pRamp) {
6691	IWineD3DSwapChain *swapchain;
6692
6693	TRACE("Relaying to swapchain\n");
6694
6695	if (IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain) == WINED3D_OK) {
6696	IWineD3DSwapChain_GetGammaRamp(swapchain, pRamp);
6697	IWineD3DSwapChain_Release(swapchain);
6698	}
6699	}
6700
6701
6702	/ ******************************************************
6703	* Notification functions
6704	******************************************************/
6705	/** This function must be called in the release of a resource when ref == 0,
6706	* the contents of resource must still be correct,
6707	* any handles to other resource held by the caller must be closed
6708	* (e.g. a texture should release all held surfaces because telling the device that it's been released.)
6709	*****************************************************/
6710	void device_resource_add(IWineD3DDeviceImpl This, IWineD3DResource resource)
6711	{
6712	TRACE("(%p) : Adding resource %p\n", This, resource);
6713
6714	list_add_head(&This->resources, &((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
6715	}
6716
6717	static void device_resource_remove(IWineD3DDeviceImpl This, IWineD3DResource resource)
6718	{
6719	TRACE("(%p) : Removing resource %p\n", This, resource);
6720
6721	list_remove(&((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
6722	}
6723
6724	void device_resource_released(IWineD3DDeviceImpl This, IWineD3DResource resource)
6725	{
6726	WINED3DRESOURCETYPE type = IWineD3DResource_GetType(resource);
6727	int counter;
6728
6729	TRACE("(%p) : resource %p\n", This, resource);
6730
6731	context_resource_released((IWineD3DDevice *)This, resource, type);
6732
6733	switch (type) {
6734	/* TODO: check front and back buffers, rendertargets etc.. possibly swapchains? */
6735	case WINED3DRTYPE_SURFACE: {
6736	unsigned int i;
6737
6738	if (This->d3d_initialized)
6739	{
6740	for (i = 0; i < This->adapter->gl_info.limits.buffers; ++i)
6741	{
6742	if (This->render_targets[i] == (IWineD3DSurface *)resource) {
6743	This->render_targets[i] = NULL;
6744	}
6745	}
6746	if (This->stencilBufferTarget == (IWineD3DSurface *)resource) {
6747	This->stencilBufferTarget = NULL;
6748	}
6749	}
6750
6751	break;
6752	}
6753	case WINED3DRTYPE_TEXTURE:
6754	case WINED3DRTYPE_CUBETEXTURE:
6755	case WINED3DRTYPE_VOLUMETEXTURE:
6756	for (counter = 0; counter < MAX_COMBINED_SAMPLERS; counter++) {
6757	if (This->stateBlock != NULL && This->stateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
6758	WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
6759	This->stateBlock->textures[counter] = NULL;
6760	}
6761	if (This->updateStateBlock != This->stateBlock ){
6762	if (This->updateStateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
6763	WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
6764	This->updateStateBlock->textures[counter] = NULL;
6765	}
6766	}
6767	}
6768	break;
6769	case WINED3DRTYPE_VOLUME:
6770	/* TODO: nothing really? */
6771	break;
6772	case WINED3DRTYPE_BUFFER:
6773	{
6774	int streamNumber;
6775	TRACE("Cleaning up stream pointers\n");
6776
6777	for(streamNumber = 0; streamNumber < MAX_STREAMS; streamNumber ++){
6778	/* FINDOUT: should a warn be generated if were recording and updateStateBlock->streamSource is lost?
6779	FINDOUT: should changes.streamSource[StreamNumber] be set ?
6780	*/
6781	if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
6782	if ((IWineD3DResource *)This->updateStateBlock->streamSource[streamNumber] == resource) {
6783	FIXME("Vertex buffer released while bound to a state block, stream %d\n", streamNumber);
6784	This->updateStateBlock->streamSource[streamNumber] = 0;
6785	/* Set changed flag? */
6786	}
6787	}
6788	if (This->stateBlock != NULL ) { /* only happens if there is an error in the application, or on reset/release (because we don't manage internal tracking properly) */
6789	if ((IWineD3DResource *)This->stateBlock->streamSource[streamNumber] == resource) {
6790	TRACE("Vertex buffer released while bound to a state block, stream %d\n", streamNumber);
6791	This->stateBlock->streamSource[streamNumber] = 0;
6792	}
6793	}
6794	}
6795
6796	if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
6797	if (This->updateStateBlock->pIndexData == (IWineD3DBuffer *)resource) {
6798	This->updateStateBlock->pIndexData = NULL;
6799	}
6800	}
6801	if (This->stateBlock != NULL ) { /* ==NULL when device is being destroyed */
6802	if (This->stateBlock->pIndexData == (IWineD3DBuffer *)resource) {
6803	This->stateBlock->pIndexData = NULL;
6804	}
6805	}
6806	}
6807	break;
6808
6809	default:
6810	FIXME("(%p) unknown resource type %p %u\n", This, resource, IWineD3DResource_GetType(resource));
6811	break;
6812	}
6813
6814
6815	/* Remove the resource from the resourceStore */
6816	device_resource_remove(This, resource);
6817
6818	TRACE("Resource released\n");
6819
6820	}
6821
6822	static HRESULT WINAPI IWineD3DDeviceImpl_EnumResources(IWineD3DDevice iface, D3DCB_ENUMRESOURCES pCallback, void pData) {
6823	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6824	IWineD3DResourceImpl resource, cursor;
6825	HRESULT ret;
6826	TRACE("(%p)->(%p,%p)\n", This, pCallback, pData);
6827
6828	LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
6829	TRACE("enumerating resource %p\n", resource);
6830	IWineD3DResource_AddRef((IWineD3DResource *) resource);
6831	ret = pCallback((IWineD3DResource *) resource, pData);
6832	if(ret == S_FALSE) {
6833	TRACE("Canceling enumeration\n");
6834	break;
6835	}
6836	}
6837	return WINED3D_OK;
6838	}
6839
6840	static HRESULT WINAPI IWineD3DDeviceImpl_GetSurfaceFromDC(IWineD3DDevice iface, HDC dc, IWineD3DSurface *surface)
6841	{
6842	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6843	IWineD3DResourceImpl *resource;
6844
6845	LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry)
6846	{
6847	WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource);
6848	if (type == WINED3DRTYPE_SURFACE)
6849	{
6850	if (((IWineD3DSurfaceImpl *)resource)->hDC == dc)
6851	{
6852	TRACE("Found surface %p for dc %p.\n", resource, dc);
6853	surface = (IWineD3DSurface )resource;
6854	return WINED3D_OK;
6855	}
6856	}
6857	}
6858
6859	return WINED3DERR_INVALIDCALL;
6860	}
6861
6862	#ifdef VBOX_WITH_WDDM
6863	static HRESULT WINAPI IWineD3DDeviceImpl_Flush(IWineD3DDevice *iface)
6864	{
6865	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6866	struct wined3d_context *context;
6867	int i;
6868	for (i = 0; i < This->numContexts; ++i)
6869	{
6870	context = This->contexts[i];
6871	if (context_acquire_context(context, NULL, CTXUSAGE_RESOURCELOAD, TRUE))
6872	{
6873	Assert(context->valid);
6874	wglFlush();
6875	context_release(context);
6876	}
6877	else
6878	{
6879	WARN("Invalid context, skipping flush.\n");
6880	}
6881	}
6882	return WINED3D_OK;
6883	}
6884
6885	static HRESULT WINAPI IWineD3DDeviceImpl_AddSwapChain(IWineD3DDevice iface, IWineD3DSwapChain swapchain)
6886	{
6887	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6888	VOID pvNewBuf = HeapReAlloc(GetProcessHeap(), 0, This->swapchains, (This->NumberOfSwapChains + 1) sizeof(IWineD3DSwapChain *));
6889	if(!pvNewBuf) {
6890	ERR("Out of memory!\n");
6891	return E_OUTOFMEMORY;
6892	}
6893	This->swapchains = (IWineD3DSwapChain *)pvNewBuf;
6894	This->swapchains[This->NumberOfSwapChains] = swapchain;
6895	++This->NumberOfSwapChains;
6896	return WINED3D_OK;
6897	}
6898
6899	static HRESULT WINAPI IWineD3DDeviceImpl_RemoveSwapChain(IWineD3DDevice iface, IWineD3DSwapChain swapchain)
6900	{
6901	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl ) iface;
6902	int i;
6903	for (i = 0; i < This->NumberOfSwapChains; ++i)
6904	{
6905	if (This->swapchains[i] == swapchain)
6906	{
6907	break;
6908	}
6909	}
6910
6911	if (i == This->NumberOfSwapChains)
6912	{
6913	WARN("swapchain 0x%p is not part of device 0x%p\n", swapchain, iface);
6914	return E_INVALIDARG;
6915	}
6916
6917	--This->NumberOfSwapChains;
6918	if (This->NumberOfSwapChains)
6919	{
6920	IWineD3DSwapChain pvNewBuf = (IWineD3DSwapChain )HeapAlloc(GetProcessHeap(), 0, (This->NumberOfSwapChains) * sizeof(IWineD3DSwapChain *));
6921	if(!pvNewBuf) {
6922	ERR("Out of memory!\n");
6923	return E_OUTOFMEMORY;
6924	}
6925	if (i) {
6926	memcpy (pvNewBuf, This->swapchains, isizeof(IWineD3DSwapChain ));
6927	}
6928	if (i < This->NumberOfSwapChains) {
6929	memcpy (pvNewBuf + i, This->swapchains +i+1, (This->NumberOfSwapChains - i)sizeof(IWineD3DSwapChain ));
6930	}
6931
6932	This->swapchains = (IWineD3DSwapChain *)pvNewBuf;
6933	}
6934	else
6935	{
6936	while (This->numContexts)
6937	{
6938	context_destroy(This, This->contexts[0]);
6939	}
6940	}
6941	return WINED3D_OK;
6942	}
6943	#endif
6944
6945	/**********************************************************
6946	* IWineD3DDevice VTbl follows
6947	**********************************************************/
6948
6949	static const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl =
6950	{
6951	/* IUnknown methods */
6952	IWineD3DDeviceImpl_QueryInterface,
6953	IWineD3DDeviceImpl_AddRef,
6954	IWineD3DDeviceImpl_Release,
6955	/* IWineD3DDevice methods */
6956	IWineD3DDeviceImpl_GetParent,
6957	/* Creation methods/
6958	IWineD3DDeviceImpl_CreateBuffer,
6959	IWineD3DDeviceImpl_CreateVertexBuffer,
6960	IWineD3DDeviceImpl_CreateIndexBuffer,
6961	IWineD3DDeviceImpl_CreateStateBlock,
6962	IWineD3DDeviceImpl_CreateSurface,
6963	IWineD3DDeviceImpl_CreateRendertargetView,
6964	IWineD3DDeviceImpl_CreateTexture,
6965	IWineD3DDeviceImpl_CreateVolumeTexture,
6966	IWineD3DDeviceImpl_CreateVolume,
6967	IWineD3DDeviceImpl_CreateCubeTexture,
6968	IWineD3DDeviceImpl_CreateQuery,
6969	IWineD3DDeviceImpl_CreateSwapChain,
6970	IWineD3DDeviceImpl_CreateVertexDeclaration,
6971	IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF,
6972	IWineD3DDeviceImpl_CreateVertexShader,
6973	IWineD3DDeviceImpl_CreateGeometryShader,
6974	IWineD3DDeviceImpl_CreatePixelShader,
6975	IWineD3DDeviceImpl_CreatePalette,
6976	/* Odd functions /
6977	IWineD3DDeviceImpl_Init3D,
6978	IWineD3DDeviceImpl_InitGDI,
6979	IWineD3DDeviceImpl_Uninit3D,
6980	IWineD3DDeviceImpl_UninitGDI,
6981	IWineD3DDeviceImpl_SetMultithreaded,
6982	IWineD3DDeviceImpl_EvictManagedResources,
6983	IWineD3DDeviceImpl_GetAvailableTextureMem,
6984	IWineD3DDeviceImpl_GetBackBuffer,
6985	IWineD3DDeviceImpl_GetCreationParameters,
6986	IWineD3DDeviceImpl_GetDeviceCaps,
6987	IWineD3DDeviceImpl_GetDirect3D,
6988	IWineD3DDeviceImpl_GetDisplayMode,
6989	IWineD3DDeviceImpl_SetDisplayMode,
6990	IWineD3DDeviceImpl_GetNumberOfSwapChains,
6991	IWineD3DDeviceImpl_GetRasterStatus,
6992	IWineD3DDeviceImpl_GetSwapChain,
6993	IWineD3DDeviceImpl_Reset,
6994	IWineD3DDeviceImpl_SetDialogBoxMode,
6995	IWineD3DDeviceImpl_SetCursorProperties,
6996	IWineD3DDeviceImpl_SetCursorPosition,
6997	IWineD3DDeviceImpl_ShowCursor,
6998	/* Getters and setters /
6999	IWineD3DDeviceImpl_SetClipPlane,
7000	IWineD3DDeviceImpl_GetClipPlane,
7001	IWineD3DDeviceImpl_SetClipStatus,
7002	IWineD3DDeviceImpl_GetClipStatus,
7003	IWineD3DDeviceImpl_SetCurrentTexturePalette,
7004	IWineD3DDeviceImpl_GetCurrentTexturePalette,
7005	IWineD3DDeviceImpl_SetDepthStencilSurface,
7006	IWineD3DDeviceImpl_GetDepthStencilSurface,
7007	IWineD3DDeviceImpl_SetGammaRamp,
7008	IWineD3DDeviceImpl_GetGammaRamp,
7009	IWineD3DDeviceImpl_SetIndexBuffer,
7010	IWineD3DDeviceImpl_GetIndexBuffer,
7011	IWineD3DDeviceImpl_SetBaseVertexIndex,
7012	IWineD3DDeviceImpl_GetBaseVertexIndex,
7013	IWineD3DDeviceImpl_SetLight,
7014	IWineD3DDeviceImpl_GetLight,
7015	IWineD3DDeviceImpl_SetLightEnable,
7016	IWineD3DDeviceImpl_GetLightEnable,
7017	IWineD3DDeviceImpl_SetMaterial,
7018	IWineD3DDeviceImpl_GetMaterial,
7019	IWineD3DDeviceImpl_SetNPatchMode,
7020	IWineD3DDeviceImpl_GetNPatchMode,
7021	IWineD3DDeviceImpl_SetPaletteEntries,
7022	IWineD3DDeviceImpl_GetPaletteEntries,
7023	IWineD3DDeviceImpl_SetPixelShader,
7024	IWineD3DDeviceImpl_GetPixelShader,
7025	IWineD3DDeviceImpl_SetPixelShaderConstantB,
7026	IWineD3DDeviceImpl_GetPixelShaderConstantB,
7027	IWineD3DDeviceImpl_SetPixelShaderConstantI,
7028	IWineD3DDeviceImpl_GetPixelShaderConstantI,
7029	IWineD3DDeviceImpl_SetPixelShaderConstantF,
7030	IWineD3DDeviceImpl_GetPixelShaderConstantF,
7031	IWineD3DDeviceImpl_SetRenderState,
7032	IWineD3DDeviceImpl_GetRenderState,
7033	IWineD3DDeviceImpl_SetRenderTarget,
7034	IWineD3DDeviceImpl_GetRenderTarget,
7035	IWineD3DDeviceImpl_SetFrontBackBuffers,
7036	IWineD3DDeviceImpl_SetSamplerState,
7037	IWineD3DDeviceImpl_GetSamplerState,
7038	IWineD3DDeviceImpl_SetScissorRect,
7039	IWineD3DDeviceImpl_GetScissorRect,
7040	IWineD3DDeviceImpl_SetSoftwareVertexProcessing,
7041	IWineD3DDeviceImpl_GetSoftwareVertexProcessing,
7042	IWineD3DDeviceImpl_SetStreamSource,
7043	IWineD3DDeviceImpl_GetStreamSource,
7044	IWineD3DDeviceImpl_SetStreamSourceFreq,
7045	IWineD3DDeviceImpl_GetStreamSourceFreq,
7046	IWineD3DDeviceImpl_SetTexture,
7047	IWineD3DDeviceImpl_GetTexture,
7048	IWineD3DDeviceImpl_SetTextureStageState,
7049	IWineD3DDeviceImpl_GetTextureStageState,
7050	IWineD3DDeviceImpl_SetTransform,
7051	IWineD3DDeviceImpl_GetTransform,
7052	IWineD3DDeviceImpl_SetVertexDeclaration,
7053	IWineD3DDeviceImpl_GetVertexDeclaration,
7054	IWineD3DDeviceImpl_SetVertexShader,
7055	IWineD3DDeviceImpl_GetVertexShader,
7056	IWineD3DDeviceImpl_SetVertexShaderConstantB,
7057	IWineD3DDeviceImpl_GetVertexShaderConstantB,
7058	IWineD3DDeviceImpl_SetVertexShaderConstantI,
7059	IWineD3DDeviceImpl_GetVertexShaderConstantI,
7060	IWineD3DDeviceImpl_SetVertexShaderConstantF,
7061	IWineD3DDeviceImpl_GetVertexShaderConstantF,
7062	IWineD3DDeviceImpl_SetViewport,
7063	IWineD3DDeviceImpl_GetViewport,
7064	IWineD3DDeviceImpl_MultiplyTransform,
7065	IWineD3DDeviceImpl_ValidateDevice,
7066	IWineD3DDeviceImpl_ProcessVertices,
7067	/* State block */
7068	IWineD3DDeviceImpl_BeginStateBlock,
7069	IWineD3DDeviceImpl_EndStateBlock,
7070	/* Scene management */
7071	IWineD3DDeviceImpl_BeginScene,
7072	IWineD3DDeviceImpl_EndScene,
7073	IWineD3DDeviceImpl_Present,
7074	IWineD3DDeviceImpl_Clear,
7075	IWineD3DDeviceImpl_ClearRendertargetView,
7076	/* Drawing */
7077	IWineD3DDeviceImpl_SetPrimitiveType,
7078	IWineD3DDeviceImpl_GetPrimitiveType,
7079	IWineD3DDeviceImpl_DrawPrimitive,
7080	IWineD3DDeviceImpl_DrawIndexedPrimitive,
7081	IWineD3DDeviceImpl_DrawPrimitiveUP,
7082	IWineD3DDeviceImpl_DrawIndexedPrimitiveUP,
7083	IWineD3DDeviceImpl_DrawPrimitiveStrided,
7084	IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided,
7085	IWineD3DDeviceImpl_DrawRectPatch,
7086	IWineD3DDeviceImpl_DrawTriPatch,
7087	IWineD3DDeviceImpl_DeletePatch,
7088	IWineD3DDeviceImpl_ColorFill,
7089	IWineD3DDeviceImpl_UpdateTexture,
7090	IWineD3DDeviceImpl_UpdateSurface,
7091	IWineD3DDeviceImpl_GetFrontBufferData,
7092	/* object tracking */
7093	IWineD3DDeviceImpl_EnumResources,
7094	IWineD3DDeviceImpl_GetSurfaceFromDC,
7095	IWineD3DDeviceImpl_AcquireFocusWindow,
7096	IWineD3DDeviceImpl_ReleaseFocusWindow,
7097	#ifdef VBOX_WITH_WDDM
7098	/* VBox WDDM extensions */
7099	IWineD3DDeviceImpl_Flush,
7100	IWineD3DDeviceImpl_AddSwapChain,
7101	IWineD3DDeviceImpl_RemoveSwapChain,
7102	#endif
7103	};
7104
7105	HRESULT device_init(IWineD3DDeviceImpl device, IWineD3DImpl wined3d,
7106	UINT adapter_idx, WINED3DDEVTYPE device_type, HWND focus_window, DWORD flags,
7107	IUnknown parent, IWineD3DDeviceParent device_parent)
7108	{
7109	struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
7110	const struct fragment_pipeline *fragment_pipeline;
7111	struct shader_caps shader_caps;
7112	struct fragment_caps ffp_caps;
7113	WINED3DDISPLAYMODE mode;
7114	unsigned int i;
7115	HRESULT hr;
7116
7117	device->lpVtbl = &IWineD3DDevice_Vtbl;
7118	device->ref = 1;
7119	device->wined3d = (IWineD3D *)wined3d;
7120	IWineD3D_AddRef(device->wined3d);
7121	device->adapter = wined3d->adapter_count ? adapter : NULL;
7122	device->parent = parent;
7123	device->device_parent = device_parent;
7124	list_init(&device->resources);
7125	list_init(&device->shaders);
7126
7127	device->surface_alignment = wined3d->dxVersion == 7 ? DDRAW_PITCH_ALIGNMENT : D3D8_PITCH_ALIGNMENT;
7128	device->posFixup[0] = 1.0f; /* This is needed to get the x coord unmodified through a MAD. */
7129
7130	/* Get the initial screen setup for ddraw. */
7131	hr = IWineD3D_GetAdapterDisplayMode((IWineD3D *)wined3d, adapter_idx, &mode);
7132	if (FAILED(hr))
7133	{
7134	ERR("Failed to get the adapter's display mode, hr %#x.\n", hr);
7135	IWineD3D_Release(device->wined3d);
7136	return hr;
7137	}
7138	device->ddraw_width = mode.Width;
7139	device->ddraw_height = mode.Height;
7140	device->ddraw_format = mode.Format;
7141
7142	/* Save the creation parameters. */
7143	device->createParms.AdapterOrdinal = adapter_idx;
7144	device->createParms.DeviceType = device_type;
7145	device->createParms.hFocusWindow = focus_window;
7146	device->createParms.BehaviorFlags = flags;
7147
7148	device->devType = device_type;
7149	for (i = 0; i < PATCHMAP_SIZE; ++i) list_init(&device->patches[i]);
7150
7151	select_shader_mode(&adapter->gl_info, &device->ps_selected_mode, &device->vs_selected_mode);
7152	device->shader_backend = adapter->shader_backend;
7153
7154	memset(&shader_caps, 0, sizeof(shader_caps));
7155	device->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
7156	device->d3d_vshader_constantF = shader_caps.MaxVertexShaderConst;
7157	device->d3d_pshader_constantF = shader_caps.MaxPixelShaderConst;
7158	device->vs_clipping = shader_caps.VSClipping;
7159
7160	memset(&ffp_caps, 0, sizeof(ffp_caps));
7161	fragment_pipeline = adapter->fragment_pipe;
7162	device->frag_pipe = fragment_pipeline;
7163	fragment_pipeline->get_caps(&adapter->gl_info, &ffp_caps);
7164	device->max_ffp_textures = ffp_caps.MaxSimultaneousTextures;
7165
7166	hr = compile_state_table(device->StateTable, device->multistate_funcs, &adapter->gl_info,
7167	ffp_vertexstate_template, fragment_pipeline, misc_state_template);
7168	if (FAILED(hr))
7169	{
7170	ERR("Failed to compile state table, hr %#x.\n", hr);
7171	IWineD3D_Release(device->wined3d);
7172	return hr;
7173	}
7174
7175	device->blitter = adapter->blitter;
7176
7177	return WINED3D_OK;
7178	}
7179
7180
7181	void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state) {
7182	DWORD rep = This->StateTable[state].representative;
7183	struct wined3d_context *context;
7184	DWORD idx;
7185	BYTE shift;
7186	UINT i;
7187
7188	for(i = 0; i < This->numContexts; i++) {
7189	context = This->contexts[i];
7190	if(isStateDirty(context, rep)) continue;
7191
7192	context->dirtyArray[context->numDirtyEntries++] = rep;
7193	idx = rep / (sizeof(context->isStateDirty) CHAR_BIT);
7194	shift = rep & ((sizeof(context->isStateDirty) CHAR_BIT) - 1);
7195	context->isStateDirty[idx] \|= (1 << shift);
7196	}
7197	}
7198
7199	void get_drawable_size_fbo(struct wined3d_context context, UINT width, UINT *height)
7200	{
7201	IWineD3DSurfaceImpl surface = (IWineD3DSurfaceImpl )context->current_rt;
7202	/* The drawable size of a fbo target is the opengl texture size, which is the power of two size. */
7203	*width = surface->pow2Width;
7204	*height = surface->pow2Height;
7205	}
7206
7207	void get_drawable_size_backbuffer(struct wined3d_context context, UINT width, UINT *height)
7208	{
7209	#ifdef VBOX_WITH_WDDM
7210	IWineD3DSwapChainImpl *swapchain = context->currentSwapchain;
7211	#else
7212	IWineD3DSwapChainImpl *swapchain = context->swapchain;
7213	#endif
7214	/* The drawable size of a backbuffer / aux buffer offscreen target is the size of the
7215	* current context's drawable, which is the size of the back buffer of the swapchain
7216	* the active context belongs to. */
7217	*width = swapchain->presentParms.BackBufferWidth;
7218	*height = swapchain->presentParms.BackBufferHeight;
7219	}
7220
7221	LRESULT device_process_message(IWineD3DDeviceImpl *device, HWND window,
7222	UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc)
7223	{
7224	if (device->filter_messages)
7225	{
7226	TRACE("Filtering message: window %p, message %#x, wparam %#lx, lparam %#lx.\n",
7227	window, message, wparam, lparam);
7228	return DefWindowProcW(window, message, wparam, lparam);
7229	}
7230
7231	if (message == WM_DESTROY)
7232	{
7233	TRACE("unregister window %p.\n", window);
7234	wined3d_unregister_window(window);
7235
7236	if (device->focus_window == window) device->focus_window = NULL;
7237	else ERR("Window %p is not the focus window for device %p.\n", window, device);
7238	}
7239
7240	return CallWindowProcW(proc, window, message, wparam, lparam);
7241	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c@ 33085

Download in other formats: