WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/state_trackers/nine/device9.c

Rev	Author	Line No.	Line
5564	serge	1	/*
		2	* Copyright 2011 Joakim Sindholt
		3	*
		4	* Permission is hereby granted, free of charge, to any person obtaining a
		5	* copy of this software and associated documentation files (the "Software"),
		6	* to deal in the Software without restriction, including without limitation
		7	* on the rights to use, copy, modify, merge, publish, distribute, sub
		8	* license, and/or sell copies of the Software, and to permit persons to whom
		9	* the Software is furnished to do so, subject to the following conditions:
		10	*
		11	* The above copyright notice and this permission notice (including the next
		12	* paragraph) shall be included in all copies or substantial portions of the
		13	* Software.
		14	*
		15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		17	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
		18	* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
		19	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
		20	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
		21	* USE OR OTHER DEALINGS IN THE SOFTWARE. */
		22
		23	#include "device9.h"
		24	#include "stateblock9.h"
		25	#include "surface9.h"
		26	#include "swapchain9.h"
		27	#include "swapchain9ex.h"
		28	#include "indexbuffer9.h"
		29	#include "vertexbuffer9.h"
		30	#include "vertexdeclaration9.h"
		31	#include "vertexshader9.h"
		32	#include "pixelshader9.h"
		33	#include "query9.h"
		34	#include "texture9.h"
		35	#include "cubetexture9.h"
		36	#include "volumetexture9.h"
		37	#include "nine_helpers.h"
		38	#include "nine_pipe.h"
		39	#include "nine_ff.h"
		40	#include "nine_dump.h"
		41
		42	#include "pipe/p_screen.h"
		43	#include "pipe/p_context.h"
		44	#include "pipe/p_config.h"
		45	#include "util/u_math.h"
		46	#include "util/u_inlines.h"
		47	#include "util/u_hash_table.h"
		48	#include "util/u_format.h"
		49	#include "util/u_surface.h"
		50	#include "util/u_upload_mgr.h"
		51	#include "hud/hud_context.h"
		52
		53	#include "cso_cache/cso_context.h"
		54
		55	#define DBG_CHANNEL DBG_DEVICE
		56
		57	#if defined(PIPE_CC_GCC) && (defined(PIPE_ARCH_X86) \|\| defined(PIPE_ARCH_X86_64))
		58
		59	#include
		60
		61	static void nine_setup_fpu()
		62	{
		63	fpu_control_t c;
		64
		65	_FPU_GETCW(c);
		66	/* clear the control word */
		67	c &= _FPU_RESERVED;
		68	/* d3d9 doc/wine tests: mask all exceptions, use single-precision
		69	* and round to nearest */
		70	c \|= _FPU_MASK_IM \| _FPU_MASK_DM \| _FPU_MASK_ZM \| _FPU_MASK_OM \|
		71	_FPU_MASK_UM \| _FPU_MASK_PM \| _FPU_SINGLE \| _FPU_RC_NEAREST;
		72	_FPU_SETCW(c);
		73	}
		74
		75	#else
		76
		77	static void nine_setup_fpu(void)
		78	{
		79	WARN_ONCE("FPU setup not supported on non-x86 platforms\n");
		80	}
		81
		82	#endif
		83
		84	static void
		85	NineDevice9_SetDefaultState( struct NineDevice9 *This, boolean is_reset )
		86	{
		87	struct NineSurface9 *refSurf = NULL;
		88
		89	DBG("This=%p is_reset=%d\n", This, (int) is_reset);
		90
		91	assert(!This->is_recording);
		92
		93	nine_state_set_defaults(This, &This->caps, is_reset);
		94
		95	This->state.viewport.X = 0;
		96	This->state.viewport.Y = 0;
		97	This->state.viewport.Width = 0;
		98	This->state.viewport.Height = 0;
		99
		100	This->state.scissor.minx = 0;
		101	This->state.scissor.miny = 0;
		102	This->state.scissor.maxx = 0xffff;
		103	This->state.scissor.maxy = 0xffff;
		104
		105	if (This->nswapchains && This->swapchains[0]->params.BackBufferCount)
		106	refSurf = This->swapchains[0]->buffers[0];
		107
		108	if (refSurf) {
		109	This->state.viewport.Width = refSurf->desc.Width;
		110	This->state.viewport.Height = refSurf->desc.Height;
		111	This->state.scissor.maxx = refSurf->desc.Width;
		112	This->state.scissor.maxy = refSurf->desc.Height;
		113	}
		114
		115	if (This->nswapchains && This->swapchains[0]->params.EnableAutoDepthStencil)
		116	This->state.rs[D3DRS_ZENABLE] = TRUE;
		117	if (This->state.rs[D3DRS_ZENABLE])
		118	NineDevice9_SetDepthStencilSurface(
		119	This, (IDirect3DSurface9 *)This->swapchains[0]->zsbuf);
		120	}
		121
		122	void
		123	NineDevice9_RestoreNonCSOState( struct NineDevice9 *This, unsigned mask )
		124	{
		125	struct pipe_context *pipe = This->pipe;
		126
		127	DBG("This=%p mask=%u\n", This, mask);
		128
		129	if (mask & 0x1) {
		130	struct pipe_constant_buffer cb;
		131	cb.buffer_offset = 0;
		132
		133	if (This->prefer_user_constbuf) {
		134	cb.buffer = NULL;
		135	cb.user_buffer = This->state.vs_const_f;
		136	} else {
		137	cb.buffer = This->constbuf_vs;
		138	cb.user_buffer = NULL;
		139	}
		140	cb.buffer_size = This->vs_const_size;
		141	pipe->set_constant_buffer(pipe, PIPE_SHADER_VERTEX, 0, &cb);
		142
		143	if (This->prefer_user_constbuf) {
		144	cb.user_buffer = This->state.ps_const_f;
		145	} else {
		146	cb.buffer = This->constbuf_ps;
		147	}
		148	cb.buffer_size = This->ps_const_size;
		149	pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, 0, &cb);
		150	}
		151
		152	if (mask & 0x2) {
		153	struct pipe_poly_stipple stipple;
		154	memset(&stipple, ~0, sizeof(stipple));
		155	pipe->set_polygon_stipple(pipe, &stipple);
		156	}
		157
		158	This->state.changed.group = NINE_STATE_ALL;
		159	This->state.changed.vtxbuf = (1ULL << This->caps.MaxStreams) - 1;
		160	This->state.changed.ucp = (1 << PIPE_MAX_CLIP_PLANES) - 1;
		161	This->state.changed.texture = NINE_PS_SAMPLERS_MASK \| NINE_VS_SAMPLERS_MASK;
		162	}
		163
		164	#define GET_PCAP(n) pScreen->get_param(pScreen, PIPE_CAP_##n)
		165	HRESULT
		166	NineDevice9_ctor( struct NineDevice9 *This,
		167	struct NineUnknownParams *pParams,
		168	struct pipe_screen *pScreen,
		169	D3DDEVICE_CREATION_PARAMETERS *pCreationParameters,
		170	D3DCAPS9 *pCaps,
		171	D3DPRESENT_PARAMETERS *pPresentationParameters,
		172	IDirect3D9 *pD3D9,
		173	ID3DPresentGroup *pPresentationGroup,
		174	struct d3dadapter9_context *pCTX,
		175	boolean ex,
		176	D3DDISPLAYMODEEX *pFullscreenDisplayMode )
		177	{
		178	unsigned i;
		179	HRESULT hr = NineUnknown_ctor(&This->base, pParams);
		180
		181	DBG("This=%p pParams=%p pScreen=%p pCreationParameters=%p pCaps=%p pPresentationParameters=%p "
		182	"pD3D9=%p pPresentationGroup=%p pCTX=%p ex=%d pFullscreenDisplayMode=%p\n",
		183	This, pParams, pScreen, pCreationParameters, pCaps, pPresentationParameters, pD3D9,
		184	pPresentationGroup, pCTX, (int) ex, pFullscreenDisplayMode);
		185
		186	if (FAILED(hr)) { return hr; }
		187
		188	list_inithead(&This->update_textures);
		189
		190	This->screen = pScreen;
		191	This->caps = *pCaps;
		192	This->d3d9 = pD3D9;
		193	This->params = *pCreationParameters;
		194	This->ex = ex;
		195	This->present = pPresentationGroup;
		196	IDirect3D9_AddRef(This->d3d9);
		197	ID3DPresentGroup_AddRef(This->present);
		198
		199	if (!(This->params.BehaviorFlags & D3DCREATE_FPU_PRESERVE))
		200	nine_setup_fpu();
		201
		202	if (This->params.BehaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING)
		203	DBG("Application asked full Software Vertex Processing. Ignoring.\n");
		204	if (This->params.BehaviorFlags & D3DCREATE_MIXED_VERTEXPROCESSING)
		205	DBG("Application asked mixed Software Vertex Processing. Ignoring.\n");
		206
		207	This->pipe = This->screen->context_create(This->screen, NULL);
		208	if (!This->pipe) { return E_OUTOFMEMORY; } /* guess */
		209
		210	This->cso = cso_create_context(This->pipe);
		211	if (!This->cso) { return E_OUTOFMEMORY; } /* also a guess */
		212
		213	/* Create first, it messes up our state. */
		214	This->hud = hud_create(This->pipe, This->cso); /* NULL result is fine */
		215
		216	/* create implicit swapchains */
		217	This->nswapchains = ID3DPresentGroup_GetMultiheadCount(This->present);
		218	This->swapchains = CALLOC(This->nswapchains,
		219	sizeof(struct NineSwapChain9 *));
		220	if (!This->swapchains) { return E_OUTOFMEMORY; }
		221
		222	for (i = 0; i < This->nswapchains; ++i) {
		223	ID3DPresent *present;
		224
		225	hr = ID3DPresentGroup_GetPresent(This->present, i, &present);
		226	if (FAILED(hr))
		227	return hr;
		228
		229	if (ex) {
		230	D3DDISPLAYMODEEX *mode = NULL;
		231	struct NineSwapChain9Ex **ret =
		232	(struct NineSwapChain9Ex **)&This->swapchains[i];
		233
		234	if (pFullscreenDisplayMode) mode = &(pFullscreenDisplayMode[i]);
		235	/* when this is a Device9Ex, it should create SwapChain9Exs */
		236	hr = NineSwapChain9Ex_new(This, TRUE, present,
		237	&pPresentationParameters[i], pCTX,
		238	This->params.hFocusWindow, mode, ret);
		239	} else {
		240	hr = NineSwapChain9_new(This, TRUE, present,
		241	&pPresentationParameters[i], pCTX,
		242	This->params.hFocusWindow,
		243	&This->swapchains[i]);
		244	}
		245
		246	ID3DPresent_Release(present);
		247	if (FAILED(hr))
		248	return hr;
		249	NineUnknown_ConvertRefToBind(NineUnknown(This->swapchains[i]));
		250
		251	hr = NineSwapChain9_GetBackBuffer(This->swapchains[i], 0,
		252	D3DBACKBUFFER_TYPE_MONO,
		253	(IDirect3DSurface9 **)
		254	&This->state.rt[i]);
		255	if (FAILED(hr))
		256	return hr;
		257	NineUnknown_ConvertRefToBind(NineUnknown(This->state.rt[i]));
		258	}
		259
		260	/* Initialize a dummy VBO to be used when a a vertex declaration does not
		261	* specify all the inputs needed by vertex shader, on win default behavior
		262	* is to pass 0,0,0,0 to the shader */
		263	{
		264	struct pipe_transfer *transfer;
		265	struct pipe_resource tmpl;
		266	struct pipe_box box;
		267	unsigned char *data;
		268
		269	tmpl.target = PIPE_BUFFER;
		270	tmpl.format = PIPE_FORMAT_R8_UNORM;
		271	tmpl.width0 = 16; /* 4 floats */
		272	tmpl.height0 = 1;
		273	tmpl.depth0 = 1;
		274	tmpl.array_size = 1;
		275	tmpl.last_level = 0;
		276	tmpl.nr_samples = 0;
		277	tmpl.usage = PIPE_USAGE_DEFAULT;
		278	tmpl.bind = PIPE_BIND_VERTEX_BUFFER \| PIPE_BIND_TRANSFER_WRITE;
		279	tmpl.flags = 0;
		280	This->dummy_vbo = pScreen->resource_create(pScreen, &tmpl);
		281
		282	if (!This->dummy_vbo)
		283	return D3DERR_OUTOFVIDEOMEMORY;
		284
		285	u_box_1d(0, 16, &box);
		286	data = This->pipe->transfer_map(This->pipe, This->dummy_vbo, 0,
		287	PIPE_TRANSFER_WRITE \|
		288	PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
		289	&box, &transfer);
		290	assert(data);
		291	assert(transfer);
		292	memset(data, 0, 16);
		293	This->pipe->transfer_unmap(This->pipe, transfer);
		294	}
		295
		296	This->cursor.software = FALSE;
		297	This->cursor.hotspot.x = -1;
		298	This->cursor.hotspot.y = -1;
		299	{
		300	struct pipe_resource tmpl;
		301	tmpl.target = PIPE_TEXTURE_2D;
		302	tmpl.format = PIPE_FORMAT_R8G8B8A8_UNORM;
		303	tmpl.width0 = 64;
		304	tmpl.height0 = 64;
		305	tmpl.depth0 = 1;
		306	tmpl.array_size = 1;
		307	tmpl.last_level = 0;
		308	tmpl.nr_samples = 0;
		309	tmpl.usage = PIPE_USAGE_DEFAULT;
		310	tmpl.bind = PIPE_BIND_CURSOR \| PIPE_BIND_SAMPLER_VIEW;
		311	tmpl.flags = 0;
		312
		313	This->cursor.image = pScreen->resource_create(pScreen, &tmpl);
		314	if (!This->cursor.image)
		315	return D3DERR_OUTOFVIDEOMEMORY;
		316	}
		317
		318	/* Create constant buffers. */
		319	{
		320	struct pipe_resource tmpl;
		321	unsigned max_const_vs, max_const_ps;
		322
		323	/* vs 3.0: >= 256 float constants, but for cards with exactly 256 slots,
		324	* we have to take in some more slots for int and bool*/
		325	max_const_vs = _min(pScreen->get_shader_param(pScreen, PIPE_SHADER_VERTEX,
		326	PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) /
		327	sizeof(float[4]),
		328	NINE_MAX_CONST_ALL);
		329	/* ps 3.0: 224 float constants. All cards supported support at least
		330	* 256 constants for ps */
		331	max_const_ps = NINE_MAX_CONST_F_PS3 + (NINE_MAX_CONST_I + NINE_MAX_CONST_B / 4);
		332
		333	This->max_vs_const_f = max_const_vs -
		334	(NINE_MAX_CONST_I + NINE_MAX_CONST_B / 4);
		335	This->max_ps_const_f = max_const_ps -
		336	(NINE_MAX_CONST_I + NINE_MAX_CONST_B / 4);
		337
		338	This->vs_const_size = max_const_vs * sizeof(float[4]);
		339	This->ps_const_size = max_const_ps * sizeof(float[4]);
		340	/* Include space for I,B constants for user constbuf. */
		341	This->state.vs_const_f = CALLOC(This->vs_const_size, 1);
		342	This->state.ps_const_f = CALLOC(This->ps_const_size, 1);
		343	This->state.vs_lconstf_temp = CALLOC(This->vs_const_size,1);
		344	if (!This->state.vs_const_f \|\| !This->state.ps_const_f \|\|
		345	!This->state.vs_lconstf_temp)
		346	return E_OUTOFMEMORY;
		347
		348	if (strstr(pScreen->get_name(pScreen), "AMD") \|\|
		349	strstr(pScreen->get_name(pScreen), "ATI")) {
		350	This->prefer_user_constbuf = TRUE;
		351	This->driver_bugs.buggy_barycentrics = TRUE;
		352	}
		353
		354	tmpl.target = PIPE_BUFFER;
		355	tmpl.format = PIPE_FORMAT_R8_UNORM;
		356	tmpl.height0 = 1;
		357	tmpl.depth0 = 1;
		358	tmpl.array_size = 1;
		359	tmpl.last_level = 0;
		360	tmpl.nr_samples = 0;
		361	tmpl.usage = PIPE_USAGE_DYNAMIC;
		362	tmpl.bind = PIPE_BIND_CONSTANT_BUFFER;
		363	tmpl.flags = 0;
		364
		365	tmpl.width0 = This->vs_const_size;
		366	This->constbuf_vs = pScreen->resource_create(pScreen, &tmpl);
		367
		368	tmpl.width0 = This->ps_const_size;
		369	This->constbuf_ps = pScreen->resource_create(pScreen, &tmpl);
		370
		371	if (!This->constbuf_vs \|\| !This->constbuf_ps)
		372	return E_OUTOFMEMORY;
		373	}
		374
		375	/* allocate dummy texture/sampler for when there are missing ones bound */
		376	{
		377	struct pipe_resource tmplt;
		378	struct pipe_sampler_view templ;
		379
		380	tmplt.target = PIPE_TEXTURE_2D;
		381	tmplt.width0 = 1;
		382	tmplt.height0 = 1;
		383	tmplt.depth0 = 1;
		384	tmplt.last_level = 0;
		385	tmplt.array_size = 1;
		386	tmplt.usage = PIPE_USAGE_DEFAULT;
		387	tmplt.flags = 0;
		388	tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM;
		389	tmplt.bind = PIPE_BIND_SAMPLER_VIEW;
		390	tmplt.nr_samples = 0;
		391
		392	This->dummy_texture = This->screen->resource_create(This->screen, &tmplt);
		393	if (!This->dummy_texture)
		394	return D3DERR_DRIVERINTERNALERROR;
		395
		396	templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
		397	templ.u.tex.first_layer = 0;
		398	templ.u.tex.last_layer = 0;
		399	templ.u.tex.first_level = 0;
		400	templ.u.tex.last_level = 0;
		401	templ.swizzle_r = PIPE_SWIZZLE_ZERO;
		402	templ.swizzle_g = PIPE_SWIZZLE_ZERO;
		403	templ.swizzle_b = PIPE_SWIZZLE_ZERO;
		404	templ.swizzle_a = PIPE_SWIZZLE_ONE;
		405	templ.target = This->dummy_texture->target;
		406
		407	This->dummy_sampler = This->pipe->create_sampler_view(This->pipe, This->dummy_texture, &templ);
		408	if (!This->dummy_sampler)
		409	return D3DERR_DRIVERINTERNALERROR;
		410	}
		411
		412	/* Allocate upload helper for drivers that suck (from st pov ;). */
		413	{
		414	unsigned bind = 0;
		415
		416	This->driver_caps.user_vbufs = GET_PCAP(USER_VERTEX_BUFFERS);
		417	This->driver_caps.user_ibufs = GET_PCAP(USER_INDEX_BUFFERS);
		418
		419	if (!This->driver_caps.user_vbufs) bind \|= PIPE_BIND_VERTEX_BUFFER;
		420	if (!This->driver_caps.user_ibufs) bind \|= PIPE_BIND_INDEX_BUFFER;
		421	if (bind)
		422	This->upload = u_upload_create(This->pipe, 1 << 20, 4, bind);
		423	}
		424
		425	This->driver_caps.window_space_position_support = GET_PCAP(TGSI_VS_WINDOW_SPACE_POSITION);
		426	This->driver_caps.vs_integer = pScreen->get_shader_param(pScreen, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_INTEGERS);
		427	This->driver_caps.ps_integer = pScreen->get_shader_param(pScreen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS);
		428
		429	nine_ff_init(This); /* initialize fixed function code */
		430
		431	NineDevice9_SetDefaultState(This, FALSE);
		432	NineDevice9_RestoreNonCSOState(This, ~0);
		433
		434	This->update = &This->state;
		435	nine_update_state(This, ~0);
		436
		437	ID3DPresentGroup_Release(This->present);
		438
		439	return D3D_OK;
		440	}
		441	#undef GET_PCAP
		442
		443	void
		444	NineDevice9_dtor( struct NineDevice9 *This )
		445	{
		446	unsigned i;
		447
		448	DBG("This=%p\n", This);
		449
		450	if (This->pipe && This->cso)
		451	nine_pipe_context_clear(This);
		452	nine_ff_fini(This);
		453	nine_state_clear(&This->state, TRUE);
		454
		455	if (This->upload)
		456	u_upload_destroy(This->upload);
		457
		458	nine_bind(&This->record, NULL);
		459
		460	pipe_sampler_view_reference(&This->dummy_sampler, NULL);
		461	pipe_resource_reference(&This->dummy_texture, NULL);
		462	pipe_resource_reference(&This->constbuf_vs, NULL);
		463	pipe_resource_reference(&This->constbuf_ps, NULL);
		464	pipe_resource_reference(&This->dummy_vbo, NULL);
		465	FREE(This->state.vs_const_f);
		466	FREE(This->state.ps_const_f);
		467	FREE(This->state.vs_lconstf_temp);
		468
		469	if (This->swapchains) {
		470	for (i = 0; i < This->nswapchains; ++i)
		471	NineUnknown_Unbind(NineUnknown(This->swapchains[i]));
		472	FREE(This->swapchains);
		473	}
		474
		475	/* state stuff */
		476	if (This->pipe) {
		477	if (This->cso) {
		478	cso_destroy_context(This->cso);
		479	}
		480	if (This->pipe->destroy) { This->pipe->destroy(This->pipe); }
		481	}
		482
		483	if (This->present) { ID3DPresentGroup_Release(This->present); }
		484	if (This->d3d9) { IDirect3D9_Release(This->d3d9); }
		485
		486	NineUnknown_dtor(&This->base);
		487	}
		488
		489	struct pipe_screen *
		490	NineDevice9_GetScreen( struct NineDevice9 *This )
		491	{
		492	return This->screen;
		493	}
		494
		495	struct pipe_context *
		496	NineDevice9_GetPipe( struct NineDevice9 *This )
		497	{
		498	return This->pipe;
		499	}
		500
		501	struct cso_context *
		502	NineDevice9_GetCSO( struct NineDevice9 *This )
		503	{
		504	return This->cso;
		505	}
		506
		507	const D3DCAPS9 *
		508	NineDevice9_GetCaps( struct NineDevice9 *This )
		509	{
		510	return &This->caps;
		511	}
		512
		513	static INLINE void
		514	NineDevice9_PauseRecording( struct NineDevice9 *This )
		515	{
		516	if (This->record) {
		517	This->update = &This->state;
		518	This->is_recording = FALSE;
		519	}
		520	}
		521
		522	static INLINE void
		523	NineDevice9_ResumeRecording( struct NineDevice9 *This )
		524	{
		525	if (This->record) {
		526	This->update = &This->record->state;
		527	This->is_recording = TRUE;
		528	}
		529	}
		530
		531	HRESULT WINAPI
		532	NineDevice9_TestCooperativeLevel( struct NineDevice9 *This )
		533	{
		534	return D3D_OK; /* TODO */
		535	}
		536
		537	UINT WINAPI
		538	NineDevice9_GetAvailableTextureMem( struct NineDevice9 *This )
		539	{
		540	const unsigned mem = This->screen->get_param(This->screen, PIPE_CAP_VIDEO_MEMORY);
		541	if (mem < 4096)
		542	return mem << 20;
		543	else
		544	return UINT_MAX;
		545	}
		546
		547	HRESULT WINAPI
		548	NineDevice9_EvictManagedResources( struct NineDevice9 *This )
		549	{
		550	/* We don't really need to do anything here, but might want to free up
		551	* the GPU virtual address space by killing pipe_resources.
		552	*/
		553	STUB(D3D_OK);
		554	}
		555
		556	HRESULT WINAPI
		557	NineDevice9_GetDirect3D( struct NineDevice9 *This,
		558	IDirect3D9 **ppD3D9 )
		559	{
		560	user_assert(ppD3D9 != NULL, E_POINTER);
		561	IDirect3D9_AddRef(This->d3d9);
		562	*ppD3D9 = This->d3d9;
		563	return D3D_OK;
		564	}
		565
		566	HRESULT WINAPI
		567	NineDevice9_GetDeviceCaps( struct NineDevice9 *This,
		568	D3DCAPS9 *pCaps )
		569	{
		570	user_assert(pCaps != NULL, D3DERR_INVALIDCALL);
		571	*pCaps = This->caps;
		572	return D3D_OK;
		573	}
		574
		575	HRESULT WINAPI
		576	NineDevice9_GetDisplayMode( struct NineDevice9 *This,
		577	UINT iSwapChain,
		578	D3DDISPLAYMODE *pMode )
		579	{
		580	DBG("This=%p iSwapChain=%u pMode=%p\n", This, iSwapChain, pMode);
		581
		582	user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
		583
		584	return NineSwapChain9_GetDisplayMode(This->swapchains[iSwapChain], pMode);
		585	}
		586
		587	HRESULT WINAPI
		588	NineDevice9_GetCreationParameters( struct NineDevice9 *This,
		589	D3DDEVICE_CREATION_PARAMETERS *pParameters )
		590	{
		591	user_assert(pParameters != NULL, D3DERR_INVALIDCALL);
		592	*pParameters = This->params;
		593	return D3D_OK;
		594	}
		595
		596	HRESULT WINAPI
		597	NineDevice9_SetCursorProperties( struct NineDevice9 *This,
		598	UINT XHotSpot,
		599	UINT YHotSpot,
		600	IDirect3DSurface9 *pCursorBitmap )
		601	{
		602	/* TODO: hardware cursor */
		603	struct NineSurface9 *surf = NineSurface9(pCursorBitmap);
		604	struct pipe_context *pipe = This->pipe;
		605	struct pipe_box box;
		606	struct pipe_transfer *transfer;
		607	void *ptr;
		608
		609	DBG_FLAG(DBG_SWAPCHAIN, "This=%p XHotSpot=%u YHotSpot=%u "
		610	"pCursorBitmap=%p\n", This, XHotSpot, YHotSpot, pCursorBitmap);
		611
		612	user_assert(pCursorBitmap, D3DERR_INVALIDCALL);
		613
		614	This->cursor.w = MIN2(surf->desc.Width, This->cursor.image->width0);
		615	This->cursor.h = MIN2(surf->desc.Height, This->cursor.image->height0);
		616
		617	u_box_origin_2d(This->cursor.w, This->cursor.h, &box);
		618
		619	ptr = pipe->transfer_map(pipe, This->cursor.image, 0,
		620	PIPE_TRANSFER_WRITE \|
		621	PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
		622	&box, &transfer);
		623	if (!ptr)
		624	ret_err("Failed to update cursor image.\n", D3DERR_DRIVERINTERNALERROR);
		625
		626	This->cursor.hotspot.x = XHotSpot;
		627	This->cursor.hotspot.y = YHotSpot;
		628
		629	/* Copy cursor image to internal storage. */
		630	{
		631	D3DLOCKED_RECT lock;
		632	HRESULT hr;
		633	const struct util_format_description *sfmt =
		634	util_format_description(surf->base.info.format);
		635	assert(sfmt);
		636
		637	hr = NineSurface9_LockRect(surf, &lock, NULL, D3DLOCK_READONLY);
		638	if (FAILED(hr))
		639	ret_err("Failed to map cursor source image.\n",
		640	D3DERR_DRIVERINTERNALERROR);
		641
		642	sfmt->unpack_rgba_8unorm(ptr, transfer->stride,
		643	lock.pBits, lock.Pitch,
		644	This->cursor.w, This->cursor.h);
		645
		646	if (!This->cursor.software &&
		647	This->cursor.w == 32 && This->cursor.h == 32)
		648	ID3DPresent_SetCursor(This->swapchains[0]->present,
		649	lock.pBits, &This->cursor.hotspot,
		650	This->cursor.visible);
		651
		652	NineSurface9_UnlockRect(surf);
		653	}
		654	pipe->transfer_unmap(pipe, transfer);
		655
		656	return D3D_OK;
		657	}
		658
		659	void WINAPI
		660	NineDevice9_SetCursorPosition( struct NineDevice9 *This,
		661	int X,
		662	int Y,
		663	DWORD Flags )
		664	{
		665	struct NineSwapChain9 *swap = This->swapchains[0];
		666
		667	DBG("This=%p X=%d Y=%d Flags=%d\n", This, X, Y, Flags);
		668
		669	This->cursor.pos.x = X;
		670	This->cursor.pos.y = Y;
		671
		672	if (!This->cursor.software)
		673	ID3DPresent_SetCursorPos(swap->present, &This->cursor.pos);
		674	}
		675
		676	BOOL WINAPI
		677	NineDevice9_ShowCursor( struct NineDevice9 *This,
		678	BOOL bShow )
		679	{
		680	BOOL old = This->cursor.visible;
		681
		682	DBG("This=%p bShow=%d\n", This, (int) bShow);
		683
		684	This->cursor.visible = bShow && (This->cursor.hotspot.x != -1);
		685	if (!This->cursor.software)
		686	ID3DPresent_SetCursor(This->swapchains[0]->present, NULL, NULL, bShow);
		687
		688	return old;
		689	}
		690
		691	HRESULT WINAPI
		692	NineDevice9_CreateAdditionalSwapChain( struct NineDevice9 *This,
		693	D3DPRESENT_PARAMETERS *pPresentationParameters,
		694	IDirect3DSwapChain9 **pSwapChain )
		695	{
		696	struct NineSwapChain9 swapchain, tmplt = This->swapchains[0];
		697	ID3DPresent *present;
		698	HRESULT hr;
		699
		700	DBG("This=%p pPresentationParameters=%p pSwapChain=%p\n",
		701	This, pPresentationParameters, pSwapChain);
		702
		703	user_assert(pPresentationParameters, D3DERR_INVALIDCALL);
		704
		705	hr = ID3DPresentGroup_CreateAdditionalPresent(This->present, pPresentationParameters, &present);
		706
		707	if (FAILED(hr))
		708	return hr;
		709
		710	hr = NineSwapChain9_new(This, FALSE, present, pPresentationParameters,
		711	tmplt->actx,
		712	tmplt->params.hDeviceWindow,
		713	&swapchain);
		714	if (FAILED(hr))
		715	return hr;
		716
		717	pSwapChain = (IDirect3DSwapChain9 )swapchain;
		718	return D3D_OK;
		719	}
		720
		721	HRESULT WINAPI
		722	NineDevice9_GetSwapChain( struct NineDevice9 *This,
		723	UINT iSwapChain,
		724	IDirect3DSwapChain9 **pSwapChain )
		725	{
		726	user_assert(pSwapChain != NULL, D3DERR_INVALIDCALL);
		727
		728	*pSwapChain = NULL;
		729	user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
		730
		731	NineUnknown_AddRef(NineUnknown(This->swapchains[iSwapChain]));
		732	pSwapChain = (IDirect3DSwapChain9 )This->swapchains[iSwapChain];
		733
		734	return D3D_OK;
		735	}
		736
		737	UINT WINAPI
		738	NineDevice9_GetNumberOfSwapChains( struct NineDevice9 *This )
		739	{
		740	return This->nswapchains;
		741	}
		742
		743	HRESULT WINAPI
		744	NineDevice9_Reset( struct NineDevice9 *This,
		745	D3DPRESENT_PARAMETERS *pPresentationParameters )
		746	{
		747	HRESULT hr = D3D_OK;
		748	unsigned i;
		749
		750	DBG("This=%p pPresentationParameters=%p\n", This, pPresentationParameters);
		751
		752	for (i = 0; i < This->nswapchains; ++i) {
		753	D3DPRESENT_PARAMETERS *params = &pPresentationParameters[i];
		754	hr = NineSwapChain9_Resize(This->swapchains[i], params, NULL);
		755	if (FAILED(hr))
		756	return (hr == D3DERR_OUTOFVIDEOMEMORY) ? hr : D3DERR_DEVICELOST;
		757	}
		758
		759	nine_pipe_context_clear(This);
		760	nine_state_clear(&This->state, TRUE);
		761
		762	NineDevice9_SetDefaultState(This, TRUE);
		763	NineDevice9_SetRenderTarget(
		764	This, 0, (IDirect3DSurface9 *)This->swapchains[0]->buffers[0]);
		765	/* XXX: better use GetBackBuffer here ? */
		766
		767	return hr;
		768	}
		769
		770	HRESULT WINAPI
		771	NineDevice9_Present( struct NineDevice9 *This,
		772	const RECT *pSourceRect,
		773	const RECT *pDestRect,
		774	HWND hDestWindowOverride,
		775	const RGNDATA *pDirtyRegion )
		776	{
		777	unsigned i;
		778	HRESULT hr;
		779
		780	DBG("This=%p pSourceRect=%p pDestRect=%p hDestWindowOverride=%p pDirtyRegion=%p\n",
		781	This, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
		782
		783	/* XXX is this right? */
		784	for (i = 0; i < This->nswapchains; ++i) {
		785	hr = NineSwapChain9_Present(This->swapchains[i], pSourceRect, pDestRect,
		786	hDestWindowOverride, pDirtyRegion, 0);
		787	if (FAILED(hr)) { return hr; }
		788	}
		789
		790	return D3D_OK;
		791	}
		792
		793	HRESULT WINAPI
		794	NineDevice9_GetBackBuffer( struct NineDevice9 *This,
		795	UINT iSwapChain,
		796	UINT iBackBuffer,
		797	D3DBACKBUFFER_TYPE Type,
		798	IDirect3DSurface9 **ppBackBuffer )
		799	{
		800	user_assert(ppBackBuffer != NULL, D3DERR_INVALIDCALL);
		801	user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
		802
		803	return NineSwapChain9_GetBackBuffer(This->swapchains[iSwapChain],
		804	iBackBuffer, Type, ppBackBuffer);
		805	}
		806
		807	HRESULT WINAPI
		808	NineDevice9_GetRasterStatus( struct NineDevice9 *This,
		809	UINT iSwapChain,
		810	D3DRASTER_STATUS *pRasterStatus )
		811	{
		812	user_assert(pRasterStatus != NULL, D3DERR_INVALIDCALL);
		813	user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
		814
		815	return NineSwapChain9_GetRasterStatus(This->swapchains[iSwapChain],
		816	pRasterStatus);
		817	}
		818
		819	HRESULT WINAPI
		820	NineDevice9_SetDialogBoxMode( struct NineDevice9 *This,
		821	BOOL bEnableDialogs )
		822	{
		823	STUB(D3DERR_INVALIDCALL);
		824	}
		825
		826	void WINAPI
		827	NineDevice9_SetGammaRamp( struct NineDevice9 *This,
		828	UINT iSwapChain,
		829	DWORD Flags,
		830	const D3DGAMMARAMP *pRamp )
		831	{
		832	DBG("This=%p iSwapChain=%u Flags=%x pRamp=%p\n", This,
		833	iSwapChain, Flags, pRamp);
		834
		835	user_warn(iSwapChain >= This->nswapchains);
		836	user_warn(!pRamp);
		837
		838	if (pRamp && (iSwapChain < This->nswapchains)) {
		839	struct NineSwapChain9 *swap = This->swapchains[iSwapChain];
		840	swap->gamma = *pRamp;
		841	ID3DPresent_SetGammaRamp(swap->present, pRamp, swap->params.hDeviceWindow);
		842	}
		843	}
		844
		845	void WINAPI
		846	NineDevice9_GetGammaRamp( struct NineDevice9 *This,
		847	UINT iSwapChain,
		848	D3DGAMMARAMP *pRamp )
		849	{
		850	DBG("This=%p iSwapChain=%u pRamp=%p\n", This, iSwapChain, pRamp);
		851
		852	user_warn(iSwapChain >= This->nswapchains);
		853	user_warn(!pRamp);
		854
		855	if (pRamp && (iSwapChain < This->nswapchains))
		856	*pRamp = This->swapchains[iSwapChain]->gamma;
		857	}
		858
		859	HRESULT WINAPI
		860	NineDevice9_CreateTexture( struct NineDevice9 *This,
		861	UINT Width,
		862	UINT Height,
		863	UINT Levels,
		864	DWORD Usage,
		865	D3DFORMAT Format,
		866	D3DPOOL Pool,
		867	IDirect3DTexture9 **ppTexture,
		868	HANDLE *pSharedHandle )
		869	{
		870	struct NineTexture9 *tex;
		871	HRESULT hr;
		872
		873	DBG("This=%p Width=%u Height=%u Levels=%u Usage=%s Format=%s Pool=%s "
		874	"ppOut=%p pSharedHandle=%p\n", This, Width, Height, Levels,
		875	nine_D3DUSAGE_to_str(Usage), d3dformat_to_string(Format),
		876	nine_D3DPOOL_to_str(Pool), ppTexture, pSharedHandle);
		877
		878	Usage &= D3DUSAGE_AUTOGENMIPMAP \| D3DUSAGE_DEPTHSTENCIL \| D3DUSAGE_DMAP \|
		879	D3DUSAGE_DYNAMIC \| D3DUSAGE_NONSECURE \| D3DUSAGE_RENDERTARGET \|
		880	D3DUSAGE_SOFTWAREPROCESSING \| D3DUSAGE_TEXTAPI;
		881
		882	*ppTexture = NULL;
		883	user_assert(Width && Height, D3DERR_INVALIDCALL);
		884	user_assert(!pSharedHandle \|\| This->ex, D3DERR_INVALIDCALL);
		885	/* When is used shared handle, Pool must be
		886	* SYSTEMMEM with Levels 1 or DEFAULT with any Levels */
		887	user_assert(!pSharedHandle \|\| Pool != D3DPOOL_SYSTEMMEM \|\| Levels == 1,
		888	D3DERR_INVALIDCALL);
		889	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_SYSTEMMEM \|\| Pool == D3DPOOL_DEFAULT,
		890	D3DERR_INVALIDCALL);
		891	user_assert((Usage != D3DUSAGE_AUTOGENMIPMAP \|\| Levels <= 1), D3DERR_INVALIDCALL);
		892
		893	hr = NineTexture9_new(This, Width, Height, Levels, Usage, Format, Pool,
		894	&tex, pSharedHandle);
		895	if (SUCCEEDED(hr))
		896	ppTexture = (IDirect3DTexture9 )tex;
		897
		898	return hr;
		899	}
		900
		901	HRESULT WINAPI
		902	NineDevice9_CreateVolumeTexture( struct NineDevice9 *This,
		903	UINT Width,
		904	UINT Height,
		905	UINT Depth,
		906	UINT Levels,
		907	DWORD Usage,
		908	D3DFORMAT Format,
		909	D3DPOOL Pool,
		910	IDirect3DVolumeTexture9 **ppVolumeTexture,
		911	HANDLE *pSharedHandle )
		912	{
		913	struct NineVolumeTexture9 *tex;
		914	HRESULT hr;
		915
		916	DBG("This=%p Width=%u Height=%u Depth=%u Levels=%u Usage=%s Format=%s Pool=%s "
		917	"ppOut=%p pSharedHandle=%p\n", This, Width, Height, Depth, Levels,
		918	nine_D3DUSAGE_to_str(Usage), d3dformat_to_string(Format),
		919	nine_D3DPOOL_to_str(Pool), ppVolumeTexture, pSharedHandle);
		920
		921	Usage &= D3DUSAGE_DYNAMIC \| D3DUSAGE_NONSECURE \|
		922	D3DUSAGE_SOFTWAREPROCESSING;
		923
		924	*ppVolumeTexture = NULL;
		925	user_assert(Width && Height && Depth, D3DERR_INVALIDCALL);
		926	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		927
		928	hr = NineVolumeTexture9_new(This, Width, Height, Depth, Levels,
		929	Usage, Format, Pool, &tex, pSharedHandle);
		930	if (SUCCEEDED(hr))
		931	ppVolumeTexture = (IDirect3DVolumeTexture9 )tex;
		932
		933	return hr;
		934	}
		935
		936	HRESULT WINAPI
		937	NineDevice9_CreateCubeTexture( struct NineDevice9 *This,
		938	UINT EdgeLength,
		939	UINT Levels,
		940	DWORD Usage,
		941	D3DFORMAT Format,
		942	D3DPOOL Pool,
		943	IDirect3DCubeTexture9 **ppCubeTexture,
		944	HANDLE *pSharedHandle )
		945	{
		946	struct NineCubeTexture9 *tex;
		947	HRESULT hr;
		948
		949	DBG("This=%p EdgeLength=%u Levels=%u Usage=%s Format=%s Pool=%s ppOut=%p "
		950	"pSharedHandle=%p\n", This, EdgeLength, Levels,
		951	nine_D3DUSAGE_to_str(Usage), d3dformat_to_string(Format),
		952	nine_D3DPOOL_to_str(Pool), ppCubeTexture, pSharedHandle);
		953
		954	Usage &= D3DUSAGE_AUTOGENMIPMAP \| D3DUSAGE_DEPTHSTENCIL \| D3DUSAGE_DYNAMIC \|
		955	D3DUSAGE_NONSECURE \| D3DUSAGE_RENDERTARGET \|
		956	D3DUSAGE_SOFTWAREPROCESSING;
		957
		958	*ppCubeTexture = NULL;
		959	user_assert(EdgeLength, D3DERR_INVALIDCALL);
		960	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		961
		962	hr = NineCubeTexture9_new(This, EdgeLength, Levels, Usage, Format, Pool,
		963	&tex, pSharedHandle);
		964	if (SUCCEEDED(hr))
		965	ppCubeTexture = (IDirect3DCubeTexture9 )tex;
		966
		967	return hr;
		968	}
		969
		970	HRESULT WINAPI
		971	NineDevice9_CreateVertexBuffer( struct NineDevice9 *This,
		972	UINT Length,
		973	DWORD Usage,
		974	DWORD FVF,
		975	D3DPOOL Pool,
		976	IDirect3DVertexBuffer9 **ppVertexBuffer,
		977	HANDLE *pSharedHandle )
		978	{
		979	struct NineVertexBuffer9 *buf;
		980	HRESULT hr;
		981	D3DVERTEXBUFFER_DESC desc;
		982
		983	DBG("This=%p Length=%u Usage=%x FVF=%x Pool=%u ppOut=%p pSharedHandle=%p\n",
		984	This, Length, Usage, FVF, Pool, ppVertexBuffer, pSharedHandle);
		985
		986	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT, D3DERR_NOTAVAILABLE);
		987
		988	desc.Format = D3DFMT_VERTEXDATA;
		989	desc.Type = D3DRTYPE_VERTEXBUFFER;
		990	desc.Usage = Usage &
		991	(D3DUSAGE_DONOTCLIP \| D3DUSAGE_DYNAMIC \| D3DUSAGE_NONSECURE \|
		992	D3DUSAGE_NPATCHES \| D3DUSAGE_POINTS \| D3DUSAGE_RTPATCHES \|
		993	D3DUSAGE_SOFTWAREPROCESSING \| D3DUSAGE_TEXTAPI \|
		994	D3DUSAGE_WRITEONLY);
		995	desc.Pool = Pool;
		996	desc.Size = Length;
		997	desc.FVF = FVF;
		998
		999	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1000	user_assert(desc.Usage == Usage, D3DERR_INVALIDCALL);
		1001
		1002	hr = NineVertexBuffer9_new(This, &desc, &buf);
		1003	if (SUCCEEDED(hr))
		1004	ppVertexBuffer = (IDirect3DVertexBuffer9 )buf;
		1005	return hr;
		1006	}
		1007
		1008	HRESULT WINAPI
		1009	NineDevice9_CreateIndexBuffer( struct NineDevice9 *This,
		1010	UINT Length,
		1011	DWORD Usage,
		1012	D3DFORMAT Format,
		1013	D3DPOOL Pool,
		1014	IDirect3DIndexBuffer9 **ppIndexBuffer,
		1015	HANDLE *pSharedHandle )
		1016	{
		1017	struct NineIndexBuffer9 *buf;
		1018	HRESULT hr;
		1019	D3DINDEXBUFFER_DESC desc;
		1020
		1021	DBG("This=%p Length=%u Usage=%x Format=%s Pool=%u ppOut=%p "
		1022	"pSharedHandle=%p\n", This, Length, Usage,
		1023	d3dformat_to_string(Format), Pool, ppIndexBuffer, pSharedHandle);
		1024
		1025	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT, D3DERR_NOTAVAILABLE);
		1026
		1027	desc.Format = Format;
		1028	desc.Type = D3DRTYPE_INDEXBUFFER;
		1029	desc.Usage = Usage &
		1030	(D3DUSAGE_DONOTCLIP \| D3DUSAGE_DYNAMIC \| D3DUSAGE_NONSECURE \|
		1031	D3DUSAGE_NPATCHES \| D3DUSAGE_POINTS \| D3DUSAGE_RTPATCHES \|
		1032	D3DUSAGE_SOFTWAREPROCESSING \| D3DUSAGE_WRITEONLY);
		1033	desc.Pool = Pool;
		1034	desc.Size = Length;
		1035
		1036	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1037	user_assert(desc.Usage == Usage, D3DERR_INVALIDCALL);
		1038
		1039	hr = NineIndexBuffer9_new(This, &desc, &buf);
		1040	if (SUCCEEDED(hr))
		1041	ppIndexBuffer = (IDirect3DIndexBuffer9 )buf;
		1042	return hr;
		1043	}
		1044
		1045	static HRESULT
		1046	create_zs_or_rt_surface(struct NineDevice9 *This,
		1047	unsigned type, /* 0 = RT, 1 = ZS, 2 = plain */
		1048	D3DPOOL Pool,
		1049	UINT Width, UINT Height,
		1050	D3DFORMAT Format,
		1051	D3DMULTISAMPLE_TYPE MultiSample,
		1052	DWORD MultisampleQuality,
		1053	BOOL Discard_or_Lockable,
		1054	IDirect3DSurface9 **ppSurface,
		1055	HANDLE *pSharedHandle)
		1056	{
		1057	struct NineSurface9 *surface;
		1058	struct pipe_screen *screen = This->screen;
		1059	struct pipe_resource *resource = NULL;
		1060	HRESULT hr;
		1061	D3DSURFACE_DESC desc;
		1062	struct pipe_resource templ;
		1063
		1064	DBG("This=%p type=%u Pool=%s Width=%u Height=%u Format=%s MS=%u Quality=%u "
		1065	"Discard_or_Lockable=%i ppSurface=%p pSharedHandle=%p\n",
		1066	This, type, nine_D3DPOOL_to_str(Pool), Width, Height,
		1067	d3dformat_to_string(Format), MultiSample, MultisampleQuality,
		1068	Discard_or_Lockable, ppSurface, pSharedHandle);
		1069
		1070	if (pSharedHandle)
		1071	DBG("FIXME Used shared handle! This option isn't probably handled correctly!\n");
		1072
		1073	user_assert(Width && Height, D3DERR_INVALIDCALL);
		1074	user_assert(Pool != D3DPOOL_MANAGED, D3DERR_INVALIDCALL);
		1075
		1076	templ.target = PIPE_TEXTURE_2D;
		1077	templ.width0 = Width;
		1078	templ.height0 = Height;
		1079	templ.depth0 = 1;
		1080	templ.array_size = 1;
		1081	templ.last_level = 0;
		1082	templ.nr_samples = (unsigned)MultiSample;
		1083	templ.usage = PIPE_USAGE_DEFAULT;
		1084	templ.flags = 0;
		1085	templ.bind = PIPE_BIND_SAMPLER_VIEW; /* StretchRect */
		1086	switch (type) {
		1087	case 0: templ.bind \|= PIPE_BIND_RENDER_TARGET; break;
		1088	case 1: templ.bind = d3d9_get_pipe_depth_format_bindings(Format); break;
		1089	default:
		1090	assert(type == 2);
		1091	break;
		1092	}
		1093	templ.format = d3d9_to_pipe_format_checked(screen, Format, templ.target,
		1094	templ.nr_samples, templ.bind,
		1095	FALSE);
		1096
		1097	desc.Format = Format;
		1098	desc.Type = D3DRTYPE_SURFACE;
		1099	desc.Usage = 0;
		1100	desc.Pool = Pool;
		1101	desc.MultiSampleType = MultiSample;
		1102	desc.MultiSampleQuality = MultisampleQuality;
		1103	desc.Width = Width;
		1104	desc.Height = Height;
		1105	switch (type) {
		1106	case 0: desc.Usage = D3DUSAGE_RENDERTARGET; break;
		1107	case 1: desc.Usage = D3DUSAGE_DEPTHSTENCIL; break;
		1108	default: break;
		1109	}
		1110
		1111	if (Pool == D3DPOOL_DEFAULT && Format != D3DFMT_NULL) {
		1112	/* resource_create doesn't return an error code, so check format here */
		1113	user_assert(templ.format != PIPE_FORMAT_NONE, D3DERR_INVALIDCALL);
		1114	resource = screen->resource_create(screen, &templ);
		1115	user_assert(resource, D3DERR_OUTOFVIDEOMEMORY);
		1116	if (Discard_or_Lockable && (desc.Usage & D3DUSAGE_RENDERTARGET))
		1117	resource->flags \|= NINE_RESOURCE_FLAG_LOCKABLE;
		1118	} else {
		1119	resource = NULL;
		1120	}
		1121	hr = NineSurface9_new(This, NULL, resource, NULL, 0, 0, 0, &desc, &surface);
		1122	pipe_resource_reference(&resource, NULL);
		1123
		1124	if (SUCCEEDED(hr))
		1125	ppSurface = (IDirect3DSurface9 )surface;
		1126	return hr;
		1127	}
		1128
		1129	HRESULT WINAPI
		1130	NineDevice9_CreateRenderTarget( struct NineDevice9 *This,
		1131	UINT Width,
		1132	UINT Height,
		1133	D3DFORMAT Format,
		1134	D3DMULTISAMPLE_TYPE MultiSample,
		1135	DWORD MultisampleQuality,
		1136	BOOL Lockable,
		1137	IDirect3DSurface9 **ppSurface,
		1138	HANDLE *pSharedHandle )
		1139	{
		1140	*ppSurface = NULL;
		1141	return create_zs_or_rt_surface(This, 0, D3DPOOL_DEFAULT,
		1142	Width, Height, Format,
		1143	MultiSample, MultisampleQuality,
		1144	Lockable, ppSurface, pSharedHandle);
		1145	}
		1146
		1147	HRESULT WINAPI
		1148	NineDevice9_CreateDepthStencilSurface( struct NineDevice9 *This,
		1149	UINT Width,
		1150	UINT Height,
		1151	D3DFORMAT Format,
		1152	D3DMULTISAMPLE_TYPE MultiSample,
		1153	DWORD MultisampleQuality,
		1154	BOOL Discard,
		1155	IDirect3DSurface9 **ppSurface,
		1156	HANDLE *pSharedHandle )
		1157	{
		1158	*ppSurface = NULL;
		1159	if (!depth_stencil_format(Format))
		1160	return D3DERR_NOTAVAILABLE;
		1161	return create_zs_or_rt_surface(This, 1, D3DPOOL_DEFAULT,
		1162	Width, Height, Format,
		1163	MultiSample, MultisampleQuality,
		1164	Discard, ppSurface, pSharedHandle);
		1165	}
		1166
		1167	HRESULT WINAPI
		1168	NineDevice9_UpdateSurface( struct NineDevice9 *This,
		1169	IDirect3DSurface9 *pSourceSurface,
		1170	const RECT *pSourceRect,
		1171	IDirect3DSurface9 *pDestinationSurface,
		1172	const POINT *pDestPoint )
		1173	{
		1174	struct NineSurface9 *dst = NineSurface9(pDestinationSurface);
		1175	struct NineSurface9 *src = NineSurface9(pSourceSurface);
		1176
		1177	DBG("This=%p pSourceSurface=%p pDestinationSurface=%p "
		1178	"pSourceRect=%p pDestPoint=%p\n", This,
		1179	pSourceSurface, pDestinationSurface, pSourceRect, pDestPoint);
		1180	if (pSourceRect)
		1181	DBG("pSourceRect = (%u,%u)-(%u,%u)\n",
		1182	pSourceRect->left, pSourceRect->top,
		1183	pSourceRect->right, pSourceRect->bottom);
		1184	if (pDestPoint)
		1185	DBG("pDestPoint = (%u,%u)\n", pDestPoint->x, pDestPoint->y);
		1186
		1187	user_assert(dst->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1188	user_assert(src->base.pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
		1189
		1190	user_assert(dst->desc.MultiSampleType == D3DMULTISAMPLE_NONE, D3DERR_INVALIDCALL);
		1191	user_assert(src->desc.MultiSampleType == D3DMULTISAMPLE_NONE, D3DERR_INVALIDCALL);
		1192
		1193	return NineSurface9_CopySurface(dst, src, pDestPoint, pSourceRect);
		1194	}
		1195
		1196	HRESULT WINAPI
		1197	NineDevice9_UpdateTexture( struct NineDevice9 *This,
		1198	IDirect3DBaseTexture9 *pSourceTexture,
		1199	IDirect3DBaseTexture9 *pDestinationTexture )
		1200	{
		1201	struct NineBaseTexture9 *dstb = NineBaseTexture9(pDestinationTexture);
		1202	struct NineBaseTexture9 *srcb = NineBaseTexture9(pSourceTexture);
		1203	unsigned l, m;
		1204	unsigned last_level = dstb->base.info.last_level;
		1205
		1206	DBG("This=%p pSourceTexture=%p pDestinationTexture=%p\n", This,
		1207	pSourceTexture, pDestinationTexture);
		1208
		1209	user_assert(pSourceTexture != pDestinationTexture, D3DERR_INVALIDCALL);
		1210
		1211	user_assert(dstb->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1212	user_assert(srcb->base.pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
		1213
		1214	if (dstb->base.usage & D3DUSAGE_AUTOGENMIPMAP) {
		1215	/* Only the first level is updated, the others regenerated. */
		1216	last_level = 0;
		1217	/* if the source has D3DUSAGE_AUTOGENMIPMAP, we have to ignore
		1218	* the sublevels, thus level 0 has to match */
		1219	user_assert(!(srcb->base.usage & D3DUSAGE_AUTOGENMIPMAP) \|\|
		1220	(srcb->base.info.width0 == dstb->base.info.width0 &&
		1221	srcb->base.info.height0 == dstb->base.info.height0 &&
		1222	srcb->base.info.depth0 == dstb->base.info.depth0),
		1223	D3DERR_INVALIDCALL);
		1224	} else {
		1225	user_assert(!(srcb->base.usage & D3DUSAGE_AUTOGENMIPMAP), D3DERR_INVALIDCALL);
		1226	}
		1227
		1228	user_assert(dstb->base.type == srcb->base.type, D3DERR_INVALIDCALL);
		1229
		1230	/* TODO: We can restrict the update to the dirty portions of the source.
		1231	* Yes, this seems silly, but it's what MSDN says ...
		1232	*/
		1233
		1234	/* Find src level that matches dst level 0: */
		1235	user_assert(srcb->base.info.width0 >= dstb->base.info.width0 &&
		1236	srcb->base.info.height0 >= dstb->base.info.height0 &&
		1237	srcb->base.info.depth0 >= dstb->base.info.depth0,
		1238	D3DERR_INVALIDCALL);
		1239	for (m = 0; m <= srcb->base.info.last_level; ++m) {
		1240	unsigned w = u_minify(srcb->base.info.width0, m);
		1241	unsigned h = u_minify(srcb->base.info.height0, m);
		1242	unsigned d = u_minify(srcb->base.info.depth0, m);
		1243
		1244	if (w == dstb->base.info.width0 &&
		1245	h == dstb->base.info.height0 &&
		1246	d == dstb->base.info.depth0)
		1247	break;
		1248	}
		1249	user_assert(m <= srcb->base.info.last_level, D3DERR_INVALIDCALL);
		1250
		1251	last_level = MIN2(last_level, srcb->base.info.last_level - m);
		1252
		1253	if (dstb->base.type == D3DRTYPE_TEXTURE) {
		1254	struct NineTexture9 *dst = NineTexture9(dstb);
		1255	struct NineTexture9 *src = NineTexture9(srcb);
		1256
		1257	for (l = 0; l <= last_level; ++l, ++m)
		1258	NineSurface9_CopySurface(dst->surfaces[l],
		1259	src->surfaces[m], NULL, NULL);
		1260	} else
		1261	if (dstb->base.type == D3DRTYPE_CUBETEXTURE) {
		1262	struct NineCubeTexture9 *dst = NineCubeTexture9(dstb);
		1263	struct NineCubeTexture9 *src = NineCubeTexture9(srcb);
		1264	unsigned z;
		1265
		1266	/* GPUs usually have them stored as arrays of mip-mapped 2D textures. */
		1267	for (z = 0; z < 6; ++z) {
		1268	for (l = 0; l <= last_level; ++l, ++m) {
		1269	NineSurface9_CopySurface(dst->surfaces[l * 6 + z],
		1270	src->surfaces[m * 6 + z], NULL, NULL);
		1271	}
		1272	m -= l;
		1273	}
		1274	} else
		1275	if (dstb->base.type == D3DRTYPE_VOLUMETEXTURE) {
		1276	struct NineVolumeTexture9 *dst = NineVolumeTexture9(dstb);
		1277	struct NineVolumeTexture9 *src = NineVolumeTexture9(srcb);
		1278
		1279	for (l = 0; l <= last_level; ++l, ++m)
		1280	NineVolume9_CopyVolume(dst->volumes[l],
		1281	src->volumes[m], 0, 0, 0, NULL);
		1282	} else{
		1283	assert(!"invalid texture type");
		1284	}
		1285
		1286	if (dstb->base.usage & D3DUSAGE_AUTOGENMIPMAP) {
		1287	dstb->dirty_mip = TRUE;
		1288	NineBaseTexture9_GenerateMipSubLevels(dstb);
		1289	}
		1290
		1291	return D3D_OK;
		1292	}
		1293
		1294	HRESULT WINAPI
		1295	NineDevice9_GetRenderTargetData( struct NineDevice9 *This,
		1296	IDirect3DSurface9 *pRenderTarget,
		1297	IDirect3DSurface9 *pDestSurface )
		1298	{
		1299	struct NineSurface9 *dst = NineSurface9(pDestSurface);
		1300	struct NineSurface9 *src = NineSurface9(pRenderTarget);
		1301
		1302	DBG("This=%p pRenderTarget=%p pDestSurface=%p\n",
		1303	This, pRenderTarget, pDestSurface);
		1304
		1305	user_assert(dst->desc.Pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
		1306	user_assert(src->desc.Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1307
		1308	user_assert(dst->desc.MultiSampleType < 2, D3DERR_INVALIDCALL);
		1309	user_assert(src->desc.MultiSampleType < 2, D3DERR_INVALIDCALL);
		1310
		1311	return NineSurface9_CopySurface(dst, src, NULL, NULL);
		1312	}
		1313
		1314	HRESULT WINAPI
		1315	NineDevice9_GetFrontBufferData( struct NineDevice9 *This,
		1316	UINT iSwapChain,
		1317	IDirect3DSurface9 *pDestSurface )
		1318	{
		1319	DBG("This=%p iSwapChain=%u pDestSurface=%p\n", This,
		1320	iSwapChain, pDestSurface);
		1321
		1322	user_assert(pDestSurface != NULL, D3DERR_INVALIDCALL);
		1323	user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
		1324
		1325	return NineSwapChain9_GetFrontBufferData(This->swapchains[iSwapChain],
		1326	pDestSurface);
		1327	}
		1328
		1329	HRESULT WINAPI
		1330	NineDevice9_StretchRect( struct NineDevice9 *This,
		1331	IDirect3DSurface9 *pSourceSurface,
		1332	const RECT *pSourceRect,
		1333	IDirect3DSurface9 *pDestSurface,
		1334	const RECT *pDestRect,
		1335	D3DTEXTUREFILTERTYPE Filter )
		1336	{
		1337	struct pipe_screen *screen = This->screen;
		1338	struct pipe_context *pipe = This->pipe;
		1339	struct NineSurface9 *dst = NineSurface9(pDestSurface);
		1340	struct NineSurface9 *src = NineSurface9(pSourceSurface);
		1341	struct pipe_resource *dst_res = NineSurface9_GetResource(dst);
		1342	struct pipe_resource *src_res = NineSurface9_GetResource(src);
		1343	const boolean zs = util_format_is_depth_or_stencil(dst_res->format);
		1344	struct pipe_blit_info blit;
		1345	boolean scaled, clamped, ms, flip_x = FALSE, flip_y = FALSE;
		1346
		1347	DBG("This=%p pSourceSurface=%p pSourceRect=%p pDestSurface=%p "
		1348	"pDestRect=%p Filter=%u\n",
		1349	This, pSourceSurface, pSourceRect, pDestSurface, pDestRect, Filter);
		1350	if (pSourceRect)
		1351	DBG("pSourceRect=(%u,%u)-(%u,%u)\n",
		1352	pSourceRect->left, pSourceRect->top,
		1353	pSourceRect->right, pSourceRect->bottom);
		1354	if (pDestRect)
		1355	DBG("pDestRect=(%u,%u)-(%u,%u)\n", pDestRect->left, pDestRect->top,
		1356	pDestRect->right, pDestRect->bottom);
		1357
		1358	user_assert(!zs \|\| !This->in_scene, D3DERR_INVALIDCALL);
		1359	user_assert(!zs \|\| !pSourceRect \|\|
		1360	(pSourceRect->left == 0 &&
		1361	pSourceRect->top == 0 &&
		1362	pSourceRect->right == src->desc.Width &&
		1363	pSourceRect->bottom == src->desc.Height), D3DERR_INVALIDCALL);
		1364	user_assert(!zs \|\| !pDestRect \|\|
		1365	(pDestRect->left == 0 &&
		1366	pDestRect->top == 0 &&
		1367	pDestRect->right == dst->desc.Width &&
		1368	pDestRect->bottom == dst->desc.Height), D3DERR_INVALIDCALL);
		1369	user_assert(!zs \|\|
		1370	(dst->desc.Width == src->desc.Width &&
		1371	dst->desc.Height == src->desc.Height), D3DERR_INVALIDCALL);
		1372	user_assert(zs \|\| !util_format_is_depth_or_stencil(src_res->format),
		1373	D3DERR_INVALIDCALL);
		1374	user_assert(!zs \|\| dst->desc.Format == src->desc.Format,
		1375	D3DERR_INVALIDCALL);
		1376	user_assert(screen->is_format_supported(screen, src_res->format,
		1377	src_res->target,
		1378	src_res->nr_samples,
		1379	PIPE_BIND_SAMPLER_VIEW),
		1380	D3DERR_INVALIDCALL);
		1381	user_assert(dst->base.pool == D3DPOOL_DEFAULT &&
		1382	src->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1383
		1384	/* We might want to permit these, but wine thinks we shouldn't. */
		1385	user_assert(!pDestRect \|\|
		1386	(pDestRect->left <= pDestRect->right &&
		1387	pDestRect->top <= pDestRect->bottom), D3DERR_INVALIDCALL);
		1388	user_assert(!pSourceRect \|\|
		1389	(pSourceRect->left <= pSourceRect->right &&
		1390	pSourceRect->top <= pSourceRect->bottom), D3DERR_INVALIDCALL);
		1391
		1392	memset(&blit, 0, sizeof(blit));
		1393	blit.dst.resource = dst_res;
		1394	blit.dst.level = dst->level;
		1395	blit.dst.box.z = dst->layer;
		1396	blit.dst.box.depth = 1;
		1397	blit.dst.format = dst_res->format;
		1398	if (pDestRect) {
		1399	flip_x = pDestRect->left > pDestRect->right;
		1400	if (flip_x) {
		1401	blit.dst.box.x = pDestRect->right;
		1402	blit.dst.box.width = pDestRect->left - pDestRect->right;
		1403	} else {
		1404	blit.dst.box.x = pDestRect->left;
		1405	blit.dst.box.width = pDestRect->right - pDestRect->left;
		1406	}
		1407	flip_y = pDestRect->top > pDestRect->bottom;
		1408	if (flip_y) {
		1409	blit.dst.box.y = pDestRect->bottom;
		1410	blit.dst.box.height = pDestRect->top - pDestRect->bottom;
		1411	} else {
		1412	blit.dst.box.y = pDestRect->top;
		1413	blit.dst.box.height = pDestRect->bottom - pDestRect->top;
		1414	}
		1415	} else {
		1416	blit.dst.box.x = 0;
		1417	blit.dst.box.y = 0;
		1418	blit.dst.box.width = dst->desc.Width;
		1419	blit.dst.box.height = dst->desc.Height;
		1420	}
		1421	blit.src.resource = src_res;
		1422	blit.src.level = src->level;
		1423	blit.src.box.z = src->layer;
		1424	blit.src.box.depth = 1;
		1425	blit.src.format = src_res->format;
		1426	if (pSourceRect) {
		1427	if (flip_x ^ (pSourceRect->left > pSourceRect->right)) {
		1428	blit.src.box.x = pSourceRect->right;
		1429	blit.src.box.width = pSourceRect->left - pSourceRect->right;
		1430	} else {
		1431	blit.src.box.x = pSourceRect->left;
		1432	blit.src.box.width = pSourceRect->right - pSourceRect->left;
		1433	}
		1434	if (flip_y ^ (pSourceRect->top > pSourceRect->bottom)) {
		1435	blit.src.box.y = pSourceRect->bottom;
		1436	blit.src.box.height = pSourceRect->top - pSourceRect->bottom;
		1437	} else {
		1438	blit.src.box.y = pSourceRect->top;
		1439	blit.src.box.height = pSourceRect->bottom - pSourceRect->top;
		1440	}
		1441	} else {
		1442	blit.src.box.x = flip_x ? src->desc.Width : 0;
		1443	blit.src.box.y = flip_y ? src->desc.Height : 0;
		1444	blit.src.box.width = flip_x ? -src->desc.Width : src->desc.Width;
		1445	blit.src.box.height = flip_y ? -src->desc.Height : src->desc.Height;
		1446	}
		1447	blit.mask = zs ? PIPE_MASK_ZS : PIPE_MASK_RGBA;
		1448	blit.filter = Filter == D3DTEXF_LINEAR ?
		1449	PIPE_TEX_FILTER_LINEAR : PIPE_TEX_FILTER_NEAREST;
		1450	blit.scissor_enable = FALSE;
		1451
		1452	/* If both of a src and dst dimension are negative, flip them. */
		1453	if (blit.dst.box.width < 0 && blit.src.box.width < 0) {
		1454	blit.dst.box.width = -blit.dst.box.width;
		1455	blit.src.box.width = -blit.src.box.width;
		1456	}
		1457	if (blit.dst.box.height < 0 && blit.src.box.height < 0) {
		1458	blit.dst.box.height = -blit.dst.box.height;
		1459	blit.src.box.height = -blit.src.box.height;
		1460	}
		1461	scaled =
		1462	blit.dst.box.width != blit.src.box.width \|\|
		1463	blit.dst.box.height != blit.src.box.height;
		1464
		1465	user_assert(!scaled \|\| dst != src, D3DERR_INVALIDCALL);
		1466	user_assert(!scaled \|\|
		1467	!NineSurface9_IsOffscreenPlain(dst) \|\|
		1468	NineSurface9_IsOffscreenPlain(src), D3DERR_INVALIDCALL);
		1469	user_assert(!scaled \|\|
		1470	(!util_format_is_compressed(dst->base.info.format) &&
		1471	!util_format_is_compressed(src->base.info.format)),
		1472	D3DERR_INVALIDCALL);
		1473
		1474	user_warn(src == dst &&
		1475	u_box_test_intersection_2d(&blit.src.box, &blit.dst.box));
		1476
		1477	/* Check for clipping/clamping: */
		1478	{
		1479	struct pipe_box box;
		1480	int xy;
		1481
		1482	xy = u_box_clip_2d(&box, &blit.dst.box,
		1483	dst->desc.Width, dst->desc.Height);
		1484	if (xy < 0)
		1485	return D3D_OK;
		1486	if (xy == 0)
		1487	xy = u_box_clip_2d(&box, &blit.src.box,
		1488	src->desc.Width, src->desc.Height);
		1489	clamped = !!xy;
		1490	}
		1491
		1492	ms = (dst->desc.MultiSampleType \| 1) != (src->desc.MultiSampleType \| 1);
		1493
		1494	if (clamped \|\| scaled \|\| (blit.dst.format != blit.src.format) \|\| ms) {
		1495	DBG("using pipe->blit()\n");
		1496	/* TODO: software scaling */
		1497	user_assert(screen->is_format_supported(screen, dst_res->format,
		1498	dst_res->target,
		1499	dst_res->nr_samples,
		1500	zs ? PIPE_BIND_DEPTH_STENCIL :
		1501	PIPE_BIND_RENDER_TARGET),
		1502	D3DERR_INVALIDCALL);
		1503
		1504	pipe->blit(pipe, &blit);
		1505	} else {
		1506	assert(blit.dst.box.x >= 0 && blit.dst.box.y >= 0 &&
		1507	blit.src.box.x >= 0 && blit.src.box.y >= 0 &&
		1508	blit.dst.box.x + blit.dst.box.width <= dst->desc.Width &&
		1509	blit.src.box.x + blit.src.box.width <= src->desc.Width &&
		1510	blit.dst.box.y + blit.dst.box.height <= dst->desc.Height &&
		1511	blit.src.box.y + blit.src.box.height <= src->desc.Height);
		1512	/* Or drivers might crash ... */
		1513	DBG("Using resource_copy_region.\n");
		1514	pipe->resource_copy_region(pipe,
		1515	blit.dst.resource, blit.dst.level,
		1516	blit.dst.box.x, blit.dst.box.y, blit.dst.box.z,
		1517	blit.src.resource, blit.src.level,
		1518	&blit.src.box);
		1519	}
		1520
		1521	/* Communicate the container it needs to update sublevels - if apply */
		1522	NineSurface9_MarkContainerDirty(dst);
		1523
		1524	return D3D_OK;
		1525	}
		1526
		1527	HRESULT WINAPI
		1528	NineDevice9_ColorFill( struct NineDevice9 *This,
		1529	IDirect3DSurface9 *pSurface,
		1530	const RECT *pRect,
		1531	D3DCOLOR color )
		1532	{
		1533	struct pipe_context *pipe = This->pipe;
		1534	struct NineSurface9 *surf = NineSurface9(pSurface);
		1535	struct pipe_surface *psurf;
		1536	unsigned x, y, w, h;
		1537	union pipe_color_union rgba;
		1538	boolean fallback;
		1539
		1540	DBG("This=%p pSurface=%p pRect=%p color=%08x\n", This,
		1541	pSurface, pRect, color);
		1542	if (pRect)
		1543	DBG("pRect=(%u,%u)-(%u,%u)\n", pRect->left, pRect->top,
		1544	pRect->right, pRect->bottom);
		1545
		1546	user_assert(surf->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
		1547
		1548	user_assert((surf->base.usage & D3DUSAGE_RENDERTARGET) \|\|
		1549	NineSurface9_IsOffscreenPlain(surf), D3DERR_INVALIDCALL);
		1550
		1551	if (pRect) {
		1552	x = pRect->left;
		1553	y = pRect->top;
		1554	w = pRect->right - pRect->left;
		1555	h = pRect->bottom - pRect->top;
		1556	} else{
		1557	x = 0;
		1558	y = 0;
		1559	w = surf->desc.Width;
		1560	h = surf->desc.Height;
		1561	}
		1562	d3dcolor_to_pipe_color_union(&rgba, color);
		1563
		1564	fallback =
		1565	!This->screen->is_format_supported(This->screen, surf->base.info.format,
		1566	surf->base.info.target,
		1567	surf->base.info.nr_samples,
		1568	PIPE_BIND_RENDER_TARGET);
		1569	if (!fallback) {
		1570	psurf = NineSurface9_GetSurface(surf, 0);
		1571	if (!psurf)
		1572	fallback = TRUE;
		1573	}
		1574
		1575	if (!fallback) {
		1576	pipe->clear_render_target(pipe, psurf, &rgba, x, y, w, h);
		1577	} else {
		1578	D3DLOCKED_RECT lock;
		1579	union util_color uc;
		1580	HRESULT hr;
		1581	/* XXX: lock pRect and fix util_fill_rect */
		1582	hr = NineSurface9_LockRect(surf, &lock, NULL, 0);
		1583	if (FAILED(hr))
		1584	return hr;
		1585	util_pack_color_ub(color >> 16, color >> 8, color >> 0, color >> 24,
		1586	surf->base.info.format, &uc);
		1587	util_fill_rect(lock.pBits, surf->base.info.format,lock.Pitch,
		1588	x, y, w, h, &uc);
		1589	NineSurface9_UnlockRect(surf);
		1590	}
		1591
		1592	return D3D_OK;
		1593	}
		1594
		1595	HRESULT WINAPI
		1596	NineDevice9_CreateOffscreenPlainSurface( struct NineDevice9 *This,
		1597	UINT Width,
		1598	UINT Height,
		1599	D3DFORMAT Format,
		1600	D3DPOOL Pool,
		1601	IDirect3DSurface9 **ppSurface,
		1602	HANDLE *pSharedHandle )
		1603	{
		1604	HRESULT hr;
		1605
		1606	DBG("This=%p Width=%u Height=%u Format=%s(0x%x) Pool=%u "
		1607	"ppSurface=%p pSharedHandle=%p\n", This,
		1608	Width, Height, d3dformat_to_string(Format), Format, Pool,
		1609	ppSurface, pSharedHandle);
		1610
		1611	*ppSurface = NULL;
		1612	user_assert(!pSharedHandle \|\| Pool == D3DPOOL_DEFAULT
		1613	\|\| Pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
		1614	user_assert(Pool != D3DPOOL_MANAGED, D3DERR_INVALIDCALL);
		1615
		1616	/* Can be used with StretchRect and ColorFill. It's also always lockable.
		1617	*/
		1618	hr = create_zs_or_rt_surface(This, 2, Pool, Width, Height,
		1619	Format,
		1620	D3DMULTISAMPLE_NONE, 0,
		1621	TRUE,
		1622	ppSurface, pSharedHandle);
		1623	if (FAILED(hr))
		1624	DBG("Failed to create surface.\n");
		1625	return hr;
		1626	}
		1627
		1628	HRESULT WINAPI
		1629	NineDevice9_SetRenderTarget( struct NineDevice9 *This,
		1630	DWORD RenderTargetIndex,
		1631	IDirect3DSurface9 *pRenderTarget )
		1632	{
		1633	struct NineSurface9 *rt = NineSurface9(pRenderTarget);
		1634	const unsigned i = RenderTargetIndex;
		1635
		1636	DBG("This=%p RenderTargetIndex=%u pRenderTarget=%p\n", This,
		1637	RenderTargetIndex, pRenderTarget);
		1638
		1639	user_assert(i < This->caps.NumSimultaneousRTs, D3DERR_INVALIDCALL);
		1640	user_assert(i != 0 \|\| pRenderTarget, D3DERR_INVALIDCALL);
		1641	user_assert(!pRenderTarget \|\|
		1642	rt->desc.Usage & D3DUSAGE_RENDERTARGET, D3DERR_INVALIDCALL);
		1643
		1644	if (i == 0) {
		1645	This->state.viewport.X = 0;
		1646	This->state.viewport.Y = 0;
		1647	This->state.viewport.Width = rt->desc.Width;
		1648	This->state.viewport.Height = rt->desc.Height;
		1649	This->state.viewport.MinZ = 0.0f;
		1650	This->state.viewport.MaxZ = 1.0f;
		1651
		1652	This->state.scissor.minx = 0;
		1653	This->state.scissor.miny = 0;
		1654	This->state.scissor.maxx = rt->desc.Width;
		1655	This->state.scissor.maxy = rt->desc.Height;
		1656
		1657	This->state.changed.group \|= NINE_STATE_VIEWPORT \| NINE_STATE_SCISSOR;
		1658	}
		1659
		1660	if (This->state.rt[i] != NineSurface9(pRenderTarget)) {
		1661	nine_bind(&This->state.rt[i], pRenderTarget);
		1662	This->state.changed.group \|= NINE_STATE_FB;
		1663	}
		1664	return D3D_OK;
		1665	}
		1666
		1667	HRESULT WINAPI
		1668	NineDevice9_GetRenderTarget( struct NineDevice9 *This,
		1669	DWORD RenderTargetIndex,
		1670	IDirect3DSurface9 **ppRenderTarget )
		1671	{
		1672	const unsigned i = RenderTargetIndex;
		1673
		1674	user_assert(i < This->caps.NumSimultaneousRTs, D3DERR_INVALIDCALL);
		1675	user_assert(ppRenderTarget, D3DERR_INVALIDCALL);
		1676
		1677	ppRenderTarget = (IDirect3DSurface9 )This->state.rt[i];
		1678	if (!This->state.rt[i])
		1679	return D3DERR_NOTFOUND;
		1680
		1681	NineUnknown_AddRef(NineUnknown(This->state.rt[i]));
		1682	return D3D_OK;
		1683	}
		1684
		1685	HRESULT WINAPI
		1686	NineDevice9_SetDepthStencilSurface( struct NineDevice9 *This,
		1687	IDirect3DSurface9 *pNewZStencil )
		1688	{
		1689	DBG("This=%p pNewZStencil=%p\n", This, pNewZStencil);
		1690
		1691	if (This->state.ds != NineSurface9(pNewZStencil)) {
		1692	nine_bind(&This->state.ds, pNewZStencil);
		1693	This->state.changed.group \|= NINE_STATE_FB;
		1694	}
		1695	return D3D_OK;
		1696	}
		1697
		1698	HRESULT WINAPI
		1699	NineDevice9_GetDepthStencilSurface( struct NineDevice9 *This,
		1700	IDirect3DSurface9 **ppZStencilSurface )
		1701	{
		1702	user_assert(ppZStencilSurface, D3DERR_INVALIDCALL);
		1703
		1704	ppZStencilSurface = (IDirect3DSurface9 )This->state.ds;
		1705	if (!This->state.ds)
		1706	return D3DERR_NOTFOUND;
		1707
		1708	NineUnknown_AddRef(NineUnknown(This->state.ds));
		1709	return D3D_OK;
		1710	}
		1711
		1712	HRESULT WINAPI
		1713	NineDevice9_BeginScene( struct NineDevice9 *This )
		1714	{
		1715	DBG("This=%p\n", This);
		1716	user_assert(!This->in_scene, D3DERR_INVALIDCALL);
		1717	This->in_scene = TRUE;
		1718	/* Do we want to do anything else here ? */
		1719	return D3D_OK;
		1720	}
		1721
		1722	HRESULT WINAPI
		1723	NineDevice9_EndScene( struct NineDevice9 *This )
		1724	{
		1725	DBG("This=%p\n", This);
		1726	user_assert(This->in_scene, D3DERR_INVALIDCALL);
		1727	This->in_scene = FALSE;
		1728	return D3D_OK;
		1729	}
		1730
		1731	HRESULT WINAPI
		1732	NineDevice9_Clear( struct NineDevice9 *This,
		1733	DWORD Count,
		1734	const D3DRECT *pRects,
		1735	DWORD Flags,
		1736	D3DCOLOR Color,
		1737	float Z,
		1738	DWORD Stencil )
		1739	{
		1740	const int sRGB = This->state.rs[D3DRS_SRGBWRITEENABLE] ? 1 : 0;
		1741	struct pipe_surface cbuf, zsbuf;
		1742	struct pipe_context *pipe = This->pipe;
		1743	struct NineSurface9 *zsbuf_surf = This->state.ds;
		1744	struct NineSurface9 *rt;
		1745	unsigned bufs = 0;
		1746	unsigned r, i;
		1747	union pipe_color_union rgba;
		1748	unsigned rt_mask = 0;
		1749	D3DRECT rect;
		1750
		1751	DBG("This=%p Count=%u pRects=%p Flags=%x Color=%08x Z=%f Stencil=%x\n",
		1752	This, Count, pRects, Flags, Color, Z, Stencil);
		1753
		1754	user_assert(This->state.ds \|\| !(Flags & NINED3DCLEAR_DEPTHSTENCIL),
		1755	D3DERR_INVALIDCALL);
		1756	user_assert(!(Flags & D3DCLEAR_STENCIL) \|\|
		1757	(zsbuf_surf &&
		1758	util_format_is_depth_and_stencil(zsbuf_surf->base.info.format)),
		1759	D3DERR_INVALIDCALL);
		1760	#ifdef NINE_STRICT
		1761	user_assert((Count && pRects) \|\| (!Count && !pRects), D3DERR_INVALIDCALL);
		1762	#else
		1763	user_warn((pRects && !Count) \|\| (!pRects && Count));
		1764	if (pRects && !Count)
		1765	return D3D_OK;
		1766	if (!pRects)
		1767	Count = 0;
		1768	#endif
		1769
		1770	if (Flags & D3DCLEAR_TARGET) bufs \|= PIPE_CLEAR_COLOR;
		1771	if (Flags & D3DCLEAR_ZBUFFER) bufs \|= PIPE_CLEAR_DEPTH;
		1772	if (Flags & D3DCLEAR_STENCIL) bufs \|= PIPE_CLEAR_STENCIL;
		1773	if (!bufs)
		1774	return D3D_OK;
		1775	d3dcolor_to_pipe_color_union(&rgba, Color);
		1776
		1777	nine_update_state(This, NINE_STATE_FB);
		1778
		1779	rect.x1 = This->state.viewport.X;
		1780	rect.y1 = This->state.viewport.Y;
		1781	rect.x2 = This->state.viewport.Width + rect.x1;
		1782	rect.y2 = This->state.viewport.Height + rect.y1;
		1783
		1784	/* Both rectangles apply, which is weird, but that's D3D9. */
		1785	if (This->state.rs[D3DRS_SCISSORTESTENABLE]) {
		1786	rect.x1 = MAX2(rect.x1, This->state.scissor.minx);
		1787	rect.y1 = MAX2(rect.y1, This->state.scissor.miny);
		1788	rect.x2 = MIN2(rect.x2, This->state.scissor.maxx);
		1789	rect.y2 = MIN2(rect.y2, This->state.scissor.maxy);
		1790	}
		1791
		1792	if (Count) {
		1793	/* Maybe apps like to specify a large rect ? */
		1794	if (pRects[0].x1 <= rect.x1 && pRects[0].x2 >= rect.x2 &&
		1795	pRects[0].y1 <= rect.y1 && pRects[0].y2 >= rect.y2) {
		1796	DBG("First rect covers viewport.\n");
		1797	Count = 0;
		1798	pRects = NULL;
		1799	}
		1800	}
		1801
		1802	if (rect.x1 >= This->state.fb.width \|\| rect.y1 >= This->state.fb.height)
		1803	return D3D_OK;
		1804
		1805	for (i = 0; i < This->caps.NumSimultaneousRTs; ++i) {
		1806	if (This->state.rt[i] && This->state.rt[i]->desc.Format != D3DFMT_NULL)
		1807	rt_mask \|= 1 << i;
		1808	}
		1809
		1810	/* fast path, clears everything at once */
		1811	if (!Count &&
		1812	(!(bufs & PIPE_CLEAR_COLOR) \|\| (rt_mask == This->state.rt_mask)) &&
		1813	rect.x1 == 0 && rect.y1 == 0 &&
		1814	/* Case we clear only render target. Check clear region vs rt. */
		1815	((!(bufs & (PIPE_CLEAR_DEPTH \| PIPE_CLEAR_STENCIL)) &&
		1816	rect.x2 >= This->state.fb.width &&
		1817	rect.y2 >= This->state.fb.height) \|\|
		1818	/* Case we clear depth buffer (and eventually rt too).
		1819	* depth buffer size is always >= rt size. Compare to clear region */
		1820	((bufs & (PIPE_CLEAR_DEPTH \| PIPE_CLEAR_STENCIL)) &&
		1821	This->state.fb.zsbuf != NULL &&
		1822	rect.x2 >= zsbuf_surf->desc.Width &&
		1823	rect.y2 >= zsbuf_surf->desc.Height))) {
		1824	DBG("Clear fast path\n");
		1825	pipe->clear(pipe, bufs, &rgba, Z, Stencil);
		1826	return D3D_OK;
		1827	}
		1828
		1829	if (!Count) {
		1830	Count = 1;
		1831	pRects = ▭
		1832	}
		1833
		1834	for (i = 0; i < This->caps.NumSimultaneousRTs; ++i) {
		1835	rt = This->state.rt[i];
		1836	if (!rt \|\| rt->desc.Format == D3DFMT_NULL \|\|
		1837	!(Flags & D3DCLEAR_TARGET))
		1838	continue; /* save space, compiler should hoist this */
		1839	cbuf = NineSurface9_GetSurface(rt, sRGB);
		1840	for (r = 0; r < Count; ++r) {
		1841	/* Don't trust users to pass these in the right order. */
		1842	unsigned x1 = MIN2(pRects[r].x1, pRects[r].x2);
		1843	unsigned y1 = MIN2(pRects[r].y1, pRects[r].y2);
		1844	unsigned x2 = MAX2(pRects[r].x1, pRects[r].x2);
		1845	unsigned y2 = MAX2(pRects[r].y1, pRects[r].y2);
		1846	#ifndef NINE_LAX
		1847	/* Drop negative rectangles (like wine expects). */
		1848	if (pRects[r].x1 > pRects[r].x2) continue;
		1849	if (pRects[r].y1 > pRects[r].y2) continue;
		1850	#endif
		1851
		1852	x1 = MAX2(x1, rect.x1);
		1853	y1 = MAX2(y1, rect.y1);
		1854	x2 = MIN3(x2, rect.x2, rt->desc.Width);
		1855	y2 = MIN3(y2, rect.y2, rt->desc.Height);
		1856
		1857	DBG("Clearing (%u..%u)x(%u..%u)\n", x1, x2, y1, y2);
		1858	pipe->clear_render_target(pipe, cbuf, &rgba,
		1859	x1, y1, x2 - x1, y2 - y1);
		1860	}
		1861	}
		1862	if (!(Flags & NINED3DCLEAR_DEPTHSTENCIL))
		1863	return D3D_OK;
		1864
		1865	bufs &= PIPE_CLEAR_DEPTHSTENCIL;
		1866
		1867	for (r = 0; r < Count; ++r) {
		1868	unsigned x1 = MIN2(pRects[r].x1, pRects[r].x2);
		1869	unsigned y1 = MIN2(pRects[r].y1, pRects[r].y2);
		1870	unsigned x2 = MAX2(pRects[r].x1, pRects[r].x2);
		1871	unsigned y2 = MAX2(pRects[r].y1, pRects[r].y2);
		1872	#ifndef NINE_LAX
		1873	/* Drop negative rectangles. */
		1874	if (pRects[r].x1 > pRects[r].x2) continue;
		1875	if (pRects[r].y1 > pRects[r].y2) continue;
		1876	#endif
		1877
		1878	x1 = MIN2(x1, rect.x1);
		1879	y1 = MIN2(y1, rect.y1);
		1880	x2 = MIN3(x2, rect.x2, zsbuf_surf->desc.Width);
		1881	y2 = MIN3(y2, rect.y2, zsbuf_surf->desc.Height);
		1882
		1883	zsbuf = NineSurface9_GetSurface(zsbuf_surf, 0);
		1884	assert(zsbuf);
		1885	pipe->clear_depth_stencil(pipe, zsbuf, bufs, Z, Stencil,
		1886	x1, y1, x2 - x1, y2 - y1);
		1887	}
		1888	return D3D_OK;
		1889	}
		1890
		1891	HRESULT WINAPI
		1892	NineDevice9_SetTransform( struct NineDevice9 *This,
		1893	D3DTRANSFORMSTATETYPE State,
		1894	const D3DMATRIX *pMatrix )
		1895	{
		1896	struct nine_state *state = This->update;
		1897	D3DMATRIX *M = nine_state_access_transform(state, State, TRUE);
		1898
		1899	DBG("This=%p State=%d pMatrix=%p\n", This, State, pMatrix);
		1900
		1901	user_assert(M, D3DERR_INVALIDCALL);
		1902
		1903	M = pMatrix;
		1904	state->ff.changed.transform[State / 32] \|= 1 << (State % 32);
		1905	state->changed.group \|= NINE_STATE_FF;
		1906
		1907	return D3D_OK;
		1908	}
		1909
		1910	HRESULT WINAPI
		1911	NineDevice9_GetTransform( struct NineDevice9 *This,
		1912	D3DTRANSFORMSTATETYPE State,
		1913	D3DMATRIX *pMatrix )
		1914	{
		1915	D3DMATRIX *M = nine_state_access_transform(&This->state, State, FALSE);
		1916	user_assert(M, D3DERR_INVALIDCALL);
		1917	pMatrix = M;
		1918	return D3D_OK;
		1919	}
		1920
		1921	HRESULT WINAPI
		1922	NineDevice9_MultiplyTransform( struct NineDevice9 *This,
		1923	D3DTRANSFORMSTATETYPE State,
		1924	const D3DMATRIX *pMatrix )
		1925	{
		1926	struct nine_state *state = This->update;
		1927	D3DMATRIX T;
		1928	D3DMATRIX *M = nine_state_access_transform(state, State, TRUE);
		1929
		1930	DBG("This=%p State=%d pMatrix=%p\n", This, State, pMatrix);
		1931
		1932	user_assert(M, D3DERR_INVALIDCALL);
		1933
		1934	nine_d3d_matrix_matrix_mul(&T, pMatrix, M);
		1935	return NineDevice9_SetTransform(This, State, &T);
		1936	}
		1937
		1938	HRESULT WINAPI
		1939	NineDevice9_SetViewport( struct NineDevice9 *This,
		1940	const D3DVIEWPORT9 *pViewport )
		1941	{
		1942	struct nine_state *state = This->update;
		1943
		1944	DBG("X=%u Y=%u W=%u H=%u MinZ=%f MaxZ=%f\n",
		1945	pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height,
		1946	pViewport->MinZ, pViewport->MaxZ);
		1947
		1948	state->viewport = *pViewport;
		1949	state->changed.group \|= NINE_STATE_VIEWPORT;
		1950
		1951	return D3D_OK;
		1952	}
		1953
		1954	HRESULT WINAPI
		1955	NineDevice9_GetViewport( struct NineDevice9 *This,
		1956	D3DVIEWPORT9 *pViewport )
		1957	{
		1958	*pViewport = This->state.viewport;
		1959	return D3D_OK;
		1960	}
		1961
		1962	HRESULT WINAPI
		1963	NineDevice9_SetMaterial( struct NineDevice9 *This,
		1964	const D3DMATERIAL9 *pMaterial )
		1965	{
		1966	struct nine_state *state = This->update;
		1967
		1968	DBG("This=%p pMaterial=%p\n", This, pMaterial);
		1969	if (pMaterial)
		1970	nine_dump_D3DMATERIAL9(DBG_FF, pMaterial);
		1971
		1972	user_assert(pMaterial, E_POINTER);
		1973
		1974	state->ff.material = *pMaterial;
		1975	state->changed.group \|= NINE_STATE_FF_MATERIAL;
		1976
		1977	return D3D_OK;
		1978	}
		1979
		1980	HRESULT WINAPI
		1981	NineDevice9_GetMaterial( struct NineDevice9 *This,
		1982	D3DMATERIAL9 *pMaterial )
		1983	{
		1984	user_assert(pMaterial, E_POINTER);
		1985	*pMaterial = This->state.ff.material;
		1986	return D3D_OK;
		1987	}
		1988
		1989	HRESULT WINAPI
		1990	NineDevice9_SetLight( struct NineDevice9 *This,
		1991	DWORD Index,
		1992	const D3DLIGHT9 *pLight )
		1993	{
		1994	struct nine_state *state = This->update;
		1995
		1996	DBG("This=%p Index=%u pLight=%p\n", This, Index, pLight);
		1997	if (pLight)
		1998	nine_dump_D3DLIGHT9(DBG_FF, pLight);
		1999
		2000	user_assert(pLight, D3DERR_INVALIDCALL);
		2001	user_assert(pLight->Type < NINED3DLIGHT_INVALID, D3DERR_INVALIDCALL);
		2002
		2003	user_assert(Index < NINE_MAX_LIGHTS, D3DERR_INVALIDCALL); /* sanity */
		2004
		2005	if (Index >= state->ff.num_lights) {
		2006	unsigned n = state->ff.num_lights;
		2007	unsigned N = Index + 1;
		2008
		2009	state->ff.light = REALLOC(state->ff.light, n * sizeof(D3DLIGHT9),
		2010	N * sizeof(D3DLIGHT9));
		2011	if (!state->ff.light)
		2012	return E_OUTOFMEMORY;
		2013	state->ff.num_lights = N;
		2014
		2015	for (; n < Index; ++n)
		2016	state->ff.light[n].Type = (D3DLIGHTTYPE)NINED3DLIGHT_INVALID;
		2017	}
		2018	state->ff.light[Index] = *pLight;
		2019
		2020	if (pLight->Type == D3DLIGHT_SPOT && pLight->Theta >= pLight->Phi) {
		2021	DBG("Warning: clamping D3DLIGHT9.Theta\n");
		2022	state->ff.light[Index].Theta = state->ff.light[Index].Phi;
		2023	}
		2024	if (pLight->Type != D3DLIGHT_DIRECTIONAL &&
		2025	pLight->Attenuation0 == 0.0f &&
		2026	pLight->Attenuation1 == 0.0f &&
		2027	pLight->Attenuation2 == 0.0f) {
		2028	DBG("Warning: all D3DLIGHT9.Attenuation[i] are 0\n");
		2029	}
		2030
		2031	state->changed.group \|= NINE_STATE_FF_LIGHTING;
		2032
		2033	return D3D_OK;
		2034	}
		2035
		2036	HRESULT WINAPI
		2037	NineDevice9_GetLight( struct NineDevice9 *This,
		2038	DWORD Index,
		2039	D3DLIGHT9 *pLight )
		2040	{
		2041	const struct nine_state *state = &This->state;
		2042
		2043	user_assert(pLight, D3DERR_INVALIDCALL);
		2044	user_assert(Index < state->ff.num_lights, D3DERR_INVALIDCALL);
		2045	user_assert(state->ff.light[Index].Type < NINED3DLIGHT_INVALID,
		2046	D3DERR_INVALIDCALL);
		2047
		2048	*pLight = state->ff.light[Index];
		2049
		2050	return D3D_OK;
		2051	}
		2052
		2053	HRESULT WINAPI
		2054	NineDevice9_LightEnable( struct NineDevice9 *This,
		2055	DWORD Index,
		2056	BOOL Enable )
		2057	{
		2058	struct nine_state *state = This->update;
		2059	unsigned i;
		2060
		2061	DBG("This=%p Index=%u Enable=%i\n", This, Index, Enable);
		2062
		2063	if (Index >= state->ff.num_lights \|\|
		2064	state->ff.light[Index].Type == NINED3DLIGHT_INVALID) {
		2065	/* This should create a default light. */
		2066	D3DLIGHT9 light;
		2067	memset(&light, 0, sizeof(light));
		2068	light.Type = D3DLIGHT_DIRECTIONAL;
		2069	light.Diffuse.r = 1.0f;
		2070	light.Diffuse.g = 1.0f;
		2071	light.Diffuse.b = 1.0f;
		2072	light.Direction.z = 1.0f;
		2073	NineDevice9_SetLight(This, Index, &light);
		2074	}
		2075	user_assert(Index < state->ff.num_lights, D3DERR_INVALIDCALL);
		2076
		2077	for (i = 0; i < state->ff.num_lights_active; ++i) {
		2078	if (state->ff.active_light[i] == Index)
		2079	break;
		2080	}
		2081
		2082	if (Enable) {
		2083	if (i < state->ff.num_lights_active)
		2084	return D3D_OK;
		2085	/* XXX wine thinks this should still succeed:
		2086	*/
		2087	user_assert(i < NINE_MAX_LIGHTS_ACTIVE, D3DERR_INVALIDCALL);
		2088
		2089	state->ff.active_light[i] = Index;
		2090	state->ff.num_lights_active++;
		2091	} else {
		2092	if (i == state->ff.num_lights_active)
		2093	return D3D_OK;
		2094	--state->ff.num_lights_active;
		2095	for (; i < state->ff.num_lights_active; ++i)
		2096	state->ff.active_light[i] = state->ff.active_light[i + 1];
		2097	}
		2098	state->changed.group \|= NINE_STATE_FF_LIGHTING;
		2099
		2100	return D3D_OK;
		2101	}
		2102
		2103	HRESULT WINAPI
		2104	NineDevice9_GetLightEnable( struct NineDevice9 *This,
		2105	DWORD Index,
		2106	BOOL *pEnable )
		2107	{
		2108	const struct nine_state *state = &This->state;
		2109	unsigned i;
		2110
		2111	user_assert(Index < state->ff.num_lights, D3DERR_INVALIDCALL);
		2112	user_assert(state->ff.light[Index].Type < NINED3DLIGHT_INVALID,
		2113	D3DERR_INVALIDCALL);
		2114
		2115	for (i = 0; i < state->ff.num_lights_active; ++i)
		2116	if (state->ff.active_light[i] == Index)
		2117	break;
		2118
		2119	*pEnable = i != state->ff.num_lights_active ? 128 : 0; // Taken from wine
		2120
		2121	return D3D_OK;
		2122	}
		2123
		2124	HRESULT WINAPI
		2125	NineDevice9_SetClipPlane( struct NineDevice9 *This,
		2126	DWORD Index,
		2127	const float *pPlane )
		2128	{
		2129	struct nine_state *state = This->update;
		2130
		2131	user_assert(pPlane, D3DERR_INVALIDCALL);
		2132
		2133	DBG("This=%p Index=%u pPlane=%f %f %f %f\n", This, Index,
		2134	pPlane[0], pPlane[1],
		2135	pPlane[2], pPlane[3]);
		2136
		2137	user_assert(Index < PIPE_MAX_CLIP_PLANES, D3DERR_INVALIDCALL);
		2138
		2139	memcpy(&state->clip.ucp[Index][0], pPlane, sizeof(state->clip.ucp[0]));
		2140	state->changed.ucp \|= 1 << Index;
		2141
		2142	return D3D_OK;
		2143	}
		2144
		2145	HRESULT WINAPI
		2146	NineDevice9_GetClipPlane( struct NineDevice9 *This,
		2147	DWORD Index,
		2148	float *pPlane )
		2149	{
		2150	const struct nine_state *state = &This->state;
		2151
		2152	user_assert(Index < PIPE_MAX_CLIP_PLANES, D3DERR_INVALIDCALL);
		2153
		2154	memcpy(pPlane, &state->clip.ucp[Index][0], sizeof(state->clip.ucp[0]));
		2155	return D3D_OK;
		2156	}
		2157
		2158	#define RESZ_CODE 0x7fa05000
		2159
		2160	static HRESULT
		2161	NineDevice9_ResolveZ( struct NineDevice9 *This )
		2162	{
		2163	struct nine_state *state = &This->state;
		2164	const struct util_format_description *desc;
		2165	struct NineSurface9 *source = state->ds;
		2166	struct NineBaseTexture9 *destination = state->texture[0];
		2167	struct pipe_resource src, dst;
		2168	struct pipe_blit_info blit;
		2169
		2170	DBG("RESZ resolve\n");
		2171
		2172	user_assert(source && destination &&
		2173	destination->base.type == D3DRTYPE_TEXTURE, D3DERR_INVALIDCALL);
		2174
		2175	src = source->base.resource;
		2176	dst = destination->base.resource;
		2177
		2178	user_assert(src && dst, D3DERR_INVALIDCALL);
		2179
		2180	/* check dst is depth format. we know already for src */
		2181	desc = util_format_description(dst->format);
		2182	user_assert(desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS, D3DERR_INVALIDCALL);
		2183
		2184	memset(&blit, 0, sizeof(blit));
		2185	blit.src.resource = src;
		2186	blit.src.level = 0;
		2187	blit.src.format = src->format;
		2188	blit.src.box.z = 0;
		2189	blit.src.box.depth = 1;
		2190	blit.src.box.x = 0;
		2191	blit.src.box.y = 0;
		2192	blit.src.box.width = src->width0;
		2193	blit.src.box.height = src->height0;
		2194
		2195	blit.dst.resource = dst;
		2196	blit.dst.level = 0;
		2197	blit.dst.format = dst->format;
		2198	blit.dst.box.z = 0;
		2199	blit.dst.box.depth = 1;
		2200	blit.dst.box.x = 0;
		2201	blit.dst.box.y = 0;
		2202	blit.dst.box.width = dst->width0;
		2203	blit.dst.box.height = dst->height0;
		2204
		2205	blit.mask = PIPE_MASK_ZS;
		2206	blit.filter = PIPE_TEX_FILTER_NEAREST;
		2207	blit.scissor_enable = FALSE;
		2208
		2209	This->pipe->blit(This->pipe, &blit);
		2210	return D3D_OK;
		2211	}
		2212
		2213	#define ALPHA_TO_COVERAGE_ENABLE MAKEFOURCC('A', '2', 'M', '1')
		2214	#define ALPHA_TO_COVERAGE_DISABLE MAKEFOURCC('A', '2', 'M', '0')
		2215
		2216	HRESULT WINAPI
		2217	NineDevice9_SetRenderState( struct NineDevice9 *This,
		2218	D3DRENDERSTATETYPE State,
		2219	DWORD Value )
		2220	{
		2221	struct nine_state *state = This->update;
		2222
		2223	DBG("This=%p State=%u(%s) Value=%08x\n", This,
		2224	State, nine_d3drs_to_string(State), Value);
		2225
		2226	/* Amd hacks (equivalent to GL extensions) */
		2227	if (State == D3DRS_POINTSIZE) {
		2228	if (Value == RESZ_CODE)
		2229	return NineDevice9_ResolveZ(This);
		2230
		2231	if (Value == ALPHA_TO_COVERAGE_ENABLE \|\|
		2232	Value == ALPHA_TO_COVERAGE_DISABLE) {
		2233	state->rs[NINED3DRS_ALPHACOVERAGE] = (Value == ALPHA_TO_COVERAGE_ENABLE);
		2234	state->changed.group \|= NINE_STATE_BLEND;
		2235	return D3D_OK;
		2236	}
		2237	}
		2238
		2239	/* NV hack */
		2240	if (State == D3DRS_ADAPTIVETESS_Y &&
		2241	(Value == D3DFMT_ATOC \|\| (Value == D3DFMT_UNKNOWN && state->rs[NINED3DRS_ALPHACOVERAGE]))) {
		2242	state->rs[NINED3DRS_ALPHACOVERAGE] = (Value == D3DFMT_ATOC);
		2243	state->changed.group \|= NINE_STATE_BLEND;
		2244	return D3D_OK;
		2245	}
		2246
		2247	user_assert(State < Elements(state->rs), D3DERR_INVALIDCALL);
		2248
		2249	if (likely(state->rs[State] != Value) \|\| unlikely(This->is_recording)) {
		2250	state->rs[State] = Value;
		2251	state->changed.rs[State / 32] \|= 1 << (State % 32);
		2252	state->changed.group \|= nine_render_state_group[State];
		2253	}
		2254
		2255	return D3D_OK;
		2256	}
		2257
		2258	HRESULT WINAPI
		2259	NineDevice9_GetRenderState( struct NineDevice9 *This,
		2260	D3DRENDERSTATETYPE State,
		2261	DWORD *pValue )
		2262	{
		2263	user_assert(State < Elements(This->state.rs), D3DERR_INVALIDCALL);
		2264
		2265	*pValue = This->state.rs[State];
		2266	return D3D_OK;
		2267	}
		2268
		2269	HRESULT WINAPI
		2270	NineDevice9_CreateStateBlock( struct NineDevice9 *This,
		2271	D3DSTATEBLOCKTYPE Type,
		2272	IDirect3DStateBlock9 **ppSB )
		2273	{
		2274	struct NineStateBlock9 *nsb;
		2275	struct nine_state *dst;
		2276	HRESULT hr;
		2277	enum nine_stateblock_type type;
		2278	unsigned s;
		2279
		2280	DBG("This=%p Type=%u ppSB=%p\n", This, Type, ppSB);
		2281
		2282	user_assert(Type == D3DSBT_ALL \|\|
		2283	Type == D3DSBT_VERTEXSTATE \|\|
		2284	Type == D3DSBT_PIXELSTATE, D3DERR_INVALIDCALL);
		2285
		2286	switch (Type) {
		2287	case D3DSBT_VERTEXSTATE: type = NINESBT_VERTEXSTATE; break;
		2288	case D3DSBT_PIXELSTATE: type = NINESBT_PIXELSTATE; break;
		2289	default:
		2290	type = NINESBT_ALL;
		2291	break;
		2292	}
		2293
		2294	hr = NineStateBlock9_new(This, &nsb, type);
		2295	if (FAILED(hr))
		2296	return hr;
		2297	ppSB = (IDirect3DStateBlock9 )nsb;
		2298	dst = &nsb->state;
		2299
		2300	dst->changed.group =
		2301	NINE_STATE_TEXTURE \|
		2302	NINE_STATE_SAMPLER;
		2303
		2304	if (Type == D3DSBT_ALL \|\| Type == D3DSBT_VERTEXSTATE) {
		2305	dst->changed.group \|=
		2306	NINE_STATE_FF_LIGHTING \|
		2307	NINE_STATE_VS \| NINE_STATE_VS_CONST \|
		2308	NINE_STATE_VDECL;
		2309	/* TODO: texture/sampler state */
		2310	memcpy(dst->changed.rs,
		2311	nine_render_states_vertex, sizeof(dst->changed.rs));
		2312	nine_ranges_insert(&dst->changed.vs_const_f, 0, This->max_vs_const_f,
		2313	&This->range_pool);
		2314	dst->changed.vs_const_i = 0xffff;
		2315	dst->changed.vs_const_b = 0xffff;
		2316	for (s = 0; s < NINE_MAX_SAMPLERS; ++s)
		2317	dst->changed.sampler[s] \|= 1 << D3DSAMP_DMAPOFFSET;
		2318	if (This->state.ff.num_lights) {
		2319	dst->ff.num_lights = This->state.ff.num_lights;
		2320	/* zero'd -> light type won't be NINED3DLIGHT_INVALID, so
		2321	* all currently existing lights will be captured
		2322	*/
		2323	dst->ff.light = CALLOC(This->state.ff.num_lights,
		2324	sizeof(D3DLIGHT9));
		2325	if (!dst->ff.light) {
		2326	nine_bind(ppSB, NULL);
		2327	return E_OUTOFMEMORY;
		2328	}
		2329	}
		2330	}
		2331	if (Type == D3DSBT_ALL \|\| Type == D3DSBT_PIXELSTATE) {
		2332	dst->changed.group \|=
		2333	NINE_STATE_PS \| NINE_STATE_PS_CONST;
		2334	/* TODO: texture/sampler state */
		2335	memcpy(dst->changed.rs,
		2336	nine_render_states_pixel, sizeof(dst->changed.rs));
		2337	nine_ranges_insert(&dst->changed.ps_const_f, 0, This->max_ps_const_f,
		2338	&This->range_pool);
		2339	dst->changed.ps_const_i = 0xffff;
		2340	dst->changed.ps_const_b = 0xffff;
		2341	for (s = 0; s < NINE_MAX_SAMPLERS; ++s)
		2342	dst->changed.sampler[s] \|= 0x1ffe;
		2343	}
		2344	if (Type == D3DSBT_ALL) {
		2345	dst->changed.group \|=
		2346	NINE_STATE_VIEWPORT \|
		2347	NINE_STATE_SCISSOR \|
		2348	NINE_STATE_RASTERIZER \|
		2349	NINE_STATE_BLEND \|
		2350	NINE_STATE_DSA \|
		2351	NINE_STATE_IDXBUF \|
		2352	NINE_STATE_MATERIAL \|
		2353	NINE_STATE_BLEND_COLOR \|
		2354	NINE_STATE_SAMPLE_MASK;
		2355	memset(dst->changed.rs, ~0, (D3DRS_COUNT / 32) * sizeof(uint32_t));
		2356	dst->changed.rs[D3DRS_LAST / 32] \|= (1 << (D3DRS_COUNT % 32)) - 1;
		2357	dst->changed.vtxbuf = (1ULL << This->caps.MaxStreams) - 1;
		2358	dst->changed.stream_freq = dst->changed.vtxbuf;
		2359	dst->changed.ucp = (1 << PIPE_MAX_CLIP_PLANES) - 1;
		2360	dst->changed.texture = (1 << NINE_MAX_SAMPLERS) - 1;
		2361	}
		2362	NineStateBlock9_Capture(NineStateBlock9(*ppSB));
		2363
		2364	/* TODO: fixed function state */
		2365
		2366	return D3D_OK;
		2367	}
		2368
		2369	HRESULT WINAPI
		2370	NineDevice9_BeginStateBlock( struct NineDevice9 *This )
		2371	{
		2372	HRESULT hr;
		2373
		2374	DBG("This=%p\n", This);
		2375
		2376	user_assert(!This->record, D3DERR_INVALIDCALL);
		2377
		2378	hr = NineStateBlock9_new(This, &This->record, NINESBT_CUSTOM);
		2379	if (FAILED(hr))
		2380	return hr;
		2381	NineUnknown_ConvertRefToBind(NineUnknown(This->record));
		2382
		2383	This->update = &This->record->state;
		2384	This->is_recording = TRUE;
		2385
		2386	return D3D_OK;
		2387	}
		2388
		2389	HRESULT WINAPI
		2390	NineDevice9_EndStateBlock( struct NineDevice9 *This,
		2391	IDirect3DStateBlock9 **ppSB )
		2392	{
		2393	DBG("This=%p ppSB=%p\n", This, ppSB);
		2394
		2395	user_assert(This->record, D3DERR_INVALIDCALL);
		2396
		2397	This->update = &This->state;
		2398	This->is_recording = FALSE;
		2399
		2400	NineUnknown_AddRef(NineUnknown(This->record));
		2401	ppSB = (IDirect3DStateBlock9 )This->record;
		2402	NineUnknown_Unbind(NineUnknown(This->record));
		2403	This->record = NULL;
		2404
		2405	return D3D_OK;
		2406	}
		2407
		2408	HRESULT WINAPI
		2409	NineDevice9_SetClipStatus( struct NineDevice9 *This,
		2410	const D3DCLIPSTATUS9 *pClipStatus )
		2411	{
		2412	STUB(D3DERR_INVALIDCALL);
		2413	}
		2414
		2415	HRESULT WINAPI
		2416	NineDevice9_GetClipStatus( struct NineDevice9 *This,
		2417	D3DCLIPSTATUS9 *pClipStatus )
		2418	{
		2419	STUB(D3DERR_INVALIDCALL);
		2420	}
		2421
		2422	HRESULT WINAPI
		2423	NineDevice9_GetTexture( struct NineDevice9 *This,
		2424	DWORD Stage,
		2425	IDirect3DBaseTexture9 **ppTexture )
		2426	{
		2427	user_assert(Stage < This->caps.MaxSimultaneousTextures \|\|
		2428	Stage == D3DDMAPSAMPLER \|\|
		2429	(Stage >= D3DVERTEXTEXTURESAMPLER0 &&
		2430	Stage <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
		2431	user_assert(ppTexture, D3DERR_INVALIDCALL);
		2432
		2433	if (Stage >= D3DDMAPSAMPLER)
		2434	Stage = Stage - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
		2435
		2436	ppTexture = (IDirect3DBaseTexture9 )This->state.texture[Stage];
		2437
		2438	if (This->state.texture[Stage])
		2439	NineUnknown_AddRef(NineUnknown(This->state.texture[Stage]));
		2440	return D3D_OK;
		2441	}
		2442
		2443	HRESULT WINAPI
		2444	NineDevice9_SetTexture( struct NineDevice9 *This,
		2445	DWORD Stage,
		2446	IDirect3DBaseTexture9 *pTexture )
		2447	{
		2448	struct nine_state *state = This->update;
		2449	struct NineBaseTexture9 *tex = NineBaseTexture9(pTexture);
		2450
		2451	DBG("This=%p Stage=%u pTexture=%p\n", This, Stage, pTexture);
		2452
		2453	user_assert(Stage < This->caps.MaxSimultaneousTextures \|\|
		2454	Stage == D3DDMAPSAMPLER \|\|
		2455	(Stage >= D3DVERTEXTEXTURESAMPLER0 &&
		2456	Stage <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
		2457	user_assert(!tex \|\| (tex->base.pool != D3DPOOL_SCRATCH &&
		2458	tex->base.pool != D3DPOOL_SYSTEMMEM), D3DERR_INVALIDCALL);
		2459
		2460	if (Stage >= D3DDMAPSAMPLER)
		2461	Stage = Stage - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
		2462
		2463	if (!This->is_recording) {
		2464	struct NineBaseTexture9 *old = state->texture[Stage];
		2465	if (old == tex)
		2466	return D3D_OK;
		2467
		2468	state->samplers_shadow &= ~(1 << Stage);
		2469	if (tex) {
		2470	state->samplers_shadow \|= tex->shadow << Stage;
		2471
		2472	if ((tex->managed.dirty \| tex->dirty_mip) && LIST_IS_EMPTY(&tex->list))
		2473	list_add(&tex->list, &This->update_textures);
		2474
		2475	tex->bind_count++;
		2476	}
		2477	if (old)
		2478	old->bind_count--;
		2479	}
		2480	nine_bind(&state->texture[Stage], pTexture);
		2481
		2482	state->changed.texture \|= 1 << Stage;
		2483	state->changed.group \|= NINE_STATE_TEXTURE;
		2484
		2485	return D3D_OK;
		2486	}
		2487
		2488	HRESULT WINAPI
		2489	NineDevice9_GetTextureStageState( struct NineDevice9 *This,
		2490	DWORD Stage,
		2491	D3DTEXTURESTAGESTATETYPE Type,
		2492	DWORD *pValue )
		2493	{
		2494	const struct nine_state *state = &This->state;
		2495
		2496	user_assert(Stage < Elements(state->ff.tex_stage), D3DERR_INVALIDCALL);
		2497	user_assert(Type < Elements(state->ff.tex_stage[0]), D3DERR_INVALIDCALL);
		2498
		2499	*pValue = state->ff.tex_stage[Stage][Type];
		2500
		2501	return D3D_OK;
		2502	}
		2503
		2504	HRESULT WINAPI
		2505	NineDevice9_SetTextureStageState( struct NineDevice9 *This,
		2506	DWORD Stage,
		2507	D3DTEXTURESTAGESTATETYPE Type,
		2508	DWORD Value )
		2509	{
		2510	struct nine_state *state = This->update;
		2511
		2512	DBG("Stage=%u Type=%u Value=%08x\n", Stage, Type, Value);
		2513	nine_dump_D3DTSS_value(DBG_FF, Type, Value);
		2514
		2515	user_assert(Stage < Elements(state->ff.tex_stage), D3DERR_INVALIDCALL);
		2516	user_assert(Type < Elements(state->ff.tex_stage[0]), D3DERR_INVALIDCALL);
		2517
		2518	state->ff.tex_stage[Stage][Type] = Value;
		2519
		2520	state->changed.group \|= NINE_STATE_FF_PSSTAGES;
		2521	state->ff.changed.tex_stage[Stage][Type / 32] \|= 1 << (Type % 32);
		2522
		2523	return D3D_OK;
		2524	}
		2525
		2526	HRESULT WINAPI
		2527	NineDevice9_GetSamplerState( struct NineDevice9 *This,
		2528	DWORD Sampler,
		2529	D3DSAMPLERSTATETYPE Type,
		2530	DWORD *pValue )
		2531	{
		2532	user_assert(Sampler < This->caps.MaxSimultaneousTextures \|\|
		2533	Sampler == D3DDMAPSAMPLER \|\|
		2534	(Sampler >= D3DVERTEXTEXTURESAMPLER0 &&
		2535	Sampler <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
		2536
		2537	if (Sampler >= D3DDMAPSAMPLER)
		2538	Sampler = Sampler - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
		2539
		2540	*pValue = This->state.samp[Sampler][Type];
		2541	return D3D_OK;
		2542	}
		2543
		2544	HRESULT WINAPI
		2545	NineDevice9_SetSamplerState( struct NineDevice9 *This,
		2546	DWORD Sampler,
		2547	D3DSAMPLERSTATETYPE Type,
		2548	DWORD Value )
		2549	{
		2550	struct nine_state *state = This->update;
		2551
		2552	DBG("This=%p Sampler=%u Type=%s Value=%08x\n", This,
		2553	Sampler, nine_D3DSAMP_to_str(Type), Value);
		2554
		2555	user_assert(Sampler < This->caps.MaxSimultaneousTextures \|\|
		2556	Sampler == D3DDMAPSAMPLER \|\|
		2557	(Sampler >= D3DVERTEXTEXTURESAMPLER0 &&
		2558	Sampler <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
		2559
		2560	if (Sampler >= D3DDMAPSAMPLER)
		2561	Sampler = Sampler - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
		2562
		2563	state->samp[Sampler][Type] = Value;
		2564	state->changed.group \|= NINE_STATE_SAMPLER;
		2565	state->changed.sampler[Sampler] \|= 1 << Type;
		2566
		2567	if (Type == D3DSAMP_SRGBTEXTURE)
		2568	state->changed.srgb = TRUE;
		2569
		2570	return D3D_OK;
		2571	}
		2572
		2573	HRESULT WINAPI
		2574	NineDevice9_ValidateDevice( struct NineDevice9 *This,
		2575	DWORD *pNumPasses )
		2576	{
		2577	const struct nine_state *state = &This->state;
		2578	unsigned i;
		2579	unsigned w = 0, h = 0;
		2580
		2581	DBG("This=%p pNumPasses=%p\n", This, pNumPasses);
		2582
		2583	for (i = 0; i < Elements(state->samp); ++i) {
		2584	if (state->samp[i][D3DSAMP_MINFILTER] == D3DTEXF_NONE \|\|
		2585	state->samp[i][D3DSAMP_MAGFILTER] == D3DTEXF_NONE)
		2586	return D3DERR_UNSUPPORTEDTEXTUREFILTER;
		2587	}
		2588
		2589	for (i = 0; i < This->caps.NumSimultaneousRTs; ++i) {
		2590	if (!state->rt[i])
		2591	continue;
		2592	if (w == 0) {
		2593	w = state->rt[i]->desc.Width;
		2594	h = state->rt[i]->desc.Height;
		2595	} else
		2596	if (state->rt[i]->desc.Width != w \|\| state->rt[i]->desc.Height != h) {
		2597	return D3DERR_CONFLICTINGRENDERSTATE;
		2598	}
		2599	}
		2600	if (state->ds &&
		2601	(state->rs[D3DRS_ZENABLE] \|\| state->rs[D3DRS_STENCILENABLE])) {
		2602	if (w != 0 &&
		2603	(state->ds->desc.Width != w \|\| state->ds->desc.Height != h))
		2604	return D3DERR_CONFLICTINGRENDERSTATE;
		2605	}
		2606
		2607	if (pNumPasses)
		2608	*pNumPasses = 1;
		2609
		2610	return D3D_OK;
		2611	}
		2612
		2613	HRESULT WINAPI
		2614	NineDevice9_SetPaletteEntries( struct NineDevice9 *This,
		2615	UINT PaletteNumber,
		2616	const PALETTEENTRY *pEntries )
		2617	{
		2618	STUB(D3D_OK); /* like wine */
		2619	}
		2620
		2621	HRESULT WINAPI
		2622	NineDevice9_GetPaletteEntries( struct NineDevice9 *This,
		2623	UINT PaletteNumber,
		2624	PALETTEENTRY *pEntries )
		2625	{
		2626	STUB(D3DERR_INVALIDCALL);
		2627	}
		2628
		2629	HRESULT WINAPI
		2630	NineDevice9_SetCurrentTexturePalette( struct NineDevice9 *This,
		2631	UINT PaletteNumber )
		2632	{
		2633	STUB(D3D_OK); /* like wine */
		2634	}
		2635
		2636	HRESULT WINAPI
		2637	NineDevice9_GetCurrentTexturePalette( struct NineDevice9 *This,
		2638	UINT *PaletteNumber )
		2639	{
		2640	STUB(D3DERR_INVALIDCALL);
		2641	}
		2642
		2643	HRESULT WINAPI
		2644	NineDevice9_SetScissorRect( struct NineDevice9 *This,
		2645	const RECT *pRect )
		2646	{
		2647	struct nine_state *state = This->update;
		2648
		2649	DBG("x=(%u..%u) y=(%u..%u)\n",
		2650	pRect->left, pRect->top, pRect->right, pRect->bottom);
		2651
		2652	state->scissor.minx = pRect->left;
		2653	state->scissor.miny = pRect->top;
		2654	state->scissor.maxx = pRect->right;
		2655	state->scissor.maxy = pRect->bottom;
		2656
		2657	state->changed.group \|= NINE_STATE_SCISSOR;
		2658
		2659	return D3D_OK;
		2660	}
		2661
		2662	HRESULT WINAPI
		2663	NineDevice9_GetScissorRect( struct NineDevice9 *This,
		2664	RECT *pRect )
		2665	{
		2666	pRect->left = This->state.scissor.minx;
		2667	pRect->top = This->state.scissor.miny;
		2668	pRect->right = This->state.scissor.maxx;
		2669	pRect->bottom = This->state.scissor.maxy;
		2670
		2671	return D3D_OK;
		2672	}
		2673
		2674	HRESULT WINAPI
		2675	NineDevice9_SetSoftwareVertexProcessing( struct NineDevice9 *This,
		2676	BOOL bSoftware )
		2677	{
		2678	STUB(D3DERR_INVALIDCALL);
		2679	}
		2680
		2681	BOOL WINAPI
		2682	NineDevice9_GetSoftwareVertexProcessing( struct NineDevice9 *This )
		2683	{
		2684	return !!(This->params.BehaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING);
		2685	}
		2686
		2687	HRESULT WINAPI
		2688	NineDevice9_SetNPatchMode( struct NineDevice9 *This,
		2689	float nSegments )
		2690	{
		2691	STUB(D3DERR_INVALIDCALL);
		2692	}
		2693
		2694	float WINAPI
		2695	NineDevice9_GetNPatchMode( struct NineDevice9 *This )
		2696	{
		2697	STUB(0);
		2698	}
		2699
		2700	static INLINE void
		2701	init_draw_info(struct pipe_draw_info *info,
		2702	struct NineDevice9 *dev, D3DPRIMITIVETYPE type, UINT count)
		2703	{
		2704	info->mode = d3dprimitivetype_to_pipe_prim(type);
		2705	info->count = prim_count_to_vertex_count(type, count);
		2706	info->start_instance = 0;
		2707	info->instance_count = 1;
		2708	if (dev->state.stream_instancedata_mask & dev->state.stream_usage_mask)
		2709	info->instance_count = MAX2(dev->state.stream_freq[0] & 0x7FFFFF, 1);
		2710	info->primitive_restart = FALSE;
		2711	info->restart_index = 0;
		2712	info->count_from_stream_output = NULL;
		2713	info->indirect = NULL;
		2714	}
		2715
		2716	HRESULT WINAPI
		2717	NineDevice9_DrawPrimitive( struct NineDevice9 *This,
		2718	D3DPRIMITIVETYPE PrimitiveType,
		2719	UINT StartVertex,
		2720	UINT PrimitiveCount )
		2721	{
		2722	struct pipe_draw_info info;
		2723
		2724	DBG("iface %p, PrimitiveType %u, StartVertex %u, PrimitiveCount %u\n",
		2725	This, PrimitiveType, StartVertex, PrimitiveCount);
		2726
		2727	nine_update_state(This, ~0);
		2728
		2729	init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
		2730	info.indexed = FALSE;
		2731	info.start = StartVertex;
		2732	info.index_bias = 0;
		2733	info.min_index = info.start;
		2734	info.max_index = info.count - 1;
		2735
		2736	This->pipe->draw_vbo(This->pipe, &info);
		2737
		2738	return D3D_OK;
		2739	}
		2740
		2741	HRESULT WINAPI
		2742	NineDevice9_DrawIndexedPrimitive( struct NineDevice9 *This,
		2743	D3DPRIMITIVETYPE PrimitiveType,
		2744	INT BaseVertexIndex,
		2745	UINT MinVertexIndex,
		2746	UINT NumVertices,
		2747	UINT StartIndex,
		2748	UINT PrimitiveCount )
		2749	{
		2750	struct pipe_draw_info info;
		2751
		2752	DBG("iface %p, PrimitiveType %u, BaseVertexIndex %u, MinVertexIndex %u "
		2753	"NumVertices %u, StartIndex %u, PrimitiveCount %u\n",
		2754	This, PrimitiveType, BaseVertexIndex, MinVertexIndex, NumVertices,
		2755	StartIndex, PrimitiveCount);
		2756
		2757	user_assert(This->state.idxbuf, D3DERR_INVALIDCALL);
		2758	user_assert(This->state.vdecl, D3DERR_INVALIDCALL);
		2759
		2760	nine_update_state(This, ~0);
		2761
		2762	init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
		2763	info.indexed = TRUE;
		2764	info.start = StartIndex;
		2765	info.index_bias = BaseVertexIndex;
		2766	/* These don't include index bias: */
		2767	info.min_index = MinVertexIndex;
		2768	info.max_index = MinVertexIndex + NumVertices - 1;
		2769
		2770	This->pipe->draw_vbo(This->pipe, &info);
		2771
		2772	return D3D_OK;
		2773	}
		2774
		2775	HRESULT WINAPI
		2776	NineDevice9_DrawPrimitiveUP( struct NineDevice9 *This,
		2777	D3DPRIMITIVETYPE PrimitiveType,
		2778	UINT PrimitiveCount,
		2779	const void *pVertexStreamZeroData,
		2780	UINT VertexStreamZeroStride )
		2781	{
		2782	struct pipe_vertex_buffer vtxbuf;
		2783	struct pipe_draw_info info;
		2784
		2785	DBG("iface %p, PrimitiveType %u, PrimitiveCount %u, data %p, stride %u\n",
		2786	This, PrimitiveType, PrimitiveCount,
		2787	pVertexStreamZeroData, VertexStreamZeroStride);
		2788
		2789	user_assert(pVertexStreamZeroData && VertexStreamZeroStride,
		2790	D3DERR_INVALIDCALL);
		2791
		2792	nine_update_state(This, ~0);
		2793
		2794	init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
		2795	info.indexed = FALSE;
		2796	info.start = 0;
		2797	info.index_bias = 0;
		2798	info.min_index = 0;
		2799	info.max_index = info.count - 1;
		2800
		2801	vtxbuf.stride = VertexStreamZeroStride;
		2802	vtxbuf.buffer_offset = 0;
		2803	vtxbuf.buffer = NULL;
		2804	vtxbuf.user_buffer = pVertexStreamZeroData;
		2805
		2806	if (!This->driver_caps.user_vbufs)
		2807	u_upload_data(This->upload,
		2808	0,
		2809	(info.max_index + 1) * VertexStreamZeroStride, /* XXX */
		2810	vtxbuf.user_buffer,
		2811	&vtxbuf.buffer_offset,
		2812	&vtxbuf.buffer);
		2813
		2814	This->pipe->set_vertex_buffers(This->pipe, 0, 1, &vtxbuf);
		2815
		2816	This->pipe->draw_vbo(This->pipe, &info);
		2817
		2818	NineDevice9_PauseRecording(This);
		2819	NineDevice9_SetStreamSource(This, 0, NULL, 0, 0);
		2820	NineDevice9_ResumeRecording(This);
		2821
		2822	pipe_resource_reference(&vtxbuf.buffer, NULL);
		2823
		2824	return D3D_OK;
		2825	}
		2826
		2827	HRESULT WINAPI
		2828	NineDevice9_DrawIndexedPrimitiveUP( struct NineDevice9 *This,
		2829	D3DPRIMITIVETYPE PrimitiveType,
		2830	UINT MinVertexIndex,
		2831	UINT NumVertices,
		2832	UINT PrimitiveCount,
		2833	const void *pIndexData,
		2834	D3DFORMAT IndexDataFormat,
		2835	const void *pVertexStreamZeroData,
		2836	UINT VertexStreamZeroStride )
		2837	{
		2838	struct pipe_draw_info info;
		2839	struct pipe_vertex_buffer vbuf;
		2840	struct pipe_index_buffer ibuf;
		2841
		2842	DBG("iface %p, PrimitiveType %u, MinVertexIndex %u, NumVertices %u "
		2843	"PrimitiveCount %u, pIndexData %p, IndexDataFormat %u "
		2844	"pVertexStreamZeroData %p, VertexStreamZeroStride %u\n",
		2845	This, PrimitiveType, MinVertexIndex, NumVertices, PrimitiveCount,
		2846	pIndexData, IndexDataFormat,
		2847	pVertexStreamZeroData, VertexStreamZeroStride);
		2848
		2849	user_assert(pIndexData && pVertexStreamZeroData, D3DERR_INVALIDCALL);
		2850	user_assert(VertexStreamZeroStride, D3DERR_INVALIDCALL);
		2851	user_assert(IndexDataFormat == D3DFMT_INDEX16 \|\|
		2852	IndexDataFormat == D3DFMT_INDEX32, D3DERR_INVALIDCALL);
		2853
		2854	nine_update_state(This, ~0);
		2855
		2856	init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
		2857	info.indexed = TRUE;
		2858	info.start = 0;
		2859	info.index_bias = 0;
		2860	info.min_index = MinVertexIndex;
		2861	info.max_index = MinVertexIndex + NumVertices - 1;
		2862
		2863	vbuf.stride = VertexStreamZeroStride;
		2864	vbuf.buffer_offset = 0;
		2865	vbuf.buffer = NULL;
		2866	vbuf.user_buffer = pVertexStreamZeroData;
		2867
		2868	ibuf.index_size = (IndexDataFormat == D3DFMT_INDEX16) ? 2 : 4;
		2869	ibuf.offset = 0;
		2870	ibuf.buffer = NULL;
		2871	ibuf.user_buffer = pIndexData;
		2872
		2873	if (!This->driver_caps.user_vbufs) {
		2874	const unsigned base = info.min_index * VertexStreamZeroStride;
		2875	u_upload_data(This->upload,
		2876	base,
		2877	(info.max_index -
		2878	info.min_index + 1) * VertexStreamZeroStride, /* XXX */
		2879	(const uint8_t *)vbuf.user_buffer + base,
		2880	&vbuf.buffer_offset,
		2881	&vbuf.buffer);
		2882	/* Won't be used: */
		2883	vbuf.buffer_offset -= base;
		2884	}
		2885	if (!This->driver_caps.user_ibufs)
		2886	u_upload_data(This->upload,
		2887	0,
		2888	info.count * ibuf.index_size,
		2889	ibuf.user_buffer,
		2890	&ibuf.offset,
		2891	&ibuf.buffer);
		2892
		2893	This->pipe->set_vertex_buffers(This->pipe, 0, 1, &vbuf);
		2894	This->pipe->set_index_buffer(This->pipe, &ibuf);
		2895
		2896	This->pipe->draw_vbo(This->pipe, &info);
		2897
		2898	pipe_resource_reference(&vbuf.buffer, NULL);
		2899	pipe_resource_reference(&ibuf.buffer, NULL);
		2900
		2901	NineDevice9_PauseRecording(This);
		2902	NineDevice9_SetIndices(This, NULL);
		2903	NineDevice9_SetStreamSource(This, 0, NULL, 0, 0);
		2904	NineDevice9_ResumeRecording(This);
		2905
		2906	return D3D_OK;
		2907	}
		2908
		2909	/* TODO: Write to pDestBuffer directly if vertex declaration contains
		2910	* only f32 formats.
		2911	*/
		2912	HRESULT WINAPI
		2913	NineDevice9_ProcessVertices( struct NineDevice9 *This,
		2914	UINT SrcStartIndex,
		2915	UINT DestIndex,
		2916	UINT VertexCount,
		2917	IDirect3DVertexBuffer9 *pDestBuffer,
		2918	IDirect3DVertexDeclaration9 *pVertexDecl,
		2919	DWORD Flags )
		2920	{
		2921	struct pipe_screen *screen = This->screen;
		2922	struct NineVertexDeclaration9 *vdecl = NineVertexDeclaration9(pVertexDecl);
		2923	struct NineVertexShader9 *vs;
		2924	struct pipe_resource *resource;
		2925	struct pipe_stream_output_target *target;
		2926	struct pipe_draw_info draw;
		2927	HRESULT hr;
		2928	unsigned buffer_offset, buffer_size;
		2929
		2930	DBG("This=%p SrcStartIndex=%u DestIndex=%u VertexCount=%u "
		2931	"pDestBuffer=%p pVertexDecl=%p Flags=%d\n",
		2932	This, SrcStartIndex, DestIndex, VertexCount, pDestBuffer,
		2933	pVertexDecl, Flags);
		2934
		2935	if (!screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS))
		2936	STUB(D3DERR_INVALIDCALL);
		2937
		2938	nine_update_state(This, ~0);
		2939
		2940	/* TODO: Create shader with stream output. */
		2941	STUB(D3DERR_INVALIDCALL);
		2942	struct NineVertexBuffer9 *dst = NineVertexBuffer9(pDestBuffer);
		2943
		2944	vs = This->state.vs ? This->state.vs : This->ff.vs;
		2945
		2946	buffer_size = VertexCount * vs->so->stride[0];
		2947	if (1) {
		2948	struct pipe_resource templ;
		2949
		2950	templ.target = PIPE_BUFFER;
		2951	templ.format = PIPE_FORMAT_R8_UNORM;
		2952	templ.width0 = buffer_size;
		2953	templ.flags = 0;
		2954	templ.bind = PIPE_BIND_STREAM_OUTPUT;
		2955	templ.usage = PIPE_USAGE_STREAM;
		2956	templ.height0 = templ.depth0 = templ.array_size = 1;
		2957	templ.last_level = templ.nr_samples = 0;
		2958
		2959	resource = This->screen->resource_create(This->screen, &templ);
		2960	if (!resource)
		2961	return E_OUTOFMEMORY;
		2962	buffer_offset = 0;
		2963	} else {
		2964	/* SO matches vertex declaration */
		2965	resource = dst->base.resource;
		2966	buffer_offset = DestIndex * vs->so->stride[0];
		2967	}
		2968	target = This->pipe->create_stream_output_target(This->pipe, resource,
		2969	buffer_offset,
		2970	buffer_size);
		2971	if (!target) {
		2972	pipe_resource_reference(&resource, NULL);
		2973	return D3DERR_DRIVERINTERNALERROR;
		2974	}
		2975
		2976	if (!vdecl) {
		2977	hr = NineVertexDeclaration9_new_from_fvf(This, dst->desc.FVF, &vdecl);
		2978	if (FAILED(hr))
		2979	goto out;
		2980	}
		2981
		2982	init_draw_info(&draw, This, D3DPT_POINTLIST, VertexCount);
		2983	draw.instance_count = 1;
		2984	draw.indexed = FALSE;
		2985	draw.start = SrcStartIndex;
		2986	draw.index_bias = 0;
		2987	draw.min_index = SrcStartIndex;
		2988	draw.max_index = SrcStartIndex + VertexCount - 1;
		2989
		2990	This->pipe->set_stream_output_targets(This->pipe, 1, &target, 0);
		2991	This->pipe->draw_vbo(This->pipe, &draw);
		2992	This->pipe->set_stream_output_targets(This->pipe, 0, NULL, 0);
		2993	This->pipe->stream_output_target_destroy(This->pipe, target);
		2994
		2995	hr = NineVertexDeclaration9_ConvertStreamOutput(vdecl,
		2996	dst, DestIndex, VertexCount,
		2997	resource, vs->so);
		2998	out:
		2999	pipe_resource_reference(&resource, NULL);
		3000	if (!pVertexDecl)
		3001	NineUnknown_Release(NineUnknown(vdecl));
		3002	return hr;
		3003	}
		3004
		3005	HRESULT WINAPI
		3006	NineDevice9_CreateVertexDeclaration( struct NineDevice9 *This,
		3007	const D3DVERTEXELEMENT9 *pVertexElements,
		3008	IDirect3DVertexDeclaration9 **ppDecl )
		3009	{
		3010	struct NineVertexDeclaration9 *vdecl;
		3011
		3012	DBG("This=%p pVertexElements=%p ppDecl=%p\n",
		3013	This, pVertexElements, ppDecl);
		3014
		3015	HRESULT hr = NineVertexDeclaration9_new(This, pVertexElements, &vdecl);
		3016	if (SUCCEEDED(hr))
		3017	ppDecl = (IDirect3DVertexDeclaration9 )vdecl;
		3018
		3019	return hr;
		3020	}
		3021
		3022	HRESULT WINAPI
		3023	NineDevice9_SetVertexDeclaration( struct NineDevice9 *This,
		3024	IDirect3DVertexDeclaration9 *pDecl )
		3025	{
		3026	struct nine_state *state = This->update;
		3027
		3028	DBG("This=%p pDecl=%p\n", This, pDecl);
		3029
		3030	if (likely(!This->is_recording) && state->vdecl == NineVertexDeclaration9(pDecl))
		3031	return D3D_OK;
		3032	nine_bind(&state->vdecl, pDecl);
		3033
		3034	state->changed.group \|= NINE_STATE_VDECL;
		3035
		3036	return D3D_OK;
		3037	}
		3038
		3039	HRESULT WINAPI
		3040	NineDevice9_GetVertexDeclaration( struct NineDevice9 *This,
		3041	IDirect3DVertexDeclaration9 **ppDecl )
		3042	{
		3043	user_assert(ppDecl, D3DERR_INVALIDCALL);
		3044
		3045	ppDecl = (IDirect3DVertexDeclaration9 )This->state.vdecl;
		3046	if (*ppDecl)
		3047	NineUnknown_AddRef(NineUnknown(*ppDecl));
		3048	return D3D_OK;
		3049	}
		3050
		3051	HRESULT WINAPI
		3052	NineDevice9_SetFVF( struct NineDevice9 *This,
		3053	DWORD FVF )
		3054	{
		3055	struct NineVertexDeclaration9 *vdecl;
		3056	HRESULT hr;
		3057
		3058	DBG("FVF = %08x\n", FVF);
		3059	if (!FVF)
		3060	return D3D_OK; /* like wine */
		3061
		3062	vdecl = util_hash_table_get(This->ff.ht_fvf, &FVF);
		3063	if (!vdecl) {
		3064	hr = NineVertexDeclaration9_new_from_fvf(This, FVF, &vdecl);
		3065	if (FAILED(hr))
		3066	return hr;
		3067	vdecl->fvf = FVF;
		3068	util_hash_table_set(This->ff.ht_fvf, &vdecl->fvf, vdecl);
		3069	NineUnknown_ConvertRefToBind(NineUnknown(vdecl));
		3070	}
		3071	return NineDevice9_SetVertexDeclaration(
		3072	This, (IDirect3DVertexDeclaration9 *)vdecl);
		3073	}
		3074
		3075	HRESULT WINAPI
		3076	NineDevice9_GetFVF( struct NineDevice9 *This,
		3077	DWORD *pFVF )
		3078	{
		3079	*pFVF = This->state.vdecl ? This->state.vdecl->fvf : 0;
		3080	return D3D_OK;
		3081	}
		3082
		3083	HRESULT WINAPI
		3084	NineDevice9_CreateVertexShader( struct NineDevice9 *This,
		3085	const DWORD *pFunction,
		3086	IDirect3DVertexShader9 **ppShader )
		3087	{
		3088	struct NineVertexShader9 *vs;
		3089	HRESULT hr;
		3090
		3091	DBG("This=%p pFunction=%p ppShader=%p\n", This, pFunction, ppShader);
		3092
		3093	hr = NineVertexShader9_new(This, &vs, pFunction, NULL);
		3094	if (FAILED(hr))
		3095	return hr;
		3096	ppShader = (IDirect3DVertexShader9 )vs;
		3097	return D3D_OK;
		3098	}
		3099
		3100	HRESULT WINAPI
		3101	NineDevice9_SetVertexShader( struct NineDevice9 *This,
		3102	IDirect3DVertexShader9 *pShader )
		3103	{
		3104	struct nine_state *state = This->update;
		3105
		3106	DBG("This=%p pShader=%p\n", This, pShader);
		3107
		3108	nine_bind(&state->vs, pShader);
		3109
		3110	state->changed.group \|= NINE_STATE_VS;
		3111
		3112	return D3D_OK;
		3113	}
		3114
		3115	HRESULT WINAPI
		3116	NineDevice9_GetVertexShader( struct NineDevice9 *This,
		3117	IDirect3DVertexShader9 **ppShader )
		3118	{
		3119	user_assert(ppShader, D3DERR_INVALIDCALL);
		3120	nine_reference_set(ppShader, This->state.vs);
		3121	return D3D_OK;
		3122	}
		3123
		3124	HRESULT WINAPI
		3125	NineDevice9_SetVertexShaderConstantF( struct NineDevice9 *This,
		3126	UINT StartRegister,
		3127	const float *pConstantData,
		3128	UINT Vector4fCount )
		3129	{
		3130	struct nine_state *state = This->update;
		3131
		3132	DBG("This=%p StartRegister=%u pConstantData=%p Vector4fCount=%u\n",
		3133	This, StartRegister, pConstantData, Vector4fCount);
		3134
		3135	user_assert(StartRegister < This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
		3136	user_assert(StartRegister + Vector4fCount <= This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
		3137
		3138	if (!Vector4fCount)
		3139	return D3D_OK;
		3140	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3141
		3142	memcpy(&state->vs_const_f[StartRegister * 4],
		3143	pConstantData,
		3144	Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
		3145
		3146	nine_ranges_insert(&state->changed.vs_const_f,
		3147	StartRegister, StartRegister + Vector4fCount,
		3148	&This->range_pool);
		3149
		3150	state->changed.group \|= NINE_STATE_VS_CONST;
		3151
		3152	return D3D_OK;
		3153	}
		3154
		3155	HRESULT WINAPI
		3156	NineDevice9_GetVertexShaderConstantF( struct NineDevice9 *This,
		3157	UINT StartRegister,
		3158	float *pConstantData,
		3159	UINT Vector4fCount )
		3160	{
		3161	const struct nine_state *state = &This->state;
		3162
		3163	user_assert(StartRegister < This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
		3164	user_assert(StartRegister + Vector4fCount <= This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
		3165	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3166
		3167	memcpy(pConstantData,
		3168	&state->vs_const_f[StartRegister * 4],
		3169	Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
		3170
		3171	return D3D_OK;
		3172	}
		3173
		3174	HRESULT WINAPI
		3175	NineDevice9_SetVertexShaderConstantI( struct NineDevice9 *This,
		3176	UINT StartRegister,
		3177	const int *pConstantData,
		3178	UINT Vector4iCount )
		3179	{
		3180	struct nine_state *state = This->update;
		3181	int i;
		3182
		3183	DBG("This=%p StartRegister=%u pConstantData=%p Vector4iCount=%u\n",
		3184	This, StartRegister, pConstantData, Vector4iCount);
		3185
		3186	user_assert(StartRegister < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3187	user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3188	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3189
		3190	if (This->driver_caps.vs_integer) {
		3191	memcpy(&state->vs_const_i[StartRegister][0],
		3192	pConstantData,
		3193	Vector4iCount * sizeof(state->vs_const_i[0]));
		3194	} else {
		3195	for (i = 0; i < Vector4iCount; i++) {
		3196	state->vs_const_i[StartRegister+i][0] = fui((float)(pConstantData[4*i]));
		3197	state->vs_const_i[StartRegister+i][1] = fui((float)(pConstantData[4*i+1]));
		3198	state->vs_const_i[StartRegister+i][2] = fui((float)(pConstantData[4*i+2]));
		3199	state->vs_const_i[StartRegister+i][3] = fui((float)(pConstantData[4*i+3]));
		3200	}
		3201	}
		3202
		3203	state->changed.vs_const_i \|= ((1 << Vector4iCount) - 1) << StartRegister;
		3204	state->changed.group \|= NINE_STATE_VS_CONST;
		3205
		3206	return D3D_OK;
		3207	}
		3208
		3209	HRESULT WINAPI
		3210	NineDevice9_GetVertexShaderConstantI( struct NineDevice9 *This,
		3211	UINT StartRegister,
		3212	int *pConstantData,
		3213	UINT Vector4iCount )
		3214	{
		3215	const struct nine_state *state = &This->state;
		3216	int i;
		3217
		3218	user_assert(StartRegister < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3219	user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3220	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3221
		3222	if (This->driver_caps.vs_integer) {
		3223	memcpy(pConstantData,
		3224	&state->vs_const_i[StartRegister][0],
		3225	Vector4iCount * sizeof(state->vs_const_i[0]));
		3226	} else {
		3227	for (i = 0; i < Vector4iCount; i++) {
		3228	pConstantData[4*i] = (int32_t) uif(state->vs_const_i[StartRegister+i][0]);
		3229	pConstantData[4*i+1] = (int32_t) uif(state->vs_const_i[StartRegister+i][1]);
		3230	pConstantData[4*i+2] = (int32_t) uif(state->vs_const_i[StartRegister+i][2]);
		3231	pConstantData[4*i+3] = (int32_t) uif(state->vs_const_i[StartRegister+i][3]);
		3232	}
		3233	}
		3234
		3235	return D3D_OK;
		3236	}
		3237
		3238	HRESULT WINAPI
		3239	NineDevice9_SetVertexShaderConstantB( struct NineDevice9 *This,
		3240	UINT StartRegister,
		3241	const BOOL *pConstantData,
		3242	UINT BoolCount )
		3243	{
		3244	struct nine_state *state = This->update;
		3245	int i;
		3246	uint32_t bool_true = This->driver_caps.vs_integer ? 0xFFFFFFFF : fui(1.0f);
		3247
		3248	DBG("This=%p StartRegister=%u pConstantData=%p BoolCount=%u\n",
		3249	This, StartRegister, pConstantData, BoolCount);
		3250
		3251	user_assert(StartRegister < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3252	user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3253	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3254
		3255	for (i = 0; i < BoolCount; i++)
		3256	state->vs_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
		3257
		3258	state->changed.vs_const_b \|= ((1 << BoolCount) - 1) << StartRegister;
		3259	state->changed.group \|= NINE_STATE_VS_CONST;
		3260
		3261	return D3D_OK;
		3262	}
		3263
		3264	HRESULT WINAPI
		3265	NineDevice9_GetVertexShaderConstantB( struct NineDevice9 *This,
		3266	UINT StartRegister,
		3267	BOOL *pConstantData,
		3268	UINT BoolCount )
		3269	{
		3270	const struct nine_state *state = &This->state;
		3271	int i;
		3272
		3273	user_assert(StartRegister < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3274	user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3275	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3276
		3277	for (i = 0; i < BoolCount; i++)
		3278	pConstantData[i] = state->vs_const_b[StartRegister + i] != 0 ? TRUE : FALSE;
		3279
		3280	return D3D_OK;
		3281	}
		3282
		3283	HRESULT WINAPI
		3284	NineDevice9_SetStreamSource( struct NineDevice9 *This,
		3285	UINT StreamNumber,
		3286	IDirect3DVertexBuffer9 *pStreamData,
		3287	UINT OffsetInBytes,
		3288	UINT Stride )
		3289	{
		3290	struct nine_state *state = This->update;
		3291	struct NineVertexBuffer9 *pVBuf9 = NineVertexBuffer9(pStreamData);
		3292	const unsigned i = StreamNumber;
		3293
		3294	DBG("This=%p StreamNumber=%u pStreamData=%p OffsetInBytes=%u Stride=%u\n",
		3295	This, StreamNumber, pStreamData, OffsetInBytes, Stride);
		3296
		3297	user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
		3298	user_assert(Stride <= This->caps.MaxStreamStride, D3DERR_INVALIDCALL);
		3299
		3300	if (likely(!This->is_recording)) {
		3301	if (state->stream[i] == NineVertexBuffer9(pStreamData) &&
		3302	state->vtxbuf[i].stride == Stride &&
		3303	state->vtxbuf[i].buffer_offset == OffsetInBytes)
		3304	return D3D_OK;
		3305	}
		3306	nine_bind(&state->stream[i], pStreamData);
		3307
		3308	state->changed.vtxbuf \|= 1 << StreamNumber;
		3309
		3310	if (pStreamData) {
		3311	state->vtxbuf[i].stride = Stride;
		3312	state->vtxbuf[i].buffer_offset = OffsetInBytes;
		3313	}
		3314	state->vtxbuf[i].buffer = pStreamData ? pVBuf9->base.resource : NULL;
		3315
		3316	return D3D_OK;
		3317	}
		3318
		3319	HRESULT WINAPI
		3320	NineDevice9_GetStreamSource( struct NineDevice9 *This,
		3321	UINT StreamNumber,
		3322	IDirect3DVertexBuffer9 **ppStreamData,
		3323	UINT *pOffsetInBytes,
		3324	UINT *pStride )
		3325	{
		3326	const struct nine_state *state = &This->state;
		3327	const unsigned i = StreamNumber;
		3328
		3329	user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
		3330	user_assert(ppStreamData, D3DERR_INVALIDCALL);
		3331
		3332	nine_reference_set(ppStreamData, state->stream[i]);
		3333	*pStride = state->vtxbuf[i].stride;
		3334	*pOffsetInBytes = state->vtxbuf[i].buffer_offset;
		3335
		3336	return D3D_OK;
		3337	}
		3338
		3339	HRESULT WINAPI
		3340	NineDevice9_SetStreamSourceFreq( struct NineDevice9 *This,
		3341	UINT StreamNumber,
		3342	UINT Setting )
		3343	{
		3344	struct nine_state *state = This->update;
		3345	/* const UINT freq = Setting & 0x7FFFFF; */
		3346
		3347	DBG("This=%p StreamNumber=%u FrequencyParameter=0x%x\n", This,
		3348	StreamNumber, Setting);
		3349
		3350	user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
		3351	user_assert(StreamNumber != 0 \|\| !(Setting & D3DSTREAMSOURCE_INSTANCEDATA),
		3352	D3DERR_INVALIDCALL);
		3353	user_assert(!((Setting & D3DSTREAMSOURCE_INSTANCEDATA) &&
		3354	(Setting & D3DSTREAMSOURCE_INDEXEDDATA)), D3DERR_INVALIDCALL);
		3355	user_assert(Setting, D3DERR_INVALIDCALL);
		3356
		3357	state->stream_freq[StreamNumber] = Setting;
		3358
		3359	if (Setting & D3DSTREAMSOURCE_INSTANCEDATA)
		3360	state->stream_instancedata_mask \|= 1 << StreamNumber;
		3361	else
		3362	state->stream_instancedata_mask &= ~(1 << StreamNumber);
		3363
		3364	state->changed.stream_freq \|= 1 << StreamNumber;
		3365	return D3D_OK;
		3366	}
		3367
		3368	HRESULT WINAPI
		3369	NineDevice9_GetStreamSourceFreq( struct NineDevice9 *This,
		3370	UINT StreamNumber,
		3371	UINT *pSetting )
		3372	{
		3373	user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
		3374	*pSetting = This->state.stream_freq[StreamNumber];
		3375	return D3D_OK;
		3376	}
		3377
		3378	HRESULT WINAPI
		3379	NineDevice9_SetIndices( struct NineDevice9 *This,
		3380	IDirect3DIndexBuffer9 *pIndexData )
		3381	{
		3382	struct nine_state *state = This->update;
		3383
		3384	DBG("This=%p pIndexData=%p\n", This, pIndexData);
		3385
		3386	if (likely(!This->is_recording))
		3387	if (state->idxbuf == NineIndexBuffer9(pIndexData))
		3388	return D3D_OK;
		3389	nine_bind(&state->idxbuf, pIndexData);
		3390
		3391	state->changed.group \|= NINE_STATE_IDXBUF;
		3392
		3393	return D3D_OK;
		3394	}
		3395
		3396	/* XXX: wine/d3d9 doesn't have pBaseVertexIndex, and it doesn't make sense
		3397	* here because it's an argument passed to the Draw calls.
		3398	*/
		3399	HRESULT WINAPI
		3400	NineDevice9_GetIndices( struct NineDevice9 *This,
		3401	IDirect3DIndexBuffer9 *ppIndexData /,
		3402	UINT pBaseVertexIndex / )
		3403	{
		3404	user_assert(ppIndexData, D3DERR_INVALIDCALL);
		3405	nine_reference_set(ppIndexData, This->state.idxbuf);
		3406	return D3D_OK;
		3407	}
		3408
		3409	HRESULT WINAPI
		3410	NineDevice9_CreatePixelShader( struct NineDevice9 *This,
		3411	const DWORD *pFunction,
		3412	IDirect3DPixelShader9 **ppShader )
		3413	{
		3414	struct NinePixelShader9 *ps;
		3415	HRESULT hr;
		3416
		3417	DBG("This=%p pFunction=%p ppShader=%p\n", This, pFunction, ppShader);
		3418
		3419	hr = NinePixelShader9_new(This, &ps, pFunction, NULL);
		3420	if (FAILED(hr))
		3421	return hr;
		3422	ppShader = (IDirect3DPixelShader9 )ps;
		3423	return D3D_OK;
		3424	}
		3425
		3426	HRESULT WINAPI
		3427	NineDevice9_SetPixelShader( struct NineDevice9 *This,
		3428	IDirect3DPixelShader9 *pShader )
		3429	{
		3430	struct nine_state *state = This->update;
		3431	unsigned old_mask = state->ps ? state->ps->rt_mask : 1;
		3432	unsigned mask;
		3433
		3434	DBG("This=%p pShader=%p\n", This, pShader);
		3435
		3436	nine_bind(&state->ps, pShader);
		3437
		3438	state->changed.group \|= NINE_STATE_PS;
		3439
		3440	mask = state->ps ? state->ps->rt_mask : 1;
		3441	/* We need to update cbufs if the pixel shader would
		3442	* write to different render targets */
		3443	if (mask != old_mask)
		3444	state->changed.group \|= NINE_STATE_FB;
		3445
		3446	return D3D_OK;
		3447	}
		3448
		3449	HRESULT WINAPI
		3450	NineDevice9_GetPixelShader( struct NineDevice9 *This,
		3451	IDirect3DPixelShader9 **ppShader )
		3452	{
		3453	user_assert(ppShader, D3DERR_INVALIDCALL);
		3454	nine_reference_set(ppShader, This->state.ps);
		3455	return D3D_OK;
		3456	}
		3457
		3458	HRESULT WINAPI
		3459	NineDevice9_SetPixelShaderConstantF( struct NineDevice9 *This,
		3460	UINT StartRegister,
		3461	const float *pConstantData,
		3462	UINT Vector4fCount )
		3463	{
		3464	struct nine_state *state = This->update;
		3465
		3466	DBG("This=%p StartRegister=%u pConstantData=%p Vector4fCount=%u\n",
		3467	This, StartRegister, pConstantData, Vector4fCount);
		3468
		3469	user_assert(StartRegister < NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
		3470	user_assert(StartRegister + Vector4fCount <= NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
		3471
		3472	if (!Vector4fCount)
		3473	return D3D_OK;
		3474	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3475
		3476	memcpy(&state->ps_const_f[StartRegister * 4],
		3477	pConstantData,
		3478	Vector4fCount * 4 * sizeof(state->ps_const_f[0]));
		3479
		3480	nine_ranges_insert(&state->changed.ps_const_f,
		3481	StartRegister, StartRegister + Vector4fCount,
		3482	&This->range_pool);
		3483
		3484	state->changed.group \|= NINE_STATE_PS_CONST;
		3485
		3486	return D3D_OK;
		3487	}
		3488
		3489	HRESULT WINAPI
		3490	NineDevice9_GetPixelShaderConstantF( struct NineDevice9 *This,
		3491	UINT StartRegister,
		3492	float *pConstantData,
		3493	UINT Vector4fCount )
		3494	{
		3495	const struct nine_state *state = &This->state;
		3496
		3497	user_assert(StartRegister < NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
		3498	user_assert(StartRegister + Vector4fCount <= NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
		3499	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3500
		3501	memcpy(pConstantData,
		3502	&state->ps_const_f[StartRegister * 4],
		3503	Vector4fCount * 4 * sizeof(state->ps_const_f[0]));
		3504
		3505	return D3D_OK;
		3506	}
		3507
		3508	HRESULT WINAPI
		3509	NineDevice9_SetPixelShaderConstantI( struct NineDevice9 *This,
		3510	UINT StartRegister,
		3511	const int *pConstantData,
		3512	UINT Vector4iCount )
		3513	{
		3514	struct nine_state *state = This->update;
		3515	int i;
		3516
		3517	DBG("This=%p StartRegister=%u pConstantData=%p Vector4iCount=%u\n",
		3518	This, StartRegister, pConstantData, Vector4iCount);
		3519
		3520	user_assert(StartRegister < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3521	user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3522	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3523
		3524	if (This->driver_caps.ps_integer) {
		3525	memcpy(&state->ps_const_i[StartRegister][0],
		3526	pConstantData,
		3527	Vector4iCount * sizeof(state->ps_const_i[0]));
		3528	} else {
		3529	for (i = 0; i < Vector4iCount; i++) {
		3530	state->ps_const_i[StartRegister+i][0] = fui((float)(pConstantData[4*i]));
		3531	state->ps_const_i[StartRegister+i][1] = fui((float)(pConstantData[4*i+1]));
		3532	state->ps_const_i[StartRegister+i][2] = fui((float)(pConstantData[4*i+2]));
		3533	state->ps_const_i[StartRegister+i][3] = fui((float)(pConstantData[4*i+3]));
		3534	}
		3535	}
		3536	state->changed.ps_const_i \|= ((1 << Vector4iCount) - 1) << StartRegister;
		3537	state->changed.group \|= NINE_STATE_PS_CONST;
		3538
		3539	return D3D_OK;
		3540	}
		3541
		3542	HRESULT WINAPI
		3543	NineDevice9_GetPixelShaderConstantI( struct NineDevice9 *This,
		3544	UINT StartRegister,
		3545	int *pConstantData,
		3546	UINT Vector4iCount )
		3547	{
		3548	const struct nine_state *state = &This->state;
		3549	int i;
		3550
		3551	user_assert(StartRegister < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3552	user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
		3553	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3554
		3555	if (This->driver_caps.ps_integer) {
		3556	memcpy(pConstantData,
		3557	&state->ps_const_i[StartRegister][0],
		3558	Vector4iCount * sizeof(state->ps_const_i[0]));
		3559	} else {
		3560	for (i = 0; i < Vector4iCount; i++) {
		3561	pConstantData[4*i] = (int32_t) uif(state->ps_const_i[StartRegister+i][0]);
		3562	pConstantData[4*i+1] = (int32_t) uif(state->ps_const_i[StartRegister+i][1]);
		3563	pConstantData[4*i+2] = (int32_t) uif(state->ps_const_i[StartRegister+i][2]);
		3564	pConstantData[4*i+3] = (int32_t) uif(state->ps_const_i[StartRegister+i][3]);
		3565	}
		3566	}
		3567
		3568	return D3D_OK;
		3569	}
		3570
		3571	HRESULT WINAPI
		3572	NineDevice9_SetPixelShaderConstantB( struct NineDevice9 *This,
		3573	UINT StartRegister,
		3574	const BOOL *pConstantData,
		3575	UINT BoolCount )
		3576	{
		3577	struct nine_state *state = This->update;
		3578	int i;
		3579	uint32_t bool_true = This->driver_caps.ps_integer ? 0xFFFFFFFF : fui(1.0f);
		3580
		3581	DBG("This=%p StartRegister=%u pConstantData=%p BoolCount=%u\n",
		3582	This, StartRegister, pConstantData, BoolCount);
		3583
		3584	user_assert(StartRegister < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3585	user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3586	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3587
		3588	for (i = 0; i < BoolCount; i++)
		3589	state->ps_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
		3590
		3591	state->changed.ps_const_b \|= ((1 << BoolCount) - 1) << StartRegister;
		3592	state->changed.group \|= NINE_STATE_PS_CONST;
		3593
		3594	return D3D_OK;
		3595	}
		3596
		3597	HRESULT WINAPI
		3598	NineDevice9_GetPixelShaderConstantB( struct NineDevice9 *This,
		3599	UINT StartRegister,
		3600	BOOL *pConstantData,
		3601	UINT BoolCount )
		3602	{
		3603	const struct nine_state *state = &This->state;
		3604	int i;
		3605
		3606	user_assert(StartRegister < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3607	user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
		3608	user_assert(pConstantData, D3DERR_INVALIDCALL);
		3609
		3610	for (i = 0; i < BoolCount; i++)
		3611	pConstantData[i] = state->ps_const_b[StartRegister + i] ? TRUE : FALSE;
		3612
		3613	return D3D_OK;
		3614	}
		3615
		3616	HRESULT WINAPI
		3617	NineDevice9_DrawRectPatch( struct NineDevice9 *This,
		3618	UINT Handle,
		3619	const float *pNumSegs,
		3620	const D3DRECTPATCH_INFO *pRectPatchInfo )
		3621	{
		3622	STUB(D3DERR_INVALIDCALL);
		3623	}
		3624
		3625	HRESULT WINAPI
		3626	NineDevice9_DrawTriPatch( struct NineDevice9 *This,
		3627	UINT Handle,
		3628	const float *pNumSegs,
		3629	const D3DTRIPATCH_INFO *pTriPatchInfo )
		3630	{
		3631	STUB(D3DERR_INVALIDCALL);
		3632	}
		3633
		3634	HRESULT WINAPI
		3635	NineDevice9_DeletePatch( struct NineDevice9 *This,
		3636	UINT Handle )
		3637	{
		3638	STUB(D3DERR_INVALIDCALL);
		3639	}
		3640
		3641	HRESULT WINAPI
		3642	NineDevice9_CreateQuery( struct NineDevice9 *This,
		3643	D3DQUERYTYPE Type,
		3644	IDirect3DQuery9 **ppQuery )
		3645	{
		3646	struct NineQuery9 *query;
		3647	HRESULT hr;
		3648
		3649	DBG("This=%p Type=%d ppQuery=%p\n", This, Type, ppQuery);
		3650
		3651	hr = nine_is_query_supported(This->screen, Type);
		3652	if (!ppQuery \|\| hr != D3D_OK)
		3653	return hr;
		3654
		3655	hr = NineQuery9_new(This, &query, Type);
		3656	if (FAILED(hr))
		3657	return hr;
		3658	ppQuery = (IDirect3DQuery9 )query;
		3659	return D3D_OK;
		3660	}
		3661
		3662	IDirect3DDevice9Vtbl NineDevice9_vtable = {
		3663	(void *)NineUnknown_QueryInterface,
		3664	(void *)NineUnknown_AddRef,
		3665	(void *)NineUnknown_Release,
		3666	(void *)NineDevice9_TestCooperativeLevel,
		3667	(void *)NineDevice9_GetAvailableTextureMem,
		3668	(void *)NineDevice9_EvictManagedResources,
		3669	(void *)NineDevice9_GetDirect3D,
		3670	(void *)NineDevice9_GetDeviceCaps,
		3671	(void *)NineDevice9_GetDisplayMode,
		3672	(void *)NineDevice9_GetCreationParameters,
		3673	(void *)NineDevice9_SetCursorProperties,
		3674	(void *)NineDevice9_SetCursorPosition,
		3675	(void *)NineDevice9_ShowCursor,
		3676	(void *)NineDevice9_CreateAdditionalSwapChain,
		3677	(void *)NineDevice9_GetSwapChain,
		3678	(void *)NineDevice9_GetNumberOfSwapChains,
		3679	(void *)NineDevice9_Reset,
		3680	(void *)NineDevice9_Present,
		3681	(void *)NineDevice9_GetBackBuffer,
		3682	(void *)NineDevice9_GetRasterStatus,
		3683	(void *)NineDevice9_SetDialogBoxMode,
		3684	(void *)NineDevice9_SetGammaRamp,
		3685	(void *)NineDevice9_GetGammaRamp,
		3686	(void *)NineDevice9_CreateTexture,
		3687	(void *)NineDevice9_CreateVolumeTexture,
		3688	(void *)NineDevice9_CreateCubeTexture,
		3689	(void *)NineDevice9_CreateVertexBuffer,
		3690	(void *)NineDevice9_CreateIndexBuffer,
		3691	(void *)NineDevice9_CreateRenderTarget,
		3692	(void *)NineDevice9_CreateDepthStencilSurface,
		3693	(void *)NineDevice9_UpdateSurface,
		3694	(void *)NineDevice9_UpdateTexture,
		3695	(void *)NineDevice9_GetRenderTargetData,
		3696	(void *)NineDevice9_GetFrontBufferData,
		3697	(void *)NineDevice9_StretchRect,
		3698	(void *)NineDevice9_ColorFill,
		3699	(void *)NineDevice9_CreateOffscreenPlainSurface,
		3700	(void *)NineDevice9_SetRenderTarget,
		3701	(void *)NineDevice9_GetRenderTarget,
		3702	(void *)NineDevice9_SetDepthStencilSurface,
		3703	(void *)NineDevice9_GetDepthStencilSurface,
		3704	(void *)NineDevice9_BeginScene,
		3705	(void *)NineDevice9_EndScene,
		3706	(void *)NineDevice9_Clear,
		3707	(void *)NineDevice9_SetTransform,
		3708	(void *)NineDevice9_GetTransform,
		3709	(void *)NineDevice9_MultiplyTransform,
		3710	(void *)NineDevice9_SetViewport,
		3711	(void *)NineDevice9_GetViewport,
		3712	(void *)NineDevice9_SetMaterial,
		3713	(void *)NineDevice9_GetMaterial,
		3714	(void *)NineDevice9_SetLight,
		3715	(void *)NineDevice9_GetLight,
		3716	(void *)NineDevice9_LightEnable,
		3717	(void *)NineDevice9_GetLightEnable,
		3718	(void *)NineDevice9_SetClipPlane,
		3719	(void *)NineDevice9_GetClipPlane,
		3720	(void *)NineDevice9_SetRenderState,
		3721	(void *)NineDevice9_GetRenderState,
		3722	(void *)NineDevice9_CreateStateBlock,
		3723	(void *)NineDevice9_BeginStateBlock,
		3724	(void *)NineDevice9_EndStateBlock,
		3725	(void *)NineDevice9_SetClipStatus,
		3726	(void *)NineDevice9_GetClipStatus,
		3727	(void *)NineDevice9_GetTexture,
		3728	(void *)NineDevice9_SetTexture,
		3729	(void *)NineDevice9_GetTextureStageState,
		3730	(void *)NineDevice9_SetTextureStageState,
		3731	(void *)NineDevice9_GetSamplerState,
		3732	(void *)NineDevice9_SetSamplerState,
		3733	(void *)NineDevice9_ValidateDevice,
		3734	(void *)NineDevice9_SetPaletteEntries,
		3735	(void *)NineDevice9_GetPaletteEntries,
		3736	(void *)NineDevice9_SetCurrentTexturePalette,
		3737	(void *)NineDevice9_GetCurrentTexturePalette,
		3738	(void *)NineDevice9_SetScissorRect,
		3739	(void *)NineDevice9_GetScissorRect,
		3740	(void *)NineDevice9_SetSoftwareVertexProcessing,
		3741	(void *)NineDevice9_GetSoftwareVertexProcessing,
		3742	(void *)NineDevice9_SetNPatchMode,
		3743	(void *)NineDevice9_GetNPatchMode,
		3744	(void *)NineDevice9_DrawPrimitive,
		3745	(void *)NineDevice9_DrawIndexedPrimitive,
		3746	(void *)NineDevice9_DrawPrimitiveUP,
		3747	(void *)NineDevice9_DrawIndexedPrimitiveUP,
		3748	(void *)NineDevice9_ProcessVertices,
		3749	(void *)NineDevice9_CreateVertexDeclaration,
		3750	(void *)NineDevice9_SetVertexDeclaration,
		3751	(void *)NineDevice9_GetVertexDeclaration,
		3752	(void *)NineDevice9_SetFVF,
		3753	(void *)NineDevice9_GetFVF,
		3754	(void *)NineDevice9_CreateVertexShader,
		3755	(void *)NineDevice9_SetVertexShader,
		3756	(void *)NineDevice9_GetVertexShader,
		3757	(void *)NineDevice9_SetVertexShaderConstantF,
		3758	(void *)NineDevice9_GetVertexShaderConstantF,
		3759	(void *)NineDevice9_SetVertexShaderConstantI,
		3760	(void *)NineDevice9_GetVertexShaderConstantI,
		3761	(void *)NineDevice9_SetVertexShaderConstantB,
		3762	(void *)NineDevice9_GetVertexShaderConstantB,
		3763	(void *)NineDevice9_SetStreamSource,
		3764	(void *)NineDevice9_GetStreamSource,
		3765	(void *)NineDevice9_SetStreamSourceFreq,
		3766	(void *)NineDevice9_GetStreamSourceFreq,
		3767	(void *)NineDevice9_SetIndices,
		3768	(void *)NineDevice9_GetIndices,
		3769	(void *)NineDevice9_CreatePixelShader,
		3770	(void *)NineDevice9_SetPixelShader,
		3771	(void *)NineDevice9_GetPixelShader,
		3772	(void *)NineDevice9_SetPixelShaderConstantF,
		3773	(void *)NineDevice9_GetPixelShaderConstantF,
		3774	(void *)NineDevice9_SetPixelShaderConstantI,
		3775	(void *)NineDevice9_GetPixelShaderConstantI,
		3776	(void *)NineDevice9_SetPixelShaderConstantB,
		3777	(void *)NineDevice9_GetPixelShaderConstantB,
		3778	(void *)NineDevice9_DrawRectPatch,
		3779	(void *)NineDevice9_DrawTriPatch,
		3780	(void *)NineDevice9_DeletePatch,
		3781	(void *)NineDevice9_CreateQuery
		3782	};
		3783
		3784	static const GUID *NineDevice9_IIDs[] = {
		3785	&IID_IDirect3DDevice9,
		3786	&IID_IUnknown,
		3787	NULL
		3788	};
		3789
		3790	HRESULT
		3791	NineDevice9_new( struct pipe_screen *pScreen,
		3792	D3DDEVICE_CREATION_PARAMETERS *pCreationParameters,
		3793	D3DCAPS9 *pCaps,
		3794	D3DPRESENT_PARAMETERS *pPresentationParameters,
		3795	IDirect3D9 *pD3D9,
		3796	ID3DPresentGroup *pPresentationGroup,
		3797	struct d3dadapter9_context *pCTX,
		3798	boolean ex,
		3799	D3DDISPLAYMODEEX *pFullscreenDisplayMode,
		3800	struct NineDevice9 **ppOut )
		3801	{
		3802	BOOL lock;
		3803	lock = !!(pCreationParameters->BehaviorFlags & D3DCREATE_MULTITHREADED);
		3804
		3805	NINE_NEW(Device9, ppOut, lock, /* args */
		3806	pScreen, pCreationParameters, pCaps,
		3807	pPresentationParameters, pD3D9, pPresentationGroup, pCTX,
		3808	ex, pFullscreenDisplayMode);
		3809	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/state_trackers/nine/device9.c – Rev 5564