2 * IWineD3DSurface Implementation
4 * Copyright 1998 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2002-2005 Jason Edmeades
7 * Copyright 2002-2003 Raphael Junqueira
8 * Copyright 2004 Christian Costa
9 * Copyright 2005 Oliver Stieber
10 * Copyright 2006-2007 Stefan Dösinger for CodeWeavers
11 * Copyright 2007 Henri Verbeet
12 * Copyright 2006-2007 Roderick Colenbrander
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wine/port.h"
31 #include "wined3d_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
34 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
36 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*surf
);
37 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl
*This
, BYTE table
[256][4], BOOL colorkey
);
39 static void surface_download_data(IWineD3DSurfaceImpl
*This
) {
40 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
42 if (0 == This
->glDescription
.textureName
) {
43 ERR("Surface does not have a texture, but SFLAG_INTEXTURE is set\n");
47 if(myDevice
->createParms
.BehaviorFlags
& WINED3DCREATE_MULTITHREADED
) {
48 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
52 /* Make sure that a proper texture unit is selected, bind the texture
53 * and dirtify the sampler to restore the texture on the next draw
55 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
56 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
));
57 checkGLcall("glActiveTextureARB");
59 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(0));
60 IWineD3DSurface_BindTexture((IWineD3DSurface
*) This
);
62 if (This
->resource
.format
== WINED3DFMT_DXT1
||
63 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
64 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
65 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) { /* We can assume this as the texture would not have been created otherwise */
66 FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This
);
68 TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
69 This
->glDescription
.glFormat
, This
->glDescription
.glType
, This
->resource
.allocatedMemory
);
71 if(This
->Flags
& SFLAG_PBO
) {
72 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
73 checkGLcall("glBindBufferARB");
74 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, NULL
));
75 checkGLcall("glGetCompressedTexImageARB()");
76 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
77 checkGLcall("glBindBufferARB");
79 GL_EXTCALL(glGetCompressedTexImageARB(This
->glDescription
.target
, This
->glDescription
.level
, This
->resource
.allocatedMemory
));
80 checkGLcall("glGetCompressedTexImageARB()");
89 if(This
->Flags
& SFLAG_CONVERTED
) {
90 FIXME("Read back converted textures unsupported\n");
95 if (This
->Flags
& SFLAG_NONPOW2
) {
96 unsigned char alignment
= This
->resource
.wineD3DDevice
->surface_alignment
;
97 src_pitch
= This
->bytesPerPixel
* This
->pow2Width
;
98 dst_pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
);
99 src_pitch
= (src_pitch
+ alignment
- 1) & ~(alignment
- 1);
100 mem
= HeapAlloc(GetProcessHeap(), 0, src_pitch
* This
->pow2Height
);
102 mem
= This
->resource
.allocatedMemory
;
105 TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This
, This
->glDescription
.level
,
106 This
->glDescription
.glFormat
, This
->glDescription
.glType
, mem
);
108 if(This
->Flags
& SFLAG_PBO
) {
109 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
110 checkGLcall("glBindBufferARB");
112 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, This
->glDescription
.glFormat
,
113 This
->glDescription
.glType
, NULL
);
114 checkGLcall("glGetTexImage()");
116 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
117 checkGLcall("glBindBufferARB");
119 glGetTexImage(This
->glDescription
.target
, This
->glDescription
.level
, This
->glDescription
.glFormat
,
120 This
->glDescription
.glType
, mem
);
121 checkGLcall("glGetTexImage()");
125 if (This
->Flags
& SFLAG_NONPOW2
) {
126 LPBYTE src_data
, dst_data
;
129 * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
130 * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
131 * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
133 * We're doing this...
135 * instead of boxing the texture :
136 * |<-texture width ->| -->pow2width| /\
137 * |111111111111111111| | |
138 * |222 Texture 222222| boxed empty | texture height
139 * |3333 Data 33333333| | |
140 * |444444444444444444| | \/
141 * ----------------------------------- |
142 * | boxed empty | boxed empty | pow2height
144 * -----------------------------------
147 * we're repacking the data to the expected texture width
149 * |<-texture width ->| -->pow2width| /\
150 * |111111111111111111222222222222222| |
151 * |222333333333333333333444444444444| texture height
155 * | empty | pow2height
157 * -----------------------------------
161 * |<-texture width ->| /\
162 * |111111111111111111|
163 * |222222222222222222|texture height
164 * |333333333333333333|
165 * |444444444444444444| \/
166 * --------------------
168 * this also means that any references to allocatedMemory should work with the data as if were a
169 * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
171 * internally the texture is still stored in a boxed format so any references to textureName will
172 * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
174 * Performance should not be an issue, because applications normally do not lock the surfaces when
175 * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
176 * and doesn't have to be re-read.
179 dst_data
= This
->resource
.allocatedMemory
;
180 TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This
, src_pitch
, dst_pitch
);
181 for (y
= 1 ; y
< This
->currentDesc
.Height
; y
++) {
182 /* skip the first row */
183 src_data
+= src_pitch
;
184 dst_data
+= dst_pitch
;
185 memcpy(dst_data
, src_data
, dst_pitch
);
188 HeapFree(GetProcessHeap(), 0, mem
);
192 /* Surface has now been downloaded */
193 This
->Flags
|= SFLAG_INSYSMEM
;
196 static void surface_upload_data(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
, const GLvoid
*data
) {
197 if (This
->resource
.format
== WINED3DFMT_DXT1
||
198 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
199 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
200 if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
201 FIXME("Using DXT1/3/5 without advertized support\n");
203 /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
204 * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
205 * function uses glCompressedTexImage2D instead of the SubImage call
207 TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This
, width
, height
, data
);
210 if(This
->Flags
& SFLAG_PBO
) {
211 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
212 checkGLcall("glBindBufferARB");
213 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
215 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
216 width
, height
, 0 /* border */, This
->resource
.size
, NULL
));
217 checkGLcall("glCompressedTexSubImage2D");
219 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
220 checkGLcall("glBindBufferARB");
222 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
223 width
, height
, 0 /* border */, This
->resource
.size
, data
));
224 checkGLcall("glCompressedTexSubImage2D");
229 TRACE("(%p) : Calling glTexSubImage2D w %d, h %d, data, %p\n", This
, width
, height
, data
);
232 if(This
->Flags
& SFLAG_PBO
) {
233 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
234 checkGLcall("glBindBufferARB");
235 TRACE("(%p) pbo: %#x, data: %p\n", This
, This
->pbo
, data
);
237 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, NULL
);
238 checkGLcall("glTexSubImage2D");
240 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
241 checkGLcall("glBindBufferARB");
244 glTexSubImage2D(This
->glDescription
.target
, This
->glDescription
.level
, 0, 0, width
, height
, format
, type
, data
);
245 checkGLcall("glTexSubImage2D");
252 static void surface_allocate_surface(IWineD3DSurfaceImpl
*This
, GLenum internal
, GLsizei width
, GLsizei height
, GLenum format
, GLenum type
) {
253 BOOL enable_client_storage
= FALSE
;
256 TRACE("(%p) : Creating surface (target %#x) level %d, d3d format %s, internal format %#x, width %d, height %d, gl format %#x, gl type=%#x\n", This
,
257 This
->glDescription
.target
, This
->glDescription
.level
, debug_d3dformat(This
->resource
.format
), internal
, width
, height
, format
, type
);
259 if (This
->resource
.format
== WINED3DFMT_DXT1
||
260 This
->resource
.format
== WINED3DFMT_DXT2
|| This
->resource
.format
== WINED3DFMT_DXT3
||
261 This
->resource
.format
== WINED3DFMT_DXT4
|| This
->resource
.format
== WINED3DFMT_DXT5
) {
262 /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
263 TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
265 /* We have to point GL to the client storage memory here, because upload_data might use a PBO. This means a double upload
266 * once, unfortunately
268 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
269 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
270 This
->Flags
|= SFLAG_CLIENT
;
271 mem
= (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
272 GL_EXTCALL(glCompressedTexImage2DARB(This
->glDescription
.target
, This
->glDescription
.level
, internal
,
273 width
, height
, 0 /* border */, This
->resource
.size
, mem
));
281 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
282 if(This
->Flags
& (SFLAG_NONPOW2
| SFLAG_DIBSECTION
| SFLAG_OVERSIZE
| SFLAG_CONVERTED
) || This
->resource
.allocatedMemory
== NULL
) {
283 /* In some cases we want to disable client storage.
284 * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
285 * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
286 * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
287 * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
288 * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
290 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_FALSE
);
291 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
292 This
->Flags
&= ~SFLAG_CLIENT
;
293 enable_client_storage
= TRUE
;
295 This
->Flags
|= SFLAG_CLIENT
;
297 /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
298 * it might point into a pbo. Instead use heapMemory, but get the alignment right.
300 mem
= (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
303 glTexImage2D(This
->glDescription
.target
, This
->glDescription
.level
, internal
, width
, height
, 0, format
, type
, mem
);
304 checkGLcall("glTexImage2D");
306 if(enable_client_storage
) {
307 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
308 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
312 This
->Flags
|= SFLAG_ALLOCATED
;
315 /* In D3D the depth stencil dimensions have to be greater than or equal to the
316 * render target dimensions. With FBOs, the dimensions have to be an exact match. */
317 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
318 void surface_set_compatible_renderbuffer(IWineD3DSurface
*iface
, unsigned int width
, unsigned int height
) {
319 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
320 renderbuffer_entry_t
*entry
;
321 GLuint renderbuffer
= 0;
322 unsigned int src_width
, src_height
;
324 src_width
= This
->pow2Width
;
325 src_height
= This
->pow2Height
;
327 /* A depth stencil smaller than the render target is not valid */
328 if (width
> src_width
|| height
> src_height
) return;
330 /* Remove any renderbuffer set if the sizes match */
331 if (width
== src_width
&& height
== src_height
) {
332 This
->current_renderbuffer
= NULL
;
336 /* Look if we've already got a renderbuffer of the correct dimensions */
337 LIST_FOR_EACH_ENTRY(entry
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
338 if (entry
->width
== width
&& entry
->height
== height
) {
339 renderbuffer
= entry
->id
;
340 This
->current_renderbuffer
= entry
;
346 const GlPixelFormatDesc
*glDesc
;
347 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
349 GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer
));
350 GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT
, renderbuffer
));
351 GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT
, glDesc
->glFormat
, width
, height
));
353 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t
));
354 entry
->width
= width
;
355 entry
->height
= height
;
356 entry
->id
= renderbuffer
;
357 list_add_head(&This
->renderbuffers
, &entry
->entry
);
359 This
->current_renderbuffer
= entry
;
362 checkGLcall("set_compatible_renderbuffer");
365 GLenum
surface_get_gl_buffer(IWineD3DSurface
*iface
, IWineD3DSwapChain
*swapchain
) {
366 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
367 IWineD3DSwapChainImpl
*swapchain_impl
= (IWineD3DSwapChainImpl
*)swapchain
;
369 TRACE("(%p) : swapchain %p\n", This
, swapchain
);
371 if (swapchain_impl
->backBuffer
&& swapchain_impl
->backBuffer
[0] == iface
) {
372 TRACE("Returning GL_BACK\n");
374 } else if (swapchain_impl
->frontBuffer
== iface
) {
375 TRACE("Returning GL_FRONT\n");
379 FIXME("Higher back buffer, returning GL_BACK\n");
383 ULONG WINAPI
IWineD3DSurfaceImpl_Release(IWineD3DSurface
*iface
) {
384 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
385 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
386 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
388 IWineD3DDeviceImpl
*device
= (IWineD3DDeviceImpl
*) This
->resource
.wineD3DDevice
;
389 renderbuffer_entry_t
*entry
, *entry2
;
390 TRACE("(%p) : cleaning up\n", This
);
392 if (This
->glDescription
.textureName
!= 0) { /* release the openGL texture.. */
394 /* Need a context to destroy the texture. Use the currently active render target, but only if
395 * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
396 * When destroying the primary rt, Uninit3D will activate a context before doing anything
398 if(device
->render_targets
&& device
->render_targets
[0]) {
399 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
402 TRACE("Deleting texture %d\n", This
->glDescription
.textureName
);
404 glDeleteTextures(1, &This
->glDescription
.textureName
);
408 if(This
->Flags
& SFLAG_PBO
) {
410 GL_EXTCALL(glDeleteBuffersARB(1, &This
->pbo
));
413 if(This
->Flags
& SFLAG_DIBSECTION
) {
415 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
417 /* Release the DIB section */
418 DeleteObject(This
->dib
.DIBsection
);
419 This
->dib
.bitmap_data
= NULL
;
420 This
->resource
.allocatedMemory
= NULL
;
422 if(This
->Flags
& SFLAG_USERPTR
) IWineD3DSurface_SetMem(iface
, NULL
);
424 HeapFree(GetProcessHeap(), 0, This
->palette9
);
426 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
427 if(iface
== device
->ddraw_primary
)
428 device
->ddraw_primary
= NULL
;
430 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->renderbuffers
, renderbuffer_entry_t
, entry
) {
431 GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry
->id
));
432 HeapFree(GetProcessHeap(), 0, entry
);
435 TRACE("(%p) Released\n", This
);
436 HeapFree(GetProcessHeap(), 0, This
);
442 /* ****************************************************
443 IWineD3DSurface IWineD3DResource parts follow
444 **************************************************** */
446 void WINAPI
IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface
*iface
) {
447 /* TODO: check for locks */
448 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
449 IWineD3DBaseTexture
*baseTexture
= NULL
;
450 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
452 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
453 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
454 TRACE("Passing to container\n");
455 IWineD3DBaseTexture_PreLoad(baseTexture
);
456 IWineD3DBaseTexture_Release(baseTexture
);
458 TRACE("(%p) : About to load surface\n", This
);
460 if(!device
->isInDraw
) {
461 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
465 glEnable(This
->glDescription
.target
);/* make sure texture support is enabled in this context */
466 if (!This
->glDescription
.level
) {
467 if (!This
->glDescription
.textureName
) {
468 glGenTextures(1, &This
->glDescription
.textureName
);
469 checkGLcall("glGenTextures");
470 TRACE("Surface %p given name %d\n", This
, This
->glDescription
.textureName
);
472 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
473 checkGLcall("glBindTexture");
474 IWineD3DSurface_LoadTexture(iface
, FALSE
);
475 /* This is where we should be reducing the amount of GLMemoryUsed */
476 } else if (This
->glDescription
.textureName
) { /* NOTE: the level 0 surface of a mpmapped texture must be loaded first! */
477 /* assume this is a coding error not a real error for now */
478 FIXME("Mipmap surface has a glTexture bound to it!\n");
480 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
481 /* Tell opengl to try and keep this texture in video ram (well mostly) */
484 glPrioritizeTextures(1, &This
->glDescription
.textureName
, &tmp
);
491 /* ******************************************************
492 IWineD3DSurface IWineD3DSurface parts follow
493 ****************************************************** */
495 void WINAPI
IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface
*iface
, UINT textureName
, int target
) {
496 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
497 TRACE("(%p) : setting textureName %u, target %i\n", This
, textureName
, target
);
498 if (This
->glDescription
.textureName
== 0 && textureName
!= 0) {
499 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INTEXTURE
, FALSE
);
500 IWineD3DSurface_AddDirtyRect(iface
, NULL
);
502 This
->glDescription
.textureName
= textureName
;
503 This
->glDescription
.target
= target
;
504 This
->Flags
&= ~SFLAG_ALLOCATED
;
507 void WINAPI
IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface
*iface
, glDescriptor
**glDescription
) {
508 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
509 TRACE("(%p) : returning %p\n", This
, &This
->glDescription
);
510 *glDescription
= &This
->glDescription
;
513 /* TODO: think about moving this down to resource? */
514 const void *WINAPI
IWineD3DSurfaceImpl_GetData(IWineD3DSurface
*iface
) {
515 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
516 /* This should only be called for sysmem textures, it may be a good idea to extend this to all pools at some point in the future */
517 if (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
) {
518 FIXME(" (%p)Attempting to get system memory for a non-system memory texture\n", iface
);
520 return (CONST
void*)(This
->resource
.allocatedMemory
);
523 static void read_from_framebuffer(IWineD3DSurfaceImpl
*This
, CONST RECT
*rect
, void *dest
, UINT pitch
) {
524 IWineD3DSwapChainImpl
*swapchain
;
525 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
529 BYTE
*row
, *top
, *bottom
;
533 BOOL srcIsUpsideDown
;
535 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
536 static BOOL warned
= FALSE
;
538 ERR("The application tries to lock the render target, but render target locking is disabled\n");
544 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
545 /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
546 * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
547 * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
548 * context->last_was_blit set on the unlock.
550 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
553 /* Select the correct read buffer, and give some debug output.
554 * There is no need to keep track of the current read buffer or reset it, every part of the code
555 * that reads sets the read buffer as desired.
558 /* Locking the primary render target which is not on a swapchain(=offscreen render target).
559 * Read from the back buffer
561 TRACE("Locking offscreen render target\n");
562 glReadBuffer(myDevice
->offscreenBuffer
);
563 srcIsUpsideDown
= TRUE
;
565 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
566 TRACE("Locking %#x buffer\n", buffer
);
567 glReadBuffer(buffer
);
568 checkGLcall("glReadBuffer");
570 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
571 srcIsUpsideDown
= FALSE
;
574 /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
578 local_rect
.right
= This
->currentDesc
.Width
;
579 local_rect
.bottom
= This
->currentDesc
.Height
;
583 /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
585 switch(This
->resource
.format
)
589 if(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) {
590 /* In case of P8 render targets the index is stored in the alpha component */
592 type
= GL_UNSIGNED_BYTE
;
594 bpp
= This
->bytesPerPixel
;
596 /* GL can't return palettized data, so read ARGB pixels into a
597 * separate block of memory and convert them into palettized format
598 * in software. Slow, but if the app means to use palettized render
599 * targets and locks it...
601 * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
602 * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
603 * for the color channels when palettizing the colors.
606 type
= GL_UNSIGNED_BYTE
;
608 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* 3);
610 ERR("Out of memory\n");
614 bpp
= This
->bytesPerPixel
* 3;
621 fmt
= This
->glDescription
.glFormat
;
622 type
= This
->glDescription
.glType
;
623 bpp
= This
->bytesPerPixel
;
626 if(This
->Flags
& SFLAG_PBO
) {
627 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, This
->pbo
));
628 checkGLcall("glBindBufferARB");
631 glReadPixels(local_rect
.left
, local_rect
.top
,
632 local_rect
.right
- local_rect
.left
,
633 local_rect
.bottom
- local_rect
.top
,
635 vcheckGLcall("glReadPixels");
637 if(This
->Flags
& SFLAG_PBO
) {
638 GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB
, 0));
639 checkGLcall("glBindBufferARB");
641 /* Check if we need to flip the image. If we need to flip use glMapBufferARB
642 * to get a pointer to it and perform the flipping in software. This is a lot
643 * faster than calling glReadPixels for each line. In case we want more speed
644 * we should rerender it flipped in a FBO and read the data back from the FBO. */
645 if(!srcIsUpsideDown
) {
646 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
647 checkGLcall("glBindBufferARB");
649 mem
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
650 checkGLcall("glMapBufferARB");
654 /* TODO: Merge this with the palettization loop below for P8 targets */
655 if(!srcIsUpsideDown
) {
657 /* glReadPixels returns the image upside down, and there is no way to prevent this.
658 Flip the lines in software */
659 len
= (local_rect
.right
- local_rect
.left
) * bpp
;
660 off
= local_rect
.left
* bpp
;
662 row
= HeapAlloc(GetProcessHeap(), 0, len
);
664 ERR("Out of memory\n");
665 if(This
->resource
.format
== WINED3DFMT_P8
) HeapFree(GetProcessHeap(), 0, mem
);
670 top
= mem
+ pitch
* local_rect
.top
;
671 bottom
= ((BYTE
*) mem
) + pitch
* ( local_rect
.bottom
- local_rect
.top
- 1);
672 for(i
= 0; i
< (local_rect
.bottom
- local_rect
.top
) / 2; i
++) {
673 memcpy(row
, top
+ off
, len
);
674 memcpy(top
+ off
, bottom
+ off
, len
);
675 memcpy(bottom
+ off
, row
, len
);
679 HeapFree(GetProcessHeap(), 0, row
);
681 /* Unmap the temp PBO buffer */
682 if(This
->Flags
& SFLAG_PBO
) {
683 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
684 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
688 /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
689 * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
690 * the same color but we have no choice.
691 * In case of render targets, the index is stored in the alpha component so no conversion is needed.
693 if((This
->resource
.format
== WINED3DFMT_P8
) && !(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)) {
695 DWORD width
= pitch
/ 3;
698 pal
= This
->palette
->palents
;
700 pal
= This
->resource
.wineD3DDevice
->palettes
[This
->resource
.wineD3DDevice
->currentPalette
];
703 for(y
= local_rect
.top
; y
< local_rect
.bottom
; y
++) {
704 for(x
= local_rect
.left
; x
< local_rect
.right
; x
++) {
705 /* start lines pixels */
706 BYTE
*blue
= (BYTE
*) ((BYTE
*) mem
) + y
* pitch
+ x
* (sizeof(BYTE
) * 3);
707 BYTE
*green
= blue
+ 1;
708 BYTE
*red
= green
+ 1;
710 for(c
= 0; c
< 256; c
++) {
711 if(*red
== pal
[c
].peRed
&&
712 *green
== pal
[c
].peGreen
&&
713 *blue
== pal
[c
].peBlue
)
715 *((BYTE
*) dest
+ y
* width
+ x
) = c
;
721 HeapFree(GetProcessHeap(), 0, mem
);
726 static void surface_prepare_system_memory(IWineD3DSurfaceImpl
*This
) {
727 /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
728 * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
731 if(!(This
->Flags
& SFLAG_DYNLOCK
)) {
733 /* MAXLOCKCOUNT is defined in wined3d_private.h */
734 if(This
->lockCount
> MAXLOCKCOUNT
) {
735 TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
736 This
->Flags
|= SFLAG_DYNLOCK
;
740 /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
741 * Also don't create a PBO for systemmem surfaces.
743 if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT
) && (This
->Flags
& SFLAG_DYNLOCK
) && !(This
->Flags
& (SFLAG_PBO
| SFLAG_CONVERTED
| SFLAG_NONPOW2
)) && (This
->resource
.pool
!= WINED3DPOOL_SYSTEMMEM
)) {
747 GL_EXTCALL(glGenBuffersARB(1, &This
->pbo
));
748 error
= glGetError();
749 if(This
->pbo
== 0 || error
!= GL_NO_ERROR
) {
750 ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error
), error
);
753 TRACE("Attaching pbo=%#x to (%p)\n", This
->pbo
, This
);
755 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
756 checkGLcall("glBindBufferARB");
758 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->resource
.size
+ 4, This
->resource
.allocatedMemory
, GL_STREAM_DRAW_ARB
));
759 checkGLcall("glBufferDataARB");
761 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
762 checkGLcall("glBindBufferARB");
764 /* We don't need the system memory anymore and we can't even use it for PBOs */
765 if(!(This
->Flags
& SFLAG_CLIENT
)) {
766 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
767 This
->resource
.heapMemory
= NULL
;
769 This
->resource
.allocatedMemory
= NULL
;
770 This
->Flags
|= SFLAG_PBO
;
772 } else if(!(This
->resource
.allocatedMemory
|| This
->Flags
& SFLAG_PBO
)) {
773 /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
776 if(!This
->resource
.heapMemory
) {
777 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap() ,0 , This
->resource
.size
+ RESOURCE_ALIGNMENT
);
779 This
->resource
.allocatedMemory
=
780 (BYTE
*)(((ULONG_PTR
) This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
781 if(This
->Flags
& SFLAG_INSYSMEM
) {
782 ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
787 static HRESULT WINAPI
IWineD3DSurfaceImpl_LockRect(IWineD3DSurface
*iface
, WINED3DLOCKED_RECT
* pLockedRect
, CONST RECT
* pRect
, DWORD Flags
) {
788 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
789 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
790 IWineD3DSwapChain
*swapchain
= NULL
;
792 TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This
, pRect
, Flags
, pLockedRect
, This
->resource
.allocatedMemory
);
794 /* This is also done in the base class, but we have to verify this before loading any data from
795 * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
796 * may interfere, and all other bad things may happen
798 if (This
->Flags
& SFLAG_LOCKED
) {
799 WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
800 return WINED3DERR_INVALIDCALL
;
802 This
->Flags
|= SFLAG_LOCKED
;
804 if (!(This
->Flags
& SFLAG_LOCKABLE
))
806 TRACE("Warning: trying to lock unlockable surf@%p\n", This
);
809 if (Flags
& WINED3DLOCK_DISCARD
) {
810 /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
811 TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
812 This
->Flags
|= SFLAG_INSYSMEM
;
815 if (This
->Flags
& SFLAG_INSYSMEM
) {
816 TRACE("Local copy is up to date, not downloading data\n");
817 surface_prepare_system_memory(This
); /* Makes sure memory is allocated */
821 /* Now download the surface content from opengl
822 * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
823 * Offscreen targets which are not active at the moment or are higher targets(fbos) can be locked with the texture path
825 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
826 if(swapchain
|| iface
== myDevice
->render_targets
[0]) {
827 const RECT
*pass_rect
= pRect
;
829 /* IWineD3DSurface_LoadLocation does not check if the rectangle specifies the full surfaces
830 * because most caller functions do not need that. So do that here
835 pRect
->right
== This
->currentDesc
.Width
&&
836 pRect
->bottom
== This
->currentDesc
.Height
) {
840 switch(wined3d_settings
.rendertargetlock_mode
) {
843 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
845 /* Disabled for now. LoadLocation prefers the texture over the drawable as the source. So if we copy to the
846 * texture first, then to sysmem, we'll avoid glReadPixels and use glCopyTexImage and glGetTexImage2D instead.
847 * This may be faster on some cards
849 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* No partial texture copy yet */);
856 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, pRect
);
862 if(swapchain
) IWineD3DSwapChain_Release(swapchain
);
864 } else if(iface
== myDevice
->stencilBufferTarget
) {
865 /** the depth stencil in openGL has a format of GL_FLOAT
866 * which should be good for WINED3DFMT_D16_LOCKABLE
868 * it is unclear what format the stencil buffer is in except.
869 * 'Each index is converted to fixed point...
870 * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
871 * mappings in the table GL_PIXEL_MAP_S_TO_S.
872 * glReadPixels(This->lockedRect.left,
873 * This->lockedRect.bottom - j - 1,
874 * This->lockedRect.right - This->lockedRect.left,
876 * GL_DEPTH_COMPONENT,
878 * (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
880 * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
881 * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
882 * none of that is the case the problem is not in this function :-)
883 ********************************************/
884 FIXME("Depth stencil locking not supported yet\n");
886 /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
887 TRACE("locking an ordinary surface\n");
888 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
892 if(This
->Flags
& SFLAG_PBO
) {
893 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
895 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
896 checkGLcall("glBindBufferARB");
898 /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
899 if(This
->resource
.allocatedMemory
) {
900 ERR("The surface already has PBO memory allocated!\n");
903 This
->resource
.allocatedMemory
= GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, GL_READ_WRITE_ARB
));
904 checkGLcall("glMapBufferARB");
906 /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
907 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
908 checkGLcall("glBindBufferARB");
913 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
916 IWineD3DBaseTexture
*pBaseTexture
;
919 * as seen in msdn docs
921 IWineD3DSurface_AddDirtyRect(iface
, pRect
);
923 /** Dirtify Container if needed */
924 if (WINED3D_OK
== IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&pBaseTexture
) && pBaseTexture
!= NULL
) {
925 TRACE("Making container dirty\n");
926 IWineD3DBaseTexture_SetDirty(pBaseTexture
, TRUE
);
927 IWineD3DBaseTexture_Release(pBaseTexture
);
929 TRACE("Surface is standalone, no need to dirty the container\n");
933 return IWineD3DBaseSurfaceImpl_LockRect(iface
, pLockedRect
, pRect
, Flags
);
936 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl
*This
) {
938 GLint prev_rasterpos
[4];
940 BOOL storechanged
= FALSE
, memory_allocated
= FALSE
;
944 UINT pitch
= IWineD3DSurface_GetPitch((IWineD3DSurface
*) This
); /* target is argb, 4 byte */
945 IWineD3DDeviceImpl
*myDevice
= (IWineD3DDeviceImpl
*) This
->resource
.wineD3DDevice
;
946 IWineD3DSwapChainImpl
*swapchain
;
948 /* Activate the correct context for the render target */
949 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
952 IWineD3DSurface_GetContainer((IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
954 /* Primary offscreen render target */
955 TRACE("Offscreen render target\n");
956 glDrawBuffer(myDevice
->offscreenBuffer
);
957 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
959 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*) This
, (IWineD3DSwapChain
*)swapchain
);
960 TRACE("Unlocking %#x buffer\n", buffer
);
961 glDrawBuffer(buffer
);
962 checkGLcall("glDrawBuffer");
964 IWineD3DSwapChain_Release((IWineD3DSwapChain
*)swapchain
);
967 glDisable(GL_TEXTURE_2D
);
968 vcheckGLcall("glDisable(GL_TEXTURE_2D)");
971 vcheckGLcall("glFlush");
972 glGetIntegerv(GL_PACK_SWAP_BYTES
, &prev_store
);
973 vcheckGLcall("glIntegerv");
974 glGetIntegerv(GL_CURRENT_RASTER_POSITION
, &prev_rasterpos
[0]);
975 vcheckGLcall("glIntegerv");
976 glPixelZoom(1.0, -1.0);
977 vcheckGLcall("glPixelZoom");
979 /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
980 glGetIntegerv(GL_UNPACK_ROW_LENGTH
, &skipBytes
);
981 glPixelStorei(GL_UNPACK_ROW_LENGTH
, This
->currentDesc
.Width
);
983 glRasterPos3i(This
->lockedRect
.left
, This
->lockedRect
.top
, 1);
984 vcheckGLcall("glRasterPos2f");
986 /* Some drivers(radeon dri, others?) don't like exceptions during
987 * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
988 * after ReleaseDC. Reading it will cause an exception, which x11drv will
989 * catch to put the dib section in InSync mode, which leads to a crash
990 * and a blocked x server on my radeon card.
992 * The following lines read the dib section so it is put in inSync mode
993 * before glDrawPixels is called and the crash is prevented. There won't
994 * be any interfering gdi accesses, because UnlockRect is called from
995 * ReleaseDC, and the app won't use the dc any more afterwards.
997 if((This
->Flags
& SFLAG_DIBSECTION
) && !(This
->Flags
& SFLAG_PBO
)) {
999 read
= This
->resource
.allocatedMemory
[0];
1002 switch (This
->resource
.format
) {
1003 /* No special care needed */
1004 case WINED3DFMT_A4R4G4B4
:
1005 case WINED3DFMT_R5G6B5
:
1006 case WINED3DFMT_A1R5G5B5
:
1007 case WINED3DFMT_R8G8B8
:
1008 type
= This
->glDescription
.glType
;
1009 fmt
= This
->glDescription
.glFormat
;
1010 mem
= This
->resource
.allocatedMemory
;
1011 bpp
= This
->bytesPerPixel
;
1014 case WINED3DFMT_X4R4G4B4
:
1017 unsigned short *data
;
1018 data
= (unsigned short *)This
->resource
.allocatedMemory
;
1019 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1025 type
= This
->glDescription
.glType
;
1026 fmt
= This
->glDescription
.glFormat
;
1027 mem
= This
->resource
.allocatedMemory
;
1028 bpp
= This
->bytesPerPixel
;
1032 case WINED3DFMT_X1R5G5B5
:
1035 unsigned short *data
;
1036 data
= (unsigned short *)This
->resource
.allocatedMemory
;
1037 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1043 type
= This
->glDescription
.glType
;
1044 fmt
= This
->glDescription
.glFormat
;
1045 mem
= This
->resource
.allocatedMemory
;
1046 bpp
= This
->bytesPerPixel
;
1050 case WINED3DFMT_X8R8G8B8
:
1052 /* make sure the X byte is set to alpha on, since it
1053 could be any random value. This fixes the intro movie in Pirates! */
1056 data
= (unsigned int *)This
->resource
.allocatedMemory
;
1057 size
= (This
->lockedRect
.bottom
- This
->lockedRect
.top
) * (This
->lockedRect
.right
- This
->lockedRect
.left
);
1059 *data
|= 0xFF000000;
1066 case WINED3DFMT_A8R8G8B8
:
1068 glPixelStorei(GL_PACK_SWAP_BYTES
, TRUE
);
1069 vcheckGLcall("glPixelStorei");
1070 storechanged
= TRUE
;
1071 type
= This
->glDescription
.glType
;
1072 fmt
= This
->glDescription
.glFormat
;
1073 mem
= This
->resource
.allocatedMemory
;
1074 bpp
= This
->bytesPerPixel
;
1078 case WINED3DFMT_A2R10G10B10
:
1080 glPixelStorei(GL_PACK_SWAP_BYTES
, TRUE
);
1081 vcheckGLcall("glPixelStorei");
1082 storechanged
= TRUE
;
1083 type
= This
->glDescription
.glType
;
1084 fmt
= This
->glDescription
.glFormat
;
1085 mem
= This
->resource
.allocatedMemory
;
1086 bpp
= This
->bytesPerPixel
;
1092 int height
= This
->glRect
.bottom
- This
->glRect
.top
;
1093 type
= GL_UNSIGNED_BYTE
;
1096 mem
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
* sizeof(DWORD
));
1098 ERR("Out of memory\n");
1101 memory_allocated
= TRUE
;
1102 d3dfmt_convert_surface(This
->resource
.allocatedMemory
,
1110 bpp
= This
->bytesPerPixel
* 4;
1116 FIXME("Unsupported Format %u in locking func\n", This
->resource
.format
);
1119 type
= This
->glDescription
.glType
;
1120 fmt
= This
->glDescription
.glFormat
;
1121 mem
= This
->resource
.allocatedMemory
;
1122 bpp
= This
->bytesPerPixel
;
1125 if(This
->Flags
& SFLAG_PBO
) {
1126 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1127 checkGLcall("glBindBufferARB");
1130 glDrawPixels(This
->lockedRect
.right
- This
->lockedRect
.left
,
1131 (This
->lockedRect
.bottom
- This
->lockedRect
.top
)-1,
1133 mem
+ bpp
* This
->lockedRect
.left
+ pitch
* This
->lockedRect
.top
);
1134 checkGLcall("glDrawPixels");
1137 if(This
->Flags
& SFLAG_PBO
) {
1138 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1139 checkGLcall("glBindBufferARB");
1142 glPixelZoom(1.0,1.0);
1143 vcheckGLcall("glPixelZoom");
1145 glRasterPos3iv(&prev_rasterpos
[0]);
1146 vcheckGLcall("glRasterPos3iv");
1148 /* Reset to previous pack row length */
1149 glPixelStorei(GL_UNPACK_ROW_LENGTH
, skipBytes
);
1150 vcheckGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1152 glPixelStorei(GL_PACK_SWAP_BYTES
, prev_store
);
1153 vcheckGLcall("glPixelStorei GL_PACK_SWAP_BYTES");
1156 /* Blitting environment requires that 2D texturing is enabled. It was turned off before,
1159 glEnable(GL_TEXTURE_2D
);
1160 checkGLcall("glEnable(GL_TEXTURE_2D)");
1162 if(memory_allocated
) HeapFree(GetProcessHeap(), 0, mem
);
1165 glDrawBuffer(myDevice
->offscreenBuffer
);
1166 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1167 } else if(swapchain
->backBuffer
) {
1168 glDrawBuffer(GL_BACK
);
1169 checkGLcall("glDrawBuffer(GL_BACK)");
1171 glDrawBuffer(GL_FRONT
);
1172 checkGLcall("glDrawBuffer(GL_FRONT)");
1179 static HRESULT WINAPI
IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface
*iface
) {
1180 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1181 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
1182 IWineD3DSwapChainImpl
*swapchain
= NULL
;
1185 if (!(This
->Flags
& SFLAG_LOCKED
)) {
1186 WARN("trying to Unlock an unlocked surf@%p\n", This
);
1187 return WINED3DERR_INVALIDCALL
;
1190 if (This
->Flags
& SFLAG_PBO
) {
1191 TRACE("Freeing PBO memory\n");
1192 ActivateContext(myDevice
, myDevice
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
1194 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, This
->pbo
));
1195 GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
));
1196 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
1197 checkGLcall("glUnmapBufferARB");
1199 This
->resource
.allocatedMemory
= NULL
;
1202 TRACE("(%p) : dirtyfied(%d)\n", This
, This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
) ? 0 : 1);
1204 if (This
->Flags
& (SFLAG_INDRAWABLE
| SFLAG_INTEXTURE
)) {
1205 TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This
);
1209 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1210 if(swapchain
|| (myDevice
->render_targets
&& iface
== myDevice
->render_targets
[0])) {
1211 if(wined3d_settings
.rendertargetlock_mode
== RTL_DISABLE
) {
1212 static BOOL warned
= FALSE
;
1214 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1217 if(swapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
1221 if(This
->dirtyRect
.left
== 0 &&
1222 This
->dirtyRect
.top
== 0 &&
1223 This
->dirtyRect
.right
== This
->currentDesc
.Width
&&
1224 This
->dirtyRect
.bottom
== This
->currentDesc
.Height
) {
1227 /* TODO: Proper partial rectangle tracking */
1228 fullsurface
= FALSE
;
1229 This
->Flags
|= SFLAG_INSYSMEM
;
1232 switch(wined3d_settings
.rendertargetlock_mode
) {
1235 ActivateContext(myDevice
, iface
, CTXUSAGE_BLIT
);
1237 if (This
->glDescription
.textureName
== 0) {
1238 glGenTextures(1, &This
->glDescription
.textureName
);
1239 checkGLcall("glGenTextures");
1241 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
1242 checkGLcall("glBindTexture(GL_TEXTURE_2D, This->glDescription.textureName);");
1244 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* partial texture loading not supported yet */);
1250 IWineD3DSurface_LoadLocation(iface
, SFLAG_INDRAWABLE
, fullsurface
? NULL
: &This
->dirtyRect
);
1255 /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite
1256 * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where
1257 * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy
1258 * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is
1259 * not fully up to date because only a subrectangle was read in LockRect.
1261 This
->Flags
&= ~SFLAG_INSYSMEM
;
1262 This
->Flags
|= SFLAG_INDRAWABLE
;
1265 This
->dirtyRect
.left
= This
->currentDesc
.Width
;
1266 This
->dirtyRect
.top
= This
->currentDesc
.Height
;
1267 This
->dirtyRect
.right
= 0;
1268 This
->dirtyRect
.bottom
= 0;
1269 } else if(iface
== myDevice
->stencilBufferTarget
) {
1270 FIXME("Depth Stencil buffer locking is not implemented\n");
1272 /* The rest should be a normal texture */
1273 IWineD3DBaseTextureImpl
*impl
;
1274 /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1275 * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1276 * states need resetting
1278 if(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&impl
) == WINED3D_OK
) {
1279 if(impl
->baseTexture
.bindCount
) {
1280 IWineD3DDeviceImpl_MarkStateDirty(myDevice
, STATE_SAMPLER(impl
->baseTexture
.sampler
));
1282 IWineD3DBaseTexture_Release((IWineD3DBaseTexture
*) impl
);
1287 This
->Flags
&= ~SFLAG_LOCKED
;
1288 memset(&This
->lockedRect
, 0, sizeof(RECT
));
1292 HRESULT WINAPI
IWineD3DSurfaceImpl_GetDC(IWineD3DSurface
*iface
, HDC
*pHDC
) {
1293 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1294 WINED3DLOCKED_RECT lock
;
1298 TRACE("(%p)->(%p)\n",This
,pHDC
);
1300 if(This
->Flags
& SFLAG_USERPTR
) {
1301 ERR("Not supported on surfaces with an application-provided surfaces\n");
1302 return WINEDDERR_NODC
;
1305 /* Give more detailed info for ddraw */
1306 if (This
->Flags
& SFLAG_DCINUSE
)
1307 return WINEDDERR_DCALREADYCREATED
;
1309 /* Can't GetDC if the surface is locked */
1310 if (This
->Flags
& SFLAG_LOCKED
)
1311 return WINED3DERR_INVALIDCALL
;
1313 memset(&lock
, 0, sizeof(lock
)); /* To be sure */
1315 /* Create a DIB section if there isn't a hdc yet */
1317 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface
);
1318 if(This
->Flags
& SFLAG_CLIENT
) {
1319 IWineD3DSurface_PreLoad(iface
);
1322 /* Use the dib section from now on if we are not using a PBO */
1323 if(!(This
->Flags
& SFLAG_PBO
))
1324 This
->resource
.allocatedMemory
= This
->dib
.bitmap_data
;
1327 /* Lock the surface */
1328 hr
= IWineD3DSurface_LockRect(iface
,
1333 if(This
->Flags
& SFLAG_PBO
) {
1334 /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1335 memcpy(This
->dib
.bitmap_data
, This
->resource
.allocatedMemory
, This
->dib
.bitmap_size
);
1339 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr
);
1340 /* keep the dib section */
1344 if(This
->resource
.format
== WINED3DFMT_P8
||
1345 This
->resource
.format
== WINED3DFMT_A8P8
) {
1348 PALETTEENTRY ent
[256];
1350 GetPaletteEntries(This
->palette
->hpal
, 0, 256, ent
);
1351 for (n
=0; n
<256; n
++) {
1352 col
[n
].rgbRed
= ent
[n
].peRed
;
1353 col
[n
].rgbGreen
= ent
[n
].peGreen
;
1354 col
[n
].rgbBlue
= ent
[n
].peBlue
;
1355 col
[n
].rgbReserved
= 0;
1358 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1360 for (n
=0; n
<256; n
++) {
1361 col
[n
].rgbRed
= device
->palettes
[device
->currentPalette
][n
].peRed
;
1362 col
[n
].rgbGreen
= device
->palettes
[device
->currentPalette
][n
].peGreen
;
1363 col
[n
].rgbBlue
= device
->palettes
[device
->currentPalette
][n
].peBlue
;
1364 col
[n
].rgbReserved
= 0;
1368 SetDIBColorTable(This
->hDC
, 0, 256, col
);
1372 TRACE("returning %p\n",*pHDC
);
1373 This
->Flags
|= SFLAG_DCINUSE
;
1378 HRESULT WINAPI
IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface
*iface
, HDC hDC
) {
1379 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
1381 TRACE("(%p)->(%p)\n",This
,hDC
);
1383 if (!(This
->Flags
& SFLAG_DCINUSE
))
1384 return WINED3DERR_INVALIDCALL
;
1386 if (This
->hDC
!=hDC
) {
1387 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC
, This
->hDC
);
1388 return WINED3DERR_INVALIDCALL
;
1391 if((This
->Flags
& SFLAG_PBO
) && This
->resource
.allocatedMemory
) {
1392 /* Copy the contents of the DIB over to the PBO */
1393 memcpy(This
->resource
.allocatedMemory
, This
->dib
.bitmap_data
, This
->dib
.bitmap_size
);
1396 /* we locked first, so unlock now */
1397 IWineD3DSurface_UnlockRect(iface
);
1399 This
->Flags
&= ~SFLAG_DCINUSE
;
1404 /* ******************************************************
1405 IWineD3DSurface Internal (No mapping to directx api) parts follow
1406 ****************************************************** */
1408 HRESULT
d3dfmt_get_conv(IWineD3DSurfaceImpl
*This
, BOOL need_alpha_ck
, BOOL use_texturing
, GLenum
*format
, GLenum
*internal
, GLenum
*type
, CONVERT_TYPES
*convert
, int *target_bpp
, BOOL srgb_mode
) {
1409 BOOL colorkey_active
= need_alpha_ck
&& (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
);
1410 const GlPixelFormatDesc
*glDesc
;
1411 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1412 BOOL p8_render_target
= FALSE
;
1413 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
1415 /* Default values: From the surface */
1416 *format
= glDesc
->glFormat
;
1417 *internal
= srgb_mode
?glDesc
->glGammaInternal
:glDesc
->glInternal
;
1418 *type
= glDesc
->glType
;
1419 *convert
= NO_CONVERSION
;
1420 *target_bpp
= This
->bytesPerPixel
;
1422 /* Ok, now look if we have to do any conversion */
1423 switch(This
->resource
.format
) {
1429 if (device
->render_targets
&& device
->render_targets
[0]) {
1430 IWineD3DSurfaceImpl
* render_target
= (IWineD3DSurfaceImpl
*)device
->render_targets
[0];
1431 if((render_target
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) && (render_target
->resource
.format
== WINED3DFMT_P8
))
1432 p8_render_target
= TRUE
;
1435 /* Use conversion when the paletted texture extension is not available, or when it is available make sure it is used
1436 * for texturing as it won't work for calls like glDraw-/glReadPixels and further also use conversion in case of color keying.
1437 * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which conflicts with this.
1439 if( !(GL_SUPPORT(EXT_PALETTED_TEXTURE
) || (GL_SUPPORT(ARB_FRAGMENT_PROGRAM
) && p8_render_target
)) || colorkey_active
|| (!use_texturing
&& GL_SUPPORT(EXT_PALETTED_TEXTURE
)) ) {
1441 *internal
= GL_RGBA
;
1442 *type
= GL_UNSIGNED_BYTE
;
1444 if(colorkey_active
) {
1445 *convert
= CONVERT_PALETTED_CK
;
1447 *convert
= CONVERT_PALETTED
;
1450 else if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) {
1452 *internal
= GL_RGBA
;
1453 *type
= GL_UNSIGNED_BYTE
;
1459 case WINED3DFMT_R3G3B2
:
1460 /* **********************
1461 GL_UNSIGNED_BYTE_3_3_2
1462 ********************** */
1463 if (colorkey_active
) {
1464 /* This texture format will never be used.. So do not care about color keying
1465 up until the point in time it will be needed :-) */
1466 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1470 case WINED3DFMT_R5G6B5
:
1471 if (colorkey_active
) {
1472 *convert
= CONVERT_CK_565
;
1474 *internal
= GL_RGBA
;
1475 *type
= GL_UNSIGNED_SHORT_5_5_5_1
;
1479 case WINED3DFMT_X1R5G5B5
:
1480 if (colorkey_active
) {
1481 *convert
= CONVERT_CK_5551
;
1483 *internal
= GL_RGBA
;
1484 *type
= GL_UNSIGNED_SHORT_1_5_5_5_REV
;
1488 case WINED3DFMT_R8G8B8
:
1489 if (colorkey_active
) {
1490 *convert
= CONVERT_CK_RGB24
;
1492 *internal
= GL_RGBA
;
1493 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1498 case WINED3DFMT_X8R8G8B8
:
1499 if (colorkey_active
) {
1500 *convert
= CONVERT_RGB32_888
;
1502 *internal
= GL_RGBA
;
1503 *type
= GL_UNSIGNED_INT_8_8_8_8
;
1507 case WINED3DFMT_V8U8
:
1508 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1509 else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
1510 *format
= GL_DUDV_ATI
;
1511 *internal
= GL_DU8DV8_ATI
;
1513 /* No conversion - Just change the gl type */
1516 *convert
= CONVERT_V8U8
;
1518 *internal
= GL_RGB8
;
1519 *type
= GL_UNSIGNED_BYTE
;
1523 case WINED3DFMT_L6V5U5
:
1524 *convert
= CONVERT_L6V5U5
;
1525 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1527 /* Use format and types from table */
1529 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1532 *internal
= GL_RGB5
;
1533 *type
= GL_UNSIGNED_SHORT_5_6_5
;
1537 case WINED3DFMT_X8L8V8U8
:
1538 *convert
= CONVERT_X8L8V8U8
;
1540 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1541 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1542 * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1543 * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1544 * the needed type and format parameter, so the internal format contains a
1545 * 4th component, which is returned as alpha
1548 /* Not supported by GL_ATI_envmap_bumpmap */
1550 *internal
= GL_RGB8
;
1551 *type
= GL_UNSIGNED_INT_8_8_8_8_REV
;
1555 case WINED3DFMT_Q8W8V8U8
:
1556 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1557 *convert
= CONVERT_Q8W8V8U8
;
1559 *internal
= GL_RGBA8
;
1560 *type
= GL_UNSIGNED_BYTE
;
1562 /* Not supported by GL_ATI_envmap_bumpmap */
1565 case WINED3DFMT_V16U16
:
1566 if(GL_SUPPORT(NV_TEXTURE_SHADER3
)) break;
1567 *convert
= CONVERT_V16U16
;
1569 *internal
= GL_RGB16_EXT
;
1570 *type
= GL_UNSIGNED_SHORT
;
1572 /* What should I do here about GL_ATI_envmap_bumpmap?
1573 * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1577 case WINED3DFMT_A4L4
:
1578 /* A4L4 exists as an internal gl format, but for some reason there is not
1579 * format+type combination to load it. Thus convert it to A8L8, then load it
1580 * with A4L4 internal, but A8L8 format+type
1582 *convert
= CONVERT_A4L4
;
1583 *format
= GL_LUMINANCE_ALPHA
;
1584 *internal
= GL_LUMINANCE4_ALPHA4
;
1585 *type
= GL_UNSIGNED_BYTE
;
1589 case WINED3DFMT_R32F
:
1590 /* Can be loaded in theory with fmt=GL_RED, type=GL_FLOAT, but this fails. The reason
1591 * is that D3D expects the undefined green, blue and alpha channels to return 1.0
1592 * when sampling, but OpenGL sets green and blue to 0.0 instead. Thus we have to inject
1595 * The alpha channel defaults to 1.0 in opengl, so nothing has to be done about it.
1597 *convert
= CONVERT_R32F
;
1599 *internal
= GL_RGB32F_ARB
;
1604 case WINED3DFMT_R16F
:
1605 /* Similar to R32F */
1606 *convert
= CONVERT_R16F
;
1608 *internal
= GL_RGB16F_ARB
;
1609 *type
= GL_HALF_FLOAT_ARB
;
1620 HRESULT
d3dfmt_convert_surface(BYTE
*src
, BYTE
*dst
, UINT pitch
, UINT width
, UINT height
, UINT outpitch
, CONVERT_TYPES convert
, IWineD3DSurfaceImpl
*This
) {
1621 BYTE
*source
, *dest
;
1622 TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src
, dst
, pitch
, height
, outpitch
, convert
,This
);
1627 memcpy(dst
, src
, pitch
* height
);
1630 case CONVERT_PALETTED
:
1631 case CONVERT_PALETTED_CK
:
1633 IWineD3DPaletteImpl
* pal
= This
->palette
;
1638 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1641 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
1643 for (y
= 0; y
< height
; y
++)
1645 source
= src
+ pitch
* y
;
1646 dest
= dst
+ outpitch
* y
;
1647 /* This is an 1 bpp format, using the width here is fine */
1648 for (x
= 0; x
< width
; x
++) {
1649 BYTE color
= *source
++;
1650 *dest
++ = table
[color
][0];
1651 *dest
++ = table
[color
][1];
1652 *dest
++ = table
[color
][2];
1653 *dest
++ = table
[color
][3];
1659 case CONVERT_CK_565
:
1661 /* Converting the 565 format in 5551 packed to emulate color-keying.
1663 Note : in all these conversion, it would be best to average the averaging
1664 pixels to get the color of the pixel that will be color-keyed to
1665 prevent 'color bleeding'. This will be done later on if ever it is
1668 Note2: Nvidia documents say that their driver does not support alpha + color keying
1669 on the same surface and disables color keying in such a case
1675 TRACE("Color keyed 565\n");
1677 for (y
= 0; y
< height
; y
++) {
1678 Source
= (WORD
*) (src
+ y
* pitch
);
1679 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1680 for (x
= 0; x
< width
; x
++ ) {
1681 WORD color
= *Source
++;
1682 *Dest
= ((color
& 0xFFC0) | ((color
& 0x1F) << 1));
1683 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1684 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1693 case CONVERT_CK_5551
:
1695 /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1699 TRACE("Color keyed 5551\n");
1700 for (y
= 0; y
< height
; y
++) {
1701 Source
= (WORD
*) (src
+ y
* pitch
);
1702 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1703 for (x
= 0; x
< width
; x
++ ) {
1704 WORD color
= *Source
++;
1706 if ((color
< This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
1707 (color
> This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1711 *Dest
&= ~(1 << 15);
1723 unsigned char *Dest
;
1724 for(y
= 0; y
< height
; y
++) {
1725 Source
= (short *) (src
+ y
* pitch
);
1726 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1727 for (x
= 0; x
< width
; x
++ ) {
1728 long color
= (*Source
++);
1729 /* B */ Dest
[0] = 0xff;
1730 /* G */ Dest
[1] = (color
>> 8) + 128; /* V */
1731 /* R */ Dest
[2] = (color
) + 128; /* U */
1738 case CONVERT_V16U16
:
1742 unsigned short *Dest
;
1743 for(y
= 0; y
< height
; y
++) {
1744 Source
= (DWORD
*) (src
+ y
* pitch
);
1745 Dest
= (unsigned short *) (dst
+ y
* outpitch
);
1746 for (x
= 0; x
< width
; x
++ ) {
1747 DWORD color
= (*Source
++);
1748 /* B */ Dest
[0] = 0xffff;
1749 /* G */ Dest
[1] = (color
>> 16) + 32768; /* V */
1750 /* R */ Dest
[2] = (color
) + 32768; /* U */
1757 case CONVERT_Q8W8V8U8
:
1761 unsigned char *Dest
;
1762 for(y
= 0; y
< height
; y
++) {
1763 Source
= (DWORD
*) (src
+ y
* pitch
);
1764 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1765 for (x
= 0; x
< width
; x
++ ) {
1766 long color
= (*Source
++);
1767 /* B */ Dest
[0] = ((color
>> 16) & 0xff) + 128; /* W */
1768 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1769 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1770 /* A */ Dest
[3] = ((color
>> 24) & 0xff) + 128; /* Q */
1777 case CONVERT_L6V5U5
:
1781 unsigned char *Dest
;
1783 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1784 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
1785 * fixed function and shaders without further conversion once the surface is
1788 for(y
= 0; y
< height
; y
++) {
1789 Source
= (WORD
*) (src
+ y
* pitch
);
1790 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1791 for (x
= 0; x
< width
; x
++ ) {
1792 short color
= (*Source
++);
1793 unsigned char l
= ((color
>> 10) & 0xfc);
1794 char v
= ((color
>> 5) & 0x3e);
1795 char u
= ((color
) & 0x1f);
1797 /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
1798 * and doubles the positive range. Thus shift left only once, gl does the 2nd
1799 * shift. GL reads a signed value and converts it into an unsigned value.
1801 /* M */ Dest
[2] = l
<< 1;
1803 /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
1804 * from 5 bit values to 8 bit values.
1806 /* V */ Dest
[1] = v
<< 3;
1807 /* U */ Dest
[0] = u
<< 3;
1812 for(y
= 0; y
< height
; y
++) {
1813 unsigned short *Dest_s
= (unsigned short *) (dst
+ y
* outpitch
);
1814 Source
= (WORD
*) (src
+ y
* pitch
);
1815 for (x
= 0; x
< width
; x
++ ) {
1816 short color
= (*Source
++);
1817 unsigned char l
= ((color
>> 10) & 0xfc);
1818 short v
= ((color
>> 5) & 0x3e);
1819 short u
= ((color
) & 0x1f);
1820 short v_conv
= v
+ 16;
1821 short u_conv
= u
+ 16;
1823 *Dest_s
= ((v_conv
<< 11) & 0xf800) | ((l
<< 5) & 0x7e0) | (u_conv
& 0x1f);
1831 case CONVERT_X8L8V8U8
:
1835 unsigned char *Dest
;
1837 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1838 /* This implementation works with the fixed function pipeline and shaders
1839 * without further modification after converting the surface.
1841 for(y
= 0; y
< height
; y
++) {
1842 Source
= (DWORD
*) (src
+ y
* pitch
);
1843 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1844 for (x
= 0; x
< width
; x
++ ) {
1845 long color
= (*Source
++);
1846 /* L */ Dest
[2] = ((color
>> 16) & 0xff); /* L */
1847 /* V */ Dest
[1] = ((color
>> 8 ) & 0xff); /* V */
1848 /* U */ Dest
[0] = (color
& 0xff); /* U */
1849 /* I */ Dest
[3] = 255; /* X */
1854 /* Doesn't work correctly with the fixed function pipeline, but can work in
1855 * shaders if the shader is adjusted. (There's no use for this format in gl's
1856 * standard fixed function pipeline anyway).
1858 for(y
= 0; y
< height
; y
++) {
1859 Source
= (DWORD
*) (src
+ y
* pitch
);
1860 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1861 for (x
= 0; x
< width
; x
++ ) {
1862 long color
= (*Source
++);
1863 /* B */ Dest
[0] = ((color
>> 16) & 0xff); /* L */
1864 /* G */ Dest
[1] = ((color
>> 8 ) & 0xff) + 128; /* V */
1865 /* R */ Dest
[2] = (color
& 0xff) + 128; /* U */
1876 unsigned char *Source
;
1877 unsigned char *Dest
;
1878 for(y
= 0; y
< height
; y
++) {
1879 Source
= (unsigned char *) (src
+ y
* pitch
);
1880 Dest
= (unsigned char *) (dst
+ y
* outpitch
);
1881 for (x
= 0; x
< width
; x
++ ) {
1882 unsigned char color
= (*Source
++);
1883 /* A */ Dest
[1] = (color
& 0xf0) << 0;
1884 /* L */ Dest
[0] = (color
& 0x0f) << 4;
1896 for(y
= 0; y
< height
; y
++) {
1897 Source
= (float *) (src
+ y
* pitch
);
1898 Dest
= (float *) (dst
+ y
* outpitch
);
1899 for (x
= 0; x
< width
; x
++ ) {
1900 float color
= (*Source
++);
1916 for(y
= 0; y
< height
; y
++) {
1917 Source
= (WORD
*) (src
+ y
* pitch
);
1918 Dest
= (WORD
*) (dst
+ y
* outpitch
);
1919 for (x
= 0; x
< width
; x
++ ) {
1920 WORD color
= (*Source
++);
1930 ERR("Unsupported conversation type %d\n", convert
);
1935 static void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl
*This
, BYTE table
[256][4], BOOL colorkey
) {
1936 IWineD3DPaletteImpl
* pal
= This
->palette
;
1937 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1938 BOOL index_in_alpha
= FALSE
;
1941 /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
1942 * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
1943 * is slow. Further RGB->P8 conversion is not possible because palettes can have
1944 * duplicate entries. Store the color key in the unused alpha component to speed the
1945 * download up and to make conversion unneeded. */
1946 if (device
->render_targets
&& device
->render_targets
[0]) {
1947 IWineD3DSurfaceImpl
* render_target
= (IWineD3DSurfaceImpl
*)device
->render_targets
[0];
1949 if(render_target
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
)
1950 index_in_alpha
= TRUE
;
1954 /* Still no palette? Use the device's palette */
1955 /* Get the surface's palette */
1956 for (i
= 0; i
< 256; i
++) {
1957 table
[i
][0] = device
->palettes
[device
->currentPalette
][i
].peRed
;
1958 table
[i
][1] = device
->palettes
[device
->currentPalette
][i
].peGreen
;
1959 table
[i
][2] = device
->palettes
[device
->currentPalette
][i
].peBlue
;
1961 if(index_in_alpha
) {
1963 } else if (colorkey
&&
1964 (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1965 (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1966 /* We should maybe here put a more 'neutral' color than the standard bright purple
1967 one often used by application to prevent the nice purple borders when bi-linear
1975 TRACE("Using surface palette %p\n", pal
);
1976 /* Get the surface's palette */
1977 for (i
= 0; i
< 256; i
++) {
1978 table
[i
][0] = pal
->palents
[i
].peRed
;
1979 table
[i
][1] = pal
->palents
[i
].peGreen
;
1980 table
[i
][2] = pal
->palents
[i
].peBlue
;
1982 if(index_in_alpha
) {
1985 else if (colorkey
&&
1986 (i
>= This
->SrcBltCKey
.dwColorSpaceLowValue
) &&
1987 (i
<= This
->SrcBltCKey
.dwColorSpaceHighValue
)) {
1988 /* We should maybe here put a more 'neutral' color than the standard bright purple
1989 one often used by application to prevent the nice purple borders when bi-linear
1992 } else if(pal
->Flags
& WINEDDPCAPS_ALPHA
) {
1993 table
[i
][3] = pal
->palents
[i
].peFlags
;
2001 const char *fragment_palette_conversion
=
2004 "PARAM constants = { 0.996, 0.00195, 0, 0 };\n" /* { 255/256, 0.5/255*255/256, 0, 0 } */
2005 "TEX index.x, fragment.texcoord[0], texture[0], 2D;\n" /* store the red-component of the current pixel */
2006 "MAD index.x, index.x, constants.x, constants.y;\n" /* Scale the index by 255/256 and add a bias of '0.5' in order to sample in the middle */
2007 "TEX result.color, index, texture[1], 1D;\n" /* use the red-component as a index in the palette to get the final color */
2010 /* This function is used in case of 8bit paletted textures to upload the palette.
2011 It supports GL_EXT_paletted_texture and GL_ARB_fragment_program, support for other
2012 extensions like ATI_fragment_shaders is possible.
2014 static void d3dfmt_p8_upload_palette(IWineD3DSurface
*iface
, CONVERT_TYPES convert
) {
2015 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2017 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2019 d3dfmt_p8_init_palette(This
, table
, (convert
== CONVERT_PALETTED_CK
));
2021 /* Try to use the paletted texture extension */
2022 if(GL_SUPPORT(EXT_PALETTED_TEXTURE
))
2024 TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
2025 GL_EXTCALL(glColorTableEXT(GL_TEXTURE_2D
,GL_RGBA
,256,GL_RGBA
,GL_UNSIGNED_BYTE
, table
));
2029 /* Let a fragment shader do the color conversion by uploading the palette to a 1D texture.
2030 * The 8bit pixel data will be used as an index in this palette texture to retrieve the final color. */
2031 TRACE("Using fragment shaders for emulating 8-bit paletted texture support\n");
2033 /* Create the fragment program if we don't have it */
2034 if(!device
->paletteConversionShader
)
2036 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2037 GL_EXTCALL(glGenProgramsARB(1, &device
->paletteConversionShader
));
2038 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2039 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
, strlen(fragment_palette_conversion
), (const GLbyte
*)fragment_palette_conversion
));
2040 glDisable(GL_FRAGMENT_PROGRAM_ARB
);
2043 glEnable(GL_FRAGMENT_PROGRAM_ARB
);
2044 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB
, device
->paletteConversionShader
));
2046 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE1
));
2047 glEnable(GL_TEXTURE_1D
);
2048 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
2050 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2051 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
); /* Make sure we have discrete color levels. */
2052 glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
2053 glTexImage1D(GL_TEXTURE_1D
, 0, GL_RGBA
, 256, 0, GL_RGBA
, GL_UNSIGNED_BYTE
, table
); /* Upload the palette */
2055 /* Switch back to unit 0 in which the 2D texture will be stored. */
2056 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0
));
2058 /* Rebind the texture because it isn't bound anymore */
2059 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2063 static BOOL
palette9_changed(IWineD3DSurfaceImpl
*This
) {
2064 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2066 if(This
->palette
|| (This
->resource
.format
!= WINED3DFMT_P8
&& This
->resource
.format
!= WINED3DFMT_A8P8
)) {
2067 /* If a ddraw-style palette is attached assume no d3d9 palette change.
2068 * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2073 if(This
->palette9
) {
2074 if(memcmp(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256) == 0) {
2078 This
->palette9
= HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY
) * 256);
2080 memcpy(This
->palette9
, &device
->palettes
[device
->currentPalette
], sizeof(PALETTEENTRY
) * 256);
2084 static inline void clear_unused_channels(IWineD3DSurfaceImpl
*This
) {
2085 GLboolean oldwrite
[4];
2087 /* Some formats have only some color channels, and the others are 1.0.
2088 * since our rendering renders to all channels, and those pixel formats
2089 * are emulated by using a full texture with the other channels set to 1.0
2090 * manually, clear the unused channels.
2092 * This could be done with hacking colorwriteenable to mask the colors,
2093 * but before drawing the buffer would have to be cleared too, so there's
2096 switch(This
->resource
.format
) {
2097 case WINED3DFMT_R16F
:
2098 case WINED3DFMT_R32F
:
2099 TRACE("R16F or R32F format, clearing green, blue and alpha to 1.0\n");
2100 /* Do not activate a context, the correct drawable is active already
2101 * though just the read buffer is set, make sure to have the correct draw
2104 glDrawBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
2105 glDisable(GL_SCISSOR_TEST
);
2106 glGetBooleanv(GL_COLOR_WRITEMASK
, oldwrite
);
2107 glColorMask(GL_FALSE
, GL_TRUE
, GL_TRUE
, GL_TRUE
);
2108 glClearColor(0.0, 1.0, 1.0, 1.0);
2109 glClear(GL_COLOR_BUFFER_BIT
);
2110 glColorMask(oldwrite
[0], oldwrite
[1], oldwrite
[2], oldwrite
[3]);
2111 if(!This
->resource
.wineD3DDevice
->render_offscreen
) glDrawBuffer(GL_BACK
);
2112 checkGLcall("Unused channel clear\n");
2119 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface
*iface
, BOOL srgb_mode
) {
2120 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2122 if (!(This
->Flags
& SFLAG_INTEXTURE
)) {
2123 TRACE("Reloading because surface is dirty\n");
2124 } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2125 ((This
->Flags
& SFLAG_GLCKEY
) && (!(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
))) ||
2126 /* Reload: vice versa OR */
2127 ((!(This
->Flags
& SFLAG_GLCKEY
)) && (This
->CKeyFlags
& WINEDDSD_CKSRCBLT
)) ||
2128 /* Also reload: Color key is active AND the color key has changed */
2129 ((This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) && (
2130 (This
->glCKey
.dwColorSpaceLowValue
!= This
->SrcBltCKey
.dwColorSpaceLowValue
) ||
2131 (This
->glCKey
.dwColorSpaceHighValue
!= This
->SrcBltCKey
.dwColorSpaceHighValue
)))) {
2132 TRACE("Reloading because of color keying\n");
2133 /* To perform the color key conversion we need a sysmem copy of
2134 * the surface. Make sure we have it
2136 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
2137 } else if(palette9_changed(This
)) {
2138 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
2139 /* TODO: This is not necessarily needed with hw palettized texture support */
2140 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
);
2142 TRACE("surface is already in texture\n");
2146 /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2147 * These resources are not bound by device size or format restrictions. Because of this,
2148 * these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2149 * However, these resources can always be created, locked, and copied.
2151 if (This
->resource
.pool
== WINED3DPOOL_SCRATCH
)
2153 FIXME("(%p) Operation not supported for scratch textures\n",This
);
2154 return WINED3DERR_INVALIDCALL
;
2157 This
->srgb
= srgb_mode
;
2158 IWineD3DSurface_LoadLocation(iface
, SFLAG_INTEXTURE
, NULL
/* no partial locking for textures yet */);
2162 static unsigned int gen
= 0;
2165 if ((gen
% 10) == 0) {
2166 snprintf(buffer
, sizeof(buffer
), "/tmp/surface%p_type%u_level%u_%u.ppm", This
, This
->glDescription
.target
, This
->glDescription
.level
, gen
);
2167 IWineD3DSurfaceImpl_SaveSnapshot(iface
, buffer
);
2170 * debugging crash code
2179 if (!(This
->Flags
& SFLAG_DONOTFREE
)) {
2180 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
2181 This
->resource
.allocatedMemory
= NULL
;
2182 This
->resource
.heapMemory
= NULL
;
2183 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, FALSE
);
2189 static void WINAPI
IWineD3DSurfaceImpl_BindTexture(IWineD3DSurface
*iface
) {
2190 /* TODO: check for locks */
2191 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2192 IWineD3DBaseTexture
*baseTexture
= NULL
;
2193 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
2195 TRACE("(%p)Checking to see if the container is a base texture\n", This
);
2196 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2197 TRACE("Passing to container\n");
2198 IWineD3DBaseTexture_BindTexture(baseTexture
);
2199 IWineD3DBaseTexture_Release(baseTexture
);
2201 TRACE("(%p) : Binding surface\n", This
);
2203 if(!device
->isInDraw
) {
2204 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
2207 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2215 HRESULT WINAPI
IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface
*iface
, const char* filename
) {
2218 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2219 char *allocatedMemory
;
2221 IWineD3DSwapChain
*swapChain
= NULL
;
2223 GLuint tmpTexture
= 0;
2226 Textures may not be stored in ->allocatedgMemory and a GlTexture
2227 so we should lock the surface before saving a snapshot, or at least check that
2229 /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2230 by calling GetTexImage and in compressed form by calling
2231 GetCompressedTexImageARB. Queried compressed images can be saved and
2232 later reused by calling CompressedTexImage[123]DARB. Pre-compressed
2233 texture images do not need to be processed by the GL and should
2234 significantly improve texture loading performance relative to uncompressed
2237 /* Setup the width and height to be the internal texture width and height. */
2238 width
= This
->pow2Width
;
2239 height
= This
->pow2Height
;
2240 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2241 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **)&swapChain
);
2243 if (This
->Flags
& SFLAG_INDRAWABLE
&& !(This
->Flags
& SFLAG_INTEXTURE
)) {
2244 /* if were not a real texture then read the back buffer into a real texture */
2245 /* we don't want to interfere with the back buffer so read the data into a temporary
2246 * texture and then save the data out of the temporary texture
2250 TRACE("(%p) Reading render target into texture\n", This
);
2251 glEnable(GL_TEXTURE_2D
);
2253 glGenTextures(1, &tmpTexture
);
2254 glBindTexture(GL_TEXTURE_2D
, tmpTexture
);
2256 glTexImage2D(GL_TEXTURE_2D
,
2263 GL_UNSIGNED_INT_8_8_8_8_REV
,
2266 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
2267 vcheckGLcall("glGetIntegerv");
2268 glReadBuffer(swapChain
? GL_BACK
: This
->resource
.wineD3DDevice
->offscreenBuffer
);
2269 vcheckGLcall("glReadBuffer");
2270 glCopyTexImage2D(GL_TEXTURE_2D
,
2279 checkGLcall("glCopyTexImage2D");
2280 glReadBuffer(prevRead
);
2283 } else { /* bind the real texture, and make sure it up to date */
2284 IWineD3DSurface_PreLoad(iface
);
2286 allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, width
* height
* 4);
2288 FIXME("Saving texture level %d width %d height %d\n", This
->glDescription
.level
, width
, height
);
2289 glGetTexImage(GL_TEXTURE_2D
,
2290 This
->glDescription
.level
,
2292 GL_UNSIGNED_INT_8_8_8_8_REV
,
2294 checkGLcall("glTexImage2D");
2296 glBindTexture(GL_TEXTURE_2D
, 0);
2297 glDeleteTextures(1, &tmpTexture
);
2301 f
= fopen(filename
, "w+");
2303 ERR("opening of %s failed with: %s\n", filename
, strerror(errno
));
2304 return WINED3DERR_INVALIDCALL
;
2306 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2307 TRACE("(%p) opened %s with format %s\n", This
, filename
, debug_d3dformat(This
->resource
.format
));
2322 fwrite(&width
,2,1,f
);
2324 fwrite(&height
,2,1,f
);
2329 /* if the data is upside down if we've fetched it from a back buffer, so it needs flipping again to make it the correct way up */
2331 textureRow
= allocatedMemory
+ (width
* (height
- 1) *4);
2333 textureRow
= allocatedMemory
;
2334 for (y
= 0 ; y
< height
; y
++) {
2335 for (i
= 0; i
< width
; i
++) {
2336 color
= *((DWORD
*)textureRow
);
2337 fputc((color
>> 16) & 0xFF, f
); /* B */
2338 fputc((color
>> 8) & 0xFF, f
); /* G */
2339 fputc((color
>> 0) & 0xFF, f
); /* R */
2340 fputc((color
>> 24) & 0xFF, f
); /* A */
2343 /* take two rows of the pointer to the texture memory */
2345 (textureRow
-= width
<< 3);
2348 TRACE("Closing file\n");
2352 IWineD3DSwapChain_Release(swapChain
);
2354 HeapFree(GetProcessHeap(), 0, allocatedMemory
);
2359 * Slightly inefficient way to handle multiple dirty rects but it works :)
2361 extern HRESULT WINAPI
IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface
*iface
, CONST RECT
* pDirtyRect
) {
2362 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2363 IWineD3DBaseTexture
*baseTexture
= NULL
;
2365 if (!(This
->Flags
& SFLAG_INSYSMEM
) && (This
->Flags
& SFLAG_INTEXTURE
))
2366 IWineD3DSurface_LoadLocation(iface
, SFLAG_INSYSMEM
, NULL
/* no partial locking for textures yet */);
2368 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2369 if (NULL
!= pDirtyRect
) {
2370 This
->dirtyRect
.left
= min(This
->dirtyRect
.left
, pDirtyRect
->left
);
2371 This
->dirtyRect
.top
= min(This
->dirtyRect
.top
, pDirtyRect
->top
);
2372 This
->dirtyRect
.right
= max(This
->dirtyRect
.right
, pDirtyRect
->right
);
2373 This
->dirtyRect
.bottom
= max(This
->dirtyRect
.bottom
, pDirtyRect
->bottom
);
2375 This
->dirtyRect
.left
= 0;
2376 This
->dirtyRect
.top
= 0;
2377 This
->dirtyRect
.right
= This
->currentDesc
.Width
;
2378 This
->dirtyRect
.bottom
= This
->currentDesc
.Height
;
2380 TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This
, This
->dirtyRect
.left
,
2381 This
->dirtyRect
.top
, This
->dirtyRect
.right
, This
->dirtyRect
.bottom
);
2382 /* if the container is a basetexture then mark it dirty. */
2383 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&baseTexture
) == WINED3D_OK
) {
2384 TRACE("Passing to container\n");
2385 IWineD3DBaseTexture_SetDirty(baseTexture
, TRUE
);
2386 IWineD3DBaseTexture_Release(baseTexture
);
2391 HRESULT WINAPI
IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface
*iface
, WINED3DFORMAT format
) {
2392 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2394 const GlPixelFormatDesc
*glDesc
;
2395 getFormatDescEntry(format
, &GLINFO_LOCATION
, &glDesc
);
2397 TRACE("(%p) : Calling base function first\n", This
);
2398 hr
= IWineD3DBaseSurfaceImpl_SetFormat(iface
, format
);
2400 /* Setup some glformat defaults */
2401 This
->glDescription
.glFormat
= glDesc
->glFormat
;
2402 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
2403 This
->glDescription
.glType
= glDesc
->glType
;
2405 This
->Flags
&= ~SFLAG_ALLOCATED
;
2406 TRACE("(%p) : glFormat %d, glFotmatInternal %d, glType %d\n", This
,
2407 This
->glDescription
.glFormat
, This
->glDescription
.glFormatInternal
, This
->glDescription
.glType
);
2412 HRESULT WINAPI
IWineD3DSurfaceImpl_SetMem(IWineD3DSurface
*iface
, void *Mem
) {
2413 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
2415 if(This
->Flags
& (SFLAG_LOCKED
| SFLAG_DCINUSE
)) {
2416 WARN("Surface is locked or the HDC is in use\n");
2417 return WINED3DERR_INVALIDCALL
;
2420 if(Mem
&& Mem
!= This
->resource
.allocatedMemory
) {
2421 void *release
= NULL
;
2423 /* Do I have to copy the old surface content? */
2424 if(This
->Flags
& SFLAG_DIBSECTION
) {
2425 /* Release the DC. No need to hold the critical section for the update
2426 * Thread because this thread runs only on front buffers, but this method
2427 * fails for render targets in the check above.
2429 SelectObject(This
->hDC
, This
->dib
.holdbitmap
);
2430 DeleteDC(This
->hDC
);
2431 /* Release the DIB section */
2432 DeleteObject(This
->dib
.DIBsection
);
2433 This
->dib
.bitmap_data
= NULL
;
2434 This
->resource
.allocatedMemory
= NULL
;
2436 This
->Flags
&= ~SFLAG_DIBSECTION
;
2437 } else if(!(This
->Flags
& SFLAG_USERPTR
)) {
2438 release
= This
->resource
.heapMemory
;
2439 This
->resource
.heapMemory
= NULL
;
2441 This
->resource
.allocatedMemory
= Mem
;
2442 This
->Flags
|= SFLAG_USERPTR
| SFLAG_INSYSMEM
;
2444 /* Now the surface memory is most up do date. Invalidate drawable and texture */
2445 IWineD3DSurface_ModifyLocation(iface
, SFLAG_INSYSMEM
, TRUE
);
2447 /* For client textures opengl has to be notified */
2448 if(This
->Flags
& SFLAG_CLIENT
) {
2449 This
->Flags
&= ~SFLAG_ALLOCATED
;
2450 IWineD3DSurface_PreLoad(iface
);
2451 /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2454 /* Now free the old memory if any */
2455 HeapFree(GetProcessHeap(), 0, release
);
2456 } else if(This
->Flags
& SFLAG_USERPTR
) {
2457 /* Lockrect and GetDC will re-create the dib section and allocated memory */
2458 This
->resource
.allocatedMemory
= NULL
;
2459 /* HeapMemory should be NULL already */
2460 if(This
->resource
.heapMemory
!= NULL
) ERR("User pointer surface has heap memory allocated\n");
2461 This
->Flags
&= ~SFLAG_USERPTR
;
2463 if(This
->Flags
& SFLAG_CLIENT
) {
2464 This
->Flags
&= ~SFLAG_ALLOCATED
;
2465 /* This respecifies an empty texture and opengl knows that the old memory is gone */
2466 IWineD3DSurface_PreLoad(iface
);
2472 static HRESULT WINAPI
IWineD3DSurfaceImpl_Flip(IWineD3DSurface
*iface
, IWineD3DSurface
*override
, DWORD Flags
) {
2473 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
2474 IWineD3DSwapChainImpl
*swapchain
= NULL
;
2476 TRACE("(%p)->(%p,%x)\n", This
, override
, Flags
);
2478 /* Flipping is only supported on RenderTargets */
2479 if( !(This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ) return WINEDDERR_NOTFLIPPABLE
;
2482 /* DDraw sets this for the X11 surfaces, so don't confuse the user
2483 * FIXME("(%p) Target override is not supported by now\n", This);
2484 * Additionally, it isn't really possible to support triple-buffering
2485 * properly on opengl at all
2489 IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
2491 ERR("Flipped surface is not on a swapchain\n");
2492 return WINEDDERR_NOTFLIPPABLE
;
2495 /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2496 * and only d3d8 and d3d9 apps specify the presentation interval
2498 if((Flags
& (WINEDDFLIP_NOVSYNC
| WINEDDFLIP_INTERVAL2
| WINEDDFLIP_INTERVAL3
| WINEDDFLIP_INTERVAL4
)) == 0) {
2499 /* Most common case first to avoid wasting time on all the other cases */
2500 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_ONE
;
2501 } else if(Flags
& WINEDDFLIP_NOVSYNC
) {
2502 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
2503 } else if(Flags
& WINEDDFLIP_INTERVAL2
) {
2504 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_TWO
;
2505 } else if(Flags
& WINEDDFLIP_INTERVAL3
) {
2506 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_THREE
;
2508 swapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_FOUR
;
2511 /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2512 hr
= IWineD3DSwapChain_Present((IWineD3DSwapChain
*) swapchain
, NULL
, NULL
, 0, NULL
, 0);
2513 IWineD3DSwapChain_Release((IWineD3DSwapChain
*) swapchain
);
2517 /* Does a direct frame buffer -> texture copy. Stretching is done
2518 * with single pixel copy calls
2520 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2521 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2524 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2527 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2529 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2531 /* Bind the target texture */
2532 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
2533 checkGLcall("glBindTexture");
2535 glReadBuffer(myDevice
->offscreenBuffer
);
2537 GLenum buffer
= surface_get_gl_buffer(SrcSurface
, (IWineD3DSwapChain
*)swapchain
);
2538 glReadBuffer(buffer
);
2540 checkGLcall("glReadBuffer");
2542 xrel
= (float) (srect
->x2
- srect
->x1
) / (float) (drect
->x2
- drect
->x1
);
2543 yrel
= (float) (srect
->y2
- srect
->y1
) / (float) (drect
->y2
- drect
->y1
);
2545 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2546 FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2548 if(Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) {
2549 ERR("Texture filtering not supported in direct blit\n");
2551 } else if((Filter
!= WINED3DTEXF_NONE
&& Filter
!= WINED3DTEXF_POINT
) && ((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2552 ERR("Texture filtering not supported in direct blit\n");
2556 !((xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) &&
2557 !((yrel
- 1.0 < -eps
) || (yrel
- 1.0 > eps
))) {
2558 /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2560 glCopyTexSubImage2D(This
->glDescription
.target
,
2561 This
->glDescription
.level
,
2562 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2563 srect
->x1
, Src
->currentDesc
.Height
- srect
->y2
,
2564 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2566 UINT yoffset
= Src
->currentDesc
.Height
- srect
->y1
+ drect
->y1
- 1;
2567 /* I have to process this row by row to swap the image,
2568 * otherwise it would be upside down, so stretching in y direction
2569 * doesn't cost extra time
2571 * However, stretching in x direction can be avoided if not necessary
2573 for(row
= drect
->y1
; row
< drect
->y2
; row
++) {
2574 if( (xrel
- 1.0 < -eps
) || (xrel
- 1.0 > eps
)) {
2575 /* Well, that stuff works, but it's very slow.
2576 * find a better way instead
2580 for(col
= drect
->x1
; col
< drect
->x2
; col
++) {
2581 glCopyTexSubImage2D(This
->glDescription
.target
,
2582 This
->glDescription
.level
,
2583 drect
->x1
+ col
, row
, /* xoffset, yoffset */
2584 srect
->x1
+ col
* xrel
, yoffset
- (int) (row
* yrel
),
2588 glCopyTexSubImage2D(This
->glDescription
.target
,
2589 This
->glDescription
.level
,
2590 drect
->x1
, row
, /* xoffset, yoffset */
2591 srect
->x1
, yoffset
- (int) (row
* yrel
),
2592 drect
->x2
-drect
->x1
, 1);
2597 vcheckGLcall("glCopyTexSubImage2D");
2601 /* Uses the hardware to stretch and flip the image */
2602 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl
*This
, IWineD3DSurface
*SrcSurface
, IWineD3DSwapChainImpl
*swapchain
, WINED3DRECT
*srect
, WINED3DRECT
*drect
, BOOL upsidedown
, WINED3DTEXTUREFILTERTYPE Filter
) {
2603 GLuint src
, backup
= 0;
2604 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2605 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2606 float left
, right
, top
, bottom
; /* Texture coordinates */
2607 UINT fbwidth
= Src
->currentDesc
.Width
;
2608 UINT fbheight
= Src
->currentDesc
.Height
;
2609 GLenum drawBuffer
= GL_BACK
;
2611 TRACE("Using hwstretch blit\n");
2612 /* Activate the Proper context for reading from the source surface, set it up for blitting */
2613 ActivateContext(myDevice
, SrcSurface
, CTXUSAGE_BLIT
);
2615 IWineD3DSurface_PreLoad((IWineD3DSurface
*) This
);
2617 /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2618 * This way we don't have to wait for the 2nd readback to finish to leave this function.
2620 if(GL_LIMITS(aux_buffers
) >= 2) {
2621 /* Got more than one aux buffer? Use the 2nd aux buffer */
2622 drawBuffer
= GL_AUX1
;
2623 } else if((swapchain
|| myDevice
->offscreenBuffer
== GL_BACK
) && GL_LIMITS(aux_buffers
) >= 1) {
2624 /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2625 drawBuffer
= GL_AUX0
;
2628 if(!swapchain
&& wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
2629 glGenTextures(1, &backup
);
2630 checkGLcall("glGenTextures\n");
2631 glBindTexture(GL_TEXTURE_2D
, backup
);
2632 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2634 /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2635 * we are reading from the back buffer, the backup can be used as source texture
2637 if(Src
->glDescription
.textureName
== 0) {
2638 /* Get it a description */
2639 IWineD3DSurface_PreLoad(SrcSurface
);
2641 glBindTexture(GL_TEXTURE_2D
, Src
->glDescription
.textureName
);
2642 checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2644 /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2645 Src
->Flags
&= ~SFLAG_INTEXTURE
;
2648 glReadBuffer(GL_BACK
);
2649 checkGLcall("glReadBuffer(GL_BACK)");
2651 /* TODO: Only back up the part that will be overwritten */
2652 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2653 0, 0 /* read offsets */,
2658 checkGLcall("glCopyTexSubImage2D");
2660 /* No issue with overriding these - the sampler is dirty due to blit usage */
2661 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
,
2662 stateLookup
[WINELOOKUP_MAGFILTER
][Filter
- minLookup
[WINELOOKUP_MAGFILTER
]]);
2663 checkGLcall("glTexParameteri");
2664 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
2665 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
2666 checkGLcall("glTexParameteri");
2668 if(!swapchain
|| (IWineD3DSurface
*) Src
== swapchain
->backBuffer
[0]) {
2669 src
= backup
? backup
: Src
->glDescription
.textureName
;
2671 glReadBuffer(GL_FRONT
);
2672 checkGLcall("glReadBuffer(GL_FRONT)");
2674 glGenTextures(1, &src
);
2675 checkGLcall("glGenTextures(1, &src)");
2676 glBindTexture(GL_TEXTURE_2D
, src
);
2677 checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2679 /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2680 * out for power of 2 sizes
2682 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA
, Src
->pow2Width
, Src
->pow2Height
, 0,
2683 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
2684 checkGLcall("glTexImage2D");
2685 glCopyTexSubImage2D(GL_TEXTURE_2D
, 0,
2686 0, 0 /* read offsets */,
2691 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
2692 checkGLcall("glTexParameteri");
2693 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
2694 checkGLcall("glTexParameteri");
2696 glReadBuffer(GL_BACK
);
2697 checkGLcall("glReadBuffer(GL_BACK)");
2699 checkGLcall("glEnd and previous");
2701 left
= (float) srect
->x1
/ (float) Src
->pow2Width
;
2702 right
= (float) srect
->x2
/ (float) Src
->pow2Width
;
2705 top
= (float) (Src
->currentDesc
.Height
- srect
->y1
) / (float) Src
->pow2Height
;
2706 bottom
= (float) (Src
->currentDesc
.Height
- srect
->y2
) / (float) Src
->pow2Height
;
2708 top
= (float) (Src
->currentDesc
.Height
- srect
->y2
) / (float) Src
->pow2Height
;
2709 bottom
= (float) (Src
->currentDesc
.Height
- srect
->y1
) / (float) Src
->pow2Height
;
2712 /* draw the source texture stretched and upside down. The correct surface is bound already */
2713 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
2714 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
2716 glDrawBuffer(drawBuffer
);
2717 glReadBuffer(drawBuffer
);
2721 glTexCoord2f(left
, bottom
);
2722 glVertex2i(0, fbheight
);
2725 glTexCoord2f(left
, top
);
2726 glVertex2i(0, fbheight
- drect
->y2
- drect
->y1
);
2729 glTexCoord2f(right
, top
);
2730 glVertex2i(drect
->x2
- drect
->x1
, fbheight
- drect
->y2
- drect
->y1
);
2733 glTexCoord2f(right
, bottom
);
2734 glVertex2i(drect
->x2
- drect
->x1
, fbheight
);
2736 checkGLcall("glEnd and previous");
2738 /* Now read the stretched and upside down image into the destination texture */
2739 glBindTexture(This
->glDescription
.target
, This
->glDescription
.textureName
);
2740 checkGLcall("glBindTexture");
2741 glCopyTexSubImage2D(This
->glDescription
.target
,
2743 drect
->x1
, drect
->y1
, /* xoffset, yoffset */
2744 0, 0, /* We blitted the image to the origin */
2745 drect
->x2
- drect
->x1
, drect
->y2
- drect
->y1
);
2746 checkGLcall("glCopyTexSubImage2D");
2748 /* Write the back buffer backup back */
2749 glBindTexture(GL_TEXTURE_2D
, backup
? backup
: Src
->glDescription
.textureName
);
2750 checkGLcall("glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName)");
2752 if(drawBuffer
== GL_BACK
) {
2755 glTexCoord2f(0.0, (float) fbheight
/ (float) Src
->pow2Height
);
2759 glTexCoord2f(0.0, 0.0);
2760 glVertex2i(0, fbheight
);
2763 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, 0.0);
2764 glVertex2i(fbwidth
, Src
->currentDesc
.Height
);
2767 glTexCoord2f((float) fbwidth
/ (float) Src
->pow2Width
, (float) fbheight
/ (float) Src
->pow2Height
);
2768 glVertex2i(fbwidth
, 0);
2771 /* Restore the old draw buffer */
2772 glDrawBuffer(GL_BACK
);
2776 if(src
!= Src
->glDescription
.textureName
&& src
!= backup
) {
2777 glDeleteTextures(1, &src
);
2778 checkGLcall("glDeleteTextures(1, &src)");
2781 glDeleteTextures(1, &backup
);
2782 checkGLcall("glDeleteTextures(1, &backup)");
2787 /* Not called from the VTable */
2788 static HRESULT
IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
2790 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
2791 IWineD3DSwapChainImpl
*srcSwapchain
= NULL
, *dstSwapchain
= NULL
;
2792 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
2794 TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
2796 /* Get the swapchain. One of the surfaces has to be a primary surface */
2797 if(This
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
2798 WARN("Destination is in sysmem, rejecting gl blt\n");
2799 return WINED3DERR_INVALIDCALL
;
2801 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) This
, &IID_IWineD3DSwapChain
, (void **)&dstSwapchain
);
2802 if(dstSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) dstSwapchain
);
2804 if(Src
->resource
.pool
== WINED3DPOOL_SYSTEMMEM
) {
2805 WARN("Src is in sysmem, rejecting gl blt\n");
2806 return WINED3DERR_INVALIDCALL
;
2808 IWineD3DSurface_GetContainer( (IWineD3DSurface
*) Src
, &IID_IWineD3DSwapChain
, (void **)&srcSwapchain
);
2809 if(srcSwapchain
) IWineD3DSwapChain_Release((IWineD3DSwapChain
*) srcSwapchain
);
2812 /* Early sort out of cases where no render target is used */
2813 if(!dstSwapchain
&& !srcSwapchain
&&
2814 SrcSurface
!= myDevice
->render_targets
[0] && This
!= (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
2815 TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src
, This
);
2816 return WINED3DERR_INVALIDCALL
;
2819 /* No destination color keying supported */
2820 if(Flags
& (WINEDDBLT_KEYDEST
| WINEDDBLT_KEYDESTOVERRIDE
)) {
2821 /* Can we support that with glBlendFunc if blitting to the frame buffer? */
2822 TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
2823 return WINED3DERR_INVALIDCALL
;
2827 rect
.x1
= DestRect
->left
;
2828 rect
.y1
= DestRect
->top
;
2829 rect
.x2
= DestRect
->right
;
2830 rect
.y2
= DestRect
->bottom
;
2834 rect
.x2
= This
->currentDesc
.Width
;
2835 rect
.y2
= This
->currentDesc
.Height
;
2838 /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
2839 if(dstSwapchain
&& dstSwapchain
== srcSwapchain
&& dstSwapchain
->backBuffer
&&
2840 ((IWineD3DSurface
*) This
== dstSwapchain
->frontBuffer
) && SrcSurface
== dstSwapchain
->backBuffer
[0]) {
2841 /* Half-life does a Blt from the back buffer to the front buffer,
2842 * Full surface size, no flags... Use present instead
2844 * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
2847 /* Check rects - IWineD3DDevice_Present doesn't handle them */
2851 TRACE("Looking if a Present can be done...\n");
2852 /* Source Rectangle must be full surface */
2854 if(SrcRect
->left
!= 0 || SrcRect
->top
!= 0 ||
2855 SrcRect
->right
!= Src
->currentDesc
.Width
|| SrcRect
->bottom
!= Src
->currentDesc
.Height
) {
2856 TRACE("No, Source rectangle doesn't match\n");
2862 mySrcRect
.right
= Src
->currentDesc
.Width
;
2863 mySrcRect
.bottom
= Src
->currentDesc
.Height
;
2865 /* No stretching may occur */
2866 if(mySrcRect
.right
!= rect
.x2
- rect
.x1
||
2867 mySrcRect
.bottom
!= rect
.y2
- rect
.y1
) {
2868 TRACE("No, stretching is done\n");
2872 /* Destination must be full surface or match the clipping rectangle */
2873 if(This
->clipper
&& ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
)
2877 GetClientRect(((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
, &cliprect
);
2882 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl
*) This
->clipper
)->hWnd
,
2885 if(pos
[0].x
!= cliprect
.left
|| pos
[0].y
!= cliprect
.top
||
2886 pos
[1].x
!= cliprect
.right
|| pos
[1].y
!= cliprect
.bottom
)
2888 TRACE("No, dest rectangle doesn't match(clipper)\n");
2889 TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect
.left
, cliprect
.top
, cliprect
.right
, cliprect
.bottom
);
2890 TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect
.x1
, rect
.y1
, rect
.x2
, rect
.y2
);
2896 if(rect
.x1
!= 0 || rect
.y1
!= 0 ||
2897 rect
.x2
!= This
->currentDesc
.Width
|| rect
.y2
!= This
->currentDesc
.Height
) {
2898 TRACE("No, dest rectangle doesn't match(surface size)\n");
2905 /* These flags are unimportant for the flag check, remove them */
2906 if((Flags
& ~(WINEDDBLT_DONOTWAIT
| WINEDDBLT_WAIT
)) == 0) {
2907 WINED3DSWAPEFFECT orig_swap
= dstSwapchain
->presentParms
.SwapEffect
;
2909 /* The idea behind this is that a glReadPixels and a glDrawPixels call
2910 * take very long, while a flip is fast.
2911 * This applies to Half-Life, which does such Blts every time it finished
2912 * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
2913 * menu. This is also used by all apps when they do windowed rendering
2915 * The problem is that flipping is not really the same as copying. After a
2916 * Blt the front buffer is a copy of the back buffer, and the back buffer is
2917 * untouched. Therefore it's necessary to override the swap effect
2918 * and to set it back after the flip.
2920 * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
2924 dstSwapchain
->presentParms
.SwapEffect
= WINED3DSWAPEFFECT_COPY
;
2925 dstSwapchain
->presentParms
.PresentationInterval
= WINED3DPRESENT_INTERVAL_IMMEDIATE
;
2927 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
2928 IWineD3DSwapChain_Present((IWineD3DSwapChain
*) dstSwapchain
, NULL
, NULL
, 0, NULL
, 0);
2930 dstSwapchain
->presentParms
.SwapEffect
= orig_swap
;
2937 TRACE("Unsupported blit between buffers on the same swapchain\n");
2938 return WINED3DERR_INVALIDCALL
;
2939 } else if((dstSwapchain
|| This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) &&
2940 (srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) ) {
2941 ERR("Can't perform hardware blit between 2 different swapchains, falling back to software\n");
2942 return WINED3DERR_INVALIDCALL
;
2945 if(srcSwapchain
|| SrcSurface
== myDevice
->render_targets
[0]) {
2946 /* Blit from render target to texture */
2948 BOOL upsideDown
, stretchx
;
2950 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
2951 TRACE("Color keying not supported by frame buffer to texture blit\n");
2952 return WINED3DERR_INVALIDCALL
;
2953 /* Destination color key is checked above */
2956 /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
2957 * glCopyTexSubImage is a bit picky about the parameters we pass to it
2960 if(SrcRect
->top
< SrcRect
->bottom
) {
2961 srect
.y1
= SrcRect
->top
;
2962 srect
.y2
= SrcRect
->bottom
;
2965 srect
.y1
= SrcRect
->bottom
;
2966 srect
.y2
= SrcRect
->top
;
2969 srect
.x1
= SrcRect
->left
;
2970 srect
.x2
= SrcRect
->right
;
2974 srect
.x2
= Src
->currentDesc
.Width
;
2975 srect
.y2
= Src
->currentDesc
.Height
;
2978 if(rect
.x1
> rect
.x2
) {
2982 upsideDown
= !upsideDown
;
2985 TRACE("Reading from an offscreen target\n");
2986 upsideDown
= !upsideDown
;
2989 if(rect
.x2
- rect
.x1
!= srect
.x2
- srect
.x1
) {
2995 /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
2996 * flip the image nor scale it.
2998 * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
2999 * -> If the app wants a image width an unscaled width, copy it line per line
3000 * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3001 * than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3002 * back buffer. This is slower than reading line per line, thus not used for flipping
3003 * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3006 * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3007 * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3010 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& GL_SUPPORT(EXT_FRAMEBUFFER_BLIT
)) {
3011 stretch_rect_fbo((IWineD3DDevice
*)myDevice
, SrcSurface
, &srect
,
3012 (IWineD3DSurface
*)This
, &rect
, Filter
, upsideDown
);
3013 } else if((!stretchx
) || rect
.x2
- rect
.x1
> Src
->currentDesc
.Width
||
3014 rect
.y2
- rect
.y1
> Src
->currentDesc
.Height
) {
3015 TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3016 fb_copy_to_texture_direct(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
3018 TRACE("Using hardware stretching to flip / stretch the texture\n");
3019 fb_copy_to_texture_hwstretch(This
, SrcSurface
, srcSwapchain
, &srect
, &rect
, upsideDown
, Filter
);
3022 if(!(This
->Flags
& SFLAG_DONOTFREE
)) {
3023 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
3024 This
->resource
.allocatedMemory
= NULL
;
3025 This
->resource
.heapMemory
= NULL
;
3027 This
->Flags
&= ~SFLAG_INSYSMEM
;
3029 /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3030 * path is never entered
3032 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INTEXTURE
, TRUE
);
3036 /* Blit from offscreen surface to render target */
3037 float glTexCoord
[4];
3038 DWORD oldCKeyFlags
= Src
->CKeyFlags
;
3039 WINEDDCOLORKEY oldBltCKey
= This
->SrcBltCKey
;
3040 RECT SourceRectangle
;
3042 TRACE("Blt from surface %p to rendertarget %p\n", Src
, This
);
3045 SourceRectangle
.left
= SrcRect
->left
;
3046 SourceRectangle
.right
= SrcRect
->right
;
3047 SourceRectangle
.top
= SrcRect
->top
;
3048 SourceRectangle
.bottom
= SrcRect
->bottom
;
3050 SourceRectangle
.left
= 0;
3051 SourceRectangle
.right
= Src
->currentDesc
.Width
;
3052 SourceRectangle
.top
= 0;
3053 SourceRectangle
.bottom
= Src
->currentDesc
.Height
;
3056 if(!CalculateTexRect(Src
, &SourceRectangle
, glTexCoord
)) {
3057 /* Fall back to software */
3058 WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src
,
3059 SourceRectangle
.left
, SourceRectangle
.top
,
3060 SourceRectangle
.right
, SourceRectangle
.bottom
);
3061 return WINED3DERR_INVALIDCALL
;
3064 /* Color keying: Check if we have to do a color keyed blt,
3065 * and if not check if a color key is activated.
3067 * Just modify the color keying parameters in the surface and restore them afterwards
3068 * The surface keeps track of the color key last used to load the opengl surface.
3069 * PreLoad will catch the change to the flags and color key and reload if necessary.
3071 if(Flags
& WINEDDBLT_KEYSRC
) {
3072 /* Use color key from surface */
3073 } else if(Flags
& WINEDDBLT_KEYSRCOVERRIDE
) {
3074 /* Use color key from DDBltFx */
3075 Src
->CKeyFlags
|= WINEDDSD_CKSRCBLT
;
3076 This
->SrcBltCKey
= DDBltFx
->ddckSrcColorkey
;
3078 /* Do not use color key */
3079 Src
->CKeyFlags
&= ~WINEDDSD_CKSRCBLT
;
3082 /* Now load the surface */
3083 IWineD3DSurface_PreLoad((IWineD3DSurface
*) Src
);
3086 /* Activate the destination context, set it up for blitting */
3087 ActivateContext(myDevice
, (IWineD3DSurface
*) This
, CTXUSAGE_BLIT
);
3091 TRACE("Drawing to offscreen buffer\n");
3092 glDrawBuffer(myDevice
->offscreenBuffer
);
3093 checkGLcall("glDrawBuffer");
3095 GLenum buffer
= surface_get_gl_buffer((IWineD3DSurface
*)This
, (IWineD3DSwapChain
*)dstSwapchain
);
3096 TRACE("Drawing to %#x buffer\n", buffer
);
3097 glDrawBuffer(buffer
);
3098 checkGLcall("glDrawBuffer");
3101 /* Bind the texture */
3102 glBindTexture(GL_TEXTURE_2D
, Src
->glDescription
.textureName
);
3103 checkGLcall("glBindTexture");
3105 /* Filtering for StretchRect */
3106 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
,
3107 stateLookup
[WINELOOKUP_MAGFILTER
][Filter
- minLookup
[WINELOOKUP_MAGFILTER
]]);
3108 checkGLcall("glTexParameteri");
3109 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
3110 minMipLookup
[Filter
][WINED3DTEXF_NONE
]);
3111 checkGLcall("glTexParameteri");
3112 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
3113 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
3114 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
3115 checkGLcall("glTexEnvi");
3117 /* This is for color keying */
3118 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3119 glEnable(GL_ALPHA_TEST
);
3120 checkGLcall("glEnable GL_ALPHA_TEST");
3121 glAlphaFunc(GL_NOTEQUAL
, 0.0);
3122 checkGLcall("glAlphaFunc\n");
3124 glDisable(GL_ALPHA_TEST
);
3125 checkGLcall("glDisable GL_ALPHA_TEST");
3128 /* Draw a textured quad
3132 glColor3d(1.0f
, 1.0f
, 1.0f
);
3133 glTexCoord2f(glTexCoord
[0], glTexCoord
[2]);
3138 glTexCoord2f(glTexCoord
[0], glTexCoord
[3]);
3139 glVertex3f(rect
.x1
, rect
.y2
, 0.0);
3141 glTexCoord2f(glTexCoord
[1], glTexCoord
[3]);
3146 glTexCoord2f(glTexCoord
[1], glTexCoord
[2]);
3151 checkGLcall("glEnd");
3153 if(Flags
& (WINEDDBLT_KEYSRC
| WINEDDBLT_KEYSRCOVERRIDE
)) {
3154 glDisable(GL_ALPHA_TEST
);
3155 checkGLcall("glDisable(GL_ALPHA_TEST)");
3158 /* Flush in case the drawable is used by multiple GL contexts */
3159 if(dstSwapchain
&& (dstSwapchain
->num_contexts
>= 2))
3162 /* Unbind the texture */
3163 glBindTexture(GL_TEXTURE_2D
, 0);
3164 checkGLcall("glEnable glBindTexture");
3166 /* The draw buffer should only need to be restored if we were drawing to the front buffer, and there is a back buffer.
3167 * otherwise the context manager should choose between GL_BACK / offscreenDrawBuffer
3169 if(dstSwapchain
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
&& dstSwapchain
->backBuffer
) {
3170 glDrawBuffer(GL_BACK
);
3171 checkGLcall("glDrawBuffer");
3173 /* Restore the color key parameters */
3174 Src
->CKeyFlags
= oldCKeyFlags
;
3175 This
->SrcBltCKey
= oldBltCKey
;
3179 /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3180 /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3183 IWineD3DSurface_ModifyLocation((IWineD3DSurface
*) This
, SFLAG_INDRAWABLE
, TRUE
);
3184 /* TODO: This should be moved to ModifyLocation() */
3185 if(!(dstSwapchain
|| wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
)) {
3186 This
->Flags
|= SFLAG_INTEXTURE
;
3191 /* Source-Less Blit to render target */
3192 if (Flags
& WINEDDBLT_COLORFILL
) {
3193 /* This is easy to handle for the D3D Device... */
3196 TRACE("Colorfill\n");
3198 /* The color as given in the Blt function is in the format of the frame-buffer...
3199 * 'clear' expect it in ARGB format => we need to do some conversion :-)
3201 if (This
->resource
.format
== WINED3DFMT_P8
) {
3202 if (This
->palette
) {
3203 color
= ((0xFF000000) |
3204 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peRed
<< 16) |
3205 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peGreen
<< 8) |
3206 (This
->palette
->palents
[DDBltFx
->u5
.dwFillColor
].peBlue
));
3211 else if (This
->resource
.format
== WINED3DFMT_R5G6B5
) {
3212 if (DDBltFx
->u5
.dwFillColor
== 0xFFFF) {
3215 color
= ((0xFF000000) |
3216 ((DDBltFx
->u5
.dwFillColor
& 0xF800) << 8) |
3217 ((DDBltFx
->u5
.dwFillColor
& 0x07E0) << 5) |
3218 ((DDBltFx
->u5
.dwFillColor
& 0x001F) << 3));
3221 else if ((This
->resource
.format
== WINED3DFMT_R8G8B8
) ||
3222 (This
->resource
.format
== WINED3DFMT_X8R8G8B8
) ) {
3223 color
= 0xFF000000 | DDBltFx
->u5
.dwFillColor
;
3225 else if (This
->resource
.format
== WINED3DFMT_A8R8G8B8
) {
3226 color
= DDBltFx
->u5
.dwFillColor
;
3229 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3230 return WINED3DERR_INVALIDCALL
;
3233 TRACE("Calling GetSwapChain with mydevice = %p\n", myDevice
);
3234 if(dstSwapchain
&& dstSwapchain
->backBuffer
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->backBuffer
[0]) {
3235 glDrawBuffer(GL_BACK
);
3236 checkGLcall("glDrawBuffer(GL_BACK)");
3237 } else if (dstSwapchain
&& This
== (IWineD3DSurfaceImpl
*) dstSwapchain
->frontBuffer
) {
3238 glDrawBuffer(GL_FRONT
);
3239 checkGLcall("glDrawBuffer(GL_FRONT)");
3240 } else if(This
== (IWineD3DSurfaceImpl
*) myDevice
->render_targets
[0]) {
3241 glDrawBuffer(myDevice
->offscreenBuffer
);
3242 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer3)");
3244 TRACE("Surface is higher back buffer, falling back to software\n");
3245 return WINED3DERR_INVALIDCALL
;
3248 TRACE("(%p) executing Render Target override, color = %x\n", This
, color
);
3250 IWineD3DDevice_Clear( (IWineD3DDevice
*) myDevice
,
3251 1 /* Number of rectangles */,
3253 WINED3DCLEAR_TARGET
,
3258 /* Restore the original draw buffer */
3260 glDrawBuffer(myDevice
->offscreenBuffer
);
3261 } else if(dstSwapchain
->backBuffer
&& dstSwapchain
->backBuffer
[0]) {
3262 glDrawBuffer(GL_BACK
);
3264 vcheckGLcall("glDrawBuffer");
3270 /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3271 TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3272 return WINED3DERR_INVALIDCALL
;
3275 static HRESULT WINAPI
IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl
*This
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
)
3277 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3280 if (Flags
& WINEDDBLT_DEPTHFILL
) {
3281 switch(This
->resource
.format
) {
3282 case WINED3DFMT_D16
:
3283 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000ffff;
3285 case WINED3DFMT_D15S1
:
3286 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x0000fffe;
3288 case WINED3DFMT_D24S8
:
3289 case WINED3DFMT_D24X8
:
3290 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0x00ffffff;
3292 case WINED3DFMT_D32
:
3293 depth
= (float) DDBltFx
->u5
.dwFillDepth
/ (float) 0xffffffff;
3297 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This
->resource
.format
));
3300 return IWineD3DDevice_Clear((IWineD3DDevice
*) myDevice
,
3301 DestRect
== NULL
? 0 : 1,
3302 (WINED3DRECT
*) DestRect
,
3303 WINED3DCLEAR_ZBUFFER
,
3309 FIXME("(%p): Unsupp depthstencil blit\n", This
);
3310 return WINED3DERR_INVALIDCALL
;
3313 static HRESULT WINAPI
IWineD3DSurfaceImpl_Blt(IWineD3DSurface
*iface
, RECT
*DestRect
, IWineD3DSurface
*SrcSurface
, RECT
*SrcRect
, DWORD Flags
, WINEDDBLTFX
*DDBltFx
, WINED3DTEXTUREFILTERTYPE Filter
) {
3314 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*)iface
;
3315 IWineD3DSurfaceImpl
*Src
= (IWineD3DSurfaceImpl
*) SrcSurface
;
3316 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3317 TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
);
3318 TRACE("(%p): Usage is %s\n", This
, debug_d3dusage(This
->resource
.usage
));
3320 /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3321 * except depth blits, which seem to work
3323 if(iface
== myDevice
->stencilBufferTarget
|| (SrcSurface
&& SrcSurface
== myDevice
->stencilBufferTarget
)) {
3324 if(myDevice
->inScene
&& !(Flags
& WINEDDBLT_DEPTHFILL
)) {
3325 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3326 return WINED3DERR_INVALIDCALL
;
3327 } else if(IWineD3DSurfaceImpl_BltZ(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
) == WINED3D_OK
) {
3328 TRACE("Z Blit override handled the blit\n");
3333 /* Special cases for RenderTargets */
3334 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3335 ( Src
&& (Src
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3336 if(IWineD3DSurfaceImpl_BltOverride(This
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
) == WINED3D_OK
) return WINED3D_OK
;
3339 /* For the rest call the X11 surface implementation.
3340 * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3341 * other Blts are rather rare
3343 return IWineD3DBaseSurfaceImpl_Blt(iface
, DestRect
, SrcSurface
, SrcRect
, Flags
, DDBltFx
, Filter
);
3346 HRESULT WINAPI
IWineD3DSurfaceImpl_BltFast(IWineD3DSurface
*iface
, DWORD dstx
, DWORD dsty
, IWineD3DSurface
*Source
, RECT
*rsrc
, DWORD trans
) {
3347 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3348 IWineD3DSurfaceImpl
*srcImpl
= (IWineD3DSurfaceImpl
*) Source
;
3349 IWineD3DDeviceImpl
*myDevice
= This
->resource
.wineD3DDevice
;
3350 TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3352 if(myDevice
->inScene
&&
3353 (iface
== myDevice
->stencilBufferTarget
||
3354 (Source
&& Source
== myDevice
->stencilBufferTarget
))) {
3355 TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3356 return WINED3DERR_INVALIDCALL
;
3359 /* Special cases for RenderTargets */
3360 if( (This
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) ||
3361 ( srcImpl
&& (srcImpl
->resource
.usage
& WINED3DUSAGE_RENDERTARGET
) )) {
3363 RECT SrcRect
, DstRect
;
3367 SrcRect
.left
= rsrc
->left
;
3368 SrcRect
.top
= rsrc
->top
;
3369 SrcRect
.bottom
= rsrc
->bottom
;
3370 SrcRect
.right
= rsrc
->right
;
3374 SrcRect
.right
= srcImpl
->currentDesc
.Width
;
3375 SrcRect
.bottom
= srcImpl
->currentDesc
.Height
;
3378 DstRect
.left
= dstx
;
3380 DstRect
.right
= dstx
+ SrcRect
.right
- SrcRect
.left
;
3381 DstRect
.bottom
= dsty
+ SrcRect
.bottom
- SrcRect
.top
;
3383 /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3384 if(trans
& WINEDDBLTFAST_SRCCOLORKEY
)
3385 Flags
|= WINEDDBLT_KEYSRC
;
3386 if(trans
& WINEDDBLTFAST_DESTCOLORKEY
)
3387 Flags
|= WINEDDBLT_KEYDEST
;
3388 if(trans
& WINEDDBLTFAST_WAIT
)
3389 Flags
|= WINEDDBLT_WAIT
;
3390 if(trans
& WINEDDBLTFAST_DONOTWAIT
)
3391 Flags
|= WINEDDBLT_DONOTWAIT
;
3393 if(IWineD3DSurfaceImpl_BltOverride(This
, &DstRect
, Source
, &SrcRect
, Flags
, NULL
, WINED3DTEXF_POINT
) == WINED3D_OK
) return WINED3D_OK
;
3397 return IWineD3DBaseSurfaceImpl_BltFast(iface
, dstx
, dsty
, Source
, rsrc
, trans
);
3400 static HRESULT WINAPI
IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface
*iface
) {
3401 /** Check against the maximum texture sizes supported by the video card **/
3402 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3403 unsigned int pow2Width
, pow2Height
;
3404 const GlPixelFormatDesc
*glDesc
;
3406 getFormatDescEntry(This
->resource
.format
, &GLINFO_LOCATION
, &glDesc
);
3407 /* Setup some glformat defaults */
3408 This
->glDescription
.glFormat
= glDesc
->glFormat
;
3409 This
->glDescription
.glFormatInternal
= glDesc
->glInternal
;
3410 This
->glDescription
.glType
= glDesc
->glType
;
3412 This
->glDescription
.textureName
= 0;
3413 This
->glDescription
.target
= GL_TEXTURE_2D
;
3415 /* Non-power2 support */
3416 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO
)) {
3417 pow2Width
= This
->currentDesc
.Width
;
3418 pow2Height
= This
->currentDesc
.Height
;
3420 /* Find the nearest pow2 match */
3421 pow2Width
= pow2Height
= 1;
3422 while (pow2Width
< This
->currentDesc
.Width
) pow2Width
<<= 1;
3423 while (pow2Height
< This
->currentDesc
.Height
) pow2Height
<<= 1;
3425 This
->pow2Width
= pow2Width
;
3426 This
->pow2Height
= pow2Height
;
3428 if (pow2Width
> This
->currentDesc
.Width
|| pow2Height
> This
->currentDesc
.Height
) {
3429 WINED3DFORMAT Format
= This
->resource
.format
;
3430 /** TODO: add support for non power two compressed textures **/
3431 if (Format
== WINED3DFMT_DXT1
|| Format
== WINED3DFMT_DXT2
|| Format
== WINED3DFMT_DXT3
3432 || Format
== WINED3DFMT_DXT4
|| Format
== WINED3DFMT_DXT5
) {
3433 FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3434 This
, This
->currentDesc
.Width
, This
->currentDesc
.Height
);
3435 return WINED3DERR_NOTAVAILABLE
;
3439 if(pow2Width
!= This
->currentDesc
.Width
||
3440 pow2Height
!= This
->currentDesc
.Height
) {
3441 This
->Flags
|= SFLAG_NONPOW2
;
3444 TRACE("%p\n", This
);
3445 if ((This
->pow2Width
> GL_LIMITS(texture_size
) || This
->pow2Height
> GL_LIMITS(texture_size
)) && !(This
->resource
.usage
& (WINED3DUSAGE_RENDERTARGET
| WINED3DUSAGE_DEPTHSTENCIL
))) {
3446 /* one of three options
3447 1: Do the same as we do with nonpow 2 and scale the texture, (any texture ops would require the texture to be scaled which is potentially slow)
3448 2: Set the texture to the maximum size (bad idea)
3449 3: WARN and return WINED3DERR_NOTAVAILABLE;
3450 4: Create the surface, but allow it to be used only for DirectDraw Blts. Some apps(e.g. Swat 3) create textures with a Height of 16 and a Width > 3000 and blt 16x16 letter areas from them to the render target.
3452 WARN("(%p) Creating an oversized surface\n", This
);
3453 This
->Flags
|= SFLAG_OVERSIZE
;
3455 /* This will be initialized on the first blt */
3456 This
->glRect
.left
= 0;
3457 This
->glRect
.top
= 0;
3458 This
->glRect
.right
= 0;
3459 This
->glRect
.bottom
= 0;
3461 /* No oversize, gl rect is the full texture size */
3462 This
->Flags
&= ~SFLAG_OVERSIZE
;
3463 This
->glRect
.left
= 0;
3464 This
->glRect
.top
= 0;
3465 This
->glRect
.right
= This
->pow2Width
;
3466 This
->glRect
.bottom
= This
->pow2Height
;
3469 This
->Flags
|= SFLAG_INSYSMEM
;
3474 static void WINAPI
IWineD3DSurfaceImpl_ModifyLocation(IWineD3DSurface
*iface
, DWORD flag
, BOOL persistent
) {
3475 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3476 IWineD3DBaseTexture
*texture
;
3478 TRACE("(%p)->(%s, %s)\n", iface
,
3479 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
3480 persistent
? "TRUE" : "FALSE");
3482 /* TODO: For offscreen textures with fbo offscreen rendering the drawable is the same as the texture.*/
3484 if((This
->Flags
& SFLAG_INTEXTURE
) && !(flag
& SFLAG_INTEXTURE
)) {
3485 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&texture
) == WINED3D_OK
) {
3486 TRACE("Passing to container\n");
3487 IWineD3DBaseTexture_SetDirty(texture
, TRUE
);
3488 IWineD3DBaseTexture_Release(texture
);
3491 This
->Flags
&= ~SFLAG_LOCATIONS
;
3492 This
->Flags
|= flag
;
3494 if((This
->Flags
& SFLAG_INTEXTURE
) && (flag
& SFLAG_INTEXTURE
)) {
3495 if (IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DBaseTexture
, (void **)&texture
) == WINED3D_OK
) {
3496 TRACE("Passing to container\n");
3497 IWineD3DBaseTexture_SetDirty(texture
, TRUE
);
3498 IWineD3DBaseTexture_Release(texture
);
3501 This
->Flags
&= ~flag
;
3509 static inline void surface_blt_to_drawable(IWineD3DSurfaceImpl
*This
, const RECT
*rect_in
) {
3510 struct coords coords
[4];
3512 IWineD3DSwapChain
*swapchain
= NULL
;
3514 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3521 rect
.right
= This
->currentDesc
.Width
;
3522 rect
.bottom
= This
->currentDesc
.Height
;
3525 ActivateContext(device
, device
->render_targets
[0], CTXUSAGE_BLIT
);
3528 if(This
->glDescription
.target
== GL_TEXTURE_2D
) {
3529 glBindTexture(GL_TEXTURE_2D
, This
->glDescription
.textureName
);
3530 checkGLcall("GL_TEXTURE_2D, This->glDescription.textureName)");
3531 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
3532 checkGLcall("glTexParameteri");
3533 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
3534 checkGLcall("glTexParameteri");
3536 coords
[0].x
= rect
.left
/ This
->pow2Width
;
3539 coords
[1].x
= rect
.left
/ This
->pow2Width
;
3542 coords
[2].x
= rect
.right
/ This
->pow2Width
;
3545 coords
[3].x
= rect
.right
/ This
->pow2Width
;
3548 coords
[0].y
= rect
.top
/ This
->pow2Height
;
3549 coords
[1].y
= rect
.bottom
/ This
->pow2Height
;
3550 coords
[2].y
= rect
.bottom
/ This
->pow2Height
;
3551 coords
[3].y
= rect
.top
/ This
->pow2Height
;
3553 /* Must be a cube map */
3554 glDisable(GL_TEXTURE_2D
);
3555 checkGLcall("glDisable(GL_TEXTURE_2D)");
3556 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
3557 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
3558 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB
, This
->glDescription
.textureName
);
3559 checkGLcall("GL_TEXTURE_CUBE_MAP_ARB, This->glDescription.textureName)");
3560 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
3561 checkGLcall("glTexParameteri");
3562 glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
3563 checkGLcall("glTexParameteri");
3565 switch(This
->glDescription
.target
) {
3566 case GL_TEXTURE_CUBE_MAP_POSITIVE_X
:
3567 coords
[0].x
= 1; coords
[0].y
= -1; coords
[0].z
= 1;
3568 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
3569 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
3570 coords
[3].x
= 1; coords
[3].y
= -1; coords
[3].z
= -1;
3573 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X
:
3574 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
3575 coords
[1].x
= -1; coords
[1].y
= 1; coords
[1].z
= 1;
3576 coords
[2].x
= -1; coords
[2].y
= 1; coords
[2].z
= -1;
3577 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
3580 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y
:
3581 coords
[0].x
= -1; coords
[0].y
= 1; coords
[0].z
= 1;
3582 coords
[1].x
= 1; coords
[1].y
= 1; coords
[1].z
= 1;
3583 coords
[2].x
= 1; coords
[2].y
= 1; coords
[2].z
= -1;
3584 coords
[3].x
= -1; coords
[3].y
= 1; coords
[3].z
= -1;
3587 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
:
3588 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
3589 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
3590 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
3591 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
3594 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z
:
3595 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= 1;
3596 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= 1;
3597 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= 1;
3598 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= 1;
3601 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
:
3602 coords
[0].x
= -1; coords
[0].y
= -1; coords
[0].z
= -1;
3603 coords
[1].x
= 1; coords
[1].y
= -1; coords
[1].z
= -1;
3604 coords
[2].x
= 1; coords
[2].y
= -1; coords
[2].z
= -1;
3605 coords
[3].x
= -1; coords
[3].y
= -1; coords
[3].z
= -1;
3608 ERR("Unexpected texture target\n");
3615 glTexCoord3iv((GLint
*) &coords
[0]);
3616 glVertex2i(rect
.left
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
3618 glTexCoord3iv((GLint
*) &coords
[1]);
3619 glVertex2i(0, device
->render_offscreen
? rect
.top
: rect
.bottom
);
3621 glTexCoord3iv((GLint
*) &coords
[2]);
3622 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.top
: rect
.bottom
);
3624 glTexCoord3iv((GLint
*) &coords
[3]);
3625 glVertex2i(rect
.right
, device
->render_offscreen
? rect
.bottom
: rect
.top
);
3627 checkGLcall("glEnd");
3629 if(This
->glDescription
.target
!= GL_TEXTURE_2D
) {
3630 glEnable(GL_TEXTURE_2D
);
3631 checkGLcall("glEnable(GL_TEXTURE_2D)");
3632 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
3633 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3636 hr
= IWineD3DSurface_GetContainer((IWineD3DSurface
*)This
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
3637 if(hr
== WINED3D_OK
&& swapchain
) {
3638 /* Make sure to flush the buffers. This is needed in apps like Red Alert II and Tiberian SUN that use multiple WGL contexts. */
3639 if(((IWineD3DSwapChainImpl
*)swapchain
)->num_contexts
>= 2)
3642 IWineD3DSwapChain_Release(swapchain
);
3647 /*****************************************************************************
3648 * IWineD3DSurface::LoadLocation
3650 * Copies the current surface data from wherever it is to the requested
3651 * location. The location is one of the surface flags, SFLAG_INSYSMEM,
3652 * SFLAG_INTEXTURE and SFLAG_INDRAWABLE. When the surface is current in
3653 * multiple locations, the gl texture is prefered over the drawable, which is
3654 * prefered over system memory. The PBO counts as system memory. If rect is
3655 * not NULL, only the specified rectangle is copied(only supported for
3656 * sysmem<->drawable copies at the moment). If rect is NULL, the destination
3657 * location is marked up to date after the copy.
3660 * flag: Surface location flag to be updated
3661 * rect: rectangle to be copied
3664 * WINED3D_OK on success
3665 * WINED3DERR_DEVICELOST on an internal error
3667 *****************************************************************************/
3668 static HRESULT WINAPI
IWineD3DSurfaceImpl_LoadLocation(IWineD3DSurface
*iface
, DWORD flag
, const RECT
*rect
) {
3669 IWineD3DSurfaceImpl
*This
= (IWineD3DSurfaceImpl
*) iface
;
3670 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
3671 GLenum format
, internal
, type
;
3672 CONVERT_TYPES convert
;
3674 int width
, pitch
, outpitch
;
3677 TRACE("(%p)->(%s, %p)\n", iface
,
3678 flag
== SFLAG_INSYSMEM
? "SFLAG_INSYSMEM" : flag
== SFLAG_INDRAWABLE
? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
3681 TRACE("Rectangle: (%d,%d)-(%d,%d)\n", rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
3684 /* TODO: For fbo targets, texture == drawable */
3685 if(This
->Flags
& flag
) {
3686 TRACE("Location already up to date\n");
3690 if(!(This
->Flags
& SFLAG_LOCATIONS
)) {
3691 ERR("Surface does not have any up to date location\n");
3692 This
->Flags
|= SFLAG_LOST
;
3693 return WINED3DERR_DEVICELOST
;
3696 if(flag
== SFLAG_INSYSMEM
) {
3697 surface_prepare_system_memory(This
);
3699 /* Download the surface to system memory */
3700 if(This
->Flags
& SFLAG_INTEXTURE
) {
3701 surface_download_data(This
);
3703 read_from_framebuffer(This
, rect
,
3704 This
->resource
.allocatedMemory
,
3705 IWineD3DSurface_GetPitch(iface
));
3707 } else if(flag
== SFLAG_INDRAWABLE
) {
3708 if(This
->Flags
& SFLAG_INTEXTURE
) {
3709 surface_blt_to_drawable(This
, rect
);
3711 flush_to_framebuffer_drawpixels(This
);
3713 } else /* if(flag == SFLAG_INTEXTURE) */ {
3714 d3dfmt_get_conv(This
, TRUE
/* We need color keying */, TRUE
/* We will use textures */, &format
, &internal
, &type
, &convert
, &bpp
, This
->srgb
);
3716 if (This
->Flags
& SFLAG_INDRAWABLE
) {
3720 glGetIntegerv(GL_READ_BUFFER
, &prevRead
);
3721 vcheckGLcall("glGetIntegerv");
3722 glReadBuffer(This
->resource
.wineD3DDevice
->offscreenBuffer
);
3723 vcheckGLcall("glReadBuffer");
3725 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
3726 surface_allocate_surface(This
, internal
, This
->pow2Width
,
3727 This
->pow2Height
, format
, type
);
3730 clear_unused_channels(This
);
3732 glCopyTexSubImage2D(This
->glDescription
.target
,
3733 This
->glDescription
.level
,
3735 This
->currentDesc
.Width
,
3736 This
->currentDesc
.Height
);
3737 checkGLcall("glCopyTexSubImage2D");
3739 glReadBuffer(prevRead
);
3740 vcheckGLcall("glReadBuffer");
3744 TRACE("Updated target %d\n", This
->glDescription
.target
);
3746 /* The only place where LoadTexture() might get called when isInDraw=1
3747 * is ActivateContext where lastActiveRenderTarget is preloaded.
3749 if(iface
== device
->lastActiveRenderTarget
&& device
->isInDraw
)
3750 ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
3752 /* Otherwise: System memory copy must be most up to date */
3754 if(This
->CKeyFlags
& WINEDDSD_CKSRCBLT
) {
3755 This
->Flags
|= SFLAG_GLCKEY
;
3756 This
->glCKey
= This
->SrcBltCKey
;
3758 else This
->Flags
&= ~SFLAG_GLCKEY
;
3760 /* The width is in 'length' not in bytes */
3761 width
= This
->currentDesc
.Width
;
3762 pitch
= IWineD3DSurface_GetPitch(iface
);
3764 if((convert
!= NO_CONVERSION
) && This
->resource
.allocatedMemory
) {
3765 int height
= This
->currentDesc
.Height
;
3767 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
3768 outpitch
= width
* bpp
;
3769 outpitch
= (outpitch
+ device
->surface_alignment
- 1) & ~(device
->surface_alignment
- 1);
3771 mem
= HeapAlloc(GetProcessHeap(), 0, outpitch
* height
);
3773 ERR("Out of memory %d, %d!\n", outpitch
, height
);
3774 return WINED3DERR_OUTOFVIDEOMEMORY
;
3776 d3dfmt_convert_surface(This
->resource
.allocatedMemory
, mem
, pitch
, width
, height
, outpitch
, convert
, This
);
3778 This
->Flags
|= SFLAG_CONVERTED
;
3779 } else if( (This
->resource
.format
== WINED3DFMT_P8
) && (GL_SUPPORT(EXT_PALETTED_TEXTURE
) || GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) ) {
3780 d3dfmt_p8_upload_palette(iface
, convert
);
3781 This
->Flags
&= ~SFLAG_CONVERTED
;
3782 mem
= This
->resource
.allocatedMemory
;
3784 This
->Flags
&= ~SFLAG_CONVERTED
;
3785 mem
= This
->resource
.allocatedMemory
;
3788 /* Make sure the correct pitch is used */
3789 glPixelStorei(GL_UNPACK_ROW_LENGTH
, width
);
3791 if ((This
->Flags
& SFLAG_NONPOW2
) && !(This
->Flags
& SFLAG_OVERSIZE
)) {
3792 TRACE("non power of two support\n");
3793 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
3794 surface_allocate_surface(This
, internal
, This
->pow2Width
, This
->pow2Height
, format
, type
);
3796 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
3797 surface_upload_data(This
, internal
, This
->currentDesc
.Width
, This
->currentDesc
.Height
, format
, type
, mem
);
3800 /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
3801 * changed. So also keep track of memory changes. In this case the texture has to be reallocated
3803 if(!(This
->Flags
& SFLAG_ALLOCATED
)) {
3804 surface_allocate_surface(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
);
3806 if (mem
|| (This
->Flags
& SFLAG_PBO
)) {
3807 surface_upload_data(This
, internal
, This
->glRect
.right
- This
->glRect
.left
, This
->glRect
.bottom
- This
->glRect
.top
, format
, type
, mem
);
3811 /* Restore the default pitch */
3812 glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
3814 /* Don't delete PBO memory */
3815 if((mem
!= This
->resource
.allocatedMemory
) && !(This
->Flags
& SFLAG_PBO
))
3816 HeapFree(GetProcessHeap(), 0, mem
);
3821 This
->Flags
|= flag
;
3827 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl
=
3830 IWineD3DBaseSurfaceImpl_QueryInterface
,
3831 IWineD3DBaseSurfaceImpl_AddRef
,
3832 IWineD3DSurfaceImpl_Release
,
3833 /* IWineD3DResource */
3834 IWineD3DBaseSurfaceImpl_GetParent
,
3835 IWineD3DBaseSurfaceImpl_GetDevice
,
3836 IWineD3DBaseSurfaceImpl_SetPrivateData
,
3837 IWineD3DBaseSurfaceImpl_GetPrivateData
,
3838 IWineD3DBaseSurfaceImpl_FreePrivateData
,
3839 IWineD3DBaseSurfaceImpl_SetPriority
,
3840 IWineD3DBaseSurfaceImpl_GetPriority
,
3841 IWineD3DSurfaceImpl_PreLoad
,
3842 IWineD3DBaseSurfaceImpl_GetType
,
3843 /* IWineD3DSurface */
3844 IWineD3DBaseSurfaceImpl_GetContainer
,
3845 IWineD3DBaseSurfaceImpl_GetDesc
,
3846 IWineD3DSurfaceImpl_LockRect
,
3847 IWineD3DSurfaceImpl_UnlockRect
,
3848 IWineD3DSurfaceImpl_GetDC
,
3849 IWineD3DSurfaceImpl_ReleaseDC
,
3850 IWineD3DSurfaceImpl_Flip
,
3851 IWineD3DSurfaceImpl_Blt
,
3852 IWineD3DBaseSurfaceImpl_GetBltStatus
,
3853 IWineD3DBaseSurfaceImpl_GetFlipStatus
,
3854 IWineD3DBaseSurfaceImpl_IsLost
,
3855 IWineD3DBaseSurfaceImpl_Restore
,
3856 IWineD3DSurfaceImpl_BltFast
,
3857 IWineD3DBaseSurfaceImpl_GetPalette
,
3858 IWineD3DBaseSurfaceImpl_SetPalette
,
3859 IWineD3DBaseSurfaceImpl_RealizePalette
,
3860 IWineD3DBaseSurfaceImpl_SetColorKey
,
3861 IWineD3DBaseSurfaceImpl_GetPitch
,
3862 IWineD3DSurfaceImpl_SetMem
,
3863 IWineD3DBaseSurfaceImpl_SetOverlayPosition
,
3864 IWineD3DBaseSurfaceImpl_GetOverlayPosition
,
3865 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder
,
3866 IWineD3DBaseSurfaceImpl_UpdateOverlay
,
3867 IWineD3DBaseSurfaceImpl_SetClipper
,
3868 IWineD3DBaseSurfaceImpl_GetClipper
,
3870 IWineD3DSurfaceImpl_AddDirtyRect
,
3871 IWineD3DSurfaceImpl_LoadTexture
,
3872 IWineD3DSurfaceImpl_BindTexture
,
3873 IWineD3DSurfaceImpl_SaveSnapshot
,
3874 IWineD3DBaseSurfaceImpl_SetContainer
,
3875 IWineD3DSurfaceImpl_SetGlTextureDesc
,
3876 IWineD3DSurfaceImpl_GetGlDesc
,
3877 IWineD3DSurfaceImpl_GetData
,
3878 IWineD3DSurfaceImpl_SetFormat
,
3879 IWineD3DSurfaceImpl_PrivateSetup
,
3880 IWineD3DSurfaceImpl_ModifyLocation
,
3881 IWineD3DSurfaceImpl_LoadLocation