wined3d: Remove empty texture stage applying loop.
[wine] / dlls / wined3d / context.c
1 /*
2  * Context and render target management in wined3d
3  *
4  * Copyright 2007 Stefan Dösinger for CodeWeavers
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include "config.h"
22 #include <stdio.h>
23 #ifdef HAVE_FLOAT_H
24 # include <float.h>
25 #endif
26 #include "wined3d_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
29
30 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
31
32 /*****************************************************************************
33  * Context_MarkStateDirty
34  *
35  * Marks a state in a context dirty. Only one context, opposed to
36  * IWineD3DDeviceImpl_MarkStateDirty, which marks the state dirty in all
37  * contexts
38  *
39  * Params:
40  *  context: Context to mark the state dirty in
41  *  state: State to mark dirty
42  *
43  *****************************************************************************/
44 static void Context_MarkStateDirty(WineD3DContext *context, DWORD state) {
45     DWORD rep = StateTable[state].representative;
46     DWORD idx;
47     BYTE shift;
48
49     if(!rep || isStateDirty(context, rep)) return;
50
51     context->dirtyArray[context->numDirtyEntries++] = rep;
52     idx = rep >> 5;
53     shift = rep & 0x1f;
54     context->isStateDirty[idx] |= (1 << shift);
55 }
56
57 /*****************************************************************************
58  * AddContextToArray
59  *
60  * Adds a context to the context array. Helper function for CreateContext
61  *
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
64  * here.
65  *
66  * Params:
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.
71  *
72  *****************************************************************************/
73 static WineD3DContext *AddContextToArray(IWineD3DDeviceImpl *This, Display *display, GLXContext glCtx, Drawable drawable) {
74     WineD3DContext **oldArray = This->contexts;
75     DWORD state;
76
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;
81         return NULL;
82     }
83     if(oldArray) {
84         memcpy(This->contexts, oldArray, sizeof(*This->contexts) * This->numContexts);
85     }
86
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;
92         return NULL;
93     }
94
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);
99
100     /* Mark all states dirty to force a proper initialization of the states on the first use of the context
101      */
102     for(state = 0; state <= STATE_HIGHEST; state++) {
103         Context_MarkStateDirty(This->contexts[This->numContexts], state);
104     }
105
106     This->numContexts++;
107     TRACE("Created context %p\n", This->contexts[This->numContexts - 1]);
108     return This->contexts[This->numContexts - 1];
109 }
110
111 /* Returns an array of compatible FBconfig(s).
112  * The array must be freed with XFree. Requires ENTER_GL()
113  */
114 static GLXFBConfig* pbuffer_find_fbconfigs(
115     IWineD3DDeviceImpl* This,
116     IWineD3DSurfaceImpl* RenderSurface,
117     Display *display) {
118
119     GLXFBConfig* cfgs = NULL;
120     int nCfgs = 0;
121     int attribs[256];
122     int nAttribs = 0;
123
124     IWineD3DSurface *StencilSurface = This->stencilBufferTarget;
125     WINED3DFORMAT BackBufferFormat = RenderSurface->resource.format;
126     WINED3DFORMAT StencilBufferFormat = (NULL != StencilSurface) ? ((IWineD3DSurfaceImpl *) StencilSurface)->resource.format : 0;
127
128     /* TODO:
129      *  if StencilSurface == NULL && zBufferTarget != NULL then switch the zbuffer off,
130      *  it StencilSurface != NULL && zBufferTarget == NULL switch it on
131      */
132
133 #define PUSH1(att)        attribs[nAttribs++] = (att);
134 #define PUSH2(att,value)  attribs[nAttribs++] = (att); attribs[nAttribs++] = (value);
135
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!)*/
137
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 */);
143     PUSH1(None);
144     TRACE("calling chooseFGConfig\n");
145     cfgs = glXChooseFBConfig(display,
146                              DefaultScreen(display),
147                              attribs, &nCfgs);
148     if (cfgs == NULL) {
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
151            why we failed. */
152         static BOOL show_message = TRUE;
153         if (show_message) {
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;
157         }
158         nAttribs = 0;
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 */);
165         PUSH1(None);
166         cfgs = glXChooseFBConfig(display,
167                                  DefaultScreen(display),
168                                  attribs, &nCfgs);
169     }
170
171     if (cfgs == NULL) {
172         ERR("Could not get a valid FBConfig for (%u,%s)/(%u,%s)\n",
173             BackBufferFormat, debug_d3dformat(BackBufferFormat),
174             StencilBufferFormat, debug_d3dformat(StencilBufferFormat));
175     } else {
176 #ifdef EXTRA_TRACES
177         int i;
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]);
182         }
183 #endif
184     }
185 #undef PUSH1
186 #undef PUSH2
187
188    return cfgs;
189 }
190
191 /*****************************************************************************
192  * CreateContext
193  *
194  * Creates a new context for a window, or a pbuffer context.
195  *
196  * * Params:
197  *  This: Device to activate the context for
198  *  target: Surface this context will render to
199  *  display: X11 connection
200  *  win: Taget window. NULL for a pbuffer
201  *
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;
209
210     TRACE("(%p): Creating a %s context for render target %p\n", This, win ? "onscreen" : "offscreen", target);
211
212     if(!win) {
213         int attribs[256];
214         int nAttribs = 0;
215
216         TRACE("Creating a pBuffer drawable for the new context\n");
217
218         cfgs = pbuffer_find_fbconfigs(This, target, display);
219         if(!cfgs) {
220             ERR("Cannot find a frame buffer configuration for the pbuffer\n");
221             goto out;
222         }
223
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;
229
230         visinfo = glXGetVisualFromFBConfig(display, cfgs[0]);
231         if(!visinfo) {
232             ERR("Cannot find a visual for the pbuffer\n");
233             goto out;
234         }
235
236         drawable = glXCreatePbuffer(display, cfgs[0], attribs);
237
238         if(!drawable) {
239             ERR("Cannot create a pbuffer\n");
240             goto out;
241         }
242         XFree(cfgs);
243         cfgs = NULL;
244     } else {
245         /* Create an onscreen target */
246         XVisualInfo             template;
247         int                     num;
248
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);
254
255         if (NULL == visinfo) {
256             ERR("cannot really get XVisual\n");
257             goto out;
258         } else {
259             int n, value;
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);
292             }
293             /* Now choose a similar visual ID*/
294         }
295     }
296
297     ctx = glXCreateContext(display, visinfo,
298                            This->numContexts ? This->contexts[0]->glCtx : NULL,
299                            GL_TRUE);
300     if(!ctx) {
301         ERR("Failed to create a glX context\n");
302         if(drawable != win) glXDestroyPbuffer(display, drawable);
303         goto out;
304     }
305     ret = AddContextToArray(This, display, ctx, drawable);
306     if(!ret) {
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);
310         goto out;
311     }
312     ret->surface = (IWineD3DSurface *) target;
313     ret->isPBuffer = win == 0;
314
315     TRACE("Successfully created new context %p\n", ret);
316
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");
322         goto out;
323     }
324
325     TRACE("Setting up the screen\n");
326     /* Clear the screen */
327     glClearColor(1.0, 0.0, 0.0, 0.0);
328     checkGLcall("glClearColor");
329     glClearIndex(0);
330     glClearDepth(1);
331     glClearStencil(0xffff);
332
333     checkGLcall("glClear");
334
335     glColor3f(1.0, 1.0, 1.0);
336     checkGLcall("glColor3f");
337
338     glEnable(GL_LIGHTING);
339     checkGLcall("glEnable");
340
341     glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
342     checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
343
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);");
346
347     glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
348     checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
349
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);");
354
355     if(oldDrawable && oldCtx) {
356         glXMakeCurrent(display, oldDrawable, oldCtx);
357     }
358
359 out:
360     if(visinfo) XFree(visinfo);
361     if(cfgs) XFree(cfgs);
362     return ret;
363 }
364
365 /*****************************************************************************
366  * RemoveContextFromArray
367  *
368  * Removes a context from the context manager. The opengl context is not
369  * destroyed or unset. context is not a valid pointer after that call.
370  *
371  * Simmilar to the former call this isn't a performance critical function. A
372  * helper function for DestroyContext.
373  *
374  * Params:
375  *  This: Device to activate the context for
376  *  context: Context to remove
377  *
378  *****************************************************************************/
379 static void RemoveContextFromArray(IWineD3DDeviceImpl *This, WineD3DContext *context) {
380     UINT t, s;
381     WineD3DContext **oldArray = This->contexts;
382
383     TRACE("Removing ctx %p\n", context);
384
385     This->numContexts--;
386
387     if(This->numContexts) {
388         This->contexts = HeapAlloc(GetProcessHeap(), 0, sizeof(*This->contexts) * This->numContexts);
389         if(!This->contexts) {
390             ERR("Cannot allocate a new context array, PANIC!!!\n");
391         }
392         t = 0;
393         for(s = 0; s < This->numContexts; s++) {
394             if(oldArray[s] == context) continue;
395             This->contexts[t] = oldArray[s];
396             t++;
397         }
398     } else {
399         This->contexts = NULL;
400     }
401
402     HeapFree(GetProcessHeap(), 0, context);
403     HeapFree(GetProcessHeap(), 0, oldArray);
404 }
405
406 /*****************************************************************************
407  * DestroyContext
408  *
409  * Destroys a wineD3DContext
410  *
411  * Params:
412  *  This: Device to activate the context for
413  *  context: Context to destroy
414  *
415  *****************************************************************************/
416 void DestroyContext(IWineD3DDeviceImpl *This, WineD3DContext *context) {
417
418     /* check that we are the current context first */
419     TRACE("Destroying ctx %p\n", context);
420     if(glXGetCurrentContext() == context->glCtx){
421         glXMakeCurrent(context->display, None, NULL);
422     }
423
424     glXDestroyContext(context->display, context->glCtx);
425     if(context->isPBuffer) {
426         glXDestroyPbuffer(context->display, context->drawable);
427     }
428     RemoveContextFromArray(This, context);
429 }
430
431 /*****************************************************************************
432  * SetupForBlit
433  *
434  * Sets up a context for DirectDraw blitting.
435  * All texture units are disabled, except unit 0
436  * Texture unit 0 is activted where GL_TEXTURE_2D is activated
437  * fog, lighting, blending, alpha test, z test, scissor test, culling diabled
438  * color writing enabled for all channels
439  * register combiners disabled, shaders disabled
440  * world matris is set to identity, texture matrix 0 too
441  * projection matrix is setup for drawing screen coordinates
442  *
443  * Params:
444  *  This: Device to activate the context for
445  *  context: Context to setup
446  *  width: render target width
447  *  height: render target height
448  *
449  *****************************************************************************/
450 static inline void SetupForBlit(IWineD3DDeviceImpl *This, WineD3DContext *context, UINT width, UINT height) {
451     int i;
452
453     TRACE("Setting up context %p for blitting\n", context);
454     if(context->last_was_blit) {
455         TRACE("Context is already set up for blitting, nothing to do\n");
456         return;
457     }
458     context->last_was_blit = TRUE;
459
460     /* TODO: Use a display list */
461
462     /* Disable shaders */
463     This->shader_backend->shader_cleanup((IWineD3DDevice *) This);
464     Context_MarkStateDirty(context, STATE_VSHADER);
465     Context_MarkStateDirty(context, STATE_PIXELSHADER);
466
467     /* Disable all textures. The caller can then bind a texture it wants to blit
468      * from
469      */
470     if(GL_SUPPORT(NV_REGISTER_COMBINERS)) {
471         glDisable(GL_REGISTER_COMBINERS_NV);
472         checkGLcall("glDisable(GL_REGISTER_COMBINERS_NV)");
473     }
474     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
475         for(i = GL_LIMITS(samplers) - 1; i > 0 ; i--) {
476             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
477                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
478                 checkGLcall("glActiveTextureARB");
479             }
480             glDisable(GL_TEXTURE_CUBE_MAP_ARB);
481             checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
482             glDisable(GL_TEXTURE_3D);
483             checkGLcall("glDisable GL_TEXTURE_3D");
484             glDisable(GL_TEXTURE_2D);
485             checkGLcall("glDisable GL_TEXTURE_2D");
486             glDisable(GL_TEXTURE_1D);
487             checkGLcall("glDisable GL_TEXTURE_1D");
488
489             if(i < MAX_TEXTURES) {
490                 Context_MarkStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
491             }
492             Context_MarkStateDirty(context, STATE_SAMPLER(i));
493         }
494         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
495         checkGLcall("glActiveTextureARB");
496     }
497     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
498     checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
499     glDisable(GL_TEXTURE_3D);
500     checkGLcall("glDisable GL_TEXTURE_3D");
501     glDisable(GL_TEXTURE_1D);
502     checkGLcall("glDisable GL_TEXTURE_1D");
503     glEnable(GL_TEXTURE_2D);
504     checkGLcall("glEnable GL_TEXTURE_2D");
505
506     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
507
508     glMatrixMode(GL_TEXTURE);
509     checkGLcall("glMatrixMode(GL_TEXTURE)");
510     glLoadIdentity();
511     checkGLcall("glLoadIdentity()");
512     Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0));
513
514     if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
515         glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
516                   GL_TEXTURE_LOD_BIAS_EXT,
517                   0.0);
518         checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
519     }
520     Context_MarkStateDirty(context, STATE_SAMPLER(0));
521     Context_MarkStateDirty(context, STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP));
522
523     /* Other misc states */
524     glDisable(GL_ALPHA_TEST);
525     checkGLcall("glDisable(GL_ALPHA_TEST)");
526     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHATESTENABLE));
527     glDisable(GL_LIGHTING);
528     checkGLcall("glDisable GL_LIGHTING");
529     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING));
530     glDisable(GL_DEPTH_TEST);
531     checkGLcall("glDisable GL_DEPTH_TEST");
532     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ZENABLE));
533     glDisable(GL_FOG);
534     checkGLcall("glDisable GL_FOG");
535     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_FOGENABLE));
536     glDisable(GL_BLEND);
537     checkGLcall("glDisable GL_BLEND");
538     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
539     glDisable(GL_CULL_FACE);
540     checkGLcall("glDisable GL_CULL_FACE");
541     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_CULLMODE));
542     glDisable(GL_STENCIL_TEST);
543     checkGLcall("glDisable GL_STENCIL_TEST");
544     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_STENCILENABLE));
545     if(GL_SUPPORT(ARB_POINT_SPRITE)) {
546         glDisable(GL_POINT_SPRITE_ARB);
547         checkGLcall("glDisable GL_POINT_SPRITE_ARB");
548         Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_POINTSPRITEENABLE));
549     }
550     glColorMask(GL_TRUE, GL_TRUE,GL_TRUE,GL_TRUE);
551     checkGLcall("glColorMask");
552     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPING));
553
554     /* Setup transforms */
555     glMatrixMode(GL_MODELVIEW);
556     checkGLcall("glMatrixMode(GL_MODELVIEW)");
557     glLoadIdentity();
558     checkGLcall("glLoadIdentity()");
559     Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)));
560
561     glMatrixMode(GL_PROJECTION);
562     checkGLcall("glMatrixMode(GL_PROJECTION)");
563     glLoadIdentity();
564     checkGLcall("glLoadIdentity()");
565     glOrtho(0, width, height, 0, 0.0, -1.0);
566     checkGLcall("glOrtho");
567     Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION));
568
569     context->last_was_rhw = TRUE;
570     Context_MarkStateDirty(context, STATE_VDECL); /* because of last_was_rhw = TRUE */
571
572     glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)");
573     glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)");
574     glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)");
575     glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)");
576     glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)");
577     glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)");
578     Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPING));
579
580     glViewport(0, 0, width, height);
581     checkGLcall("glViewport");
582     Context_MarkStateDirty(context, STATE_VIEWPORT);
583 }
584
585 /*****************************************************************************
586  * ActivateContext
587  *
588  * Finds a rendering context and drawable matching the device and render
589  * target for the current thread, activates them and puts them into the
590  * requested state.
591  *
592  * Params:
593  *  This: Device to activate the context for
594  *  target: Requested render target
595  *  usage: Prepares the context for blitting, drawing or other actions
596  *
597  *****************************************************************************/
598 void ActivateContext(IWineD3DDeviceImpl *This, IWineD3DSurface *target, ContextUsage usage) {
599     DWORD tid = This->createParms.BehaviorFlags & D3DCREATE_MULTITHREADED ? GetCurrentThreadId() : 0;
600     int                           i;
601     DWORD                         dirtyState, idx;
602     BYTE                          shift;
603     WineD3DContext                *context = This->activeContext;
604     BOOL                          oldRenderOffscreen = This->render_offscreen;
605
606     TRACE("(%p): Selecting context for render target %p, thread %d\n", This, target, tid);
607
608     if(This->lastActiveRenderTarget != target) {
609         IWineD3DSwapChain *swapchain = NULL;
610         HRESULT hr;
611         BOOL readTexture = wined3d_settings.offscreen_rendering_mode != ORM_FBO && This->render_offscreen;
612
613         hr = IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **) &swapchain);
614         if(hr == WINED3D_OK && swapchain) {
615             TRACE("Rendering onscreen\n");
616             context = ((IWineD3DSwapChainImpl *) swapchain)->context;
617             This->render_offscreen = FALSE;
618             /* The context != This->activeContext will catch a NOP context change. This can occur
619              * if we are switching back to swapchain rendering in case of FBO or Back Buffer offscreen
620              * rendering. No context change is needed in that case
621              */
622
623             if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && oldRenderOffscreen) {
624                 set_render_target_fbo((IWineD3DDevice *) This, 0, target);
625             }
626             IWineD3DSwapChain_Release(swapchain);
627
628             if(oldRenderOffscreen) {
629                 Context_MarkStateDirty(context, WINED3DRS_CULLMODE);
630             }
631         } else {
632             TRACE("Rendering offscreen\n");
633             This->render_offscreen = TRUE;
634
635             switch(wined3d_settings.offscreen_rendering_mode) {
636                 case ORM_FBO:
637                     /* FBOs do not need a different context. Stay with whatever context is active at the moment */
638                     if(This->activeContext) {
639                         context = This->activeContext;
640                     } else {
641                         /* This may happen if the app jumps streight into offscreen rendering
642                          * Start using the context of the primary swapchain
643                          */
644                         context = ((IWineD3DSwapChainImpl *) This->swapchains[0])->context;
645                     }
646                     set_render_target_fbo((IWineD3DDevice *) This, 0, target);
647                     break;
648
649                 case ORM_PBUFFER:
650                 {
651                     IWineD3DSurfaceImpl *targetimpl = (IWineD3DSurfaceImpl *) target;
652                     if(This->pbufferContext == NULL ||
653                        This->pbufferWidth < targetimpl->currentDesc.Width ||
654                        This->pbufferHeight < targetimpl->currentDesc.Height) {
655                         if(This->pbufferContext) {
656                             DestroyContext(This, This->pbufferContext);
657                         }
658
659                         /* The display is irrelevant here, the window is 0. But CreateContext needs a valid X connection.
660                          * Create the context on the same server as the primary swapchain. The primary swapchain is exists at this point.
661                          */
662                         This->pbufferContext = CreateContext(This, targetimpl,
663                                                              ((IWineD3DSwapChainImpl *) This->swapchains[0])->context->display,
664                                                              0 /* Window */);
665                         This->pbufferWidth = targetimpl->currentDesc.Width;
666                         This->pbufferHeight = targetimpl->currentDesc.Height;
667                     }
668
669                     if(This->pbufferContext) {
670                         context = This->pbufferContext;
671                         break;
672                     } else {
673                         ERR("Failed to create a buffer context and drawable, falling back to back buffer offscreen rendering\n");
674                         wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
675                     }
676                 }
677
678                 case ORM_BACKBUFFER:
679                     /* Stay with the currently active context for back buffer rendering */
680                     if(This->activeContext) {
681                         context = This->activeContext;
682                     } else {
683                         /* This may happen if the app jumps streight into offscreen rendering
684                          * Start using the context of the primary swapchain
685                          */
686                         context = ((IWineD3DSwapChainImpl *) This->swapchains[0])->context;
687                     }
688                     break;
689             }
690
691             if(!oldRenderOffscreen) {
692                 Context_MarkStateDirty(context, WINED3DRS_CULLMODE);
693             }
694         }
695         if (readTexture) {
696             /* Do that before switching the context:
697              * Read the back buffer of the old drawable into the destination texture
698              */
699             IWineD3DSurface_SetPBufferState(This->lastActiveRenderTarget, TRUE /* inPBuffer */, FALSE /* inTexture */);
700             IWineD3DSurface_AddDirtyRect(This->lastActiveRenderTarget, NULL);
701             IWineD3DSurface_PreLoad(This->lastActiveRenderTarget);
702             IWineD3DSurface_SetPBufferState(This->lastActiveRenderTarget, FALSE /* inPBuffer */, FALSE /* inTexture */);
703         }
704         This->lastActiveRenderTarget = target;
705         if(oldRenderOffscreen != This->render_offscreen && This->depth_copy_state != WINED3D_DCS_NO_COPY) {
706             This->depth_copy_state = WINED3D_DCS_COPY;
707         }
708     } else {
709         /* Stick to the old context */
710         context = This->activeContext;
711     }
712
713     /* Activate the opengl context */
714     if(context != This->activeContext) {
715         Bool ret;
716         TRACE("Switching gl ctx to %p, drawable=%ld, ctx=%p\n", context, context->drawable, context->glCtx);
717         ret = glXMakeCurrent(context->display, context->drawable, context->glCtx);
718         if(ret == FALSE) {
719             ERR("Failed to activate the new context\n");
720         }
721         This->activeContext = context;
722     }
723
724     switch(usage) {
725         case CTXUSAGE_RESOURCELOAD:
726             /* This does not require any special states to be set up */
727             break;
728
729         case CTXUSAGE_DRAWPRIM:
730             /* This needs all dirty states applied */
731             for(i=0; i < context->numDirtyEntries; i++) {
732                 dirtyState = context->dirtyArray[i];
733                 idx = dirtyState >> 5;
734                 shift = dirtyState & 0x1f;
735                 context->isStateDirty[idx] &= ~(1 << shift);
736                 StateTable[dirtyState].apply(dirtyState, This->stateBlock, context);
737             }
738             context->numDirtyEntries = 0; /* This makes the whole list clean */
739             context->last_was_blit = FALSE;
740             break;
741
742         case CTXUSAGE_BLIT:
743             SetupForBlit(This, context,
744                          ((IWineD3DSurfaceImpl *)target)->currentDesc.Width,
745                          ((IWineD3DSurfaceImpl *)target)->currentDesc.Height);
746             break;
747
748         default:
749             FIXME("Unexpected context usage requested\n");
750     }
751 }