surface_gdi.c@ 41283

Last change on this file since 41283 was 40388, checked in by vboxsync, 13 years ago
wddm/3d: shared resource destroy handling fixes
Property svn:eol-style set to `native`
File size: 23.8 KB

Line
1	/*
2	* 2D Surface implementation without OpenGL
3	*
4	* Copyright 1997-2000 Marcus Meissner
5	* Copyright 1998-2000 Lionel Ulmer
6	* Copyright 2000-2001 TransGaming Technologies Inc.
7	* Copyright 2002-2005 Jason Edmeades
8	* Copyright 2002-2003 Raphael Junqueira
9	* Copyright 2004 Christian Costa
10	* Copyright 2005 Oliver Stieber
11	* Copyright 2006-2008 Stefan Dösinger
12	*
13	* This library is free software; you can redistribute it and/or
14	* modify it under the terms of the GNU Lesser General Public
15	* License as published by the Free Software Foundation; either
16	* version 2.1 of the License, or (at your option) any later version.
17	*
18	* This library is distributed in the hope that it will be useful,
19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21	* Lesser General Public License for more details.
22	*
23	* You should have received a copy of the GNU Lesser General Public
24	* License along with this library; if not, write to the Free Software
25	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26	*/
27
28	/*
29	* Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
30	* other than GPL or LGPL is available it will apply instead, Oracle elects to use only
31	* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
32	* a choice of LGPL license versions is made available with the language indicating
33	* that LGPLv2 or any later version may be used, or where a choice of which version
34	* of the LGPL is applied is otherwise unspecified.
35	*/
36
37	#include "config.h"
38	#include "wine/port.h"
39	#include "wined3d_private.h"
40
41	#include <stdio.h>
42
43	/* Use the d3d_surface debug channel to have one channel for all surfaces */
44	WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
45
46	void surface_gdi_cleanup(IWineD3DSurfaceImpl *This)
47	{
48	TRACE("(%p) : Cleaning up.\n", This);
49
50	if (This->Flags & SFLAG_DIBSECTION)
51	{
52	/* Release the DC. */
53	SelectObject(This->hDC, This->dib.holdbitmap);
54	DeleteDC(This->hDC);
55	/* Release the DIB section. */
56	DeleteObject(This->dib.DIBsection);
57	This->dib.bitmap_data = NULL;
58	This->resource.allocatedMemory = NULL;
59	}
60
61	if (This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem((IWineD3DSurface *)This, NULL);
62	if (This->overlay_dest) list_remove(&This->overlay_entry);
63
64	HeapFree(GetProcessHeap(), 0, This->palette9);
65
66	resource_cleanup((IWineD3DResource *)This);
67	}
68
69	/*****************************************************************************
70	* IWineD3DSurface::Release, GDI version
71	*
72	* In general a normal COM Release method, but the GDI version doesn't have
73	* to destroy all the GL things.
74	*
75	*****************************************************************************/
76	static ULONG WINAPI IWineGDISurfaceImpl_Release(IWineD3DSurface *iface) {
77	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
78	ULONG ref = InterlockedDecrement(&This->resource.ref);
79	TRACE("(%p) : Releasing from %d\n", This, ref + 1);
80
81	if (!ref)
82	{
83	surface_gdi_cleanup(This);
84
85	TRACE("(%p) Released.\n", This);
86	HeapFree(GetProcessHeap(), 0, This);
87	}
88
89	return ref;
90	}
91
92	/*****************************************************************************
93	* IWineD3DSurface::PreLoad, GDI version
94	*
95	* This call is unsupported on GDI surfaces, if it's called something went
96	* wrong in the parent library. Write an informative warning
97	*
98	*****************************************************************************/
99	static void WINAPI
100	IWineGDISurfaceImpl_PreLoad(IWineD3DSurface *iface)
101	{
102	ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface);
103	ERR("(%p): Most likely the parent library did something wrong.\n", iface);
104	ERR("(%p): Please report to wine-devel\n", iface);
105	}
106
107	/*****************************************************************************
108	* IWineD3DSurface::UnLoad, GDI version
109	*
110	* This call is unsupported on GDI surfaces, if it's called something went
111	* wrong in the parent library. Write an informative warning.
112	*
113	*****************************************************************************/
114	static void WINAPI IWineGDISurfaceImpl_UnLoad(IWineD3DSurface *iface)
115	{
116	ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface);
117	ERR("(%p): Most likely the parent library did something wrong.\n", iface);
118	ERR("(%p): Please report to wine-devel\n", iface);
119	}
120
121	/*****************************************************************************
122	* IWineD3DSurface::LockRect, GDI version
123	*
124	* Locks the surface and returns a pointer to the surface memory
125	*
126	* Params:
127	* pLockedRect: Address to return the locking info at
128	* pRect: Rectangle to lock
129	* Flags: Some flags
130	*
131	* Returns:
132	* WINED3D_OK on success
133	* WINED3DERR_INVALIDCALL on errors
134	*
135	*****************************************************************************/
136	static HRESULT WINAPI
137	IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface,
138	WINED3DLOCKED_RECT* pLockedRect,
139	CONST RECT* pRect,
140	DWORD Flags)
141	{
142	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
143
144	/* Already locked? */
145	if(This->Flags & SFLAG_LOCKED)
146	{
147	WARN("(%p) Surface already locked\n", This);
148	/* What should I return here? */
149	return WINED3DERR_INVALIDCALL;
150	}
151	This->Flags \|= SFLAG_LOCKED;
152
153	if(!This->resource.allocatedMemory) {
154	/* This happens on gdi surfaces if the application set a user pointer and resets it.
155	* Recreate the DIB section
156	*/
157	IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
158	This->resource.allocatedMemory = This->dib.bitmap_data;
159	}
160
161	return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
162	}
163
164	/*****************************************************************************
165	* IWineD3DSurface::UnlockRect, GDI version
166	*
167	* Unlocks a surface. This implementation doesn't do much, except updating
168	* the window if the front buffer is unlocked
169	*
170	* Returns:
171	* WINED3D_OK on success
172	* WINED3DERR_INVALIDCALL on failure
173	*
174	*****************************************************************************/
175	static HRESULT WINAPI
176	IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface)
177	{
178	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
179	IWineD3DSwapChainImpl *swapchain = NULL;
180	TRACE("(%p)\n", This);
181
182	if (!(This->Flags & SFLAG_LOCKED))
183	{
184	WARN("trying to Unlock an unlocked surf@%p\n", This);
185	return WINEDDERR_NOTLOCKED;
186	}
187
188	/* Can be useful for debugging */
189	#if 0
190	{
191	static unsigned int gen = 0;
192	char buffer[4096];
193	++gen;
194	if ((gen % 10) == 0) {
195	snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm",
196	This, This->texture_target, This->texture_level, gen);
197	IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
198	}
199	/*
200	* debugging crash code
201	if (gen == 250) {
202	void** test = NULL;
203	*test = 0;
204	}
205	*/
206	}
207	#endif
208
209	/* Tell the swapchain to update the screen */
210	if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
211	{
212	if(iface == swapchain->frontBuffer)
213	{
214	x11_copy_to_screen(swapchain, &This->lockedRect);
215	}
216	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
217	}
218
219	This->Flags &= ~SFLAG_LOCKED;
220	memset(&This->lockedRect, 0, sizeof(RECT));
221	return WINED3D_OK;
222	}
223
224	/*****************************************************************************
225	* IWineD3DSurface::Flip, GDI version
226	*
227	* Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
228	* the parent library. This implementation changes the data pointers of the
229	* surfaces and copies the new front buffer content to the screen
230	*
231	* Params:
232	* override: Flipping target(e.g. back buffer)
233	*
234	* Returns:
235	* WINED3D_OK on success
236	*
237	*****************************************************************************/
238	static HRESULT WINAPI
239	IWineGDISurfaceImpl_Flip(IWineD3DSurface *iface,
240	IWineD3DSurface *override,
241	DWORD Flags)
242	{
243	IWineD3DSwapChainImpl *swapchain = NULL;
244	HRESULT hr;
245
246	if(FAILED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
247	{
248	ERR("Flipped surface is not on a swapchain\n");
249	return WINEDDERR_NOTFLIPPABLE;
250	}
251
252	hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *)swapchain,
253	NULL, NULL, swapchain->win_handle, NULL, 0);
254
255	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
256	return hr;
257	}
258
259	/*****************************************************************************
260	* IWineD3DSurface::LoadTexture, GDI version
261	*
262	* This is mutually unsupported by GDI surfaces
263	*
264	* Returns:
265	* D3DERR_INVALIDCALL
266	*
267	*****************************************************************************/
268	static HRESULT WINAPI
269	IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode)
270	{
271	ERR("Unsupported on X11 surfaces\n");
272	return WINED3DERR_INVALIDCALL;
273	}
274
275	/*****************************************************************************
276	* IWineD3DSurface::SaveSnapshot, GDI version
277	*
278	* This method writes the surface's contents to the in tga format to the
279	* file specified in filename.
280	*
281	* Params:
282	* filename: File to write to
283	*
284	* Returns:
285	* WINED3DERR_INVALIDCALL if the file couldn't be opened
286	* WINED3D_OK on success
287	*
288	*****************************************************************************/
289	static int get_shift(DWORD color_mask) {
290	int shift = 0;
291	while (color_mask > 0xFF) {
292	color_mask >>= 1;
293	shift += 1;
294	}
295	while ((color_mask & 0x80) == 0) {
296	color_mask <<= 1;
297	shift -= 1;
298	}
299	return shift;
300	}
301
302
303	static HRESULT WINAPI
304	IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface,
305	const char* filename)
306	{
307	FILE* f = NULL;
308	UINT y = 0, x = 0;
309	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
310	const struct wined3d_format_desc *format_desc = This->resource.format_desc;
311	static char *output = NULL;
312	static UINT size = 0;
313
314	if (This->pow2Width > size) {
315	output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3);
316	size = This->pow2Width;
317	}
318
319
320	f = fopen(filename, "w+");
321	if (NULL == f) {
322	ERR("opening of %s failed with\n", filename);
323	return WINED3DERR_INVALIDCALL;
324	}
325	fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height);
326
327	if (This->resource.format_desc->format == WINED3DFMT_P8_UINT)
328	{
329	unsigned char table[256][3];
330	int i;
331
332	if (This->palette == NULL) {
333	fclose(f);
334	return WINED3DERR_INVALIDCALL;
335	}
336	for (i = 0; i < 256; i++) {
337	table[i][0] = This->palette->palents[i].peRed;
338	table[i][1] = This->palette->palents[i].peGreen;
339	table[i][2] = This->palette->palents[i].peBlue;
340	}
341	for (y = 0; y < This->pow2Height; y++) {
342	unsigned char src = This->resource.allocatedMemory + (y 1 * IWineD3DSurface_GetPitch(iface));
343	for (x = 0; x < This->pow2Width; x++) {
344	unsigned char color = *src;
345	src += 1;
346
347	output[3 * x + 0] = table[color][0];
348	output[3 * x + 1] = table[color][1];
349	output[3 * x + 2] = table[color][2];
350	}
351	fwrite(output, 3 * This->pow2Width, 1, f);
352	}
353	} else {
354	int red_shift, green_shift, blue_shift, pix_width, alpha_shift;
355
356	pix_width = format_desc->byte_count;
357
358	red_shift = get_shift(format_desc->red_mask);
359	green_shift = get_shift(format_desc->green_mask);
360	blue_shift = get_shift(format_desc->blue_mask);
361	alpha_shift = get_shift(format_desc->alpha_mask);
362
363	for (y = 0; y < This->pow2Height; y++) {
364	const unsigned char src = This->resource.allocatedMemory + (y 1 * IWineD3DSurface_GetPitch(iface));
365	for (x = 0; x < This->pow2Width; x++) {
366	unsigned int color;
367	unsigned int comp;
368	int i;
369
370	color = 0;
371	for (i = 0; i < pix_width; i++) {
372	color \|= src[i] << (8 * i);
373	}
374	src += 1 * pix_width;
375
376	comp = color & format_desc->red_mask;
377	output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift;
378	comp = color & format_desc->green_mask;
379	output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift;
380	comp = color & format_desc->alpha_mask;
381	output[3 * x + 2] = alpha_shift > 0 ? comp >> alpha_shift : comp << -alpha_shift;
382	}
383	fwrite(output, 3 * This->pow2Width, 1, f);
384	}
385	}
386	fclose(f);
387	return WINED3D_OK;
388	}
389
390	static HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface iface, HDC pHDC) {
391	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
392	WINED3DLOCKED_RECT lock;
393	HRESULT hr;
394	RGBQUAD col[256];
395
396	TRACE("(%p)->(%p)\n",This,pHDC);
397
398	if(!(This->Flags & SFLAG_DIBSECTION))
399	{
400	WARN("DC not supported on this surface\n");
401	return WINED3DERR_INVALIDCALL;
402	}
403
404	if(This->Flags & SFLAG_USERPTR) {
405	ERR("Not supported on surfaces with an application-provided surfaces\n");
406	return WINEDDERR_NODC;
407	}
408
409	/* Give more detailed info for ddraw */
410	if (This->Flags & SFLAG_DCINUSE)
411	return WINEDDERR_DCALREADYCREATED;
412
413	/* Can't GetDC if the surface is locked */
414	if (This->Flags & SFLAG_LOCKED)
415	return WINED3DERR_INVALIDCALL;
416
417	memset(&lock, 0, sizeof(lock)); /* To be sure */
418
419	/* Should have a DIB section already */
420
421	/* Lock the surface */
422	hr = IWineD3DSurface_LockRect(iface,
423	&lock,
424	NULL,
425	0);
426	if(FAILED(hr)) {
427	ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
428	/* keep the dib section */
429	return hr;
430	}
431
432	if (This->resource.format_desc->format == WINED3DFMT_P8_UINT
433	\|\| This->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM)
434	{
435	unsigned int n;
436	const PALETTEENTRY *pal = NULL;
437
438	if(This->palette) {
439	pal = This->palette->palents;
440	} else {
441	IWineD3DSurfaceImpl *dds_primary;
442	IWineD3DSwapChainImpl *swapchain;
443	swapchain = (IWineD3DSwapChainImpl *)This->resource.device->swapchains[This->resource.device->NumberOfSwapChains-1];
444	dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
445	if (dds_primary && dds_primary->palette)
446	pal = dds_primary->palette->palents;
447	}
448
449	if (pal) {
450	for (n=0; n<256; n++) {
451	col[n].rgbRed = pal[n].peRed;
452	col[n].rgbGreen = pal[n].peGreen;
453	col[n].rgbBlue = pal[n].peBlue;
454	col[n].rgbReserved = 0;
455	}
456	SetDIBColorTable(This->hDC, 0, 256, col);
457	}
458	}
459
460	*pHDC = This->hDC;
461	TRACE("returning %p\n",*pHDC);
462	This->Flags \|= SFLAG_DCINUSE;
463
464	return WINED3D_OK;
465	}
466
467	static HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
468	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
469
470	TRACE("(%p)->(%p)\n",This,hDC);
471
472	if (!(This->Flags & SFLAG_DCINUSE))
473	return WINEDDERR_NODC;
474
475	if (This->hDC !=hDC) {
476	WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
477	return WINEDDERR_NODC;
478	}
479
480	/* we locked first, so unlock now */
481	IWineD3DSurface_UnlockRect(iface);
482
483	This->Flags &= ~SFLAG_DCINUSE;
484
485	return WINED3D_OK;
486	}
487
488	static HRESULT WINAPI IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface *iface) {
489	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl ) iface;
490	RGBQUAD col[256];
491	IWineD3DPaletteImpl *pal = This->palette;
492	unsigned int n;
493	IWineD3DSwapChainImpl *swapchain;
494	TRACE("(%p)\n", This);
495
496	if (!pal) return WINED3D_OK;
497
498	if(This->Flags & SFLAG_DIBSECTION) {
499	TRACE("(%p): Updating the hdc's palette\n", This);
500	for (n=0; n<256; n++) {
501	col[n].rgbRed = pal->palents[n].peRed;
502	col[n].rgbGreen = pal->palents[n].peGreen;
503	col[n].rgbBlue = pal->palents[n].peBlue;
504	col[n].rgbReserved = 0;
505	}
506	SetDIBColorTable(This->hDC, 0, 256, col);
507	}
508
509	/* Update the image because of the palette change. Some games like e.g Red Alert
510	call SetEntries a lot to implement fading. */
511	/* Tell the swapchain to update the screen */
512	if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
513	{
514	if(iface == swapchain->frontBuffer)
515	{
516	x11_copy_to_screen(swapchain, NULL);
517	}
518	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
519	}
520
521	return WINED3D_OK;
522	}
523
524	/*****************************************************************************
525	* IWineD3DSurface::PrivateSetup, GDI version
526	*
527	* Initializes the GDI surface, aka creates the DIB section we render to
528	* The DIB section creation is done by calling GetDC, which will create the
529	* section and releasing the dc to allow the app to use it. The dib section
530	* will stay until the surface is released
531	*
532	* GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
533	* are set to the real sizes to save memory. The NONPOW2 flag is unset to
534	* avoid confusion in the shared surface code.
535	*
536	* Returns:
537	* WINED3D_OK on success
538	* The return values of called methods on failure
539	*
540	*****************************************************************************/
541	static HRESULT WINAPI
542	IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface)
543	{
544	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl ) iface;
545	HRESULT hr;
546
547	if(This->resource.usage & WINED3DUSAGE_OVERLAY)
548	{
549	ERR("(%p) Overlays not yet supported by GDI surfaces\n", This);
550	return WINED3DERR_INVALIDCALL;
551	}
552
553	/* Sysmem textures have memory already allocated -
554	* release it, this avoids an unnecessary memcpy
555	*/
556	hr = IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
557	if(SUCCEEDED(hr))
558	{
559	HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
560	This->resource.heapMemory = NULL;
561	This->resource.allocatedMemory = This->dib.bitmap_data;
562	}
563
564	/* We don't mind the nonpow2 stuff in GDI */
565	This->pow2Width = This->currentDesc.Width;
566	This->pow2Height = This->currentDesc.Height;
567
568	return WINED3D_OK;
569	}
570
571	static HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface iface, void Mem) {
572	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl ) iface;
573
574	/* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
575	if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
576	ERR("Not supported on render targets\n");
577	return WINED3DERR_INVALIDCALL;
578	}
579
580	if(This->Flags & (SFLAG_LOCKED \| SFLAG_DCINUSE)) {
581	WARN("Surface is locked or the HDC is in use\n");
582	return WINED3DERR_INVALIDCALL;
583	}
584
585	if(Mem && Mem != This->resource.allocatedMemory) {
586	void *release = NULL;
587
588	/* Do I have to copy the old surface content? */
589	if(This->Flags & SFLAG_DIBSECTION) {
590	/* Release the DC. No need to hold the critical section for the update
591	* Thread because this thread runs only on front buffers, but this method
592	* fails for render targets in the check above.
593	*/
594	SelectObject(This->hDC, This->dib.holdbitmap);
595	DeleteDC(This->hDC);
596	/* Release the DIB section */
597	DeleteObject(This->dib.DIBsection);
598	This->dib.bitmap_data = NULL;
599	This->resource.allocatedMemory = NULL;
600	This->hDC = NULL;
601	This->Flags &= ~SFLAG_DIBSECTION;
602	} else if(!(This->Flags & SFLAG_USERPTR)) {
603	release = This->resource.allocatedMemory;
604	}
605	This->resource.allocatedMemory = Mem;
606	This->Flags \|= SFLAG_USERPTR \| SFLAG_INSYSMEM;
607
608	/* Now free the old memory if any */
609	HeapFree(GetProcessHeap(), 0, release);
610	} else if(This->Flags & SFLAG_USERPTR) {
611	/* LockRect and GetDC will re-create the dib section and allocated memory */
612	This->resource.allocatedMemory = NULL;
613	This->Flags &= ~SFLAG_USERPTR;
614	}
615	return WINED3D_OK;
616	}
617
618	/***************************
619	*
620	***************************/
621	static void WINAPI IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
622	TRACE("(%p)->(%s, %s)\n", iface,
623	flag == SFLAG_INSYSMEM ? "SFLAG_INSYSMEM" : flag == SFLAG_INDRAWABLE ? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
624	persistent ? "TRUE" : "FALSE");
625	/* GDI surfaces can be in system memory only */
626	if(flag != SFLAG_INSYSMEM) {
627	ERR("GDI Surface requested in gl %s memory\n", flag == SFLAG_INDRAWABLE ? "drawable" : "texture");
628	}
629	}
630
631	static HRESULT WINAPI IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface iface, DWORD flag, const RECT rect) {
632	if(flag != SFLAG_INSYSMEM) {
633	ERR("GDI Surface requested to be copied to gl %s\n", flag == SFLAG_INTEXTURE ? "texture" : "drawable");
634	} else {
635	TRACE("Surface requested in surface memory\n");
636	}
637	return WINED3D_OK;
638	}
639
640	static WINED3DSURFTYPE WINAPI IWineGDISurfaceImpl_GetImplType(IWineD3DSurface *iface) {
641	return SURFACE_GDI;
642	}
643
644	static HRESULT WINAPI IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
645	FIXME("GDI surfaces can't draw overlays yet\n");
646	return E_FAIL;
647	}
648
649	/* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
650	* only IWineD3DBaseSurface and IWineGDISurface ones.
651	*/
652	const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
653	{
654	/* IUnknown */
655	IWineD3DBaseSurfaceImpl_QueryInterface,
656	IWineD3DBaseSurfaceImpl_AddRef,
657	IWineGDISurfaceImpl_Release,
658	/* IWineD3DResource */
659	IWineD3DBaseSurfaceImpl_GetParent,
660	IWineD3DBaseSurfaceImpl_SetPrivateData,
661	IWineD3DBaseSurfaceImpl_GetPrivateData,
662	IWineD3DBaseSurfaceImpl_FreePrivateData,
663	IWineD3DBaseSurfaceImpl_SetPriority,
664	IWineD3DBaseSurfaceImpl_GetPriority,
665	IWineGDISurfaceImpl_PreLoad,
666	IWineGDISurfaceImpl_UnLoad,
667	IWineD3DBaseSurfaceImpl_GetType,
668	#ifdef VBOX_WITH_WDDM
669	IWineD3DResourceImpl_SetShRcState,
670	#endif
671	/* IWineD3DSurface */
672	IWineD3DBaseSurfaceImpl_GetContainer,
673	IWineD3DBaseSurfaceImpl_GetDesc,
674	IWineGDISurfaceImpl_LockRect,
675	IWineGDISurfaceImpl_UnlockRect,
676	IWineGDISurfaceImpl_GetDC,
677	IWineGDISurfaceImpl_ReleaseDC,
678	IWineGDISurfaceImpl_Flip,
679	IWineD3DBaseSurfaceImpl_Blt,
680	IWineD3DBaseSurfaceImpl_GetBltStatus,
681	IWineD3DBaseSurfaceImpl_GetFlipStatus,
682	IWineD3DBaseSurfaceImpl_IsLost,
683	IWineD3DBaseSurfaceImpl_Restore,
684	IWineD3DBaseSurfaceImpl_BltFast,
685	IWineD3DBaseSurfaceImpl_GetPalette,
686	IWineD3DBaseSurfaceImpl_SetPalette,
687	IWineGDISurfaceImpl_RealizePalette,
688	IWineD3DBaseSurfaceImpl_SetColorKey,
689	IWineD3DBaseSurfaceImpl_GetPitch,
690	IWineGDISurfaceImpl_SetMem,
691	IWineD3DBaseSurfaceImpl_SetOverlayPosition,
692	IWineD3DBaseSurfaceImpl_GetOverlayPosition,
693	IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
694	IWineD3DBaseSurfaceImpl_UpdateOverlay,
695	IWineD3DBaseSurfaceImpl_SetClipper,
696	IWineD3DBaseSurfaceImpl_GetClipper,
697	/* Internal use: */
698	IWineGDISurfaceImpl_LoadTexture,
699	IWineD3DBaseSurfaceImpl_BindTexture,
700	IWineGDISurfaceImpl_SaveSnapshot,
701	IWineD3DBaseSurfaceImpl_SetContainer,
702	IWineD3DBaseSurfaceImpl_GetData,
703	IWineD3DBaseSurfaceImpl_SetFormat,
704	IWineGDISurfaceImpl_PrivateSetup,
705	IWineGDISurfaceImpl_ModifyLocation,
706	IWineGDISurfaceImpl_LoadLocation,
707	IWineGDISurfaceImpl_GetImplType,
708	IWineGDISurfaceImpl_DrawOverlay
709	};

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

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/surface_gdi.c@ 41283

Download in other formats: