2 * Context and render target management in wined3d
4 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
30 #define GLINFO_LOCATION This->adapter->gl_info
32 /* The last used device.
34 * If the application creates multiple devices and switches between them, ActivateContext has to
35 * change the opengl context. This flag allows to keep track which device is active
37 static IWineD3DDeviceImpl
*last_device
;
39 /* FBO helper functions */
41 void context_bind_fbo(IWineD3DDevice
*iface
, GLenum target
, GLuint
*fbo
)
43 const IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
47 GL_EXTCALL(glGenFramebuffersEXT(1, fbo
));
48 checkGLcall("glGenFramebuffersEXT()");
49 TRACE("Created FBO %d\n", *fbo
);
52 GL_EXTCALL(glBindFramebufferEXT(target
, *fbo
));
53 checkGLcall("glBindFramebuffer()");
56 static void context_destroy_fbo(IWineD3DDeviceImpl
*This
, const GLuint
*fbo
)
60 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, *fbo
));
61 checkGLcall("glBindFramebuffer()");
62 for (i
= 0; i
< GL_LIMITS(buffers
); ++i
)
64 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT
, GL_COLOR_ATTACHMENT0_EXT
+ i
, GL_TEXTURE_2D
, 0, 0));
65 checkGLcall("glFramebufferTexture2D()");
67 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT
, GL_DEPTH_ATTACHMENT_EXT
, GL_TEXTURE_2D
, 0, 0));
68 checkGLcall("glFramebufferTexture2D()");
69 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
70 checkGLcall("glBindFramebuffer()");
71 GL_EXTCALL(glDeleteFramebuffersEXT(1, fbo
));
72 checkGLcall("glDeleteFramebuffers()");
75 static void context_apply_attachment_filter_states(IWineD3DDevice
*iface
, IWineD3DSurface
*surface
, BOOL force_preload
)
77 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
78 const IWineD3DSurfaceImpl
*surface_impl
= (IWineD3DSurfaceImpl
*)surface
;
79 IWineD3DBaseTextureImpl
*texture_impl
;
80 BOOL update_minfilter
= FALSE
;
81 BOOL update_magfilter
= FALSE
;
83 /* Update base texture states array */
84 if (SUCCEEDED(IWineD3DSurface_GetContainer(surface
, &IID_IWineD3DBaseTexture
, (void **)&texture_impl
)))
86 if (texture_impl
->baseTexture
.states
[WINED3DTEXSTA_MINFILTER
] != WINED3DTEXF_POINT
)
88 texture_impl
->baseTexture
.states
[WINED3DTEXSTA_MINFILTER
] = WINED3DTEXF_POINT
;
89 update_minfilter
= TRUE
;
92 if (texture_impl
->baseTexture
.states
[WINED3DTEXSTA_MAGFILTER
] != WINED3DTEXF_POINT
)
94 texture_impl
->baseTexture
.states
[WINED3DTEXSTA_MAGFILTER
] = WINED3DTEXF_POINT
;
95 update_magfilter
= TRUE
;
98 if (texture_impl
->baseTexture
.bindCount
)
100 WARN("Render targets should not be bound to a sampler\n");
101 IWineD3DDeviceImpl_MarkStateDirty(This
, STATE_SAMPLER(texture_impl
->baseTexture
.sampler
));
104 IWineD3DBaseTexture_Release((IWineD3DBaseTexture
*)texture_impl
);
107 if (update_minfilter
|| update_magfilter
|| force_preload
)
109 GLenum target
, bind_target
;
112 target
= surface_impl
->glDescription
.target
;
113 if (target
== GL_TEXTURE_2D
)
115 bind_target
= GL_TEXTURE_2D
;
116 glGetIntegerv(GL_TEXTURE_BINDING_2D
, &old_binding
);
117 } else if (target
== GL_TEXTURE_RECTANGLE_ARB
) {
118 bind_target
= GL_TEXTURE_RECTANGLE_ARB
;
119 glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB
, &old_binding
);
121 bind_target
= GL_TEXTURE_CUBE_MAP_ARB
;
122 glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP_ARB
, &old_binding
);
125 IWineD3DSurface_PreLoad(surface
);
127 glBindTexture(bind_target
, surface_impl
->glDescription
.textureName
);
128 if (update_minfilter
) glTexParameteri(bind_target
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
129 if (update_magfilter
) glTexParameteri(bind_target
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
130 glBindTexture(bind_target
, old_binding
);
133 checkGLcall("apply_attachment_filter_states()");
136 /* TODO: Handle stencil attachments */
137 void context_attach_depth_stencil_fbo(IWineD3DDeviceImpl
*This
, GLenum fbo_target
, IWineD3DSurface
*depth_stencil
, BOOL use_render_buffer
)
139 IWineD3DSurfaceImpl
*depth_stencil_impl
= (IWineD3DSurfaceImpl
*)depth_stencil
;
141 TRACE("Attach depth stencil %p\n", depth_stencil
);
145 if (use_render_buffer
&& depth_stencil_impl
->current_renderbuffer
)
147 GL_EXTCALL(glFramebufferRenderbufferEXT(fbo_target
, GL_DEPTH_ATTACHMENT_EXT
, GL_RENDERBUFFER_EXT
, depth_stencil_impl
->current_renderbuffer
->id
));
148 checkGLcall("glFramebufferRenderbufferEXT()");
150 context_apply_attachment_filter_states((IWineD3DDevice
*)This
, depth_stencil
, TRUE
);
152 GL_EXTCALL(glFramebufferTexture2DEXT(fbo_target
, GL_DEPTH_ATTACHMENT_EXT
, depth_stencil_impl
->glDescription
.target
,
153 depth_stencil_impl
->glDescription
.textureName
, depth_stencil_impl
->glDescription
.level
));
154 checkGLcall("glFramebufferTexture2DEXT()");
157 GL_EXTCALL(glFramebufferTexture2DEXT(fbo_target
, GL_DEPTH_ATTACHMENT_EXT
, GL_TEXTURE_2D
, 0, 0));
158 checkGLcall("glFramebufferTexture2DEXT()");
162 void context_attach_surface_fbo(IWineD3DDeviceImpl
*This
, GLenum fbo_target
, DWORD idx
, IWineD3DSurface
*surface
)
164 const IWineD3DSurfaceImpl
*surface_impl
= (IWineD3DSurfaceImpl
*)surface
;
166 TRACE("Attach surface %p to %u\n", surface
, idx
);
170 context_apply_attachment_filter_states((IWineD3DDevice
*)This
, surface
, TRUE
);
172 GL_EXTCALL(glFramebufferTexture2DEXT(fbo_target
, GL_COLOR_ATTACHMENT0_EXT
+ idx
, surface_impl
->glDescription
.target
,
173 surface_impl
->glDescription
.textureName
, surface_impl
->glDescription
.level
));
174 checkGLcall("glFramebufferTexture2DEXT()");
176 GL_EXTCALL(glFramebufferTexture2DEXT(fbo_target
, GL_COLOR_ATTACHMENT0_EXT
+ idx
, GL_TEXTURE_2D
, 0, 0));
177 checkGLcall("glFramebufferTexture2DEXT()");
181 static void context_check_fbo_status(IWineD3DDevice
*iface
)
183 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
186 status
= GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT
));
187 if (status
== GL_FRAMEBUFFER_COMPLETE_EXT
)
189 TRACE("FBO complete\n");
191 IWineD3DSurfaceImpl
*attachment
;
193 FIXME("FBO status %s (%#x)\n", debug_fbostatus(status
), status
);
195 /* Dump the FBO attachments */
196 for (i
= 0; i
< GL_LIMITS(buffers
); ++i
)
198 attachment
= (IWineD3DSurfaceImpl
*)This
->activeContext
->current_fbo
->render_targets
[i
];
201 FIXME("\tColor attachment %d: (%p) %s %ux%u\n", i
, attachment
, debug_d3dformat(attachment
->resource
.format
),
202 attachment
->pow2Width
, attachment
->pow2Height
);
205 attachment
= (IWineD3DSurfaceImpl
*)This
->activeContext
->current_fbo
->depth_stencil
;
208 FIXME("\tDepth attachment: (%p) %s %ux%u\n", attachment
, debug_d3dformat(attachment
->resource
.format
),
209 attachment
->pow2Width
, attachment
->pow2Height
);
214 static struct fbo_entry
*context_create_fbo_entry(IWineD3DDevice
*iface
)
216 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
217 struct fbo_entry
*entry
;
219 entry
= HeapAlloc(GetProcessHeap(), 0, sizeof(*entry
));
220 entry
->render_targets
= HeapAlloc(GetProcessHeap(), 0, GL_LIMITS(buffers
) * sizeof(*entry
->render_targets
));
221 memcpy(entry
->render_targets
, This
->render_targets
, GL_LIMITS(buffers
) * sizeof(*entry
->render_targets
));
222 entry
->depth_stencil
= This
->stencilBufferTarget
;
223 entry
->attached
= FALSE
;
229 static void context_destroy_fbo_entry(IWineD3DDeviceImpl
*This
, struct fbo_entry
*entry
)
233 TRACE("Destroy FBO %d\n", entry
->id
);
234 context_destroy_fbo(This
, &entry
->id
);
236 list_remove(&entry
->entry
);
237 HeapFree(GetProcessHeap(), 0, entry
->render_targets
);
238 HeapFree(GetProcessHeap(), 0, entry
);
242 static struct fbo_entry
*context_find_fbo_entry(IWineD3DDevice
*iface
, WineD3DContext
*context
)
244 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
245 struct fbo_entry
*entry
;
247 LIST_FOR_EACH_ENTRY(entry
, &context
->fbo_list
, struct fbo_entry
, entry
)
249 if (!memcmp(entry
->render_targets
, This
->render_targets
, GL_LIMITS(buffers
) * sizeof(*entry
->render_targets
))
250 && entry
->depth_stencil
== This
->stencilBufferTarget
)
256 entry
= context_create_fbo_entry(iface
);
257 list_add_head(&context
->fbo_list
, &entry
->entry
);
261 static void context_apply_fbo_entry(IWineD3DDevice
*iface
, struct fbo_entry
*entry
)
263 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
266 context_bind_fbo(iface
, GL_FRAMEBUFFER_EXT
, &entry
->id
);
268 if (!entry
->attached
)
270 /* Apply render targets */
271 for (i
= 0; i
< GL_LIMITS(buffers
); ++i
)
273 IWineD3DSurface
*render_target
= This
->render_targets
[i
];
274 context_attach_surface_fbo(This
, GL_FRAMEBUFFER_EXT
, i
, render_target
);
277 /* Apply depth targets */
278 if (This
->stencilBufferTarget
) {
279 unsigned int w
= ((IWineD3DSurfaceImpl
*)This
->render_targets
[0])->pow2Width
;
280 unsigned int h
= ((IWineD3DSurfaceImpl
*)This
->render_targets
[0])->pow2Height
;
282 surface_set_compatible_renderbuffer(This
->stencilBufferTarget
, w
, h
);
284 context_attach_depth_stencil_fbo(This
, GL_FRAMEBUFFER_EXT
, This
->stencilBufferTarget
, TRUE
);
286 entry
->attached
= TRUE
;
288 for (i
= 0; i
< GL_LIMITS(buffers
); ++i
)
290 if (This
->render_targets
[i
])
291 context_apply_attachment_filter_states(iface
, This
->render_targets
[i
], FALSE
);
293 if (This
->stencilBufferTarget
)
294 context_apply_attachment_filter_states(iface
, This
->stencilBufferTarget
, FALSE
);
297 for (i
= 0; i
< GL_LIMITS(buffers
); ++i
)
299 if (This
->render_targets
[i
])
300 This
->draw_buffers
[i
] = GL_COLOR_ATTACHMENT0_EXT
+ i
;
302 This
->draw_buffers
[i
] = GL_NONE
;
306 static void context_apply_fbo_state(IWineD3DDevice
*iface
)
308 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
309 WineD3DContext
*context
= This
->activeContext
;
311 if (This
->render_offscreen
)
313 context
->current_fbo
= context_find_fbo_entry(iface
, context
);
314 context_apply_fbo_entry(iface
, context
->current_fbo
);
316 context
->current_fbo
= NULL
;
317 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
320 context_check_fbo_status(iface
);
323 void context_resource_released(IWineD3DDevice
*iface
, IWineD3DResource
*resource
, WINED3DRESOURCETYPE type
)
325 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
330 case WINED3DRTYPE_SURFACE
:
332 for (i
= 0; i
< This
->numContexts
; ++i
)
334 struct fbo_entry
*entry
, *entry2
;
336 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &This
->contexts
[i
]->fbo_list
, struct fbo_entry
, entry
)
338 BOOL destroyed
= FALSE
;
341 for (j
= 0; !destroyed
&& j
< GL_LIMITS(buffers
); ++j
)
343 if (entry
->render_targets
[j
] == (IWineD3DSurface
*)resource
)
345 context_destroy_fbo_entry(This
, entry
);
350 if (!destroyed
&& entry
->depth_stencil
== (IWineD3DSurface
*)resource
)
351 context_destroy_fbo_entry(This
, entry
);
363 /*****************************************************************************
364 * Context_MarkStateDirty
366 * Marks a state in a context dirty. Only one context, opposed to
367 * IWineD3DDeviceImpl_MarkStateDirty, which marks the state dirty in all
371 * context: Context to mark the state dirty in
372 * state: State to mark dirty
373 * StateTable: Pointer to the state table in use(for state grouping)
375 *****************************************************************************/
376 static void Context_MarkStateDirty(WineD3DContext
*context
, DWORD state
, const struct StateEntry
*StateTable
) {
377 DWORD rep
= StateTable
[state
].representative
;
381 if(!rep
|| isStateDirty(context
, rep
)) return;
383 context
->dirtyArray
[context
->numDirtyEntries
++] = rep
;
386 context
->isStateDirty
[idx
] |= (1 << shift
);
389 /*****************************************************************************
392 * Adds a context to the context array. Helper function for CreateContext
394 * This method is not called in performance-critical code paths, only when a
395 * new render target or swapchain is created. Thus performance is not an issue
399 * This: Device to add the context for
400 * hdc: device context
401 * glCtx: WGL context to add
402 * pbuffer: optional pbuffer used with this context
404 *****************************************************************************/
405 static WineD3DContext
*AddContextToArray(IWineD3DDeviceImpl
*This
, HWND win_handle
, HDC hdc
, HGLRC glCtx
, HPBUFFERARB pbuffer
) {
406 WineD3DContext
**oldArray
= This
->contexts
;
409 This
->contexts
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
->contexts
) * (This
->numContexts
+ 1));
410 if(This
->contexts
== NULL
) {
411 ERR("Unable to grow the context array\n");
412 This
->contexts
= oldArray
;
416 memcpy(This
->contexts
, oldArray
, sizeof(*This
->contexts
) * This
->numContexts
);
419 This
->contexts
[This
->numContexts
] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WineD3DContext
));
420 if(This
->contexts
[This
->numContexts
] == NULL
) {
421 ERR("Unable to allocate a new context\n");
422 HeapFree(GetProcessHeap(), 0, This
->contexts
);
423 This
->contexts
= oldArray
;
427 This
->contexts
[This
->numContexts
]->hdc
= hdc
;
428 This
->contexts
[This
->numContexts
]->glCtx
= glCtx
;
429 This
->contexts
[This
->numContexts
]->pbuffer
= pbuffer
;
430 This
->contexts
[This
->numContexts
]->win_handle
= win_handle
;
431 HeapFree(GetProcessHeap(), 0, oldArray
);
433 /* Mark all states dirty to force a proper initialization of the states on the first use of the context
435 for(state
= 0; state
<= STATE_HIGHEST
; state
++) {
436 Context_MarkStateDirty(This
->contexts
[This
->numContexts
], state
, This
->StateTable
);
440 TRACE("Created context %p\n", This
->contexts
[This
->numContexts
- 1]);
441 return This
->contexts
[This
->numContexts
- 1];
444 /* This function takes care of WineD3D pixel format selection. */
445 static int WineD3D_ChoosePixelFormat(IWineD3DDeviceImpl
*This
, HDC hdc
, WINED3DFORMAT ColorFormat
, WINED3DFORMAT DepthStencilFormat
, BOOL auxBuffers
, int numSamples
, BOOL pbuffer
, BOOL findCompatible
)
447 int iPixelFormat
=0, matchtry
;
448 short redBits
, greenBits
, blueBits
, alphaBits
, colorBits
;
449 short depthBits
=0, stencilBits
=0;
456 /* First, try without alpha match buffers. MacOS supports aux buffers only
457 * on A8R8G8B8, and we prefer better offscreen rendering over an alpha match.
458 * Then try without aux buffers - this is the most common cause for not
459 * finding a pixel format. Also some drivers(the open source ones)
460 * only offer 32 bit ARB pixel formats. First try without an exact alpha
461 * match, then try without an exact alpha and color match.
463 { TRUE
, TRUE
, TRUE
},
464 { TRUE
, FALSE
, TRUE
},
465 { FALSE
, TRUE
, TRUE
},
466 { FALSE
, FALSE
, TRUE
},
467 { TRUE
, FALSE
, FALSE
},
468 { FALSE
, FALSE
, FALSE
},
472 int nCfgs
= This
->adapter
->nCfgs
;
474 TRACE("ColorFormat=%s, DepthStencilFormat=%s, auxBuffers=%d, numSamples=%d, pbuffer=%d, findCompatible=%d\n",
475 debug_d3dformat(ColorFormat
), debug_d3dformat(DepthStencilFormat
), auxBuffers
, numSamples
, pbuffer
, findCompatible
);
477 if(!getColorBits(ColorFormat
, &redBits
, &greenBits
, &blueBits
, &alphaBits
, &colorBits
)) {
478 ERR("Unable to get color bits for format %s (%#x)!\n", debug_d3dformat(ColorFormat
), ColorFormat
);
482 /* In WGL both color, depth and stencil are features of a pixel format. In case of D3D they are separate.
483 * You are able to add a depth + stencil surface at a later stage when you need it.
484 * In order to support this properly in WineD3D we need the ability to recreate the opengl context and
485 * drawable when this is required. This is very tricky as we need to reapply ALL opengl states for the new
486 * context, need torecreate shaders, textures and other resources.
488 * The context manager already takes care of the state problem and for the other tasks code from Reset
489 * can be used. These changes are way to risky during the 1.0 code freeze which is taking place right now.
490 * Likely a lot of other new bugs will be exposed. For that reason request a depth stencil surface all the
491 * time. It can cause a slight performance hit but fixes a lot of regressions. A fixme reminds of that this
492 * issue needs to be fixed. */
493 if(DepthStencilFormat
!= WINED3DFMT_D24S8
)
494 FIXME("Add OpenGL context recreation support to SetDepthStencilSurface\n");
496 DepthStencilFormat
= WINED3DFMT_D24S8
;
498 if(DepthStencilFormat
) {
499 getDepthStencilBits(DepthStencilFormat
, &depthBits
, &stencilBits
);
502 for(matchtry
= 0; matchtry
< (sizeof(matches
) / sizeof(matches
[0])) && !iPixelFormat
; matchtry
++) {
503 for(i
=0; i
<nCfgs
; i
++) {
504 BOOL exactDepthMatch
= TRUE
;
505 WineD3D_PixelFormat
*cfg
= &This
->adapter
->cfgs
[i
];
507 /* For now only accept RGBA formats. Perhaps some day we will
508 * allow floating point formats for pbuffers. */
509 if(cfg
->iPixelType
!= WGL_TYPE_RGBA_ARB
)
512 /* In window mode (!pbuffer) we need a window drawable format and double buffering. */
513 if(!pbuffer
&& !(cfg
->windowDrawable
&& cfg
->doubleBuffer
))
516 /* We like to have aux buffers in backbuffer mode */
517 if(auxBuffers
&& !cfg
->auxBuffers
&& matches
[matchtry
].require_aux
)
520 /* In pbuffer-mode we need a pbuffer-capable format but we don't want double buffering */
521 if(pbuffer
&& (!cfg
->pbufferDrawable
|| cfg
->doubleBuffer
))
524 if(matches
[matchtry
].exact_color
) {
525 if(cfg
->redSize
!= redBits
)
527 if(cfg
->greenSize
!= greenBits
)
529 if(cfg
->blueSize
!= blueBits
)
532 if(cfg
->redSize
< redBits
)
534 if(cfg
->greenSize
< greenBits
)
536 if(cfg
->blueSize
< blueBits
)
539 if(matches
[matchtry
].exact_alpha
) {
540 if(cfg
->alphaSize
!= alphaBits
)
543 if(cfg
->alphaSize
< alphaBits
)
547 /* We try to locate a format which matches our requirements exactly. In case of
548 * depth it is no problem to emulate 16-bit using e.g. 24-bit, so accept that. */
549 if(cfg
->depthSize
< depthBits
)
551 else if(cfg
->depthSize
> depthBits
)
552 exactDepthMatch
= FALSE
;
554 /* In all cases make sure the number of stencil bits matches our requirements
555 * even when we don't need stencil because it could affect performance EXCEPT
556 * on cards which don't offer depth formats without stencil like the i915 drivers
558 if(stencilBits
!= cfg
->stencilSize
&& !(This
->adapter
->brokenStencil
&& stencilBits
<= cfg
->stencilSize
))
561 /* Check multisampling support */
562 if(cfg
->numSamples
!= numSamples
)
565 /* When we have passed all the checks then we have found a format which matches our
566 * requirements. Note that we only check for a limit number of capabilities right now,
567 * so there can easily be a dozen of pixel formats which appear to be the 'same' but
568 * can still differ in things like multisampling, stereo, SRGB and other flags.
571 /* Exit the loop as we have found a format :) */
572 if(exactDepthMatch
) {
573 iPixelFormat
= cfg
->iPixelFormat
;
575 } else if(!iPixelFormat
) {
576 /* In the end we might end up with a format which doesn't exactly match our depth
577 * requirements. Accept the first format we found because formats with higher iPixelFormat
578 * values tend to have more extended capabilities (e.g. multisampling) which we don't need. */
579 iPixelFormat
= cfg
->iPixelFormat
;
584 /* When findCompatible is set and no suitable format was found, let ChoosePixelFormat choose a pixel format in order not to crash. */
585 if(!iPixelFormat
&& !findCompatible
) {
586 ERR("Can't find a suitable iPixelFormat\n");
588 } else if(!iPixelFormat
) {
589 PIXELFORMATDESCRIPTOR pfd
;
591 TRACE("Falling back to ChoosePixelFormat as we weren't able to find an exactly matching pixel format\n");
592 /* PixelFormat selection */
593 ZeroMemory(&pfd
, sizeof(pfd
));
594 pfd
.nSize
= sizeof(pfd
);
596 pfd
.dwFlags
= PFD_SUPPORT_OPENGL
| PFD_DOUBLEBUFFER
| PFD_DRAW_TO_WINDOW
;/*PFD_GENERIC_ACCELERATED*/
597 pfd
.iPixelType
= PFD_TYPE_RGBA
;
598 pfd
.cAlphaBits
= alphaBits
;
599 pfd
.cColorBits
= colorBits
;
600 pfd
.cDepthBits
= depthBits
;
601 pfd
.cStencilBits
= stencilBits
;
602 pfd
.iLayerType
= PFD_MAIN_PLANE
;
604 iPixelFormat
= ChoosePixelFormat(hdc
, &pfd
);
606 /* If this happens something is very wrong as ChoosePixelFormat barely fails */
607 ERR("Can't find a suitable iPixelFormat\n");
612 TRACE("Found iPixelFormat=%d for ColorFormat=%s, DepthStencilFormat=%s\n", iPixelFormat
, debug_d3dformat(ColorFormat
), debug_d3dformat(DepthStencilFormat
));
616 /*****************************************************************************
619 * Creates a new context for a window, or a pbuffer context.
622 * This: Device to activate the context for
623 * target: Surface this context will render to
624 * win_handle: handle to the window which we are drawing to
625 * create_pbuffer: tells whether to create a pbuffer or not
626 * pPresentParameters: contains the pixelformats to use for onscreen rendering
628 *****************************************************************************/
629 WineD3DContext
*CreateContext(IWineD3DDeviceImpl
*This
, IWineD3DSurfaceImpl
*target
, HWND win_handle
, BOOL create_pbuffer
, const WINED3DPRESENT_PARAMETERS
*pPresentParms
) {
630 HDC oldDrawable
, hdc
;
631 HPBUFFERARB pbuffer
= NULL
;
632 HGLRC ctx
= NULL
, oldCtx
;
633 WineD3DContext
*ret
= NULL
;
636 TRACE("(%p): Creating a %s context for render target %p\n", This
, create_pbuffer
? "offscreen" : "onscreen", target
);
639 HDC hdc_parent
= GetDC(win_handle
);
640 int iPixelFormat
= 0;
642 IWineD3DSurface
*StencilSurface
= This
->stencilBufferTarget
;
643 WINED3DFORMAT StencilBufferFormat
= (NULL
!= StencilSurface
) ? ((IWineD3DSurfaceImpl
*) StencilSurface
)->resource
.format
: 0;
645 /* Try to find a pixel format with pbuffer support. */
646 iPixelFormat
= WineD3D_ChoosePixelFormat(This
, hdc_parent
, target
->resource
.format
, StencilBufferFormat
, FALSE
/* auxBuffers */, 0 /* numSamples */, TRUE
/* PBUFFER */, FALSE
/* findCompatible */);
648 TRACE("Trying to locate a compatible pixel format because an exact match failed.\n");
650 /* For some reason we weren't able to find a format, try to find something instead of crashing.
651 * A reason for failure could have been wglChoosePixelFormatARB strictness. */
652 iPixelFormat
= WineD3D_ChoosePixelFormat(This
, hdc_parent
, target
->resource
.format
, StencilBufferFormat
, FALSE
/* auxBuffer */, 0 /* numSamples */, TRUE
/* PBUFFER */, TRUE
/* findCompatible */);
655 /* This shouldn't happen as ChoosePixelFormat always returns something */
657 ERR("Unable to locate a pixel format for a pbuffer\n");
658 ReleaseDC(win_handle
, hdc_parent
);
662 TRACE("Creating a pBuffer drawable for the new context\n");
663 pbuffer
= GL_EXTCALL(wglCreatePbufferARB(hdc_parent
, iPixelFormat
, target
->currentDesc
.Width
, target
->currentDesc
.Height
, 0));
665 ERR("Cannot create a pbuffer\n");
666 ReleaseDC(win_handle
, hdc_parent
);
670 /* In WGL a pbuffer is 'wrapped' inside a HDC to 'fool' wglMakeCurrent */
671 hdc
= GL_EXTCALL(wglGetPbufferDCARB(pbuffer
));
673 ERR("Cannot get a HDC for pbuffer (%p)\n", pbuffer
);
674 GL_EXTCALL(wglDestroyPbufferARB(pbuffer
));
675 ReleaseDC(win_handle
, hdc_parent
);
678 ReleaseDC(win_handle
, hdc_parent
);
680 PIXELFORMATDESCRIPTOR pfd
;
683 WINED3DFORMAT ColorFormat
= target
->resource
.format
;
684 WINED3DFORMAT DepthStencilFormat
= 0;
685 BOOL auxBuffers
= FALSE
;
688 hdc
= GetDC(win_handle
);
690 ERR("Cannot retrieve a device context!\n");
694 /* In case of ORM_BACKBUFFER, make sure to request an alpha component for X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */
695 if(wined3d_settings
.offscreen_rendering_mode
== ORM_BACKBUFFER
) {
698 if(target
->resource
.format
== WINED3DFMT_X4R4G4B4
)
699 ColorFormat
= WINED3DFMT_A4R4G4B4
;
700 else if(target
->resource
.format
== WINED3DFMT_X8R8G8B8
)
701 ColorFormat
= WINED3DFMT_A8R8G8B8
;
704 /* DirectDraw supports 8bit paletted render targets and these are used by old games like Starcraft and C&C.
705 * Most modern hardware doesn't support 8bit natively so we perform some form of 8bit -> 32bit conversion.
706 * The conversion (ab)uses the alpha component for storing the palette index. For this reason we require
707 * a format with 8bit alpha, so request A8R8G8B8. */
708 if(ColorFormat
== WINED3DFMT_P8
)
709 ColorFormat
= WINED3DFMT_A8R8G8B8
;
711 /* Retrieve the depth stencil format from the present parameters.
712 * The choice of the proper format can give a nice performance boost
713 * in case of GPU limited programs. */
714 if(pPresentParms
->EnableAutoDepthStencil
) {
715 TRACE("pPresentParms->EnableAutoDepthStencil=enabled; using AutoDepthStencilFormat=%s\n", debug_d3dformat(pPresentParms
->AutoDepthStencilFormat
));
716 DepthStencilFormat
= pPresentParms
->AutoDepthStencilFormat
;
719 /* D3D only allows multisampling when SwapEffect is set to WINED3DSWAPEFFECT_DISCARD */
720 if(pPresentParms
->MultiSampleType
&& (pPresentParms
->SwapEffect
== WINED3DSWAPEFFECT_DISCARD
)) {
721 if(!GL_SUPPORT(ARB_MULTISAMPLE
))
722 ERR("The program is requesting multisampling without support!\n");
724 ERR("Requesting MultiSampleType=%d\n", pPresentParms
->MultiSampleType
);
725 numSamples
= pPresentParms
->MultiSampleType
;
729 /* Try to find a pixel format which matches our requirements */
730 iPixelFormat
= WineD3D_ChoosePixelFormat(This
, hdc
, ColorFormat
, DepthStencilFormat
, auxBuffers
, numSamples
, FALSE
/* PBUFFER */, FALSE
/* findCompatible */);
732 /* Try to locate a compatible format if we weren't able to find anything */
734 TRACE("Trying to locate a compatible pixel format because an exact match failed.\n");
735 iPixelFormat
= WineD3D_ChoosePixelFormat(This
, hdc
, ColorFormat
, DepthStencilFormat
, auxBuffers
, 0 /* numSamples */, FALSE
/* PBUFFER */, TRUE
/* findCompatible */ );
738 /* If we still don't have a pixel format, something is very wrong as ChoosePixelFormat barely fails */
740 ERR("Can't find a suitable iPixelFormat\n");
744 DescribePixelFormat(hdc
, iPixelFormat
, sizeof(pfd
), &pfd
);
745 res
= SetPixelFormat(hdc
, iPixelFormat
, NULL
);
747 int oldPixelFormat
= GetPixelFormat(hdc
);
749 /* By default WGL doesn't allow pixel format adjustments but we need it here.
750 * For this reason there is a WINE-specific wglSetPixelFormat which allows you to
751 * set the pixel format multiple times. Only use it when it is really needed. */
753 if(oldPixelFormat
== iPixelFormat
) {
754 /* We don't have to do anything as the formats are the same :) */
755 } else if(oldPixelFormat
&& GL_SUPPORT(WGL_WINE_PIXEL_FORMAT_PASSTHROUGH
)) {
756 res
= GL_EXTCALL(wglSetPixelFormatWINE(hdc
, iPixelFormat
, NULL
));
759 ERR("wglSetPixelFormatWINE failed on HDC=%p for iPixelFormat=%d\n", hdc
, iPixelFormat
);
762 } else if(oldPixelFormat
) {
763 /* OpenGL doesn't allow pixel format adjustments. Print an error and continue using the old format.
764 * There's a big chance that the old format works although with a performance hit and perhaps rendering errors. */
765 ERR("HDC=%p is already set to iPixelFormat=%d and OpenGL doesn't allow changes!\n", hdc
, oldPixelFormat
);
767 ERR("SetPixelFormat failed on HDC=%p for iPixelFormat=%d\n", hdc
, iPixelFormat
);
773 ctx
= pwglCreateContext(hdc
);
774 if(This
->numContexts
) pwglShareLists(This
->contexts
[0]->glCtx
, ctx
);
777 ERR("Failed to create a WGL context\n");
779 GL_EXTCALL(wglReleasePbufferDCARB(pbuffer
, hdc
));
780 GL_EXTCALL(wglDestroyPbufferARB(pbuffer
));
784 ret
= AddContextToArray(This
, win_handle
, hdc
, ctx
, pbuffer
);
786 ERR("Failed to add the newly created context to the context list\n");
787 pwglDeleteContext(ctx
);
789 GL_EXTCALL(wglReleasePbufferDCARB(pbuffer
, hdc
));
790 GL_EXTCALL(wglDestroyPbufferARB(pbuffer
));
794 ret
->surface
= (IWineD3DSurface
*) target
;
795 ret
->isPBuffer
= create_pbuffer
;
796 ret
->tid
= GetCurrentThreadId();
797 if(This
->shader_backend
->shader_dirtifyable_constants((IWineD3DDevice
*) This
)) {
798 /* Create the dirty constants array and initialize them to dirty */
799 ret
->vshader_const_dirty
= HeapAlloc(GetProcessHeap(), 0,
800 sizeof(*ret
->vshader_const_dirty
) * GL_LIMITS(vshader_constantsF
));
801 ret
->pshader_const_dirty
= HeapAlloc(GetProcessHeap(), 0,
802 sizeof(*ret
->pshader_const_dirty
) * GL_LIMITS(pshader_constantsF
));
803 memset(ret
->vshader_const_dirty
, 1,
804 sizeof(*ret
->vshader_const_dirty
) * GL_LIMITS(vshader_constantsF
));
805 memset(ret
->pshader_const_dirty
, 1,
806 sizeof(*ret
->pshader_const_dirty
) * GL_LIMITS(pshader_constantsF
));
809 TRACE("Successfully created new context %p\n", ret
);
811 list_init(&ret
->fbo_list
);
813 /* Set up the context defaults */
814 oldCtx
= pwglGetCurrentContext();
815 oldDrawable
= pwglGetCurrentDC();
816 if(oldCtx
&& oldDrawable
) {
817 /* See comment in ActivateContext context switching */
818 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, FALSE
);
820 if(pwglMakeCurrent(hdc
, ctx
) == FALSE
) {
821 ERR("Cannot activate context to set up defaults\n");
827 glGetIntegerv(GL_AUX_BUFFERS
, &ret
->aux_buffers
);
829 TRACE("Setting up the screen\n");
830 /* Clear the screen */
831 glClearColor(1.0, 0.0, 0.0, 0.0);
832 checkGLcall("glClearColor");
835 glClearStencil(0xffff);
837 checkGLcall("glClear");
839 glColor3f(1.0, 1.0, 1.0);
840 checkGLcall("glColor3f");
842 glEnable(GL_LIGHTING
);
843 checkGLcall("glEnable");
845 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, GL_TRUE
);
846 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
848 glTexEnvf(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE_EXT
);
849 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
851 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL
, GL_SEPARATE_SPECULAR_COLOR
);
852 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
854 glPixelStorei(GL_PACK_ALIGNMENT
, This
->surface_alignment
);
855 checkGLcall("glPixelStorei(GL_PACK_ALIGNMENT, This->surface_alignment);");
856 glPixelStorei(GL_UNPACK_ALIGNMENT
, This
->surface_alignment
);
857 checkGLcall("glPixelStorei(GL_UNPACK_ALIGNMENT, This->surface_alignment);");
859 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
860 /* Most textures will use client storage if supported. Exceptions are non-native power of 2 textures
861 * and textures in DIB sections(due to the memory protection).
863 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
864 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
866 if(GL_SUPPORT(ARB_VERTEX_BLEND
)) {
867 /* Direct3D always uses n-1 weights for n world matrices and uses 1 - sum for the last one
868 * this is equal to GL_WEIGHT_SUM_UNITY_ARB. Enabling it doesn't do anything unless
869 * GL_VERTEX_BLEND_ARB isn't enabled too
871 glEnable(GL_WEIGHT_SUM_UNITY_ARB
);
872 checkGLcall("glEnable(GL_WEIGHT_SUM_UNITY_ARB)");
874 if(GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
875 /* Set up the previous texture input for all shader units. This applies to bump mapping, and in d3d
876 * the previous texture where to source the offset from is always unit - 1.
878 for(s
= 1; s
< GL_LIMITS(textures
); s
++) {
879 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ s
));
880 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_PREVIOUS_TEXTURE_INPUT_NV
, GL_TEXTURE0_ARB
+ s
- 1);
881 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, ...\n");
885 if(GL_SUPPORT(ARB_POINT_SPRITE
)) {
886 for(s
= 0; s
< GL_LIMITS(textures
); s
++) {
887 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ s
));
888 glTexEnvi(GL_POINT_SPRITE_ARB
, GL_COORD_REPLACE_ARB
, GL_TRUE
);
889 checkGLcall("glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)\n");
894 /* Never keep GL_FRAGMENT_SHADER_ATI enabled on a context that we switch away from,
895 * but enable it for the first context we create, and reenable it on the old context
897 if(oldDrawable
&& oldCtx
) {
898 pwglMakeCurrent(oldDrawable
, oldCtx
);
902 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, TRUE
);
910 /*****************************************************************************
911 * RemoveContextFromArray
913 * Removes a context from the context manager. The opengl context is not
914 * destroyed or unset. context is not a valid pointer after that call.
916 * Similar to the former call this isn't a performance critical function. A
917 * helper function for DestroyContext.
920 * This: Device to activate the context for
921 * context: Context to remove
923 *****************************************************************************/
924 static void RemoveContextFromArray(IWineD3DDeviceImpl
*This
, WineD3DContext
*context
) {
926 WineD3DContext
**oldArray
= This
->contexts
;
928 TRACE("Removing ctx %p\n", context
);
932 if(This
->numContexts
) {
933 This
->contexts
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
->contexts
) * This
->numContexts
);
934 if(!This
->contexts
) {
935 ERR("Cannot allocate a new context array, PANIC!!!\n");
938 /* Note that we decreased numContexts a few lines up, so use '<=' instead of '<' */
939 for(s
= 0; s
<= This
->numContexts
; s
++) {
940 if(oldArray
[s
] == context
) continue;
941 This
->contexts
[t
] = oldArray
[s
];
945 This
->contexts
= NULL
;
948 HeapFree(GetProcessHeap(), 0, context
);
949 HeapFree(GetProcessHeap(), 0, oldArray
);
952 /*****************************************************************************
955 * Destroys a wineD3DContext
958 * This: Device to activate the context for
959 * context: Context to destroy
961 *****************************************************************************/
962 void DestroyContext(IWineD3DDeviceImpl
*This
, WineD3DContext
*context
) {
963 struct fbo_entry
*entry
, *entry2
;
965 TRACE("Destroying ctx %p\n", context
);
967 /* The correct GL context needs to be active to cleanup the GL resources below */
968 if(pwglGetCurrentContext() != context
->glCtx
){
969 pwglMakeCurrent(context
->hdc
, context
->glCtx
);
975 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &context
->fbo_list
, struct fbo_entry
, entry
) {
976 context_destroy_fbo_entry(This
, entry
);
978 if (context
->src_fbo
) {
979 TRACE("Destroy src FBO %d\n", context
->src_fbo
);
980 context_destroy_fbo(This
, &context
->src_fbo
);
982 if (context
->dst_fbo
) {
983 TRACE("Destroy dst FBO %d\n", context
->dst_fbo
);
984 context_destroy_fbo(This
, &context
->dst_fbo
);
989 /* Cleanup the GL context */
990 pwglMakeCurrent(NULL
, NULL
);
991 if(context
->isPBuffer
) {
992 GL_EXTCALL(wglReleasePbufferDCARB(context
->pbuffer
, context
->hdc
));
993 GL_EXTCALL(wglDestroyPbufferARB(context
->pbuffer
));
994 } else ReleaseDC(context
->win_handle
, context
->hdc
);
995 pwglDeleteContext(context
->glCtx
);
997 HeapFree(GetProcessHeap(), 0, context
->vshader_const_dirty
);
998 HeapFree(GetProcessHeap(), 0, context
->pshader_const_dirty
);
999 RemoveContextFromArray(This
, context
);
1002 static inline void set_blit_dimension(UINT width
, UINT height
) {
1003 glMatrixMode(GL_PROJECTION
);
1004 checkGLcall("glMatrixMode(GL_PROJECTION)");
1006 checkGLcall("glLoadIdentity()");
1007 glOrtho(0, width
, height
, 0, 0.0, -1.0);
1008 checkGLcall("glOrtho");
1009 glViewport(0, 0, width
, height
);
1010 checkGLcall("glViewport");
1013 /*****************************************************************************
1016 * Sets up a context for DirectDraw blitting.
1017 * All texture units are disabled, texture unit 0 is set as current unit
1018 * fog, lighting, blending, alpha test, z test, scissor test, culling disabled
1019 * color writing enabled for all channels
1020 * register combiners disabled, shaders disabled
1021 * world matrix is set to identity, texture matrix 0 too
1022 * projection matrix is setup for drawing screen coordinates
1025 * This: Device to activate the context for
1026 * context: Context to setup
1027 * width: render target width
1028 * height: render target height
1030 *****************************************************************************/
1031 static inline void SetupForBlit(IWineD3DDeviceImpl
*This
, WineD3DContext
*context
, UINT width
, UINT height
) {
1033 const struct StateEntry
*StateTable
= This
->StateTable
;
1035 TRACE("Setting up context %p for blitting\n", context
);
1036 if(context
->last_was_blit
) {
1037 if(context
->blit_w
!= width
|| context
->blit_h
!= height
) {
1038 set_blit_dimension(width
, height
);
1039 context
->blit_w
= width
; context
->blit_h
= height
;
1040 /* No need to dirtify here, the states are still dirtified because they weren't
1041 * applied since the last SetupForBlit call. Otherwise last_was_blit would not
1045 TRACE("Context is already set up for blitting, nothing to do\n");
1048 context
->last_was_blit
= TRUE
;
1050 /* TODO: Use a display list */
1052 /* Disable shaders */
1053 This
->shader_backend
->shader_cleanup((IWineD3DDevice
*) This
);
1054 Context_MarkStateDirty(context
, STATE_VSHADER
, StateTable
);
1055 Context_MarkStateDirty(context
, STATE_PIXELSHADER
, StateTable
);
1057 /* Disable all textures. The caller can then bind a texture it wants to blit
1060 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
1061 /* The blitting code uses (for now) the fixed function pipeline, so make sure to reset all fixed
1062 * function texture unit. No need to care for higher samplers
1064 for(i
= GL_LIMITS(textures
) - 1; i
> 0 ; i
--) {
1065 sampler
= This
->rev_tex_unit_map
[i
];
1066 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ i
));
1067 checkGLcall("glActiveTextureARB");
1069 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
1070 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1071 checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
1073 glDisable(GL_TEXTURE_3D
);
1074 checkGLcall("glDisable GL_TEXTURE_3D");
1075 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
1076 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
1077 checkGLcall("glDisable GL_TEXTURE_RECTANGLE_ARB");
1079 glDisable(GL_TEXTURE_2D
);
1080 checkGLcall("glDisable GL_TEXTURE_2D");
1082 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
1083 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);");
1085 if (sampler
!= -1) {
1086 if (sampler
< MAX_TEXTURES
) {
1087 Context_MarkStateDirty(context
, STATE_TEXTURESTAGE(sampler
, WINED3DTSS_COLOROP
), StateTable
);
1089 Context_MarkStateDirty(context
, STATE_SAMPLER(sampler
), StateTable
);
1092 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
));
1093 checkGLcall("glActiveTextureARB");
1096 sampler
= This
->rev_tex_unit_map
[0];
1098 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
1099 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1100 checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
1102 glDisable(GL_TEXTURE_3D
);
1103 checkGLcall("glDisable GL_TEXTURE_3D");
1104 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
1105 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
1106 checkGLcall("glDisable GL_TEXTURE_RECTANGLE_ARB");
1108 glDisable(GL_TEXTURE_2D
);
1109 checkGLcall("glDisable GL_TEXTURE_2D");
1111 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
1113 glMatrixMode(GL_TEXTURE
);
1114 checkGLcall("glMatrixMode(GL_TEXTURE)");
1116 checkGLcall("glLoadIdentity()");
1118 if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS
)) {
1119 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT
,
1120 GL_TEXTURE_LOD_BIAS_EXT
,
1122 checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
1125 if (sampler
!= -1) {
1126 if (sampler
< MAX_TEXTURES
) {
1127 Context_MarkStateDirty(context
, STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ sampler
), StateTable
);
1128 Context_MarkStateDirty(context
, STATE_TEXTURESTAGE(sampler
, WINED3DTSS_COLOROP
), StateTable
);
1130 Context_MarkStateDirty(context
, STATE_SAMPLER(sampler
), StateTable
);
1133 /* Other misc states */
1134 glDisable(GL_ALPHA_TEST
);
1135 checkGLcall("glDisable(GL_ALPHA_TEST)");
1136 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), StateTable
);
1137 glDisable(GL_LIGHTING
);
1138 checkGLcall("glDisable GL_LIGHTING");
1139 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_LIGHTING
), StateTable
);
1140 glDisable(GL_DEPTH_TEST
);
1141 checkGLcall("glDisable GL_DEPTH_TEST");
1142 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ZENABLE
), StateTable
);
1144 checkGLcall("glDisable GL_FOG");
1145 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_FOGENABLE
), StateTable
);
1146 glDisable(GL_BLEND
);
1147 checkGLcall("glDisable GL_BLEND");
1148 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), StateTable
);
1149 glDisable(GL_CULL_FACE
);
1150 checkGLcall("glDisable GL_CULL_FACE");
1151 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_CULLMODE
), StateTable
);
1152 glDisable(GL_STENCIL_TEST
);
1153 checkGLcall("glDisable GL_STENCIL_TEST");
1154 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_STENCILENABLE
), StateTable
);
1155 glDisable(GL_SCISSOR_TEST
);
1156 checkGLcall("glDisable GL_SCISSOR_TEST");
1157 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), StateTable
);
1158 if(GL_SUPPORT(ARB_POINT_SPRITE
)) {
1159 glDisable(GL_POINT_SPRITE_ARB
);
1160 checkGLcall("glDisable GL_POINT_SPRITE_ARB");
1161 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), StateTable
);
1163 glColorMask(GL_TRUE
, GL_TRUE
,GL_TRUE
,GL_TRUE
);
1164 checkGLcall("glColorMask");
1165 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_CLIPPING
), StateTable
);
1166 if (GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
1167 glDisable(GL_COLOR_SUM_EXT
);
1168 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_SPECULARENABLE
), StateTable
);
1169 checkGLcall("glDisable(GL_COLOR_SUM_EXT)");
1172 /* Setup transforms */
1173 glMatrixMode(GL_MODELVIEW
);
1174 checkGLcall("glMatrixMode(GL_MODELVIEW)");
1176 checkGLcall("glLoadIdentity()");
1177 Context_MarkStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), StateTable
);
1179 context
->last_was_rhw
= TRUE
;
1180 Context_MarkStateDirty(context
, STATE_VDECL
, StateTable
); /* because of last_was_rhw = TRUE */
1182 glDisable(GL_CLIP_PLANE0
); checkGLcall("glDisable(clip plane 0)");
1183 glDisable(GL_CLIP_PLANE1
); checkGLcall("glDisable(clip plane 1)");
1184 glDisable(GL_CLIP_PLANE2
); checkGLcall("glDisable(clip plane 2)");
1185 glDisable(GL_CLIP_PLANE3
); checkGLcall("glDisable(clip plane 3)");
1186 glDisable(GL_CLIP_PLANE4
); checkGLcall("glDisable(clip plane 4)");
1187 glDisable(GL_CLIP_PLANE5
); checkGLcall("glDisable(clip plane 5)");
1188 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_CLIPPING
), StateTable
);
1190 set_blit_dimension(width
, height
);
1191 context
->blit_w
= width
; context
->blit_h
= height
;
1192 Context_MarkStateDirty(context
, STATE_VIEWPORT
, StateTable
);
1193 Context_MarkStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
), StateTable
);
1196 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, FALSE
);
1199 /*****************************************************************************
1200 * findThreadContextForSwapChain
1202 * Searches a swapchain for all contexts and picks one for the thread tid.
1203 * If none can be found the swapchain is requested to create a new context
1205 *****************************************************************************/
1206 static WineD3DContext
*findThreadContextForSwapChain(IWineD3DSwapChain
*swapchain
, DWORD tid
) {
1209 for(i
= 0; i
< ((IWineD3DSwapChainImpl
*) swapchain
)->num_contexts
; i
++) {
1210 if(((IWineD3DSwapChainImpl
*) swapchain
)->context
[i
]->tid
== tid
) {
1211 return ((IWineD3DSwapChainImpl
*) swapchain
)->context
[i
];
1216 /* Create a new context for the thread */
1217 return IWineD3DSwapChainImpl_CreateContextForThread(swapchain
);
1220 /*****************************************************************************
1223 * Finds a context for the current render target and thread
1226 * target: Render target to find the context for
1227 * tid: Thread to activate the context for
1229 * Returns: The needed context
1231 *****************************************************************************/
1232 static inline WineD3DContext
*FindContext(IWineD3DDeviceImpl
*This
, IWineD3DSurface
*target
, DWORD tid
) {
1233 IWineD3DSwapChain
*swapchain
= NULL
;
1235 BOOL readTexture
= wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
&& This
->render_offscreen
;
1236 WineD3DContext
*context
= This
->activeContext
;
1237 BOOL oldRenderOffscreen
= This
->render_offscreen
;
1238 const WINED3DFORMAT oldFmt
= ((IWineD3DSurfaceImpl
*) This
->lastActiveRenderTarget
)->resource
.format
;
1239 const WINED3DFORMAT newFmt
= ((IWineD3DSurfaceImpl
*) target
)->resource
.format
;
1240 const struct StateEntry
*StateTable
= This
->StateTable
;
1242 /* To compensate the lack of format switching with some offscreen rendering methods and on onscreen buffers
1243 * the alpha blend state changes with different render target formats
1245 if(oldFmt
!= newFmt
) {
1246 const GlPixelFormatDesc
*glDesc
;
1247 const StaticPixelFormatDesc
*old
= getFormatDescEntry(oldFmt
, NULL
, NULL
);
1248 const StaticPixelFormatDesc
*new = getFormatDescEntry(newFmt
, &GLINFO_LOCATION
, &glDesc
);
1250 /* Disable blending when the alphaMask has changed and when a format doesn't support blending */
1251 if((old
->alphaMask
&& !new->alphaMask
) || (!old
->alphaMask
&& new->alphaMask
) || !(glDesc
->Flags
& WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
)) {
1252 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), StateTable
);
1256 hr
= IWineD3DSurface_GetContainer(target
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
1257 if(hr
== WINED3D_OK
&& swapchain
) {
1258 TRACE("Rendering onscreen\n");
1260 context
= findThreadContextForSwapChain(swapchain
, tid
);
1262 This
->render_offscreen
= FALSE
;
1263 /* The context != This->activeContext will catch a NOP context change. This can occur
1264 * if we are switching back to swapchain rendering in case of FBO or Back Buffer offscreen
1265 * rendering. No context change is needed in that case
1268 if(wined3d_settings
.offscreen_rendering_mode
== ORM_PBUFFER
) {
1269 if(This
->pbufferContext
&& tid
== This
->pbufferContext
->tid
) {
1270 This
->pbufferContext
->tid
= 0;
1273 IWineD3DSwapChain_Release(swapchain
);
1275 if(oldRenderOffscreen
) {
1276 Context_MarkStateDirty(context
, WINED3DTS_PROJECTION
, StateTable
);
1277 Context_MarkStateDirty(context
, STATE_VDECL
, StateTable
);
1278 Context_MarkStateDirty(context
, STATE_VIEWPORT
, StateTable
);
1279 Context_MarkStateDirty(context
, STATE_SCISSORRECT
, StateTable
);
1280 Context_MarkStateDirty(context
, STATE_FRONTFACE
, StateTable
);
1284 TRACE("Rendering offscreen\n");
1285 This
->render_offscreen
= TRUE
;
1287 switch(wined3d_settings
.offscreen_rendering_mode
) {
1289 /* FBOs do not need a different context. Stay with whatever context is active at the moment */
1290 if(This
->activeContext
&& tid
== This
->lastThread
) {
1291 context
= This
->activeContext
;
1293 /* This may happen if the app jumps straight into offscreen rendering
1294 * Start using the context of the primary swapchain. tid == 0 is no problem
1295 * for findThreadContextForSwapChain.
1297 * Can also happen on thread switches - in that case findThreadContextForSwapChain
1298 * is perfect to call.
1300 context
= findThreadContextForSwapChain(This
->swapchains
[0], tid
);
1306 IWineD3DSurfaceImpl
*targetimpl
= (IWineD3DSurfaceImpl
*) target
;
1307 if(This
->pbufferContext
== NULL
||
1308 This
->pbufferWidth
< targetimpl
->currentDesc
.Width
||
1309 This
->pbufferHeight
< targetimpl
->currentDesc
.Height
) {
1310 if(This
->pbufferContext
) {
1311 DestroyContext(This
, This
->pbufferContext
);
1314 /* The display is irrelevant here, the window is 0. But CreateContext needs a valid X connection.
1315 * Create the context on the same server as the primary swapchain. The primary swapchain is exists at this point.
1317 This
->pbufferContext
= CreateContext(This
, targetimpl
,
1318 ((IWineD3DSwapChainImpl
*) This
->swapchains
[0])->context
[0]->win_handle
,
1319 TRUE
/* pbuffer */, &((IWineD3DSwapChainImpl
*)This
->swapchains
[0])->presentParms
);
1320 This
->pbufferWidth
= targetimpl
->currentDesc
.Width
;
1321 This
->pbufferHeight
= targetimpl
->currentDesc
.Height
;
1324 if(This
->pbufferContext
) {
1325 if(This
->pbufferContext
->tid
!= 0 && This
->pbufferContext
->tid
!= tid
) {
1326 FIXME("The PBuffr context is only supported for one thread for now!\n");
1328 This
->pbufferContext
->tid
= tid
;
1329 context
= This
->pbufferContext
;
1332 ERR("Failed to create a buffer context and drawable, falling back to back buffer offscreen rendering\n");
1333 wined3d_settings
.offscreen_rendering_mode
= ORM_BACKBUFFER
;
1337 case ORM_BACKBUFFER
:
1338 /* Stay with the currently active context for back buffer rendering */
1339 if(This
->activeContext
&& tid
== This
->lastThread
) {
1340 context
= This
->activeContext
;
1342 /* This may happen if the app jumps straight into offscreen rendering
1343 * Start using the context of the primary swapchain. tid == 0 is no problem
1344 * for findThreadContextForSwapChain.
1346 * Can also happen on thread switches - in that case findThreadContextForSwapChain
1347 * is perfect to call.
1349 context
= findThreadContextForSwapChain(This
->swapchains
[0], tid
);
1354 if(!oldRenderOffscreen
) {
1355 Context_MarkStateDirty(context
, WINED3DTS_PROJECTION
, StateTable
);
1356 Context_MarkStateDirty(context
, STATE_VDECL
, StateTable
);
1357 Context_MarkStateDirty(context
, STATE_VIEWPORT
, StateTable
);
1358 Context_MarkStateDirty(context
, STATE_SCISSORRECT
, StateTable
);
1359 Context_MarkStateDirty(context
, STATE_FRONTFACE
, StateTable
);
1363 /* When switching away from an offscreen render target, and we're not using FBOs,
1364 * we have to read the drawable into the texture. This is done via PreLoad(and
1365 * SFLAG_INDRAWABLE set on the surface). There are some things that need care though.
1366 * PreLoad needs a GL context, and FindContext is called before the context is activated.
1367 * It also has to be called with the old rendertarget active, otherwise a wrong drawable
1368 * is read. This leads to these possible situations:
1370 * 0) lastActiveRenderTarget == target && oldTid == newTid:
1371 * Nothing to do, we don't even reach this code in this case...
1373 * 1) lastActiveRenderTarget != target && oldTid == newTid:
1374 * The currently active context is OK for readback. Call PreLoad, and it
1377 * 2) lastActiveRenderTarget == target && oldTid != newTid:
1378 * Nothing to do - the drawable is unchanged
1380 * 3) lastActiveRenderTarget != target && oldTid != newTid:
1381 * This is tricky. We have to get a context with the old drawable from somewhere
1382 * before we can switch to the new context. In this case, PreLoad calls
1383 * ActivateContext(lastActiveRenderTarget) from the new(current) thread. This
1384 * is case (2) then. The old drawable is activated for the new thread, and the
1385 * readback can be done. The recursed ActivateContext does *not* call PreLoad again.
1386 * After that, the outer ActivateContext(which calls PreLoad) can activate the new
1387 * target for the new thread
1389 if (readTexture
&& This
->lastActiveRenderTarget
!= target
) {
1390 BOOL oldInDraw
= This
->isInDraw
;
1392 /* PreLoad requires a context to load the texture, thus it will call ActivateContext.
1393 * Set the isInDraw to true to signal PreLoad that it has a context. Will be tricky
1394 * when using offscreen rendering with multithreading
1396 This
->isInDraw
= TRUE
;
1398 /* Do that before switching the context:
1399 * Read the back buffer of the old drawable into the destination texture
1401 IWineD3DSurface_PreLoad(This
->lastActiveRenderTarget
);
1403 /* Assume that the drawable will be modified by some other things now */
1404 IWineD3DSurface_ModifyLocation(This
->lastActiveRenderTarget
, SFLAG_INDRAWABLE
, FALSE
);
1406 This
->isInDraw
= oldInDraw
;
1412 static void apply_draw_buffer(IWineD3DDeviceImpl
*This
, IWineD3DSurface
*target
, BOOL blit
)
1415 IWineD3DSwapChain
*swapchain
;
1417 hr
= IWineD3DSurface_GetContainer(target
, &IID_IWineD3DSwapChain
, (void **)&swapchain
);
1420 IWineD3DSwapChain_Release((IUnknown
*)swapchain
);
1421 glDrawBuffer(surface_get_gl_buffer(target
, swapchain
));
1422 checkGLcall("glDrawBuffers()");
1426 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
)
1430 if (GL_SUPPORT(ARB_DRAW_BUFFERS
))
1432 GL_EXTCALL(glDrawBuffersARB(GL_LIMITS(buffers
), This
->draw_buffers
));
1433 checkGLcall("glDrawBuffers()");
1437 glDrawBuffer(This
->draw_buffers
[0]);
1438 checkGLcall("glDrawBuffer()");
1441 glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT
);
1442 checkGLcall("glDrawBuffer()");
1447 glDrawBuffer(This
->offscreenBuffer
);
1448 checkGLcall("glDrawBuffer()");
1453 /*****************************************************************************
1456 * Finds a rendering context and drawable matching the device and render
1457 * target for the current thread, activates them and puts them into the
1461 * This: Device to activate the context for
1462 * target: Requested render target
1463 * usage: Prepares the context for blitting, drawing or other actions
1465 *****************************************************************************/
1466 void ActivateContext(IWineD3DDeviceImpl
*This
, IWineD3DSurface
*target
, ContextUsage usage
) {
1467 DWORD tid
= GetCurrentThreadId();
1469 DWORD dirtyState
, idx
;
1471 WineD3DContext
*context
;
1472 const struct StateEntry
*StateTable
= This
->StateTable
;
1474 TRACE("(%p): Selecting context for render target %p, thread %d\n", This
, target
, tid
);
1475 if(This
->lastActiveRenderTarget
!= target
|| tid
!= This
->lastThread
) {
1476 context
= FindContext(This
, target
, tid
);
1477 context
->draw_buffer_dirty
= TRUE
;
1478 This
->lastActiveRenderTarget
= target
;
1479 This
->lastThread
= tid
;
1481 /* Stick to the old context */
1482 context
= This
->activeContext
;
1485 /* Activate the opengl context */
1486 if(last_device
!= This
|| context
!= This
->activeContext
) {
1489 /* Prevent an unneeded context switch as those are expensive */
1490 if(context
->glCtx
&& (context
->glCtx
== pwglGetCurrentContext())) {
1491 TRACE("Already using gl context %p\n", context
->glCtx
);
1494 TRACE("Switching gl ctx to %p, hdc=%p ctx=%p\n", context
, context
->hdc
, context
->glCtx
);
1496 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, FALSE
);
1497 ret
= pwglMakeCurrent(context
->hdc
, context
->glCtx
);
1499 ERR("Failed to activate the new context\n");
1500 } else if(!context
->last_was_blit
) {
1501 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, TRUE
);
1504 if(This
->activeContext
->vshader_const_dirty
) {
1505 memset(This
->activeContext
->vshader_const_dirty
, 1,
1506 sizeof(*This
->activeContext
->vshader_const_dirty
) * GL_LIMITS(vshader_constantsF
));
1508 if(This
->activeContext
->pshader_const_dirty
) {
1509 memset(This
->activeContext
->pshader_const_dirty
, 1,
1510 sizeof(*This
->activeContext
->pshader_const_dirty
) * GL_LIMITS(pshader_constantsF
));
1512 This
->activeContext
= context
;
1516 /* We only need ENTER_GL for the gl calls made below and for the helper functions which make GL calls */
1520 case CTXUSAGE_CLEAR
:
1521 case CTXUSAGE_DRAWPRIM
:
1522 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
1523 context_apply_fbo_state((IWineD3DDevice
*)This
);
1525 if (context
->draw_buffer_dirty
) {
1526 apply_draw_buffer(This
, target
, FALSE
);
1527 context
->draw_buffer_dirty
= FALSE
;
1532 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
) {
1533 if (This
->render_offscreen
) {
1534 FIXME("Activating for CTXUSAGE_BLIT for an offscreen target with ORM_FBO. This should be avoided.\n");
1535 context_bind_fbo((IWineD3DDevice
*)This
, GL_FRAMEBUFFER_EXT
, &context
->dst_fbo
);
1536 context_attach_surface_fbo(This
, GL_FRAMEBUFFER_EXT
, 0, target
);
1537 GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT
, GL_DEPTH_ATTACHMENT_EXT
, GL_RENDERBUFFER_EXT
, 0));
1538 checkGLcall("glFramebufferRenderbufferEXT");
1540 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, 0));
1541 checkGLcall("glFramebufferRenderbufferEXT");
1543 context
->draw_buffer_dirty
= TRUE
;
1545 if (context
->draw_buffer_dirty
) {
1546 apply_draw_buffer(This
, target
, TRUE
);
1547 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
) {
1548 context
->draw_buffer_dirty
= FALSE
;
1558 case CTXUSAGE_RESOURCELOAD
:
1559 /* This does not require any special states to be set up */
1562 case CTXUSAGE_CLEAR
:
1563 if(context
->last_was_blit
) {
1564 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, TRUE
);
1567 /* Blending and clearing should be orthogonal, but tests on the nvidia driver show that disabling
1568 * blending when clearing improves the clearing performance incredibly.
1570 glDisable(GL_BLEND
);
1571 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), StateTable
);
1573 glEnable(GL_SCISSOR_TEST
);
1574 checkGLcall("glEnable GL_SCISSOR_TEST");
1575 context
->last_was_blit
= FALSE
;
1576 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), StateTable
);
1577 Context_MarkStateDirty(context
, STATE_SCISSORRECT
, StateTable
);
1580 case CTXUSAGE_DRAWPRIM
:
1581 /* This needs all dirty states applied */
1582 if(context
->last_was_blit
) {
1583 This
->frag_pipe
->enable_extension((IWineD3DDevice
*) This
, TRUE
);
1586 IWineD3DDeviceImpl_FindTexUnitMap(This
);
1588 for(i
=0; i
< context
->numDirtyEntries
; i
++) {
1589 dirtyState
= context
->dirtyArray
[i
];
1590 idx
= dirtyState
>> 5;
1591 shift
= dirtyState
& 0x1f;
1592 context
->isStateDirty
[idx
] &= ~(1 << shift
);
1593 StateTable
[dirtyState
].apply(dirtyState
, This
->stateBlock
, context
);
1595 context
->numDirtyEntries
= 0; /* This makes the whole list clean */
1596 context
->last_was_blit
= FALSE
;
1600 SetupForBlit(This
, context
,
1601 ((IWineD3DSurfaceImpl
*)target
)->currentDesc
.Width
,
1602 ((IWineD3DSurfaceImpl
*)target
)->currentDesc
.Height
);
1606 FIXME("Unexpected context usage requested\n");