git.oblomov.eu Git - wine/blob - dlls/wined3d/query.c

   1 /*
   2  * IWineD3DQuery implementation
   3  *
   4  * Copyright 2005 Oliver Stieber
   5  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22
  23 #include "config.h"
  24 #include "wined3d_private.h"
  25
  26 /*
  27  * Occlusion Queries:
  28  * http://www.gris.uni-tuebingen.de/~bartz/Publications/paper/hww98.pdf
  29  * http://oss.sgi.com/projects/ogl-sample/registry/ARB/occlusion_query.txt
  30  */
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  33 #define GLINFO_LOCATION This->wineD3DDevice->adapter->gl_info
  34
  35 /* *******************************************
  36    IWineD3DQuery IUnknown parts follow
  37    ******************************************* */
  38 static HRESULT  WINAPI IWineD3DQueryImpl_QueryInterface(IWineD3DQuery *iface, REFIID riid, LPVOID *ppobj)
  39 {
  40     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
  41     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
  42     if (IsEqualGUID(riid, &IID_IUnknown)
  43         || IsEqualGUID(riid, &IID_IWineD3DBase)
  44         || IsEqualGUID(riid, &IID_IWineD3DQuery)) {
  45         IUnknown_AddRef(iface);
  46         *ppobj = This;
  47         return S_OK;
  48     }
  49     *ppobj = NULL;
  50     return E_NOINTERFACE;
  51 }
  52
  53 static ULONG  WINAPI IWineD3DQueryImpl_AddRef(IWineD3DQuery *iface) {
  54     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
  55     TRACE("(%p) : AddRef increasing from %d\n", This, This->ref);
  56     return InterlockedIncrement(&This->ref);
  57 }
  58
  59 static ULONG  WINAPI IWineD3DQueryImpl_Release(IWineD3DQuery *iface) {
  60     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
  61     ULONG ref;
  62     TRACE("(%p) : Releasing from %d\n", This, This->ref);
  63     ref = InterlockedDecrement(&This->ref);
  64     if (ref == 0) {
  65         /* Queries are specific to the GL context that created them. Not
  66          * deleting the query will obviously leak it, but that's still better
  67          * than potentially deleting a different query with the same id in this
  68          * context, and (still) leaking the actual query. */
  69         if (This->type == WINED3DQUERYTYPE_EVENT)
  70         {
  71             struct wined3d_event_query *query = This->extendedData;
  72
  73             if (query->context) context_free_event_query(query);
  74         }
  75         else if (This->type == WINED3DQUERYTYPE_OCCLUSION)
  76         {
  77             struct wined3d_occlusion_query *query = This->extendedData;
  78
  79             if (query->context) context_free_occlusion_query(query);
  80         }
  81
  82         HeapFree(GetProcessHeap(), 0, This->extendedData);
  83         HeapFree(GetProcessHeap(), 0, This);
  84     }
  85     return ref;
  86 }
  87
  88 /* *******************************************
  89    IWineD3DQuery IWineD3DQuery parts follow
  90    ******************************************* */
  91 static HRESULT  WINAPI IWineD3DQueryImpl_GetParent(IWineD3DQuery *iface, IUnknown** parent){
  92     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
  93
  94     *parent= (IUnknown*) parent;
  95     IUnknown_AddRef(*parent);
  96     TRACE("(%p) : returning %p\n", This, *parent);
  97     return WINED3D_OK;
  98 }
  99
 100 static HRESULT  WINAPI IWineD3DQueryImpl_GetDevice(IWineD3DQuery* iface, IWineD3DDevice **pDevice){
 101     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 102     IWineD3DDevice_AddRef((IWineD3DDevice *)This->wineD3DDevice);
 103     *pDevice = (IWineD3DDevice *)This->wineD3DDevice;
 104     TRACE("(%p) returning %p\n", This, *pDevice);
 105     return WINED3D_OK;
 106 }
 107
 108
 109 static HRESULT  WINAPI IWineD3DQueryImpl_GetData(IWineD3DQuery* iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags){
 110     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 111     HRESULT res = S_OK;
 112
 113     TRACE("(%p) : type %#x, pData %p, dwSize %#x, dwGetDataFlags %#x\n", This, This->type, pData, dwSize, dwGetDataFlags);
 114
 115     switch (This->type){
 116
 117     case WINED3DQUERYTYPE_VCACHE:
 118     {
 119
 120         WINED3DDEVINFO_VCACHE *data = pData;
 121         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_VCACHE\n", This);
 122         if(pData == NULL || dwSize == 0) break;
 123         data->Pattern     = WINEMAKEFOURCC('C','A','C','H');
 124         data->OptMethod   = 0; /*0 get longest strips, 1 optimize vertex cache*/
 125         data->CacheSize   = 0; /*cache size, only required if OptMethod == 1*/
 126         data->MagicNumber = 0; /*only required if OptMethod == 1 (used internally)*/
 127
 128     }
 129     break;
 130     case WINED3DQUERYTYPE_RESOURCEMANAGER:
 131     {
 132         WINED3DDEVINFO_RESOURCEMANAGER *data = pData;
 133         int i;
 134         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_RESOURCEMANAGER\n", This);
 135         if(pData == NULL || dwSize == 0) break;
 136         for(i = 0; i < WINED3DRTYPECOUNT; i++){
 137             /*I'm setting the default values to 1 so as to reduce the risk of a div/0 in the caller*/
 138             /*  isTextureResident could be used to get some of this information  */
 139             data->stats[i].bThrashing            = FALSE;
 140             data->stats[i].ApproxBytesDownloaded = 1;
 141             data->stats[i].NumEvicts             = 1;
 142             data->stats[i].NumVidCreates         = 1;
 143             data->stats[i].LastPri               = 1;
 144             data->stats[i].NumUsed               = 1;
 145             data->stats[i].NumUsedInVidMem       = 1;
 146             data->stats[i].WorkingSet            = 1;
 147             data->stats[i].WorkingSetBytes       = 1;
 148             data->stats[i].TotalManaged          = 1;
 149             data->stats[i].TotalBytes            = 1;
 150         }
 151
 152     }
 153     break;
 154     case WINED3DQUERYTYPE_VERTEXSTATS:
 155     {
 156         WINED3DDEVINFO_VERTEXSTATS *data = pData;
 157         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_VERTEXSTATS\n", This);
 158         if(pData == NULL || dwSize == 0) break;
 159         data->NumRenderedTriangles      = 1;
 160         data->NumExtraClippingTriangles = 1;
 161
 162     }
 163     break;
 164     case WINED3DQUERYTYPE_TIMESTAMP:
 165     {
 166         UINT64* data = pData;
 167         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_TIMESTAMP\n", This);
 168         if(pData == NULL || dwSize == 0) break;
 169         *data = 1; /*Don't know what this is supposed to be*/
 170     }
 171     break;
 172     case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
 173     {
 174         BOOL* data = pData;
 175         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_TIMESTAMPDISJOINT\n", This);
 176         if(pData == NULL || dwSize == 0) break;
 177         *data = FALSE; /*Don't know what this is supposed to be*/
 178     }
 179     break;
 180     case WINED3DQUERYTYPE_TIMESTAMPFREQ:
 181     {
 182         UINT64* data = pData;
 183         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_TIMESTAMPFREQ\n", This);
 184         if(pData == NULL || dwSize == 0) break;
 185         *data = 1; /*Don't know what this is supposed to be*/
 186     }
 187     break;
 188     case WINED3DQUERYTYPE_PIPELINETIMINGS:
 189     {
 190         WINED3DDEVINFO_PIPELINETIMINGS *data = pData;
 191         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_PIPELINETIMINGS\n", This);
 192         if(pData == NULL || dwSize == 0) break;
 193
 194         data->VertexProcessingTimePercent    =   1.0f;
 195         data->PixelProcessingTimePercent     =   1.0f;
 196         data->OtherGPUProcessingTimePercent  =  97.0f;
 197         data->GPUIdleTimePercent             =   1.0f;
 198     }
 199     break;
 200     case WINED3DQUERYTYPE_INTERFACETIMINGS:
 201     {
 202         WINED3DDEVINFO_INTERFACETIMINGS *data = pData;
 203         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_INTERFACETIMINGS\n", This);
 204
 205         if(pData == NULL || dwSize == 0) break;
 206         data->WaitingForGPUToUseApplicationResourceTimePercent =   1.0f;
 207         data->WaitingForGPUToAcceptMoreCommandsTimePercent     =   1.0f;
 208         data->WaitingForGPUToStayWithinLatencyTimePercent      =   1.0f;
 209         data->WaitingForGPUExclusiveResourceTimePercent        =   1.0f;
 210         data->WaitingForGPUOtherTimePercent                    =  96.0f;
 211     }
 212
 213     break;
 214     case WINED3DQUERYTYPE_VERTEXTIMINGS:
 215     {
 216         WINED3DDEVINFO_STAGETIMINGS *data = pData;
 217         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_VERTEXTIMINGS\n", This);
 218
 219         if(pData == NULL || dwSize == 0) break;
 220         data->MemoryProcessingPercent      = 50.0f;
 221         data->ComputationProcessingPercent = 50.0f;
 222
 223     }
 224     break;
 225     case WINED3DQUERYTYPE_PIXELTIMINGS:
 226     {
 227         WINED3DDEVINFO_STAGETIMINGS *data = pData;
 228         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_PIXELTIMINGS\n", This);
 229
 230         if(pData == NULL || dwSize == 0) break;
 231         data->MemoryProcessingPercent      = 50.0f;
 232         data->ComputationProcessingPercent = 50.0f;
 233     }
 234     break;
 235     case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
 236     {
 237         WINED3DDEVINFO_BANDWIDTHTIMINGS *data = pData;
 238         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_BANDWIDTHTIMINGS\n", This);
 239
 240         if(pData == NULL || dwSize == 0) break;
 241         data->MaxBandwidthUtilized                =  1.0f;
 242         data->FrontEndUploadMemoryUtilizedPercent =  1.0f;
 243         data->VertexRateUtilizedPercent           =  1.0f;
 244         data->TriangleSetupRateUtilizedPercent    =  1.0f;
 245         data->FillRateUtilizedPercent             = 97.0f;
 246     }
 247     break;
 248     case WINED3DQUERYTYPE_CACHEUTILIZATION:
 249     {
 250         WINED3DDEVINFO_CACHEUTILIZATION *data = pData;
 251         FIXME("(%p): Unimplemented query WINED3DQUERYTYPE_CACHEUTILIZATION\n", This);
 252
 253         if(pData == NULL || dwSize == 0) break;
 254         data->TextureCacheHitRate             = 1.0f;
 255         data->PostTransformVertexCacheHitRate = 1.0f;
 256     }
 257
 258
 259     break;
 260     default:
 261         FIXME("(%p) Unhandled query type %d\n",This , This->type);
 262
 263     };
 264
 265     /*dwGetDataFlags = 0 || D3DGETDATA_FLUSH
 266     D3DGETDATA_FLUSH may return WINED3DERR_DEVICELOST if the device is lost
 267     */
 268     return res; /* S_OK if the query data is available*/
 269 }
 270
 271 static HRESULT  WINAPI IWineD3DOcclusionQueryImpl_GetData(IWineD3DQuery* iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags) {
 272     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *) iface;
 273     struct wined3d_occlusion_query *query = This->extendedData;
 274     DWORD* data = pData;
 275     GLuint available;
 276     GLuint samples;
 277     HRESULT res;
 278
 279     TRACE("(%p) : type D3DQUERY_OCCLUSION, pData %p, dwSize %#x, dwGetDataFlags %#x\n", This, pData, dwSize, dwGetDataFlags);
 280
 281     if (!query->context) This->state = QUERY_CREATED;
 282
 283     if (This->state == QUERY_CREATED)
 284     {
 285         /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves */
 286         TRACE("Query wasn't yet started, returning S_OK\n");
 287         if(data) *data = 0;
 288         return S_OK;
 289     }
 290
 291     if (This->state == QUERY_BUILDING)
 292     {
 293         /* Msdn says this returns an error, but our tests show that S_FALSE is returned */
 294         TRACE("Query is building, returning S_FALSE\n");
 295         return S_FALSE;
 296     }
 297
 298     if (!GL_SUPPORT(ARB_OCCLUSION_QUERY))
 299     {
 300         WARN("(%p) : Occlusion queries not supported. Returning 1.\n", This);
 301         *data = 1;
 302         return S_OK;
 303     }
 304
 305     if (query->context->tid != GetCurrentThreadId())
 306     {
 307         FIXME("%p Wrong thread, returning 1.\n", This);
 308         *data = 1;
 309         return S_OK;
 310     }
 311
 312     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
 313
 314     ENTER_GL();
 315
 316     GL_EXTCALL(glGetQueryObjectuivARB(query->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
 317     checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
 318     TRACE("(%p) : available %d.\n", This, available);
 319
 320     if (available)
 321     {
 322         if (data)
 323         {
 324             GL_EXTCALL(glGetQueryObjectuivARB(query->id, GL_QUERY_RESULT_ARB, &samples));
 325             checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
 326             TRACE("(%p) : Returning %d samples.\n", This, samples);
 327             *data = samples;
 328         }
 329         res = S_OK;
 330     }
 331     else
 332     {
 333         res = S_FALSE;
 334     }
 335
 336     LEAVE_GL();
 337
 338     return res;
 339 }
 340
 341 static HRESULT  WINAPI IWineD3DEventQueryImpl_GetData(IWineD3DQuery* iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags) {
 342     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *) iface;
 343     struct wined3d_event_query *query = This->extendedData;
 344     BOOL* data = pData;
 345
 346     TRACE("(%p) : type D3DQUERY_EVENT, pData %p, dwSize %#x, dwGetDataFlags %#x\n", This, pData, dwSize, dwGetDataFlags);
 347
 348     if (!pData || !dwSize) return S_OK;
 349
 350     if (query->context->tid != GetCurrentThreadId())
 351     {
 352         /* See comment in IWineD3DQuery::Issue, event query codeblock */
 353         FIXME("Wrong thread, reporting GPU idle.\n");
 354         *data = TRUE;
 355
 356         return S_OK;
 357     }
 358
 359     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
 360
 361     ENTER_GL();
 362
 363     if (GL_SUPPORT(APPLE_FENCE))
 364     {
 365         *data = GL_EXTCALL(glTestFenceAPPLE(query->id));
 366         checkGLcall("glTestFenceAPPLE");
 367     }
 368     else if (GL_SUPPORT(NV_FENCE))
 369     {
 370         *data = GL_EXTCALL(glTestFenceNV(query->id));
 371         checkGLcall("glTestFenceNV");
 372     }
 373     else
 374     {
 375         WARN("(%p): reporting GPU idle\n", This);
 376         *data = TRUE;
 377     }
 378
 379     LEAVE_GL();
 380
 381     return S_OK;
 382 }
 383
 384 static DWORD  WINAPI IWineD3DQueryImpl_GetDataSize(IWineD3DQuery* iface){
 385     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 386     int dataSize = 0;
 387     TRACE("(%p) : type %#x\n", This, This->type);
 388     switch(This->type){
 389     case WINED3DQUERYTYPE_VCACHE:
 390         dataSize = sizeof(WINED3DDEVINFO_VCACHE);
 391         break;
 392     case WINED3DQUERYTYPE_RESOURCEMANAGER:
 393         dataSize = sizeof(WINED3DDEVINFO_RESOURCEMANAGER);
 394         break;
 395     case WINED3DQUERYTYPE_VERTEXSTATS:
 396         dataSize = sizeof(WINED3DDEVINFO_VERTEXSTATS);
 397         break;
 398     case WINED3DQUERYTYPE_EVENT:
 399         dataSize = sizeof(BOOL);
 400         break;
 401     case WINED3DQUERYTYPE_TIMESTAMP:
 402         dataSize = sizeof(UINT64);
 403         break;
 404     case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
 405         dataSize = sizeof(BOOL);
 406         break;
 407     case WINED3DQUERYTYPE_TIMESTAMPFREQ:
 408         dataSize = sizeof(UINT64);
 409         break;
 410     case WINED3DQUERYTYPE_PIPELINETIMINGS:
 411         dataSize = sizeof(WINED3DDEVINFO_PIPELINETIMINGS);
 412         break;
 413     case WINED3DQUERYTYPE_INTERFACETIMINGS:
 414         dataSize = sizeof(WINED3DDEVINFO_INTERFACETIMINGS);
 415         break;
 416     case WINED3DQUERYTYPE_VERTEXTIMINGS:
 417         dataSize = sizeof(WINED3DDEVINFO_STAGETIMINGS);
 418         break;
 419     case WINED3DQUERYTYPE_PIXELTIMINGS:
 420         dataSize = sizeof(WINED3DDEVINFO_STAGETIMINGS);
 421         break;
 422     case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
 423         dataSize = sizeof(WINED3DQUERYTYPE_BANDWIDTHTIMINGS);
 424         break;
 425     case WINED3DQUERYTYPE_CACHEUTILIZATION:
 426         dataSize = sizeof(WINED3DDEVINFO_CACHEUTILIZATION);
 427         break;
 428     default:
 429        FIXME("(%p) Unhandled query type %d\n",This , This->type);
 430        dataSize = 0;
 431     }
 432     return dataSize;
 433 }
 434
 435 static DWORD  WINAPI IWineD3DEventQueryImpl_GetDataSize(IWineD3DQuery* iface){
 436     TRACE("(%p) : type D3DQUERY_EVENT\n", iface);
 437
 438     return sizeof(BOOL);
 439 }
 440
 441 static DWORD  WINAPI IWineD3DOcclusionQueryImpl_GetDataSize(IWineD3DQuery* iface){
 442     TRACE("(%p) : type D3DQUERY_OCCLUSION\n", iface);
 443
 444     return sizeof(DWORD);
 445 }
 446
 447 static WINED3DQUERYTYPE  WINAPI IWineD3DQueryImpl_GetType(IWineD3DQuery* iface){
 448     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 449     return This->type;
 450 }
 451
 452
 453 static HRESULT  WINAPI IWineD3DEventQueryImpl_Issue(IWineD3DQuery* iface,  DWORD dwIssueFlags) {
 454     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 455
 456     TRACE("(%p) : dwIssueFlags %#x, type D3DQUERY_EVENT\n", This, dwIssueFlags);
 457     if (dwIssueFlags & WINED3DISSUE_END)
 458     {
 459         struct wined3d_event_query *query = This->extendedData;
 460         struct WineD3DContext *context;
 461
 462         if (query->context)
 463         {
 464             if (query->context->tid != GetCurrentThreadId())
 465             {
 466                 context_free_event_query(query);
 467                 context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
 468                 context_alloc_event_query(context, query);
 469             }
 470             else
 471             {
 472                 ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
 473             }
 474         }
 475         else
 476         {
 477             context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
 478             context_alloc_event_query(context, query);
 479         }
 480
 481         ENTER_GL();
 482
 483         if (GL_SUPPORT(APPLE_FENCE))
 484         {
 485             GL_EXTCALL(glSetFenceAPPLE(query->id));
 486             checkGLcall("glSetFenceAPPLE");
 487         }
 488         else if (GL_SUPPORT(NV_FENCE))
 489         {
 490             GL_EXTCALL(glSetFenceNV(query->id, GL_ALL_COMPLETED_NV));
 491             checkGLcall("glSetFenceNV");
 492         }
 493
 494         LEAVE_GL();
 495     }
 496     else if(dwIssueFlags & WINED3DISSUE_BEGIN)
 497     {
 498         /* Started implicitly at device creation */
 499         ERR("Event query issued with START flag - what to do?\n");
 500     }
 501
 502     if(dwIssueFlags & WINED3DISSUE_BEGIN) {
 503         This->state = QUERY_BUILDING;
 504     } else {
 505         This->state = QUERY_SIGNALLED;
 506     }
 507
 508     return WINED3D_OK;
 509 }
 510
 511 static HRESULT  WINAPI IWineD3DOcclusionQueryImpl_Issue(IWineD3DQuery* iface,  DWORD dwIssueFlags) {
 512     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 513
 514     if (GL_SUPPORT(ARB_OCCLUSION_QUERY))
 515     {
 516         struct wined3d_occlusion_query *query = This->extendedData;
 517         struct WineD3DContext *context;
 518
 519         /* This is allowed according to msdn and our tests. Reset the query and restart */
 520         if (dwIssueFlags & WINED3DISSUE_BEGIN)
 521         {
 522             if (This->state == QUERY_BUILDING)
 523             {
 524                 if (query->context->tid != GetCurrentThreadId())
 525                 {
 526                     FIXME("Wrong thread, can't restart query.\n");
 527
 528                     context_free_occlusion_query(query);
 529                     context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
 530                     context_alloc_occlusion_query(context, query);
 531                 }
 532                 else
 533                 {
 534                     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
 535
 536                     ENTER_GL();
 537                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 538                     checkGLcall("glEndQuery()");
 539                     LEAVE_GL();
 540                 }
 541             }
 542             else
 543             {
 544                 if (query->context) context_free_occlusion_query(query);
 545                 context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
 546                 context_alloc_occlusion_query(context, query);
 547             }
 548
 549             ENTER_GL();
 550             GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, query->id));
 551             checkGLcall("glBeginQuery()");
 552             LEAVE_GL();
 553         }
 554         if (dwIssueFlags & WINED3DISSUE_END) {
 555             /* Msdn says _END on a non-building occlusion query returns an error, but
 556              * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
 557              * generating an error
 558              */
 559             if (This->state == QUERY_BUILDING)
 560             {
 561                 if (query->context->tid != GetCurrentThreadId())
 562                 {
 563                     FIXME("Wrong thread, can't end query.\n");
 564                 }
 565                 else
 566                 {
 567                     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
 568
 569                     ENTER_GL();
 570                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 571                     checkGLcall("glEndQuery()");
 572                     LEAVE_GL();
 573                 }
 574             }
 575         }
 576     } else {
 577         FIXME("(%p) : Occlusion queries not supported\n", This);
 578     }
 579
 580     if(dwIssueFlags & WINED3DISSUE_BEGIN) {
 581         This->state = QUERY_BUILDING;
 582     } else {
 583         This->state = QUERY_SIGNALLED;
 584     }
 585     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
 586 }
 587
 588 static HRESULT  WINAPI IWineD3DQueryImpl_Issue(IWineD3DQuery* iface,  DWORD dwIssueFlags){
 589     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 590
 591     TRACE("(%p) : dwIssueFlags %#x, type %#x\n", This, dwIssueFlags, This->type);
 592
 593     /* The fixme is printed when the app asks for the resulting data */
 594     WARN("(%p) : Unhandled query type %#x\n", This, This->type);
 595
 596     if(dwIssueFlags & WINED3DISSUE_BEGIN) {
 597         This->state = QUERY_BUILDING;
 598     } else {
 599         This->state = QUERY_SIGNALLED;
 600     }
 601
 602     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
 603 }
 604
 605
 606 /**********************************************************
 607  * IWineD3DQuery VTbl follows
 608  **********************************************************/
 609
 610 const IWineD3DQueryVtbl IWineD3DQuery_Vtbl =
 611 {
 612     /*** IUnknown methods ***/
 613     IWineD3DQueryImpl_QueryInterface,
 614     IWineD3DQueryImpl_AddRef,
 615     IWineD3DQueryImpl_Release,
 616      /*** IWineD3Dquery methods ***/
 617     IWineD3DQueryImpl_GetParent,
 618     IWineD3DQueryImpl_GetDevice,
 619     IWineD3DQueryImpl_GetData,
 620     IWineD3DQueryImpl_GetDataSize,
 621     IWineD3DQueryImpl_GetType,
 622     IWineD3DQueryImpl_Issue
 623 };
 624
 625 const IWineD3DQueryVtbl IWineD3DEventQuery_Vtbl =
 626 {
 627     /*** IUnknown methods ***/
 628     IWineD3DQueryImpl_QueryInterface,
 629     IWineD3DQueryImpl_AddRef,
 630     IWineD3DQueryImpl_Release,
 631     /*** IWineD3Dquery methods ***/
 632     IWineD3DQueryImpl_GetParent,
 633     IWineD3DQueryImpl_GetDevice,
 634     IWineD3DEventQueryImpl_GetData,
 635     IWineD3DEventQueryImpl_GetDataSize,
 636     IWineD3DQueryImpl_GetType,
 637     IWineD3DEventQueryImpl_Issue
 638 };
 639
 640 const IWineD3DQueryVtbl IWineD3DOcclusionQuery_Vtbl =
 641 {
 642     /*** IUnknown methods ***/
 643     IWineD3DQueryImpl_QueryInterface,
 644     IWineD3DQueryImpl_AddRef,
 645     IWineD3DQueryImpl_Release,
 646     /*** IWineD3Dquery methods ***/
 647     IWineD3DQueryImpl_GetParent,
 648     IWineD3DQueryImpl_GetDevice,
 649     IWineD3DOcclusionQueryImpl_GetData,
 650     IWineD3DOcclusionQueryImpl_GetDataSize,
 651     IWineD3DQueryImpl_GetType,
 652     IWineD3DOcclusionQueryImpl_Issue
 653 };