surface_gdi.c@ 22652

Last change on this file since 22652 was 21731, checked in by vboxsync, 15 years ago
crOpenGL: update to wine 1.1.26
Property svn:eol-style set to `native`
File size: 23.6 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	* Sun 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, Sun 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, NULL, NULL, 0, NULL, 0);
253	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
254	return hr;
255	}
256
257	/*****************************************************************************
258	* IWineD3DSurface::LoadTexture, GDI version
259	*
260	* This is mutually unsupported by GDI surfaces
261	*
262	* Returns:
263	* D3DERR_INVALIDCALL
264	*
265	*****************************************************************************/
266	static HRESULT WINAPI
267	IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode)
268	{
269	ERR("Unsupported on X11 surfaces\n");
270	return WINED3DERR_INVALIDCALL;
271	}
272
273	/*****************************************************************************
274	* IWineD3DSurface::SaveSnapshot, GDI version
275	*
276	* This method writes the surface's contents to the in tga format to the
277	* file specified in filename.
278	*
279	* Params:
280	* filename: File to write to
281	*
282	* Returns:
283	* WINED3DERR_INVALIDCALL if the file couldn't be opened
284	* WINED3D_OK on success
285	*
286	*****************************************************************************/
287	static int get_shift(DWORD color_mask) {
288	int shift = 0;
289	while (color_mask > 0xFF) {
290	color_mask >>= 1;
291	shift += 1;
292	}
293	while ((color_mask & 0x80) == 0) {
294	color_mask <<= 1;
295	shift -= 1;
296	}
297	return shift;
298	}
299
300
301	static HRESULT WINAPI
302	IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface,
303	const char* filename)
304	{
305	FILE* f = NULL;
306	UINT y = 0, x = 0;
307	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
308	static char *output = NULL;
309	static UINT size = 0;
310	const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
311
312	if (This->pow2Width > size) {
313	output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3);
314	size = This->pow2Width;
315	}
316
317
318	f = fopen(filename, "w+");
319	if (NULL == f) {
320	ERR("opening of %s failed with\n", filename);
321	return WINED3DERR_INVALIDCALL;
322	}
323	fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height);
324
325	if (This->resource.format_desc->format == WINED3DFMT_P8)
326	{
327	unsigned char table[256][3];
328	int i;
329
330	if (This->palette == NULL) {
331	fclose(f);
332	return WINED3DERR_INVALIDCALL;
333	}
334	for (i = 0; i < 256; i++) {
335	table[i][0] = This->palette->palents[i].peRed;
336	table[i][1] = This->palette->palents[i].peGreen;
337	table[i][2] = This->palette->palents[i].peBlue;
338	}
339	for (y = 0; y < This->pow2Height; y++) {
340	unsigned char src = This->resource.allocatedMemory + (y 1 * IWineD3DSurface_GetPitch(iface));
341	for (x = 0; x < This->pow2Width; x++) {
342	unsigned char color = *src;
343	src += 1;
344
345	output[3 * x + 0] = table[color][0];
346	output[3 * x + 1] = table[color][1];
347	output[3 * x + 2] = table[color][2];
348	}
349	fwrite(output, 3 * This->pow2Width, 1, f);
350	}
351	} else {
352	int red_shift, green_shift, blue_shift, pix_width, alpha_shift;
353
354	pix_width = format_desc->byte_count;
355
356	red_shift = get_shift(format_desc->red_mask);
357	green_shift = get_shift(format_desc->green_mask);
358	blue_shift = get_shift(format_desc->blue_mask);
359	alpha_shift = get_shift(format_desc->alpha_mask);
360
361	for (y = 0; y < This->pow2Height; y++) {
362	const unsigned char src = This->resource.allocatedMemory + (y 1 * IWineD3DSurface_GetPitch(iface));
363	for (x = 0; x < This->pow2Width; x++) {
364	unsigned int color;
365	unsigned int comp;
366	int i;
367
368	color = 0;
369	for (i = 0; i < pix_width; i++) {
370	color \|= src[i] << (8 * i);
371	}
372	src += 1 * pix_width;
373
374	comp = color & format_desc->red_mask;
375	output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift;
376	comp = color & format_desc->green_mask;
377	output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift;
378	comp = color & format_desc->alpha_mask;
379	output[3 * x + 2] = alpha_shift > 0 ? comp >> alpha_shift : comp << -alpha_shift;
380	}
381	fwrite(output, 3 * This->pow2Width, 1, f);
382	}
383	}
384	fclose(f);
385	return WINED3D_OK;
386	}
387
388	static HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface iface, HDC pHDC) {
389	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
390	WINED3DLOCKED_RECT lock;
391	HRESULT hr;
392	RGBQUAD col[256];
393
394	TRACE("(%p)->(%p)\n",This,pHDC);
395
396	if(This->Flags & SFLAG_USERPTR) {
397	ERR("Not supported on surfaces with an application-provided surfaces\n");
398	return WINEDDERR_NODC;
399	}
400
401	/* Give more detailed info for ddraw */
402	if (This->Flags & SFLAG_DCINUSE)
403	return WINEDDERR_DCALREADYCREATED;
404
405	/* Can't GetDC if the surface is locked */
406	if (This->Flags & SFLAG_LOCKED)
407	return WINED3DERR_INVALIDCALL;
408
409	memset(&lock, 0, sizeof(lock)); /* To be sure */
410
411	/* Should have a DIB section already */
412
413	/* Lock the surface */
414	hr = IWineD3DSurface_LockRect(iface,
415	&lock,
416	NULL,
417	0);
418	if(FAILED(hr)) {
419	ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
420	/* keep the dib section */
421	return hr;
422	}
423
424	if (This->resource.format_desc->format == WINED3DFMT_P8
425	\|\| This->resource.format_desc->format == WINED3DFMT_A8P8)
426	{
427	unsigned int n;
428	const PALETTEENTRY *pal = NULL;
429
430	if(This->palette) {
431	pal = This->palette->palents;
432	} else {
433	IWineD3DSurfaceImpl *dds_primary;
434	IWineD3DSwapChainImpl *swapchain;
435	swapchain = (IWineD3DSwapChainImpl *)This->resource.wineD3DDevice->swapchains[0];
436	dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
437	if (dds_primary && dds_primary->palette)
438	pal = dds_primary->palette->palents;
439	}
440
441	if (pal) {
442	for (n=0; n<256; n++) {
443	col[n].rgbRed = pal[n].peRed;
444	col[n].rgbGreen = pal[n].peGreen;
445	col[n].rgbBlue = pal[n].peBlue;
446	col[n].rgbReserved = 0;
447	}
448	SetDIBColorTable(This->hDC, 0, 256, col);
449	}
450	}
451
452	*pHDC = This->hDC;
453	TRACE("returning %p\n",*pHDC);
454	This->Flags \|= SFLAG_DCINUSE;
455
456	return WINED3D_OK;
457	}
458
459	static HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
460	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl )iface;
461
462	TRACE("(%p)->(%p)\n",This,hDC);
463
464	if (!(This->Flags & SFLAG_DCINUSE))
465	return WINEDDERR_NODC;
466
467	if (This->hDC !=hDC) {
468	WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
469	return WINEDDERR_NODC;
470	}
471
472	/* we locked first, so unlock now */
473	IWineD3DSurface_UnlockRect(iface);
474
475	This->Flags &= ~SFLAG_DCINUSE;
476
477	return WINED3D_OK;
478	}
479
480	static HRESULT WINAPI IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface *iface) {
481	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl ) iface;
482	RGBQUAD col[256];
483	IWineD3DPaletteImpl *pal = This->palette;
484	unsigned int n;
485	IWineD3DSwapChainImpl *swapchain;
486	TRACE("(%p)\n", This);
487
488	if (!pal) return WINED3D_OK;
489
490	if(This->Flags & SFLAG_DIBSECTION) {
491	TRACE("(%p): Updating the hdc's palette\n", This);
492	for (n=0; n<256; n++) {
493	col[n].rgbRed = pal->palents[n].peRed;
494	col[n].rgbGreen = pal->palents[n].peGreen;
495	col[n].rgbBlue = pal->palents[n].peBlue;
496	col[n].rgbReserved = 0;
497	}
498	SetDIBColorTable(This->hDC, 0, 256, col);
499	}
500
501	/* Update the image because of the palette change. Some games like e.g Red Alert
502	call SetEntries a lot to implement fading. */
503	/* Tell the swapchain to update the screen */
504	if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
505	{
506	if(iface == swapchain->frontBuffer)
507	{
508	x11_copy_to_screen(swapchain, NULL);
509	}
510	IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
511	}
512
513	return WINED3D_OK;
514	}
515
516	/*****************************************************************************
517	* IWineD3DSurface::PrivateSetup, GDI version
518	*
519	* Initializes the GDI surface, aka creates the DIB section we render to
520	* The DIB section creation is done by calling GetDC, which will create the
521	* section and releasing the dc to allow the app to use it. The dib section
522	* will stay until the surface is released
523	*
524	* GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
525	* are set to the real sizes to save memory. The NONPOW2 flag is unset to
526	* avoid confusion in the shared surface code.
527	*
528	* Returns:
529	* WINED3D_OK on success
530	* The return values of called methods on failure
531	*
532	*****************************************************************************/
533	static HRESULT WINAPI
534	IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface)
535	{
536	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl ) iface;
537
538	if(This->resource.usage & WINED3DUSAGE_OVERLAY)
539	{
540	ERR("(%p) Overlays not yet supported by GDI surfaces\n", This);
541	return WINED3DERR_INVALIDCALL;
542	}
543	/* Sysmem textures have memory already allocated -
544	* release it, this avoids an unnecessary memcpy
545	*/
546	HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
547	This->resource.allocatedMemory = NULL;
548	This->resource.heapMemory = NULL;
549
550	/* We don't mind the nonpow2 stuff in GDI */
551	This->pow2Width = This->currentDesc.Width;
552	This->pow2Height = This->currentDesc.Height;
553
554	IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
555	This->resource.allocatedMemory = This->dib.bitmap_data;
556
557	return WINED3D_OK;
558	}
559
560	static HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface iface, void Mem) {
561	IWineD3DSurfaceImpl This = (IWineD3DSurfaceImpl ) iface;
562
563	/* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
564	if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
565	ERR("Not supported on render targets\n");
566	return WINED3DERR_INVALIDCALL;
567	}
568
569	if(This->Flags & (SFLAG_LOCKED \| SFLAG_DCINUSE)) {
570	WARN("Surface is locked or the HDC is in use\n");
571	return WINED3DERR_INVALIDCALL;
572	}
573
574	if(Mem && Mem != This->resource.allocatedMemory) {
575	void *release = NULL;
576
577	/* Do I have to copy the old surface content? */
578	if(This->Flags & SFLAG_DIBSECTION) {
579	/* Release the DC. No need to hold the critical section for the update
580	* Thread because this thread runs only on front buffers, but this method
581	* fails for render targets in the check above.
582	*/
583	SelectObject(This->hDC, This->dib.holdbitmap);
584	DeleteDC(This->hDC);
585	/* Release the DIB section */
586	DeleteObject(This->dib.DIBsection);
587	This->dib.bitmap_data = NULL;
588	This->resource.allocatedMemory = NULL;
589	This->hDC = NULL;
590	This->Flags &= ~SFLAG_DIBSECTION;
591	} else if(!(This->Flags & SFLAG_USERPTR)) {
592	release = This->resource.allocatedMemory;
593	}
594	This->resource.allocatedMemory = Mem;
595	This->Flags \|= SFLAG_USERPTR \| SFLAG_INSYSMEM;
596
597	/* Now free the old memory if any */
598	HeapFree(GetProcessHeap(), 0, release);
599	} else if(This->Flags & SFLAG_USERPTR) {
600	/* LockRect and GetDC will re-create the dib section and allocated memory */
601	This->resource.allocatedMemory = NULL;
602	This->Flags &= ~SFLAG_USERPTR;
603	}
604	return WINED3D_OK;
605	}
606
607	/***************************
608	*
609	***************************/
610	static void WINAPI IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
611	TRACE("(%p)->(%s, %s)\n", iface,
612	flag == SFLAG_INSYSMEM ? "SFLAG_INSYSMEM" : flag == SFLAG_INDRAWABLE ? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
613	persistent ? "TRUE" : "FALSE");
614	/* GDI surfaces can be in system memory only */
615	if(flag != SFLAG_INSYSMEM) {
616	ERR("GDI Surface requested in gl %s memory\n", flag == SFLAG_INDRAWABLE ? "drawable" : "texture");
617	}
618	}
619
620	static HRESULT WINAPI IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface iface, DWORD flag, const RECT rect) {
621	if(flag != SFLAG_INSYSMEM) {
622	ERR("GDI Surface requested to be copied to gl %s\n", flag == SFLAG_INTEXTURE ? "texture" : "drawable");
623	} else {
624	TRACE("Surface requested in surface memory\n");
625	}
626	return WINED3D_OK;
627	}
628
629	static WINED3DSURFTYPE WINAPI IWineGDISurfaceImpl_GetImplType(IWineD3DSurface *iface) {
630	return SURFACE_GDI;
631	}
632
633	static HRESULT WINAPI IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
634	FIXME("GDI surfaces can't draw overlays yet\n");
635	return E_FAIL;
636	}
637
638	/* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
639	* only IWineD3DBaseSurface and IWineGDISurface ones.
640	*/
641	const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
642	{
643	/* IUnknown */
644	IWineD3DBaseSurfaceImpl_QueryInterface,
645	IWineD3DBaseSurfaceImpl_AddRef,
646	IWineGDISurfaceImpl_Release,
647	/* IWineD3DResource */
648	IWineD3DBaseSurfaceImpl_GetParent,
649	IWineD3DBaseSurfaceImpl_GetDevice,
650	IWineD3DBaseSurfaceImpl_SetPrivateData,
651	IWineD3DBaseSurfaceImpl_GetPrivateData,
652	IWineD3DBaseSurfaceImpl_FreePrivateData,
653	IWineD3DBaseSurfaceImpl_SetPriority,
654	IWineD3DBaseSurfaceImpl_GetPriority,
655	IWineGDISurfaceImpl_PreLoad,
656	IWineGDISurfaceImpl_UnLoad,
657	IWineD3DBaseSurfaceImpl_GetType,
658	/* IWineD3DSurface */
659	IWineD3DBaseSurfaceImpl_GetContainer,
660	IWineD3DBaseSurfaceImpl_GetDesc,
661	IWineGDISurfaceImpl_LockRect,
662	IWineGDISurfaceImpl_UnlockRect,
663	IWineGDISurfaceImpl_GetDC,
664	IWineGDISurfaceImpl_ReleaseDC,
665	IWineGDISurfaceImpl_Flip,
666	IWineD3DBaseSurfaceImpl_Blt,
667	IWineD3DBaseSurfaceImpl_GetBltStatus,
668	IWineD3DBaseSurfaceImpl_GetFlipStatus,
669	IWineD3DBaseSurfaceImpl_IsLost,
670	IWineD3DBaseSurfaceImpl_Restore,
671	IWineD3DBaseSurfaceImpl_BltFast,
672	IWineD3DBaseSurfaceImpl_GetPalette,
673	IWineD3DBaseSurfaceImpl_SetPalette,
674	IWineGDISurfaceImpl_RealizePalette,
675	IWineD3DBaseSurfaceImpl_SetColorKey,
676	IWineD3DBaseSurfaceImpl_GetPitch,
677	IWineGDISurfaceImpl_SetMem,
678	IWineD3DBaseSurfaceImpl_SetOverlayPosition,
679	IWineD3DBaseSurfaceImpl_GetOverlayPosition,
680	IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
681	IWineD3DBaseSurfaceImpl_UpdateOverlay,
682	IWineD3DBaseSurfaceImpl_SetClipper,
683	IWineD3DBaseSurfaceImpl_GetClipper,
684	/* Internal use: */
685	IWineGDISurfaceImpl_LoadTexture,
686	IWineD3DBaseSurfaceImpl_BindTexture,
687	IWineGDISurfaceImpl_SaveSnapshot,
688	IWineD3DBaseSurfaceImpl_SetContainer,
689	IWineD3DBaseSurfaceImpl_GetData,
690	IWineD3DBaseSurfaceImpl_SetFormat,
691	IWineGDISurfaceImpl_PrivateSetup,
692	IWineGDISurfaceImpl_ModifyLocation,
693	IWineGDISurfaceImpl_LoadLocation,
694	IWineGDISurfaceImpl_GetImplType,
695	IWineGDISurfaceImpl_DrawOverlay
696	};

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

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

Download in other formats: