src/mesa/main/texobj.c

   1 /* $Id: texobj.c,v 1.29 2000/10/24 02:53:18 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #ifdef PC_HEADER
  29 #include "all.h"
  30 #else
  31 #include "glheader.h"
  32 #include "colortab.h"
  33 #include "context.h"
  34 #include "enums.h"
  35 #include "hash.h"
  36 #include "mem.h"
  37 #include "teximage.h"
  38 #include "texstate.h"
  39 #include "texobj.h"
  40 #include "types.h"
  41 #endif
  42
  43
  44
  45 /*
  46  * Allocate a new texture object and add it to the linked list of texture
  47  * objects.  If name>0 then also insert the new texture object into the hash
  48  * table.
  49  * Input:  shared - the shared GL state structure to contain the texture object
  50  *         name - integer name for the texture object
  51  *         dimensions - either 1, 2, 3 or 6 (cube map)
  52  * Return:  pointer to new texture object
  53  */
  54 struct gl_texture_object *
  55 gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
  56                          GLuint dimensions)
  57 {
  58    struct gl_texture_object *obj;
  59
  60    ASSERT(dimensions <= 3 || dimensions == 6);
  61
  62    obj = CALLOC_STRUCT(gl_texture_object);
  63
  64    if (obj) {
  65       /* init the non-zero fields */
  66       _glthread_INIT_MUTEX(obj->Mutex);
  67       obj->RefCount = 1;
  68       obj->Name = name;
  69       obj->Dimensions = dimensions;
  70       obj->Priority = 1.0F;
  71       obj->WrapS = GL_REPEAT;
  72       obj->WrapT = GL_REPEAT;
  73       obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
  74       obj->MagFilter = GL_LINEAR;
  75       obj->MinLod = -1000.0;
  76       obj->MaxLod = 1000.0;
  77       obj->BaseLevel = 0;
  78       obj->MaxLevel = 1000;
  79       obj->MinMagThresh = 0.0F;
  80       _mesa_init_colortable(&obj->Palette);
  81
  82       /* insert into linked list */
  83       if (shared) {
  84          _glthread_LOCK_MUTEX(shared->Mutex);
  85          obj->Next = shared->TexObjectList;
  86          shared->TexObjectList = obj;
  87          _glthread_UNLOCK_MUTEX(shared->Mutex);
  88       }
  89
  90       if (name > 0) {
  91          /* insert into hash table */
  92          _mesa_HashInsert(shared->TexObjects, name, obj);
  93       }
  94    }
  95    return obj;
  96 }
  97
  98
  99 /*
 100  * Deallocate a texture object struct and remove it from the given
 101  * shared GL state.
 102  * Input:  shared - the shared GL state to which the object belongs
 103  *         t - the texture object to delete
 104  */
 105 void gl_free_texture_object( struct gl_shared_state *shared,
 106                              struct gl_texture_object *t )
 107 {
 108    struct gl_texture_object *tprev, *tcurr;
 109
 110    assert(t);
 111
 112    /* Remove t from dirty list so we don't touch free'd memory later.
 113     * Test for shared since Proxy texture aren't in global linked list.
 114     */
 115    if (shared)
 116       gl_remove_texobj_from_dirty_list( shared, t );
 117
 118    /* unlink t from the linked list */
 119    if (shared) {
 120       _glthread_LOCK_MUTEX(shared->Mutex);
 121       tprev = NULL;
 122       tcurr = shared->TexObjectList;
 123       while (tcurr) {
 124          if (tcurr==t) {
 125             if (tprev) {
 126                tprev->Next = t->Next;
 127             }
 128             else {
 129                shared->TexObjectList = t->Next;
 130             }
 131             break;
 132          }
 133          tprev = tcurr;
 134          tcurr = tcurr->Next;
 135       }
 136       _glthread_UNLOCK_MUTEX(shared->Mutex);
 137    }
 138
 139    if (t->Name) {
 140       /* remove from hash table */
 141       _mesa_HashRemove(shared->TexObjects, t->Name);
 142    }
 143
 144    _mesa_free_colortable_data(&t->Palette);
 145
 146    /* free texture images */
 147    {
 148       GLuint i;
 149       for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
 150          if (t->Image[i]) {
 151             _mesa_free_texture_image( t->Image[i] );
 152          }
 153       }
 154    }
 155    /* free this object */
 156    FREE( t );
 157 }
 158
 159 #if 0
 160 static void
 161 incomplete(const struct gl_texture_object *t, const char *why)
 162 {
 163    printf("Texture Obj %d incomplete because: %s\n", t->Name, why);
 164 }
 165 #else
 166 #define incomplete(a, b)
 167 #endif
 168
 169
 170 /*
 171  * Examine a texture object to determine if it is complete or not.
 172  * The t->Complete flag will be set to GL_TRUE or GL_FALSE accordingly.
 173  */
 174 void
 175 _mesa_test_texobj_completeness( const GLcontext *ctx,
 176                                 struct gl_texture_object *t )
 177 {
 178    const GLint baseLevel = t->BaseLevel;
 179
 180    t->Complete = GL_TRUE;  /* be optimistic */
 181
 182    /* Always need level zero image */
 183    if (!t->Image[baseLevel]) {
 184       incomplete(t, "Image[baseLevel] == NULL");
 185       t->Complete = GL_FALSE;
 186       return;
 187    }
 188
 189    /* Compute number of mipmap levels */
 190    if (t->Dimensions == 1) {
 191       t->P = t->Image[baseLevel]->WidthLog2;
 192    }
 193    else if (t->Dimensions == 2 || t->Dimensions == 6) {
 194       t->P = MAX2(t->Image[baseLevel]->WidthLog2,
 195                   t->Image[baseLevel]->HeightLog2);
 196    }
 197    else if (t->Dimensions == 3) {
 198       GLint max = MAX2(t->Image[baseLevel]->WidthLog2,
 199                        t->Image[baseLevel]->HeightLog2);
 200       max = MAX2(max, (GLint)(t->Image[baseLevel]->DepthLog2));
 201       t->P = max;
 202    }
 203
 204    /* Compute M (see the 1.2 spec) used during mipmapping */
 205    t->M = (GLfloat) (MIN2(t->MaxLevel, t->P) - t->BaseLevel);
 206
 207
 208    if (t->Dimensions == 6) {
 209       /* make sure all six level 0 images are same size */
 210       const GLint w = t->Image[baseLevel]->Width2;
 211       const GLint h = t->Image[baseLevel]->Height2;
 212       if (!t->NegX[baseLevel] ||
 213           t->NegX[baseLevel]->Width2 != w ||
 214           t->NegX[baseLevel]->Height2 != h ||
 215           !t->PosY[baseLevel] ||
 216           t->PosY[baseLevel]->Width2 != w ||
 217           t->PosY[baseLevel]->Height2 != h ||
 218           !t->NegY[baseLevel] ||
 219           t->NegY[baseLevel]->Width2 != w ||
 220           t->NegY[baseLevel]->Height2 != h ||
 221           !t->PosZ[baseLevel] ||
 222           t->PosZ[baseLevel]->Width2 != w ||
 223           t->PosZ[baseLevel]->Height2 != h ||
 224           !t->NegZ[baseLevel] ||
 225           t->NegZ[baseLevel]->Width2 != w ||
 226           t->NegZ[baseLevel]->Height2 != h) {
 227          t->Complete = GL_FALSE;
 228          incomplete(t, "Non-quare cubemap image");
 229          return;
 230       }
 231    }
 232
 233    if (t->MinFilter != GL_NEAREST && t->MinFilter != GL_LINEAR) {
 234       /*
 235        * Mipmapping: determine if we have a complete set of mipmaps
 236        */
 237       GLint i;
 238       GLint minLevel = baseLevel;
 239       GLint maxLevel = MIN2(t->P, ctx->Const.MaxTextureLevels-1);
 240       maxLevel = MIN2(maxLevel, t->MaxLevel);
 241
 242       if (minLevel > maxLevel) {
 243          t->Complete = GL_FALSE;
 244          incomplete(t, "minLevel > maxLevel");
 245          return;
 246       }
 247
 248       /* Test dimension-independent attributes */
 249       for (i = minLevel; i <= maxLevel; i++) {
 250          if (t->Image[i]) {
 251             if (t->Image[i]->Format != t->Image[baseLevel]->Format) {
 252                t->Complete = GL_FALSE;
 253                incomplete(t, "Format[i] != Format[baseLevel]");
 254                return;
 255             }
 256             if (t->Image[i]->Border != t->Image[baseLevel]->Border) {
 257                t->Complete = GL_FALSE;
 258                incomplete(t, "Border[i] != Border[baseLevel]");
 259                return;
 260             }
 261          }
 262       }
 263
 264       /* Test things which depend on number of texture image dimensions */
 265       if (t->Dimensions == 1) {
 266          /* Test 1-D mipmaps */
 267          GLuint width = t->Image[baseLevel]->Width2;
 268          for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
 269             if (width > 1) {
 270                width /= 2;
 271             }
 272             if (i >= minLevel && i <= maxLevel) {
 273                if (!t->Image[i]) {
 274                   t->Complete = GL_FALSE;
 275                   incomplete(t, "1D Image[i] == NULL");
 276                   return;
 277                }
 278                if (t->Image[i]->Width2 != width ) {
 279                   t->Complete = GL_FALSE;
 280                   incomplete(t, "1D Image[i] bad width");
 281                   return;
 282                }
 283             }
 284             if (width == 1) {
 285                return;  /* found smallest needed mipmap, all done! */
 286             }
 287          }
 288       }
 289       else if (t->Dimensions == 2) {
 290          /* Test 2-D mipmaps */
 291          GLuint width = t->Image[baseLevel]->Width2;
 292          GLuint height = t->Image[baseLevel]->Height2;
 293          for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
 294             if (width > 1) {
 295                width /= 2;
 296             }
 297             if (height > 1) {
 298                height /= 2;
 299             }
 300             if (i >= minLevel && i <= maxLevel) {
 301                if (!t->Image[i]) {
 302                   t->Complete = GL_FALSE;
 303                   incomplete(t, "2D Image[i] == NULL");
 304                   return;
 305                }
 306                if (t->Image[i]->Width2 != width) {
 307                   t->Complete = GL_FALSE;
 308                   incomplete(t, "2D Image[i] bad width");
 309                   return;
 310                }
 311                if (t->Image[i]->Height2 != height) {
 312                   t->Complete = GL_FALSE;
 313                   incomplete(t, "2D Image[i] bad height");
 314                   return;
 315                }
 316                if (width==1 && height==1) {
 317                   return;  /* found smallest needed mipmap, all done! */
 318                }
 319             }
 320          }
 321       }
 322       else if (t->Dimensions == 3) {
 323          /* Test 3-D mipmaps */
 324          GLuint width = t->Image[baseLevel]->Width2;
 325          GLuint height = t->Image[baseLevel]->Height2;
 326          GLuint depth = t->Image[baseLevel]->Depth2;
 327          for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
 328             if (width > 1) {
 329                width /= 2;
 330             }
 331             if (height > 1) {
 332                height /= 2;
 333             }
 334             if (depth > 1) {
 335                depth /= 2;
 336             }
 337             if (i >= minLevel && i <= maxLevel) {
 338                if (!t->Image[i]) {
 339                   incomplete(t, "3D Image[i] == NULL");
 340                   t->Complete = GL_FALSE;
 341                   return;
 342                }
 343                if (t->Image[i]->Width2 != width) {
 344                   t->Complete = GL_FALSE;
 345                   incomplete(t, "3D Image[i] bad width");
 346                   return;
 347                }
 348                if (t->Image[i]->Height2 != height) {
 349                   t->Complete = GL_FALSE;
 350                   incomplete(t, "3D Image[i] bad height");
 351                   return;
 352                }
 353                if (t->Image[i]->Depth2 != depth) {
 354                   t->Complete = GL_FALSE;
 355                   incomplete(t, "3D Image[i] bad depth");
 356                   return;
 357                }
 358             }
 359             if (width == 1 && height == 1 && depth == 1) {
 360                return;  /* found smallest needed mipmap, all done! */
 361             }
 362          }
 363       }
 364       else if (t->Dimensions == 6) {
 365          /* make sure 6 cube faces are consistant */
 366          GLuint width = t->Image[baseLevel]->Width2;
 367          GLuint height = t->Image[baseLevel]->Height2;
 368          for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
 369             if (width > 1) {
 370                width /= 2;
 371             }
 372             if (height > 1) {
 373                height /= 2;
 374             }
 375             if (i >= minLevel && i <= maxLevel) {
 376                /* check that we have images defined */
 377                if (!t->Image[i] || !t->NegX[i] ||
 378                    !t->PosY[i]  || !t->NegY[i] ||
 379                    !t->PosZ[i]  || !t->NegZ[i]) {
 380                   t->Complete = GL_FALSE;
 381                   incomplete(t, "CubeMap Image[i] == NULL");
 382                   return;
 383                }
 384                /* check that all six images have same size */
 385                if (t->NegX[i]->Width2!=width || t->NegX[i]->Height2!=height ||
 386                    t->PosY[i]->Width2!=width || t->PosY[i]->Height2!=height ||
 387                    t->NegY[i]->Width2!=width || t->NegY[i]->Height2!=height ||
 388                    t->PosZ[i]->Width2!=width || t->PosZ[i]->Height2!=height ||
 389                    t->NegZ[i]->Width2!=width || t->NegZ[i]->Height2!=height) {
 390                   t->Complete = GL_FALSE;
 391                   incomplete(t, "CubeMap Image[i] bad size");
 392                   return;
 393                }
 394             }
 395             if (width == 1 && height == 1) {
 396                return;  /* found smallest needed mipmap, all done! */
 397             }
 398          }
 399       }
 400       else {
 401          /* Dimensions = ??? */
 402          gl_problem(NULL, "Bug in gl_test_texture_object_completeness\n");
 403       }
 404    }
 405 }
 406
 407
 408 _glthread_DECLARE_STATIC_MUTEX(GenTexturesLock);
 409
 410
 411 /*
 412  * Execute glGenTextures
 413  */
 414 void
 415 _mesa_GenTextures( GLsizei n, GLuint *texName )
 416 {
 417    GET_CURRENT_CONTEXT(ctx);
 418    GLuint first;
 419    GLint i;
 420
 421    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGenTextures");
 422    if (n < 0) {
 423       gl_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
 424       return;
 425    }
 426
 427    if (!texName)
 428       return;
 429
 430    /*
 431     * This must be atomic (generation and allocation of texture IDs)
 432     */
 433    _glthread_LOCK_MUTEX(GenTexturesLock);
 434
 435    first = _mesa_HashFindFreeKeyBlock(ctx->Shared->TexObjects, n);
 436
 437    /* Return the texture names */
 438    for (i=0;i<n;i++) {
 439       texName[i] = first + i;
 440    }
 441
 442    /* Allocate new, empty texture objects */
 443    for (i=0;i<n;i++) {
 444       GLuint name = first + i;
 445       GLuint dims = 0;
 446       (void) gl_alloc_texture_object(ctx->Shared, name, dims);
 447    }
 448
 449    _glthread_UNLOCK_MUTEX(GenTexturesLock);
 450 }
 451
 452
 453
 454 /*
 455  * Execute glDeleteTextures
 456  */
 457 void
 458 _mesa_DeleteTextures( GLsizei n, const GLuint *texName)
 459 {
 460    GET_CURRENT_CONTEXT(ctx);
 461    GLint i;
 462
 463    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteTextures");
 464
 465    if (!texName)
 466       return;
 467
 468    for (i=0;i<n;i++) {
 469       struct gl_texture_object *t;
 470       if (texName[i]>0) {
 471          t = (struct gl_texture_object *)
 472             _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
 473          if (t) {
 474             /* First check if this texture is currently bound.
 475              * If so, unbind it and decrement the reference count.
 476              */
 477             GLuint u;
 478             for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
 479                struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
 480                GLuint d;
 481                for (d = 1 ; d <= 3 ; d++) {
 482                   if (unit->CurrentD[d] == t) {
 483                      unit->CurrentD[d] = ctx->Shared->DefaultD[d];
 484                      ctx->Shared->DefaultD[d]->RefCount++;
 485                      t->RefCount--;
 486                      ASSERT( t->RefCount >= 0 );
 487                   }
 488                }
 489             }
 490
 491             /* Decrement reference count and delete if zero */
 492             t->RefCount--;
 493             ASSERT( t->RefCount >= 0 );
 494             if (t->RefCount == 0) {
 495                if (ctx->Driver.DeleteTexture)
 496                   (*ctx->Driver.DeleteTexture)( ctx, t );
 497                gl_free_texture_object(ctx->Shared, t);
 498             }
 499          }
 500       }
 501    }
 502 }
 503
 504
 505
 506 /*
 507  * Execute glBindTexture
 508  */
 509 void
 510 _mesa_BindTexture( GLenum target, GLuint texName )
 511 {
 512    GET_CURRENT_CONTEXT(ctx);
 513    GLuint unit = ctx->Texture.CurrentUnit;
 514    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 515    struct gl_texture_object *oldTexObj;
 516    struct gl_texture_object *newTexObj;
 517    GLuint dim;
 518
 519    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
 520       fprintf(stderr, "glBindTexture %s %d\n",
 521               gl_lookup_enum_by_nr(target), (GLint) texName);
 522
 523    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBindTexture");
 524
 525    switch (target) {
 526       case GL_TEXTURE_1D:
 527          dim = 1;
 528          oldTexObj = texUnit->CurrentD[1];
 529          break;
 530       case GL_TEXTURE_2D:
 531          dim = 2;
 532          oldTexObj = texUnit->CurrentD[2];
 533          break;
 534       case GL_TEXTURE_3D:
 535          dim = 3;
 536          oldTexObj = texUnit->CurrentD[3];
 537          break;
 538       case GL_TEXTURE_CUBE_MAP_ARB:
 539          if (ctx->Extensions.HaveTextureCubeMap) {
 540             dim = 6;
 541             oldTexObj = texUnit->CurrentCubeMap;
 542             break;
 543          }
 544          /* fallthrough */
 545       default:
 546          gl_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
 547          return;
 548    }
 549
 550    if (oldTexObj->Name == texName)
 551       return;
 552
 553    if (texName == 0) {
 554       if (target == GL_TEXTURE_CUBE_MAP_ARB)
 555          newTexObj = ctx->Shared->DefaultCubeMap;
 556       else
 557          newTexObj = ctx->Shared->DefaultD[dim];
 558    }
 559    else {
 560       struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
 561       newTexObj = (struct gl_texture_object *) _mesa_HashLookup(hash, texName);
 562
 563       if (!newTexObj)
 564          newTexObj = gl_alloc_texture_object(ctx->Shared, texName, dim);
 565
 566       if (newTexObj->Dimensions != dim) {
 567          if (newTexObj->Dimensions) {
 568             /* the named texture object's dimensions don't match the target */
 569             gl_error( ctx, GL_INVALID_OPERATION, "glBindTexture" );
 570             return;
 571          }
 572          newTexObj->Dimensions = dim;
 573       }
 574    }
 575
 576    newTexObj->RefCount++;
 577
 578    switch (target) {
 579       case GL_TEXTURE_1D:
 580          texUnit->CurrentD[1] = newTexObj;
 581          break;
 582       case GL_TEXTURE_2D:
 583          texUnit->CurrentD[2] = newTexObj;
 584          break;
 585       case GL_TEXTURE_3D:
 586          texUnit->CurrentD[3] = newTexObj;
 587          break;
 588       case GL_TEXTURE_CUBE_MAP_ARB:
 589          texUnit->CurrentCubeMap = newTexObj;
 590          break;
 591       default:
 592          gl_problem(ctx, "bad target in BindTexture");
 593    }
 594
 595    /* If we've changed the CurrentD[123] texture object then update the
 596     * ctx->Texture.Current pointer to point to the new texture object.
 597     */
 598    texUnit->Current = texUnit->CurrentD[texUnit->CurrentDimension];
 599
 600    /* Check if we may have to use a new triangle rasterizer */
 601    if ((ctx->IndirectTriangles & DD_SW_RASTERIZE) &&
 602        (   oldTexObj->WrapS != newTexObj->WrapS
 603         || oldTexObj->WrapT != newTexObj->WrapT
 604         || oldTexObj->WrapR != newTexObj->WrapR
 605         || oldTexObj->MinFilter != newTexObj->MinFilter
 606         || oldTexObj->MagFilter != newTexObj->MagFilter
 607         || (oldTexObj->Image[0] && newTexObj->Image[0] &&
 608            (oldTexObj->Image[0]->Format!=newTexObj->Image[0]->Format))))
 609    {
 610       ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
 611    }
 612
 613    if (oldTexObj->Complete != newTexObj->Complete)
 614       ctx->NewState |= NEW_TEXTURING;
 615
 616    /* Pass BindTexture call to device driver */
 617    if (ctx->Driver.BindTexture) {
 618       (*ctx->Driver.BindTexture)( ctx, target, newTexObj );
 619       /* Make sure the Driver.UpdateState() function gets called! */
 620       ctx->NewState |= NEW_TEXTURING;
 621    }
 622
 623    if (oldTexObj->Name > 0) {
 624       /* never delete default (id=0) texture objects */
 625       oldTexObj->RefCount--;
 626       if (oldTexObj->RefCount <= 0) {
 627          if (ctx->Driver.DeleteTexture) {
 628             (*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
 629          }
 630          gl_free_texture_object(ctx->Shared, oldTexObj);
 631       }
 632    }
 633 }
 634
 635
 636
 637 /*
 638  * Execute glPrioritizeTextures
 639  */
 640 void
 641 _mesa_PrioritizeTextures( GLsizei n, const GLuint *texName,
 642                           const GLclampf *priorities )
 643 {
 644    GET_CURRENT_CONTEXT(ctx);
 645    GLint i;
 646
 647    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPrioritizeTextures");
 648    if (n < 0) {
 649       gl_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
 650       return;
 651    }
 652
 653    if (!priorities)
 654       return;
 655
 656    for (i = 0; i < n; i++) {
 657       if (texName[i] > 0) {
 658          struct gl_texture_object *t = (struct gl_texture_object *)
 659             _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
 660          if (t) {
 661             t->Priority = CLAMP( priorities[i], 0.0F, 1.0F );
 662             if (ctx->Driver.PrioritizeTexture)
 663                ctx->Driver.PrioritizeTexture( ctx, t, t->Priority );
 664          }
 665       }
 666    }
 667 }
 668
 669
 670
 671 /*
 672  * Execute glAreTexturesResident
 673  */
 674 GLboolean
 675 _mesa_AreTexturesResident(GLsizei n, const GLuint *texName,
 676                           GLboolean *residences)
 677 {
 678    GET_CURRENT_CONTEXT(ctx);
 679    GLboolean allResident = GL_TRUE;
 680    GLint i;
 681
 682    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx,
 683                                             "glAreTexturesResident", GL_FALSE);
 684    if (n < 0) {
 685       gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)");
 686       return GL_FALSE;
 687    }
 688
 689    if (!texName || !residences)
 690       return GL_FALSE;
 691
 692    for (i = 0; i < n; i++) {
 693       struct gl_texture_object *t;
 694       if (texName[i] == 0) {
 695          gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
 696          return GL_FALSE;
 697       }
 698       t = (struct gl_texture_object *)
 699          _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
 700       if (t) {
 701          if (ctx->Driver.IsTextureResident) {
 702             residences[i] = ctx->Driver.IsTextureResident(ctx, t);
 703             if (!residences[i])
 704                allResident = GL_FALSE;
 705          }
 706          else {
 707             residences[i] = GL_TRUE;
 708          }
 709       }
 710       else {
 711          gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
 712          return GL_FALSE;
 713       }
 714    }
 715    return allResident;
 716 }
 717
 718
 719
 720 /*
 721  * Execute glIsTexture
 722  */
 723 GLboolean
 724 _mesa_IsTexture( GLuint texture )
 725 {
 726    GET_CURRENT_CONTEXT(ctx);
 727    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glIsTextures",
 728                                                   GL_FALSE);
 729    if (texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture)) {
 730       return GL_TRUE;
 731    }
 732    else {
 733       return GL_FALSE;
 734    }
 735 }
 736