src/mesa/main/queryobj.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 #include "glheader.h"
  27 #include "context.h"
  28 #include "enums.h"
  29 #include "hash.h"
  30 #include "imports.h"
  31 #include "queryobj.h"
  32 #include "mfeatures.h"
  33 #include "mtypes.h"
  34 #include "main/dispatch.h"
  35
  36
  37 #if FEATURE_queryobj
  38
  39
  40 /**
  41  * Allocate a new query object.  This is a fallback routine called via
  42  * ctx->Driver.NewQueryObject().
  43  * \param ctx - rendering context
  44  * \param id - the new object's ID
  45  * \return pointer to new query_object object or NULL if out of memory.
  46  */
  47 static struct gl_query_object *
  48 _mesa_new_query_object(struct gl_context *ctx, GLuint id)
  49 {
  50    struct gl_query_object *q = MALLOC_STRUCT(gl_query_object);
  51    (void) ctx;
  52    if (q) {
  53       q->Id = id;
  54       q->Result = 0;
  55       q->Active = GL_FALSE;
  56       q->Ready = GL_TRUE;   /* correct, see spec */
  57    }
  58    return q;
  59 }
  60
  61
  62 /**
  63  * Begin a query.  Software driver fallback.
  64  * Called via ctx->Driver.BeginQuery().
  65  */
  66 static void
  67 _mesa_begin_query(struct gl_context *ctx, struct gl_query_object *q)
  68 {
  69    /* no-op */
  70 }
  71
  72
  73 /**
  74  * End a query.  Software driver fallback.
  75  * Called via ctx->Driver.EndQuery().
  76  */
  77 static void
  78 _mesa_end_query(struct gl_context *ctx, struct gl_query_object *q)
  79 {
  80    q->Ready = GL_TRUE;
  81 }
  82
  83
  84 /**
  85  * Wait for query to complete.  Software driver fallback.
  86  * Called via ctx->Driver.WaitQuery().
  87  */
  88 static void
  89 _mesa_wait_query(struct gl_context *ctx, struct gl_query_object *q)
  90 {
  91    /* For software drivers, _mesa_end_query() should have completed the query.
  92     * For real hardware, implement a proper WaitQuery() driver function,
  93     * which may require issuing a flush.
  94     */
  95    assert(q->Ready);
  96 }
  97
  98
  99 /**
 100  * Check if a query results are ready.  Software driver fallback.
 101  * Called via ctx->Driver.CheckQuery().
 102  */
 103 static void
 104 _mesa_check_query(struct gl_context *ctx, struct gl_query_object *q)
 105 {
 106    /* No-op for sw rendering.
 107     * HW drivers may need to flush at this time.
 108     */
 109 }
 110
 111
 112 /**
 113  * Delete a query object.  Called via ctx->Driver.DeleteQuery().
 114  * Not removed from hash table here.
 115  */
 116 static void
 117 _mesa_delete_query(struct gl_context *ctx, struct gl_query_object *q)
 118 {
 119    free(q);
 120 }
 121
 122
 123 void
 124 _mesa_init_query_object_functions(struct dd_function_table *driver)
 125 {
 126    driver->NewQueryObject = _mesa_new_query_object;
 127    driver->DeleteQuery = _mesa_delete_query;
 128    driver->BeginQuery = _mesa_begin_query;
 129    driver->EndQuery = _mesa_end_query;
 130    driver->WaitQuery = _mesa_wait_query;
 131    driver->CheckQuery = _mesa_check_query;
 132 }
 133
 134
 135 /**
 136  * Return pointer to the query object binding point for the given target.
 137  * \return NULL if invalid target, else the address of binding point
 138  */
 139 static struct gl_query_object **
 140 get_query_binding_point(struct gl_context *ctx, GLenum target)
 141 {
 142    switch (target) {
 143    case GL_SAMPLES_PASSED_ARB:
 144       if (ctx->Extensions.ARB_occlusion_query)
 145          return &ctx->Query.CurrentOcclusionObject;
 146       else
 147          return NULL;
 148    case GL_ANY_SAMPLES_PASSED:
 149       if (ctx->Extensions.ARB_occlusion_query2)
 150          return &ctx->Query.CurrentOcclusionObject;
 151       else
 152          return NULL;
 153    case GL_TIME_ELAPSED_EXT:
 154       if (ctx->Extensions.EXT_timer_query)
 155          return &ctx->Query.CurrentTimerObject;
 156       else
 157          return NULL;
 158 #if FEATURE_EXT_transform_feedback
 159    case GL_PRIMITIVES_GENERATED:
 160       if (ctx->Extensions.EXT_transform_feedback)
 161          return &ctx->Query.PrimitivesGenerated;
 162       else
 163          return NULL;
 164    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
 165       if (ctx->Extensions.EXT_transform_feedback)
 166          return &ctx->Query.PrimitivesWritten;
 167       else
 168          return NULL;
 169 #endif
 170    default:
 171       return NULL;
 172    }
 173 }
 174
 175
 176 static void GLAPIENTRY
 177 _mesa_GenQueriesARB(GLsizei n, GLuint *ids)
 178 {
 179    GLuint first;
 180    GET_CURRENT_CONTEXT(ctx);
 181    ASSERT_OUTSIDE_BEGIN_END(ctx);
 182
 183    if (MESA_VERBOSE & VERBOSE_API)
 184       _mesa_debug(ctx, "glGenQueries(%d)\n", n);
 185
 186    if (n < 0) {
 187       _mesa_error(ctx, GL_INVALID_VALUE, "glGenQueriesARB(n < 0)");
 188       return;
 189    }
 190
 191    /* No query objects can be active at this time! */
 192    if (ctx->Query.CurrentOcclusionObject ||
 193        ctx->Query.CurrentTimerObject) {
 194       _mesa_error(ctx, GL_INVALID_OPERATION, "glGenQueriesARB");
 195       return;
 196    }
 197
 198    first = _mesa_HashFindFreeKeyBlock(ctx->Query.QueryObjects, n);
 199    if (first) {
 200       GLsizei i;
 201       for (i = 0; i < n; i++) {
 202          struct gl_query_object *q
 203             = ctx->Driver.NewQueryObject(ctx, first + i);
 204          if (!q) {
 205             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenQueriesARB");
 206             return;
 207          }
 208          ids[i] = first + i;
 209          _mesa_HashInsert(ctx->Query.QueryObjects, first + i, q);
 210       }
 211    }
 212 }
 213
 214
 215 static void GLAPIENTRY
 216 _mesa_DeleteQueriesARB(GLsizei n, const GLuint *ids)
 217 {
 218    GLint i;
 219    GET_CURRENT_CONTEXT(ctx);
 220    ASSERT_OUTSIDE_BEGIN_END(ctx);
 221    FLUSH_VERTICES(ctx, 0);
 222
 223    if (MESA_VERBOSE & VERBOSE_API)
 224       _mesa_debug(ctx, "glDeleeteQueries(%d)\n", n);
 225
 226    if (n < 0) {
 227       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteQueriesARB(n < 0)");
 228       return;
 229    }
 230
 231    /* No query objects can be active at this time! */
 232    if (ctx->Query.CurrentOcclusionObject ||
 233        ctx->Query.CurrentTimerObject) {
 234       _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteQueriesARB");
 235       return;
 236    }
 237
 238    for (i = 0; i < n; i++) {
 239       if (ids[i] > 0) {
 240          struct gl_query_object *q = _mesa_lookup_query_object(ctx, ids[i]);
 241          if (q) {
 242             ASSERT(!q->Active); /* should be caught earlier */
 243             _mesa_HashRemove(ctx->Query.QueryObjects, ids[i]);
 244             ctx->Driver.DeleteQuery(ctx, q);
 245          }
 246       }
 247    }
 248 }
 249
 250
 251 static GLboolean GLAPIENTRY
 252 _mesa_IsQueryARB(GLuint id)
 253 {
 254    GET_CURRENT_CONTEXT(ctx);
 255    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 256
 257    if (MESA_VERBOSE & VERBOSE_API)
 258       _mesa_debug(ctx, "glIsQuery(%u)\n", id);
 259
 260    if (id && _mesa_lookup_query_object(ctx, id))
 261       return GL_TRUE;
 262    else
 263       return GL_FALSE;
 264 }
 265
 266
 267 static void GLAPIENTRY
 268 _mesa_BeginQueryARB(GLenum target, GLuint id)
 269 {
 270    struct gl_query_object *q, **bindpt;
 271    GET_CURRENT_CONTEXT(ctx);
 272    ASSERT_OUTSIDE_BEGIN_END(ctx);
 273
 274    if (MESA_VERBOSE & VERBOSE_API)
 275       _mesa_debug(ctx, "glBeginQuery(%s, %u)\n",
 276                   _mesa_lookup_enum_by_nr(target), id);
 277
 278    FLUSH_VERTICES(ctx, _NEW_DEPTH);
 279
 280    bindpt = get_query_binding_point(ctx, target);
 281    if (!bindpt) {
 282       _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");
 283       return;
 284    }
 285
 286    if (id == 0) {
 287       _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginQueryARB(id==0)");
 288       return;
 289    }
 290
 291    q = _mesa_lookup_query_object(ctx, id);
 292    if (!q) {
 293       /* create new object */
 294       q = ctx->Driver.NewQueryObject(ctx, id);
 295       if (!q) {
 296          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQueryARB");
 297          return;
 298       }
 299       _mesa_HashInsert(ctx->Query.QueryObjects, id, q);
 300    }
 301    else {
 302       /* pre-existing object */
 303       if (q->Active) {
 304          _mesa_error(ctx, GL_INVALID_OPERATION,
 305                      "glBeginQueryARB(query already active)");
 306          return;
 307       }
 308    }
 309
 310    q->Target = target;
 311    q->Active = GL_TRUE;
 312    q->Result = 0;
 313    q->Ready = GL_FALSE;
 314
 315    /* XXX should probably refcount query objects */
 316    *bindpt = q;
 317
 318    ctx->Driver.BeginQuery(ctx, q);
 319 }
 320
 321
 322 static void GLAPIENTRY
 323 _mesa_EndQueryARB(GLenum target)
 324 {
 325    struct gl_query_object *q, **bindpt;
 326    GET_CURRENT_CONTEXT(ctx);
 327    ASSERT_OUTSIDE_BEGIN_END(ctx);
 328
 329    if (MESA_VERBOSE & VERBOSE_API)
 330       _mesa_debug(ctx, "glEndQuery(%s)\n", _mesa_lookup_enum_by_nr(target));
 331
 332    FLUSH_VERTICES(ctx, _NEW_DEPTH);
 333
 334    bindpt = get_query_binding_point(ctx, target);
 335    if (!bindpt) {
 336       _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");
 337       return;
 338    }
 339
 340    /* XXX should probably refcount query objects */
 341    q = *bindpt;
 342    *bindpt = NULL;
 343
 344    if (!q || !q->Active) {
 345       _mesa_error(ctx, GL_INVALID_OPERATION,
 346                   "glEndQueryARB(no matching glBeginQueryARB)");
 347       return;
 348    }
 349
 350    q->Active = GL_FALSE;
 351    ctx->Driver.EndQuery(ctx, q);
 352 }
 353
 354
 355 static void GLAPIENTRY
 356 _mesa_QueryCounter(GLuint id, GLenum target)
 357 {
 358    struct gl_query_object *q;
 359    GET_CURRENT_CONTEXT(ctx);
 360    ASSERT_OUTSIDE_BEGIN_END(ctx);
 361
 362    if (MESA_VERBOSE & VERBOSE_API)
 363       _mesa_debug(ctx, "glQueryCounter(%u, %s)\n", id,
 364                   _mesa_lookup_enum_by_nr(target));
 365
 366    /* error checking */
 367    if (target != GL_TIMESTAMP) {
 368       _mesa_error(ctx, GL_INVALID_ENUM, "glQueryCounter(target)");
 369       return;
 370    }
 371
 372    if (id == 0) {
 373       _mesa_error(ctx, GL_INVALID_OPERATION, "glQueryCounter(id==0)");
 374       return;
 375    }
 376
 377    q = _mesa_lookup_query_object(ctx, id);
 378    if (!q) {
 379       /* XXX the Core profile should throw INVALID_OPERATION here */
 380
 381       /* create new object */
 382       q = ctx->Driver.NewQueryObject(ctx, id);
 383       if (!q) {
 384          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glQueryCounter");
 385          return;
 386       }
 387       _mesa_HashInsert(ctx->Query.QueryObjects, id, q);
 388    }
 389    else {
 390       if (q->Target && q->Target != GL_TIMESTAMP) {
 391          _mesa_error(ctx, GL_INVALID_OPERATION,
 392                      "glQueryCounter(id has an invalid target)");
 393          return;
 394       }
 395    }
 396
 397    if (q->Active) {
 398       _mesa_error(ctx, GL_INVALID_OPERATION, "glQueryCounter(id is active)");
 399       return;
 400    }
 401
 402    q->Target = target;
 403    q->Result = 0;
 404    q->Ready = GL_FALSE;
 405
 406    /* QueryCounter is implemented using EndQuery without BeginQuery
 407     * in drivers. This is actually Direct3D and Gallium convention. */
 408    ctx->Driver.EndQuery(ctx, q);
 409 }
 410
 411
 412 static void GLAPIENTRY
 413 _mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)
 414 {
 415    struct gl_query_object *q = NULL, **bindpt = NULL;
 416    GET_CURRENT_CONTEXT(ctx);
 417    ASSERT_OUTSIDE_BEGIN_END(ctx);
 418
 419    if (MESA_VERBOSE & VERBOSE_API)
 420       _mesa_debug(ctx, "glGetQueryiv(%s, %s)\n",
 421                   _mesa_lookup_enum_by_nr(target),
 422                   _mesa_lookup_enum_by_nr(pname));
 423
 424    if (target == GL_TIMESTAMP) {
 425       if (!ctx->Extensions.ARB_timer_query) {
 426          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryARB(target)");
 427          return;
 428       }
 429    }
 430    else {
 431       bindpt = get_query_binding_point(ctx, target);
 432       if (!bindpt) {
 433          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryARB(target)");
 434          return;
 435       }
 436
 437       q = *bindpt;
 438    }
 439
 440    switch (pname) {
 441       case GL_QUERY_COUNTER_BITS_ARB:
 442          *params = 8 * sizeof(q->Result);
 443          break;
 444       case GL_CURRENT_QUERY_ARB:
 445          *params = q ? q->Id : 0;
 446          break;
 447       default:
 448          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryivARB(pname)");
 449          return;
 450    }
 451 }
 452
 453
 454 static void GLAPIENTRY
 455 _mesa_GetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)
 456 {
 457    struct gl_query_object *q = NULL;
 458    GET_CURRENT_CONTEXT(ctx);
 459    ASSERT_OUTSIDE_BEGIN_END(ctx);
 460
 461    if (MESA_VERBOSE & VERBOSE_API)
 462       _mesa_debug(ctx, "glGetQueryObjectiv(%u, %s)\n", id,
 463                   _mesa_lookup_enum_by_nr(pname));
 464
 465    if (id)
 466       q = _mesa_lookup_query_object(ctx, id);
 467
 468    if (!q || q->Active) {
 469       _mesa_error(ctx, GL_INVALID_OPERATION,
 470                   "glGetQueryObjectivARB(id=%d is invalid or active)", id);
 471       return;
 472    }
 473
 474    switch (pname) {
 475       case GL_QUERY_RESULT_ARB:
 476          if (!q->Ready)
 477             ctx->Driver.WaitQuery(ctx, q);
 478          /* if result is too large for returned type, clamp to max value */
 479          if (q->Target == GL_ANY_SAMPLES_PASSED) {
 480             if (q->Result)
 481                *params = GL_TRUE;
 482             else
 483                *params = GL_FALSE;
 484          } else {
 485             if (q->Result > 0x7fffffff) {
 486                *params = 0x7fffffff;
 487             }
 488             else {
 489                *params = (GLint)q->Result;
 490             }
 491          }
 492          break;
 493       case GL_QUERY_RESULT_AVAILABLE_ARB:
 494          if (!q->Ready)
 495             ctx->Driver.CheckQuery( ctx, q );
 496          *params = q->Ready;
 497          break;
 498       default:
 499          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectivARB(pname)");
 500          return;
 501    }
 502 }
 503
 504
 505 static void GLAPIENTRY
 506 _mesa_GetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)
 507 {
 508    struct gl_query_object *q = NULL;
 509    GET_CURRENT_CONTEXT(ctx);
 510    ASSERT_OUTSIDE_BEGIN_END(ctx);
 511
 512    if (MESA_VERBOSE & VERBOSE_API)
 513       _mesa_debug(ctx, "glGetQueryObjectuiv(%u, %s)\n", id,
 514                   _mesa_lookup_enum_by_nr(pname));
 515
 516    if (id)
 517       q = _mesa_lookup_query_object(ctx, id);
 518
 519    if (!q || q->Active) {
 520       _mesa_error(ctx, GL_INVALID_OPERATION,
 521                   "glGetQueryObjectuivARB(id=%d is invalid or active)", id);
 522       return;
 523    }
 524
 525    switch (pname) {
 526       case GL_QUERY_RESULT_ARB:
 527          if (!q->Ready)
 528             ctx->Driver.WaitQuery(ctx, q);
 529          /* if result is too large for returned type, clamp to max value */
 530          if (q->Target == GL_ANY_SAMPLES_PASSED) {
 531             if (q->Result)
 532                *params = GL_TRUE;
 533             else
 534                *params = GL_FALSE;
 535          } else {
 536             if (q->Result > 0xffffffff) {
 537                *params = 0xffffffff;
 538             }
 539             else {
 540                *params = (GLuint)q->Result;
 541             }
 542          }
 543          break;
 544       case GL_QUERY_RESULT_AVAILABLE_ARB:
 545          if (!q->Ready)
 546             ctx->Driver.CheckQuery( ctx, q );
 547          *params = q->Ready;
 548          break;
 549       default:
 550          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectuivARB(pname)");
 551          return;
 552    }
 553 }
 554
 555
 556 /**
 557  * New with GL_EXT_timer_query
 558  */
 559 static void GLAPIENTRY
 560 _mesa_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params)
 561 {
 562    struct gl_query_object *q = NULL;
 563    GET_CURRENT_CONTEXT(ctx);
 564    ASSERT_OUTSIDE_BEGIN_END(ctx);
 565
 566    if (MESA_VERBOSE & VERBOSE_API)
 567       _mesa_debug(ctx, "glGetQueryObjecti64v(%u, %s)\n", id,
 568                   _mesa_lookup_enum_by_nr(pname));
 569
 570    if (id)
 571       q = _mesa_lookup_query_object(ctx, id);
 572
 573    if (!q || q->Active) {
 574       _mesa_error(ctx, GL_INVALID_OPERATION,
 575                   "glGetQueryObjectui64vARB(id=%d is invalid or active)", id);
 576       return;
 577    }
 578
 579    switch (pname) {
 580       case GL_QUERY_RESULT_ARB:
 581          if (!q->Ready)
 582             ctx->Driver.WaitQuery(ctx, q);
 583          *params = q->Result;
 584          break;
 585       case GL_QUERY_RESULT_AVAILABLE_ARB:
 586          if (!q->Ready)
 587             ctx->Driver.CheckQuery( ctx, q );
 588          *params = q->Ready;
 589          break;
 590       default:
 591          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjecti64vARB(pname)");
 592          return;
 593    }
 594 }
 595
 596
 597 /**
 598  * New with GL_EXT_timer_query
 599  */
 600 static void GLAPIENTRY
 601 _mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)
 602 {
 603    struct gl_query_object *q = NULL;
 604    GET_CURRENT_CONTEXT(ctx);
 605    ASSERT_OUTSIDE_BEGIN_END(ctx);
 606
 607    if (MESA_VERBOSE & VERBOSE_API)
 608       _mesa_debug(ctx, "glGetQueryObjectui64v(%u, %s)\n", id,
 609                   _mesa_lookup_enum_by_nr(pname));
 610
 611    if (id)
 612       q = _mesa_lookup_query_object(ctx, id);
 613
 614    if (!q || q->Active) {
 615       _mesa_error(ctx, GL_INVALID_OPERATION,
 616                   "glGetQueryObjectuui64vARB(id=%d is invalid or active)", id);
 617       return;
 618    }
 619
 620    switch (pname) {
 621       case GL_QUERY_RESULT_ARB:
 622          if (!q->Ready)
 623             ctx->Driver.WaitQuery(ctx, q);
 624          *params = q->Result;
 625          break;
 626       case GL_QUERY_RESULT_AVAILABLE_ARB:
 627          if (!q->Ready)
 628             ctx->Driver.CheckQuery( ctx, q );
 629          *params = q->Ready;
 630          break;
 631       default:
 632          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectui64vARB(pname)");
 633          return;
 634    }
 635 }
 636
 637
 638 void
 639 _mesa_init_queryobj_dispatch(struct _glapi_table *disp)
 640 {
 641    SET_GenQueriesARB(disp, _mesa_GenQueriesARB);
 642    SET_DeleteQueriesARB(disp, _mesa_DeleteQueriesARB);
 643    SET_IsQueryARB(disp, _mesa_IsQueryARB);
 644    SET_BeginQueryARB(disp, _mesa_BeginQueryARB);
 645    SET_EndQueryARB(disp, _mesa_EndQueryARB);
 646    SET_GetQueryivARB(disp, _mesa_GetQueryivARB);
 647    SET_GetQueryObjectivARB(disp, _mesa_GetQueryObjectivARB);
 648    SET_GetQueryObjectuivARB(disp, _mesa_GetQueryObjectuivARB);
 649    SET_QueryCounter(disp, _mesa_QueryCounter);
 650
 651    SET_GetQueryObjecti64vEXT(disp, _mesa_GetQueryObjecti64vEXT);
 652    SET_GetQueryObjectui64vEXT(disp, _mesa_GetQueryObjectui64vEXT);
 653 }
 654
 655
 656 #endif /* FEATURE_queryobj */
 657
 658
 659 /**
 660  * Allocate/init the context state related to query objects.
 661  */
 662 void
 663 _mesa_init_queryobj(struct gl_context *ctx)
 664 {
 665    ctx->Query.QueryObjects = _mesa_NewHashTable();
 666    ctx->Query.CurrentOcclusionObject = NULL;
 667 }
 668
 669
 670 /**
 671  * Callback for deleting a query object.  Called by _mesa_HashDeleteAll().
 672  */
 673 static void
 674 delete_queryobj_cb(GLuint id, void *data, void *userData)
 675 {
 676    struct gl_query_object *q= (struct gl_query_object *) data;
 677    struct gl_context *ctx = (struct gl_context *)userData;
 678    ctx->Driver.DeleteQuery(ctx, q);
 679 }
 680
 681
 682 /**
 683  * Free the context state related to query objects.
 684  */
 685 void
 686 _mesa_free_queryobj_data(struct gl_context *ctx)
 687 {
 688    _mesa_HashDeleteAll(ctx->Query.QueryObjects, delete_queryobj_cb, ctx);
 689    _mesa_DeleteHashTable(ctx->Query.QueryObjects);
 690 }