crypt32: Add array descriptor members describing offsets of outer structure.
[wine] / 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)
351     {
352         ERR("Query not started, returning TRUE.\n");
353         *data = TRUE;
354
355         return S_OK;
356     }
357
358     if (query->context->tid != GetCurrentThreadId())
359     {
360         /* See comment in IWineD3DQuery::Issue, event query codeblock */
361         FIXME("Wrong thread, reporting GPU idle.\n");
362         *data = TRUE;
363
364         return S_OK;
365     }
366
367     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
368
369     ENTER_GL();
370
371     if (GL_SUPPORT(APPLE_FENCE))
372     {
373         *data = GL_EXTCALL(glTestFenceAPPLE(query->id));
374         checkGLcall("glTestFenceAPPLE");
375     }
376     else if (GL_SUPPORT(NV_FENCE))
377     {
378         *data = GL_EXTCALL(glTestFenceNV(query->id));
379         checkGLcall("glTestFenceNV");
380     }
381     else
382     {
383         WARN("(%p): reporting GPU idle\n", This);
384         *data = TRUE;
385     }
386
387     LEAVE_GL();
388
389     return S_OK;
390 }
391
392 static DWORD  WINAPI IWineD3DQueryImpl_GetDataSize(IWineD3DQuery* iface){
393     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
394     int dataSize = 0;
395     TRACE("(%p) : type %#x\n", This, This->type);
396     switch(This->type){
397     case WINED3DQUERYTYPE_VCACHE:
398         dataSize = sizeof(WINED3DDEVINFO_VCACHE);
399         break;
400     case WINED3DQUERYTYPE_RESOURCEMANAGER:
401         dataSize = sizeof(WINED3DDEVINFO_RESOURCEMANAGER);
402         break;
403     case WINED3DQUERYTYPE_VERTEXSTATS:
404         dataSize = sizeof(WINED3DDEVINFO_VERTEXSTATS);
405         break;
406     case WINED3DQUERYTYPE_EVENT:
407         dataSize = sizeof(BOOL);
408         break;
409     case WINED3DQUERYTYPE_TIMESTAMP:
410         dataSize = sizeof(UINT64);
411         break;
412     case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
413         dataSize = sizeof(BOOL);
414         break;
415     case WINED3DQUERYTYPE_TIMESTAMPFREQ:
416         dataSize = sizeof(UINT64);
417         break;
418     case WINED3DQUERYTYPE_PIPELINETIMINGS:
419         dataSize = sizeof(WINED3DDEVINFO_PIPELINETIMINGS);
420         break;
421     case WINED3DQUERYTYPE_INTERFACETIMINGS:
422         dataSize = sizeof(WINED3DDEVINFO_INTERFACETIMINGS);
423         break;
424     case WINED3DQUERYTYPE_VERTEXTIMINGS:
425         dataSize = sizeof(WINED3DDEVINFO_STAGETIMINGS);
426         break;
427     case WINED3DQUERYTYPE_PIXELTIMINGS:
428         dataSize = sizeof(WINED3DDEVINFO_STAGETIMINGS);
429         break;
430     case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
431         dataSize = sizeof(WINED3DQUERYTYPE_BANDWIDTHTIMINGS);
432         break;
433     case WINED3DQUERYTYPE_CACHEUTILIZATION:
434         dataSize = sizeof(WINED3DDEVINFO_CACHEUTILIZATION);
435         break;
436     default:
437        FIXME("(%p) Unhandled query type %d\n",This , This->type);
438        dataSize = 0;
439     }
440     return dataSize;
441 }
442
443 static DWORD  WINAPI IWineD3DEventQueryImpl_GetDataSize(IWineD3DQuery* iface){
444     TRACE("(%p) : type D3DQUERY_EVENT\n", iface);
445
446     return sizeof(BOOL);
447 }
448
449 static DWORD  WINAPI IWineD3DOcclusionQueryImpl_GetDataSize(IWineD3DQuery* iface){
450     TRACE("(%p) : type D3DQUERY_OCCLUSION\n", iface);
451
452     return sizeof(DWORD);
453 }
454
455 static WINED3DQUERYTYPE  WINAPI IWineD3DQueryImpl_GetType(IWineD3DQuery* iface){
456     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
457     return This->type;
458 }
459
460
461 static HRESULT  WINAPI IWineD3DEventQueryImpl_Issue(IWineD3DQuery* iface,  DWORD dwIssueFlags) {
462     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
463
464     TRACE("(%p) : dwIssueFlags %#x, type D3DQUERY_EVENT\n", This, dwIssueFlags);
465     if (dwIssueFlags & WINED3DISSUE_END)
466     {
467         struct wined3d_event_query *query = This->extendedData;
468         struct wined3d_context *context;
469
470         if (query->context)
471         {
472             if (query->context->tid != GetCurrentThreadId())
473             {
474                 context_free_event_query(query);
475                 context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
476                 context_alloc_event_query(context, query);
477             }
478             else
479             {
480                 ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
481             }
482         }
483         else
484         {
485             context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
486             context_alloc_event_query(context, query);
487         }
488
489         ENTER_GL();
490
491         if (GL_SUPPORT(APPLE_FENCE))
492         {
493             GL_EXTCALL(glSetFenceAPPLE(query->id));
494             checkGLcall("glSetFenceAPPLE");
495         }
496         else if (GL_SUPPORT(NV_FENCE))
497         {
498             GL_EXTCALL(glSetFenceNV(query->id, GL_ALL_COMPLETED_NV));
499             checkGLcall("glSetFenceNV");
500         }
501
502         LEAVE_GL();
503     }
504     else if(dwIssueFlags & WINED3DISSUE_BEGIN)
505     {
506         /* Started implicitly at device creation */
507         ERR("Event query issued with START flag - what to do?\n");
508     }
509
510     if(dwIssueFlags & WINED3DISSUE_BEGIN) {
511         This->state = QUERY_BUILDING;
512     } else {
513         This->state = QUERY_SIGNALLED;
514     }
515
516     return WINED3D_OK;
517 }
518
519 static HRESULT  WINAPI IWineD3DOcclusionQueryImpl_Issue(IWineD3DQuery* iface,  DWORD dwIssueFlags) {
520     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
521
522     if (GL_SUPPORT(ARB_OCCLUSION_QUERY))
523     {
524         struct wined3d_occlusion_query *query = This->extendedData;
525         struct wined3d_context *context;
526
527         /* This is allowed according to msdn and our tests. Reset the query and restart */
528         if (dwIssueFlags & WINED3DISSUE_BEGIN)
529         {
530             if (This->state == QUERY_BUILDING)
531             {
532                 if (query->context->tid != GetCurrentThreadId())
533                 {
534                     FIXME("Wrong thread, can't restart query.\n");
535
536                     context_free_occlusion_query(query);
537                     context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
538                     context_alloc_occlusion_query(context, query);
539                 }
540                 else
541                 {
542                     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
543
544                     ENTER_GL();
545                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
546                     checkGLcall("glEndQuery()");
547                     LEAVE_GL();
548                 }
549             }
550             else
551             {
552                 if (query->context) context_free_occlusion_query(query);
553                 context = ActivateContext(This->wineD3DDevice, NULL, CTXUSAGE_RESOURCELOAD);
554                 context_alloc_occlusion_query(context, query);
555             }
556
557             ENTER_GL();
558             GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, query->id));
559             checkGLcall("glBeginQuery()");
560             LEAVE_GL();
561         }
562         if (dwIssueFlags & WINED3DISSUE_END) {
563             /* Msdn says _END on a non-building occlusion query returns an error, but
564              * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
565              * generating an error
566              */
567             if (This->state == QUERY_BUILDING)
568             {
569                 if (query->context->tid != GetCurrentThreadId())
570                 {
571                     FIXME("Wrong thread, can't end query.\n");
572                 }
573                 else
574                 {
575                     ActivateContext(This->wineD3DDevice, query->context->current_rt, CTXUSAGE_RESOURCELOAD);
576
577                     ENTER_GL();
578                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
579                     checkGLcall("glEndQuery()");
580                     LEAVE_GL();
581                 }
582             }
583         }
584     } else {
585         FIXME("(%p) : Occlusion queries not supported\n", This);
586     }
587
588     if(dwIssueFlags & WINED3DISSUE_BEGIN) {
589         This->state = QUERY_BUILDING;
590     } else {
591         This->state = QUERY_SIGNALLED;
592     }
593     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
594 }
595
596 static HRESULT  WINAPI IWineD3DQueryImpl_Issue(IWineD3DQuery* iface,  DWORD dwIssueFlags){
597     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
598
599     TRACE("(%p) : dwIssueFlags %#x, type %#x\n", This, dwIssueFlags, This->type);
600
601     /* The fixme is printed when the app asks for the resulting data */
602     WARN("(%p) : Unhandled query type %#x\n", This, This->type);
603
604     if(dwIssueFlags & WINED3DISSUE_BEGIN) {
605         This->state = QUERY_BUILDING;
606     } else {
607         This->state = QUERY_SIGNALLED;
608     }
609
610     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
611 }
612
613
614 /**********************************************************
615  * IWineD3DQuery VTbl follows
616  **********************************************************/
617
618 const IWineD3DQueryVtbl IWineD3DQuery_Vtbl =
619 {
620     /*** IUnknown methods ***/
621     IWineD3DQueryImpl_QueryInterface,
622     IWineD3DQueryImpl_AddRef,
623     IWineD3DQueryImpl_Release,
624      /*** IWineD3Dquery methods ***/
625     IWineD3DQueryImpl_GetParent,
626     IWineD3DQueryImpl_GetDevice,
627     IWineD3DQueryImpl_GetData,
628     IWineD3DQueryImpl_GetDataSize,
629     IWineD3DQueryImpl_GetType,
630     IWineD3DQueryImpl_Issue
631 };
632
633 const IWineD3DQueryVtbl IWineD3DEventQuery_Vtbl =
634 {
635     /*** IUnknown methods ***/
636     IWineD3DQueryImpl_QueryInterface,
637     IWineD3DQueryImpl_AddRef,
638     IWineD3DQueryImpl_Release,
639     /*** IWineD3Dquery methods ***/
640     IWineD3DQueryImpl_GetParent,
641     IWineD3DQueryImpl_GetDevice,
642     IWineD3DEventQueryImpl_GetData,
643     IWineD3DEventQueryImpl_GetDataSize,
644     IWineD3DQueryImpl_GetType,
645     IWineD3DEventQueryImpl_Issue
646 };
647
648 const IWineD3DQueryVtbl IWineD3DOcclusionQuery_Vtbl =
649 {
650     /*** IUnknown methods ***/
651     IWineD3DQueryImpl_QueryInterface,
652     IWineD3DQueryImpl_AddRef,
653     IWineD3DQueryImpl_Release,
654     /*** IWineD3Dquery methods ***/
655     IWineD3DQueryImpl_GetParent,
656     IWineD3DQueryImpl_GetDevice,
657     IWineD3DOcclusionQueryImpl_GetData,
658     IWineD3DOcclusionQueryImpl_GetDataSize,
659     IWineD3DQueryImpl_GetType,
660     IWineD3DOcclusionQueryImpl_Issue
661 };