2 * Context and render target management in wined3d
4 * Copyright 2007 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 ((IWineD3DImpl *)(This->wineD3D))->gl_info
32 /*****************************************************************************
33 * Context_MarkStateDirty
35 * Marks a state in a context dirty. Only one context, opposed to
36 * IWineD3DDeviceImpl_MarkStateDirty, which marks the state dirty in all
40 * context: Context to mark the state dirty in
41 * state: State to mark dirty
43 *****************************************************************************/
44 static void Context_MarkStateDirty(WineD3DContext
*context
, DWORD state
) {
45 DWORD rep
= StateTable
[state
].representative
;
49 if(!rep
|| isStateDirty(context
, rep
)) return;
51 context
->dirtyArray
[context
->numDirtyEntries
++] = rep
;
54 context
->isStateDirty
[idx
] |= (1 << shift
);
57 /*****************************************************************************
60 * Adds a context to the context array. Helper function for CreateContext
62 * This method is not called in performance-critical code paths, only when a
63 * new render target or swapchain is created. Thus performance is not an issue
67 * This: Device to add the context for
68 * display: X display this context uses
69 * glCtx: glX context to add
70 * drawable: drawable used with this context.
72 *****************************************************************************/
73 static WineD3DContext
*AddContextToArray(IWineD3DDeviceImpl
*This
, Display
*display
, GLXContext glCtx
, Drawable drawable
) {
74 WineD3DContext
**oldArray
= This
->contexts
;
77 This
->contexts
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
->contexts
) * (This
->numContexts
+ 1));
78 if(This
->contexts
== NULL
) {
79 ERR("Unable to grow the context array\n");
80 This
->contexts
= oldArray
;
84 memcpy(This
->contexts
, oldArray
, sizeof(*This
->contexts
) * This
->numContexts
);
87 This
->contexts
[This
->numContexts
] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WineD3DContext
));
88 if(This
->contexts
[This
->numContexts
] == NULL
) {
89 ERR("Unable to allocate a new context\n");
90 HeapFree(GetProcessHeap(), 0, This
->contexts
);
91 This
->contexts
= oldArray
;
95 This
->contexts
[This
->numContexts
]->display
= display
;
96 This
->contexts
[This
->numContexts
]->glCtx
= glCtx
;
97 This
->contexts
[This
->numContexts
]->drawable
= drawable
;
98 HeapFree(GetProcessHeap(), 0, oldArray
);
100 /* Mark all states dirty to force a proper initialization of the states on the first use of the context
102 for(state
= 0; state
<= STATE_HIGHEST
; state
++) {
103 Context_MarkStateDirty(This
->contexts
[This
->numContexts
], state
);
107 TRACE("Created context %p\n", This
->contexts
[This
->numContexts
- 1]);
108 return This
->contexts
[This
->numContexts
- 1];
111 /* Returns an array of compatible FBconfig(s).
112 * The array must be freed with XFree. Requires ENTER_GL()
114 static GLXFBConfig
* pbuffer_find_fbconfigs(
115 IWineD3DDeviceImpl
* This
,
116 IWineD3DSurfaceImpl
* RenderSurface
,
119 GLXFBConfig
* cfgs
= NULL
;
124 IWineD3DSurface
*StencilSurface
= This
->stencilBufferTarget
;
125 WINED3DFORMAT BackBufferFormat
= RenderSurface
->resource
.format
;
126 WINED3DFORMAT StencilBufferFormat
= (NULL
!= StencilSurface
) ? ((IWineD3DSurfaceImpl
*) StencilSurface
)->resource
.format
: 0;
129 * if StencilSurface == NULL && zBufferTarget != NULL then switch the zbuffer off,
130 * it StencilSurface != NULL && zBufferTarget == NULL switch it on
133 #define PUSH1(att) attribs[nAttribs++] = (att);
134 #define PUSH2(att,value) attribs[nAttribs++] = (att); attribs[nAttribs++] = (value);
136 /* PUSH2(GLX_BIND_TO_TEXTURE_RGBA_ATI, True); examples of this are few and far between (but I've got a nice working one!)*/
138 PUSH2(GLX_DRAWABLE_TYPE
, GLX_PBUFFER_BIT
);
139 PUSH2(GLX_X_RENDERABLE
, TRUE
);
140 PUSH2(GLX_DOUBLEBUFFER
, TRUE
);
141 TRACE("calling makeglcfg\n");
142 D3DFmtMakeGlCfg(BackBufferFormat
, StencilBufferFormat
, attribs
, &nAttribs
, FALSE
/* alternate */);
144 TRACE("calling chooseFGConfig\n");
145 cfgs
= glXChooseFBConfig(display
,
146 DefaultScreen(display
),
149 /* OK we didn't find the exact config, so use any reasonable match */
150 /* TODO: fill in the 'requested' and 'current' depths, and make sure that's
152 static BOOL show_message
= TRUE
;
154 ERR("Failed to find exact match, finding alternative but you may "
155 "suffer performance issues, try changing xfree's depth to match the requested depth\n");
156 show_message
= FALSE
;
159 PUSH2(GLX_DRAWABLE_TYPE
, GLX_PBUFFER_BIT
| GLX_WINDOW_BIT
);
160 /* PUSH2(GLX_X_RENDERABLE, TRUE); */
161 PUSH2(GLX_RENDER_TYPE
, GLX_RGBA_BIT
);
162 PUSH2(GLX_DOUBLEBUFFER
, FALSE
);
163 TRACE("calling makeglcfg\n");
164 D3DFmtMakeGlCfg(BackBufferFormat
, StencilBufferFormat
, attribs
, &nAttribs
, TRUE
/* alternate */);
166 cfgs
= glXChooseFBConfig(display
,
167 DefaultScreen(display
),
172 ERR("Could not get a valid FBConfig for (%u,%s)/(%u,%s)\n",
173 BackBufferFormat
, debug_d3dformat(BackBufferFormat
),
174 StencilBufferFormat
, debug_d3dformat(StencilBufferFormat
));
178 for (i
= 0; i
< nCfgs
; ++i
) {
179 TRACE("for (%u,%s)/(%u,%s) found config[%d]@%p\n", BackBufferFormat
,
180 debug_d3dformat(BackBufferFormat
), StencilBufferFormat
,
181 debug_d3dformat(StencilBufferFormat
), i
, cfgs
[i
]);
191 /*****************************************************************************
194 * Creates a new context for a window, or a pbuffer context.
197 * This: Device to activate the context for
198 * target: Surface this context will render to
199 * display: X11 connection
200 * win: Target window. NULL for a pbuffer
202 *****************************************************************************/
203 WineD3DContext
*CreateContext(IWineD3DDeviceImpl
*This
, IWineD3DSurfaceImpl
*target
, Display
*display
, Window win
) {
204 Drawable drawable
= win
, oldDrawable
;
205 XVisualInfo
*visinfo
= NULL
;
206 GLXFBConfig
*cfgs
= NULL
;
207 GLXContext ctx
= NULL
, oldCtx
;
208 WineD3DContext
*ret
= NULL
;
210 TRACE("(%p): Creating a %s context for render target %p\n", This
, win
? "onscreen" : "offscreen", target
);
216 TRACE("Creating a pBuffer drawable for the new context\n");
218 cfgs
= pbuffer_find_fbconfigs(This
, target
, display
);
220 ERR("Cannot find a frame buffer configuration for the pbuffer\n");
224 attribs
[nAttribs
++] = GLX_PBUFFER_WIDTH
;
225 attribs
[nAttribs
++] = target
->currentDesc
.Width
;
226 attribs
[nAttribs
++] = GLX_PBUFFER_HEIGHT
;
227 attribs
[nAttribs
++] = target
->currentDesc
.Height
;
228 attribs
[nAttribs
++] = None
;
230 visinfo
= glXGetVisualFromFBConfig(display
, cfgs
[0]);
232 ERR("Cannot find a visual for the pbuffer\n");
236 drawable
= glXCreatePbuffer(display
, cfgs
[0], attribs
);
239 ERR("Cannot create a pbuffer\n");
245 /* Create an onscreen target */
246 XVisualInfo
template;
249 template.visualid
= (VisualID
)GetPropA(GetDesktopWindow(), "__wine_x11_visual_id");
250 /* TODO: change this to find a similar visual, but one with a stencil/zbuffer buffer that matches the request
251 (or the best possible if none is requested) */
252 TRACE("Found x visual ID : %ld\n", template.visualid
);
253 visinfo
= XGetVisualInfo(display
, VisualIDMask
, &template, &num
);
255 if (NULL
== visinfo
) {
256 ERR("cannot really get XVisual\n");
260 /* Write out some debug info about the visual/s */
261 TRACE("Using x visual ID : %ld\n", template.visualid
);
262 TRACE(" visual info: %p\n", visinfo
);
263 TRACE(" num items : %d\n", num
);
264 for (n
= 0;n
< num
; n
++) {
265 TRACE("=====item=====: %d\n", n
+ 1);
266 TRACE(" visualid : %ld\n", visinfo
[n
].visualid
);
267 TRACE(" screen : %d\n", visinfo
[n
].screen
);
268 TRACE(" depth : %u\n", visinfo
[n
].depth
);
269 TRACE(" class : %d\n", visinfo
[n
].class);
270 TRACE(" red_mask : %ld\n", visinfo
[n
].red_mask
);
271 TRACE(" green_mask : %ld\n", visinfo
[n
].green_mask
);
272 TRACE(" blue_mask : %ld\n", visinfo
[n
].blue_mask
);
273 TRACE(" colormap_size : %d\n", visinfo
[n
].colormap_size
);
274 TRACE(" bits_per_rgb : %d\n", visinfo
[n
].bits_per_rgb
);
275 /* log some extra glx info */
276 glXGetConfig(display
, visinfo
, GLX_AUX_BUFFERS
, &value
);
277 TRACE(" gl_aux_buffers : %d\n", value
);
278 glXGetConfig(display
, visinfo
, GLX_BUFFER_SIZE
,&value
);
279 TRACE(" gl_buffer_size : %d\n", value
);
280 glXGetConfig(display
, visinfo
, GLX_RED_SIZE
, &value
);
281 TRACE(" gl_red_size : %d\n", value
);
282 glXGetConfig(display
, visinfo
, GLX_GREEN_SIZE
, &value
);
283 TRACE(" gl_green_size : %d\n", value
);
284 glXGetConfig(display
, visinfo
, GLX_BLUE_SIZE
, &value
);
285 TRACE(" gl_blue_size : %d\n", value
);
286 glXGetConfig(display
, visinfo
, GLX_ALPHA_SIZE
, &value
);
287 TRACE(" gl_alpha_size : %d\n", value
);
288 glXGetConfig(display
, visinfo
, GLX_DEPTH_SIZE
,&value
);
289 TRACE(" gl_depth_size : %d\n", value
);
290 glXGetConfig(display
, visinfo
, GLX_STENCIL_SIZE
, &value
);
291 TRACE(" gl_stencil_size : %d\n", value
);
293 /* Now choose a similar visual ID*/
297 ctx
= glXCreateContext(display
, visinfo
,
298 This
->numContexts
? This
->contexts
[0]->glCtx
: NULL
,
301 ERR("Failed to create a glX context\n");
302 if(drawable
!= win
) glXDestroyPbuffer(display
, drawable
);
305 ret
= AddContextToArray(This
, display
, ctx
, drawable
);
307 ERR("Failed to add the newly created context to the context list\n");
308 glXDestroyContext(display
, ctx
);
309 if(drawable
!= win
) glXDestroyPbuffer(display
, drawable
);
312 ret
->surface
= (IWineD3DSurface
*) target
;
313 ret
->isPBuffer
= win
== 0;
315 TRACE("Successfully created new context %p\n", ret
);
317 /* Set up the context defaults */
318 oldCtx
= glXGetCurrentContext();
319 oldDrawable
= glXGetCurrentDrawable();
320 if(glXMakeCurrent(display
, drawable
, ctx
) == FALSE
) {
321 ERR("Cannot activate context to set up defaults\n");
325 TRACE("Setting up the screen\n");
326 /* Clear the screen */
327 glClearColor(1.0, 0.0, 0.0, 0.0);
328 checkGLcall("glClearColor");
331 glClearStencil(0xffff);
333 checkGLcall("glClear");
335 glColor3f(1.0, 1.0, 1.0);
336 checkGLcall("glColor3f");
338 glEnable(GL_LIGHTING
);
339 checkGLcall("glEnable");
341 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, GL_TRUE
);
342 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
344 glTexEnvf(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE_EXT
);
345 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
347 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL
, GL_SEPARATE_SPECULAR_COLOR
);
348 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
350 glPixelStorei(GL_PACK_ALIGNMENT
, SURFACE_ALIGNMENT
);
351 checkGLcall("glPixelStorei(GL_PACK_ALIGNMENT, SURFACE_ALIGNMENT);");
352 glPixelStorei(GL_UNPACK_ALIGNMENT
, SURFACE_ALIGNMENT
);
353 checkGLcall("glPixelStorei(GL_UNPACK_ALIGNMENT, SURFACE_ALIGNMENT);");
355 if(GL_SUPPORT(APPLE_CLIENT_STORAGE
)) {
356 /* Most textures will use client storage if supported. Exceptions are non-native power of 2 textures
357 * and textures in DIB sections(due to the memory protection).
359 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE
, GL_TRUE
);
360 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
363 if(oldDrawable
&& oldCtx
) {
364 glXMakeCurrent(display
, oldDrawable
, oldCtx
);
368 if(visinfo
) XFree(visinfo
);
369 if(cfgs
) XFree(cfgs
);
373 /*****************************************************************************
374 * RemoveContextFromArray
376 * Removes a context from the context manager. The opengl context is not
377 * destroyed or unset. context is not a valid pointer after that call.
379 * Similar to the former call this isn't a performance critical function. A
380 * helper function for DestroyContext.
383 * This: Device to activate the context for
384 * context: Context to remove
386 *****************************************************************************/
387 static void RemoveContextFromArray(IWineD3DDeviceImpl
*This
, WineD3DContext
*context
) {
389 WineD3DContext
**oldArray
= This
->contexts
;
391 TRACE("Removing ctx %p\n", context
);
395 if(This
->numContexts
) {
396 This
->contexts
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
->contexts
) * This
->numContexts
);
397 if(!This
->contexts
) {
398 ERR("Cannot allocate a new context array, PANIC!!!\n");
401 for(s
= 0; s
< This
->numContexts
; s
++) {
402 if(oldArray
[s
] == context
) continue;
403 This
->contexts
[t
] = oldArray
[s
];
407 This
->contexts
= NULL
;
410 HeapFree(GetProcessHeap(), 0, context
);
411 HeapFree(GetProcessHeap(), 0, oldArray
);
414 /*****************************************************************************
417 * Destroys a wineD3DContext
420 * This: Device to activate the context for
421 * context: Context to destroy
423 *****************************************************************************/
424 void DestroyContext(IWineD3DDeviceImpl
*This
, WineD3DContext
*context
) {
426 /* check that we are the current context first */
427 TRACE("Destroying ctx %p\n", context
);
428 if(glXGetCurrentContext() == context
->glCtx
){
429 glXMakeCurrent(context
->display
, None
, NULL
);
432 glXDestroyContext(context
->display
, context
->glCtx
);
433 if(context
->isPBuffer
) {
434 glXDestroyPbuffer(context
->display
, context
->drawable
);
436 RemoveContextFromArray(This
, context
);
439 /*****************************************************************************
442 * Sets up a context for DirectDraw blitting.
443 * All texture units are disabled, except unit 0
444 * Texture unit 0 is activted where GL_TEXTURE_2D is activated
445 * fog, lighting, blending, alpha test, z test, scissor test, culling diabled
446 * color writing enabled for all channels
447 * register combiners disabled, shaders disabled
448 * world matris is set to identity, texture matrix 0 too
449 * projection matrix is setup for drawing screen coordinates
452 * This: Device to activate the context for
453 * context: Context to setup
454 * width: render target width
455 * height: render target height
457 *****************************************************************************/
458 static inline void SetupForBlit(IWineD3DDeviceImpl
*This
, WineD3DContext
*context
, UINT width
, UINT height
) {
461 TRACE("Setting up context %p for blitting\n", context
);
462 if(context
->last_was_blit
) {
463 TRACE("Context is already set up for blitting, nothing to do\n");
466 context
->last_was_blit
= TRUE
;
468 /* TODO: Use a display list */
470 /* Disable shaders */
471 This
->shader_backend
->shader_cleanup((IWineD3DDevice
*) This
);
472 Context_MarkStateDirty(context
, STATE_VSHADER
);
473 Context_MarkStateDirty(context
, STATE_PIXELSHADER
);
475 /* Disable all textures. The caller can then bind a texture it wants to blit
478 if(GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
479 glDisable(GL_REGISTER_COMBINERS_NV
);
480 checkGLcall("glDisable(GL_REGISTER_COMBINERS_NV)");
482 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
483 /* The blitting code uses (for now) the fixed function pipeline, so make sure to reset all fixed
484 * function texture unit. No need to care for higher samplers
486 for(i
= GL_LIMITS(textures
) - 1; i
> 0 ; i
--) {
487 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ i
));
488 checkGLcall("glActiveTextureARB");
490 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
491 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
492 checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
494 glDisable(GL_TEXTURE_3D
);
495 checkGLcall("glDisable GL_TEXTURE_3D");
496 glDisable(GL_TEXTURE_2D
);
497 checkGLcall("glDisable GL_TEXTURE_2D");
499 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
500 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);");
502 Context_MarkStateDirty(context
, STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
));
503 Context_MarkStateDirty(context
, STATE_SAMPLER(i
));
505 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
));
506 checkGLcall("glActiveTextureARB");
508 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
509 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
510 checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
512 glDisable(GL_TEXTURE_3D
);
513 checkGLcall("glDisable GL_TEXTURE_3D");
514 glEnable(GL_TEXTURE_2D
);
515 checkGLcall("glEnable GL_TEXTURE_2D");
517 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_REPLACE
);
519 glMatrixMode(GL_TEXTURE
);
520 checkGLcall("glMatrixMode(GL_TEXTURE)");
522 checkGLcall("glLoadIdentity()");
523 Context_MarkStateDirty(context
, STATE_TRANSFORM(WINED3DTS_TEXTURE0
));
525 if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS
)) {
526 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT
,
527 GL_TEXTURE_LOD_BIAS_EXT
,
529 checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
531 Context_MarkStateDirty(context
, STATE_SAMPLER(0));
532 Context_MarkStateDirty(context
, STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
));
534 /* Other misc states */
535 glDisable(GL_ALPHA_TEST
);
536 checkGLcall("glDisable(GL_ALPHA_TEST)");
537 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ALPHATESTENABLE
));
538 glDisable(GL_LIGHTING
);
539 checkGLcall("glDisable GL_LIGHTING");
540 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_LIGHTING
));
541 glDisable(GL_DEPTH_TEST
);
542 checkGLcall("glDisable GL_DEPTH_TEST");
543 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ZENABLE
));
545 checkGLcall("glDisable GL_FOG");
546 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_FOGENABLE
));
548 checkGLcall("glDisable GL_BLEND");
549 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
));
550 glDisable(GL_CULL_FACE
);
551 checkGLcall("glDisable GL_CULL_FACE");
552 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_CULLMODE
));
553 glDisable(GL_STENCIL_TEST
);
554 checkGLcall("glDisable GL_STENCIL_TEST");
555 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_STENCILENABLE
));
556 if(GL_SUPPORT(ARB_POINT_SPRITE
)) {
557 glDisable(GL_POINT_SPRITE_ARB
);
558 checkGLcall("glDisable GL_POINT_SPRITE_ARB");
559 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
));
561 glColorMask(GL_TRUE
, GL_TRUE
,GL_TRUE
,GL_TRUE
);
562 checkGLcall("glColorMask");
563 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_CLIPPING
));
565 /* Setup transforms */
566 glMatrixMode(GL_MODELVIEW
);
567 checkGLcall("glMatrixMode(GL_MODELVIEW)");
569 checkGLcall("glLoadIdentity()");
570 Context_MarkStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)));
572 glMatrixMode(GL_PROJECTION
);
573 checkGLcall("glMatrixMode(GL_PROJECTION)");
575 checkGLcall("glLoadIdentity()");
576 glOrtho(0, width
, height
, 0, 0.0, -1.0);
577 checkGLcall("glOrtho");
578 Context_MarkStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
));
580 context
->last_was_rhw
= TRUE
;
581 Context_MarkStateDirty(context
, STATE_VDECL
); /* because of last_was_rhw = TRUE */
583 glDisable(GL_CLIP_PLANE0
); checkGLcall("glDisable(clip plane 0)");
584 glDisable(GL_CLIP_PLANE1
); checkGLcall("glDisable(clip plane 1)");
585 glDisable(GL_CLIP_PLANE2
); checkGLcall("glDisable(clip plane 2)");
586 glDisable(GL_CLIP_PLANE3
); checkGLcall("glDisable(clip plane 3)");
587 glDisable(GL_CLIP_PLANE4
); checkGLcall("glDisable(clip plane 4)");
588 glDisable(GL_CLIP_PLANE5
); checkGLcall("glDisable(clip plane 5)");
589 Context_MarkStateDirty(context
, STATE_RENDER(WINED3DRS_CLIPPING
));
591 glViewport(0, 0, width
, height
);
592 checkGLcall("glViewport");
593 Context_MarkStateDirty(context
, STATE_VIEWPORT
);
596 /*****************************************************************************
599 * Finds a rendering context and drawable matching the device and render
600 * target for the current thread, activates them and puts them into the
604 * This: Device to activate the context for
605 * target: Requested render target
606 * usage: Prepares the context for blitting, drawing or other actions
608 *****************************************************************************/
609 void ActivateContext(IWineD3DDeviceImpl
*This
, IWineD3DSurface
*target
, ContextUsage usage
) {
610 DWORD tid
= This
->createParms
.BehaviorFlags
& WINED3DCREATE_MULTITHREADED
? GetCurrentThreadId() : 0;
612 DWORD dirtyState
, idx
;
614 WineD3DContext
*context
= This
->activeContext
;
615 BOOL oldRenderOffscreen
= This
->render_offscreen
;
617 TRACE("(%p): Selecting context for render target %p, thread %d\n", This
, target
, tid
);
619 if(This
->lastActiveRenderTarget
!= target
) {
620 IWineD3DSwapChain
*swapchain
= NULL
;
622 BOOL readTexture
= wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
&& This
->render_offscreen
;
624 hr
= IWineD3DSurface_GetContainer(target
, &IID_IWineD3DSwapChain
, (void **) &swapchain
);
625 if(hr
== WINED3D_OK
&& swapchain
) {
626 TRACE("Rendering onscreen\n");
627 context
= ((IWineD3DSwapChainImpl
*) swapchain
)->context
[0];
628 This
->render_offscreen
= FALSE
;
629 /* The context != This->activeContext will catch a NOP context change. This can occur
630 * if we are switching back to swapchain rendering in case of FBO or Back Buffer offscreen
631 * rendering. No context change is needed in that case
634 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& oldRenderOffscreen
) {
635 set_render_target_fbo((IWineD3DDevice
*) This
, 0, target
);
636 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_BACKBUFFER
) {
637 if(((IWineD3DSwapChainImpl
*) swapchain
)->backBuffer
) {
638 glDrawBuffer(GL_BACK
);
639 checkGLcall("glDrawBuffer(GL_BACK)");
641 glDrawBuffer(GL_FRONT
);
642 checkGLcall("glDrawBuffer(GL_FRONT)");
645 IWineD3DSwapChain_Release(swapchain
);
647 if(oldRenderOffscreen
) {
648 Context_MarkStateDirty(context
, WINED3DRS_CULLMODE
);
649 Context_MarkStateDirty(context
, WINED3DTS_PROJECTION
);
650 Context_MarkStateDirty(context
, STATE_VDECL
);
651 Context_MarkStateDirty(context
, STATE_VIEWPORT
);
654 TRACE("Rendering offscreen\n");
655 This
->render_offscreen
= TRUE
;
657 switch(wined3d_settings
.offscreen_rendering_mode
) {
659 /* FBOs do not need a different context. Stay with whatever context is active at the moment */
660 if(This
->activeContext
) {
661 context
= This
->activeContext
;
663 /* This may happen if the app jumps streight into offscreen rendering
664 * Start using the context of the primary swapchain
666 context
= ((IWineD3DSwapChainImpl
*) This
->swapchains
[0])->context
[0];
668 set_render_target_fbo((IWineD3DDevice
*) This
, 0, target
);
673 IWineD3DSurfaceImpl
*targetimpl
= (IWineD3DSurfaceImpl
*) target
;
674 if(This
->pbufferContext
== NULL
||
675 This
->pbufferWidth
< targetimpl
->currentDesc
.Width
||
676 This
->pbufferHeight
< targetimpl
->currentDesc
.Height
) {
677 if(This
->pbufferContext
) {
678 DestroyContext(This
, This
->pbufferContext
);
681 /* The display is irrelevant here, the window is 0. But CreateContext needs a valid X connection.
682 * Create the context on the same server as the primary swapchain. The primary swapchain is exists at this point.
684 This
->pbufferContext
= CreateContext(This
, targetimpl
,
685 ((IWineD3DSwapChainImpl
*) This
->swapchains
[0])->context
[0]->display
,
687 This
->pbufferWidth
= targetimpl
->currentDesc
.Width
;
688 This
->pbufferHeight
= targetimpl
->currentDesc
.Height
;
691 if(This
->pbufferContext
) {
692 context
= This
->pbufferContext
;
695 ERR("Failed to create a buffer context and drawable, falling back to back buffer offscreen rendering\n");
696 wined3d_settings
.offscreen_rendering_mode
= ORM_BACKBUFFER
;
701 /* Stay with the currently active context for back buffer rendering */
702 if(This
->activeContext
) {
703 context
= This
->activeContext
;
705 /* This may happen if the app jumps streight into offscreen rendering
706 * Start using the context of the primary swapchain
708 context
= ((IWineD3DSwapChainImpl
*) This
->swapchains
[0])->context
[0];
710 glDrawBuffer(This
->offscreenBuffer
);
711 checkGLcall("glDrawBuffer(This->offscreenBuffer)");
715 if(!oldRenderOffscreen
) {
716 Context_MarkStateDirty(context
, WINED3DRS_CULLMODE
);
717 Context_MarkStateDirty(context
, WINED3DTS_PROJECTION
);
718 Context_MarkStateDirty(context
, STATE_VDECL
);
719 Context_MarkStateDirty(context
, STATE_VIEWPORT
);
723 BOOL oldInDraw
= This
->isInDraw
;
725 /* PreLoad requires a context to load the texture, thus it will call ActivateContext.
726 * Set the isInDraw to true to signal PreLoad that it has a context. Will be tricky
727 * when using offscreen rendering with multithreading
729 This
->isInDraw
= TRUE
;
731 /* Do that before switching the context:
732 * Read the back buffer of the old drawable into the destination texture
734 IWineD3DSurface_PreLoad(This
->lastActiveRenderTarget
);
736 /* Assume that the drawable will be modified by some other things now */
737 ((IWineD3DSurfaceImpl
*) This
->lastActiveRenderTarget
)->Flags
&= ~SFLAG_INDRAWABLE
;
739 This
->isInDraw
= oldInDraw
;
741 This
->lastActiveRenderTarget
= target
;
742 if(oldRenderOffscreen
!= This
->render_offscreen
&& This
->depth_copy_state
!= WINED3D_DCS_NO_COPY
) {
743 This
->depth_copy_state
= WINED3D_DCS_COPY
;
746 /* Stick to the old context */
747 context
= This
->activeContext
;
750 /* Activate the opengl context */
751 if(context
!= This
->activeContext
) {
753 TRACE("Switching gl ctx to %p, drawable=%ld, ctx=%p\n", context
, context
->drawable
, context
->glCtx
);
754 ret
= glXMakeCurrent(context
->display
, context
->drawable
, context
->glCtx
);
756 ERR("Failed to activate the new context\n");
758 This
->activeContext
= context
;
762 case CTXUSAGE_RESOURCELOAD
:
763 /* This does not require any special states to be set up */
766 case CTXUSAGE_DRAWPRIM
:
767 /* This needs all dirty states applied */
768 for(i
=0; i
< context
->numDirtyEntries
; i
++) {
769 dirtyState
= context
->dirtyArray
[i
];
770 idx
= dirtyState
>> 5;
771 shift
= dirtyState
& 0x1f;
772 context
->isStateDirty
[idx
] &= ~(1 << shift
);
773 StateTable
[dirtyState
].apply(dirtyState
, This
->stateBlock
, context
);
775 context
->numDirtyEntries
= 0; /* This makes the whole list clean */
776 context
->last_was_blit
= FALSE
;
780 SetupForBlit(This
, context
,
781 ((IWineD3DSurfaceImpl
*)target
)->currentDesc
.Width
,
782 ((IWineD3DSurfaceImpl
*)target
)->currentDesc
.Height
);
786 FIXME("Unexpected context usage requested\n");