projects / mesa.git / blob
? search:


21f37e49bc7751fa528259e84ec72eefec6c63c4
[mesa.git] / src / mesa / main / texobj.c
1 /* $Id: texobj.c,v 1.32 2000/11/05 18:40:58 keithw 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 "macros.h"
37 #include "mem.h"
38 #include "teximage.h"
39 #include "texstate.h"
40 #include "texobj.h"
41 #include "types.h"
42 #endif
43
44
45
46 /*
47 * Allocate a new texture object and add it to the linked list of texture
48 * objects. If name>0 then also insert the new texture object into the hash
49 * table.
50 * Input: shared - the shared GL state structure to contain the texture object
51 * name - integer name for the texture object
52 * dimensions - either 1, 2, 3 or 6 (cube map)
53 * Return: pointer to new texture object
54 */
55 struct gl_texture_object *
56 gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
57 GLuint dimensions)
58 {
59 struct gl_texture_object *obj;
60
61 ASSERT(dimensions <= 3 || dimensions == 6);
62
63 obj = CALLOC_STRUCT(gl_texture_object);
64
65 if (obj) {
66 /* init the non-zero fields */
67 _glthread_INIT_MUTEX(obj->Mutex);
68 obj->RefCount = 1;
69 obj->Name = name;
70 obj->Dimensions = dimensions;
71 obj->Priority = 1.0F;
72 obj->WrapS = GL_REPEAT;
73 obj->WrapT = GL_REPEAT;
74 obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
75 obj->MagFilter = GL_LINEAR;
76 obj->MinLod = -1000.0;
77 obj->MaxLod = 1000.0;
78 obj->BaseLevel = 0;
79 obj->MaxLevel = 1000;
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 ctx->NewState |= _NEW_TEXTURE;
488 }
489 }
490 }
491
492 /* Decrement reference count and delete if zero */
493 t->RefCount--;
494 ASSERT( t->RefCount >= 0 );
495 if (t->RefCount == 0) {
496 if (ctx->Driver.DeleteTexture)
497 (*ctx->Driver.DeleteTexture)( ctx, t );
498 gl_free_texture_object(ctx->Shared, t);
499 }
500 }
501 }
502 }
503 }
504
505
506
507 /*
508 * Execute glBindTexture
509 */
510 void
511 _mesa_BindTexture( GLenum target, GLuint texName )
512 {
513 GET_CURRENT_CONTEXT(ctx);
514 GLuint unit = ctx->Texture.CurrentUnit;
515 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
516 struct gl_texture_object *oldTexObj;
517 struct gl_texture_object *newTexObj;
518 GLuint dim;
519
520 if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
521 fprintf(stderr, "glBindTexture %s %d\n",
522 gl_lookup_enum_by_nr(target), (GLint) texName);
523
524 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBindTexture");
525
526 switch (target) {
527 case GL_TEXTURE_1D:
528 dim = 1;
529 oldTexObj = texUnit->CurrentD[1];
530 break;
531 case GL_TEXTURE_2D:
532 dim = 2;
533 oldTexObj = texUnit->CurrentD[2];
534 break;
535 case GL_TEXTURE_3D:
536 dim = 3;
537 oldTexObj = texUnit->CurrentD[3];
538 break;
539 case GL_TEXTURE_CUBE_MAP_ARB:
540 if (ctx->Extensions.ARB_texture_cube_map) {
541 dim = 6;
542 oldTexObj = texUnit->CurrentCubeMap;
543 break;
544 }
545 /* fallthrough */
546 default:
547 gl_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
548 return;
549 }
550
551 if (oldTexObj->Name == texName)
552 return;
553
554 if (texName == 0) {
555 if (target == GL_TEXTURE_CUBE_MAP_ARB)
556 newTexObj = ctx->Shared->DefaultCubeMap;
557 else
558 newTexObj = ctx->Shared->DefaultD[dim];
559 }
560 else {
561 struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
562 newTexObj = (struct gl_texture_object *) _mesa_HashLookup(hash, texName);
563
564 if (!newTexObj)
565 newTexObj = gl_alloc_texture_object(ctx->Shared, texName, dim);
566
567 if (newTexObj->Dimensions != dim) {
568 if (newTexObj->Dimensions) {
569 /* the named texture object's dimensions don't match the target */
570 gl_error( ctx, GL_INVALID_OPERATION, "glBindTexture" );
571 return;
572 }
573 newTexObj->Dimensions = dim;
574 }
575 }
576
577 newTexObj->RefCount++;
578
579 switch (target) {
580 case GL_TEXTURE_1D:
581 texUnit->CurrentD[1] = newTexObj;
582 break;
583 case GL_TEXTURE_2D:
584 texUnit->CurrentD[2] = newTexObj;
585 break;
586 case GL_TEXTURE_3D:
587 texUnit->CurrentD[3] = newTexObj;
588 break;
589 case GL_TEXTURE_CUBE_MAP_ARB:
590 texUnit->CurrentCubeMap = newTexObj;
591 break;
592 default:
593 gl_problem(ctx, "bad target in BindTexture");
594 }
595
596 /* If we've changed the CurrentD[123] texture object then update the
597 * ctx->Texture.Current pointer to point to the new texture object.
598 */
599 texUnit->_Current = texUnit->CurrentD[texUnit->_CurrentDimension];
600
601 ctx->NewState |= _NEW_TEXTURE;
602
603 /* Pass BindTexture call to device driver */
604 if (ctx->Driver.BindTexture)
605 (*ctx->Driver.BindTexture)( ctx, target, newTexObj );
606
607 if (oldTexObj->Name > 0) {
608 /* never delete default (id=0) texture objects */
609 oldTexObj->RefCount--;
610 if (oldTexObj->RefCount <= 0) {
611 if (ctx->Driver.DeleteTexture) {
612 (*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
613 }
614 gl_free_texture_object(ctx->Shared, oldTexObj);
615 }
616 }
617 }
618
619
620
621 /*
622 * Execute glPrioritizeTextures
623 */
624 void
625 _mesa_PrioritizeTextures( GLsizei n, const GLuint *texName,
626 const GLclampf *priorities )
627 {
628 GET_CURRENT_CONTEXT(ctx);
629 GLint i;
630
631 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPrioritizeTextures");
632 if (n < 0) {
633 gl_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
634 return;
635 }
636
637 if (!priorities)
638 return;
639
640 for (i = 0; i < n; i++) {
641 if (texName[i] > 0) {
642 struct gl_texture_object *t = (struct gl_texture_object *)
643 _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
644 if (t) {
645 t->Priority = CLAMP( priorities[i], 0.0F, 1.0F );
646 if (ctx->Driver.PrioritizeTexture)
647 ctx->Driver.PrioritizeTexture( ctx, t, t->Priority );
648 }
649 }
650 }
651
652 ctx->NewState |= _NEW_TEXTURE;
653 }
654
655
656
657 /*
658 * Execute glAreTexturesResident
659 */
660 GLboolean
661 _mesa_AreTexturesResident(GLsizei n, const GLuint *texName,
662 GLboolean *residences)
663 {
664 GET_CURRENT_CONTEXT(ctx);
665 GLboolean allResident = GL_TRUE;
666 GLint i;
667
668 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx,
669 "glAreTexturesResident", GL_FALSE);
670 if (n < 0) {
671 gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)");
672 return GL_FALSE;
673 }
674
675 if (!texName || !residences)
676 return GL_FALSE;
677
678 for (i = 0; i < n; i++) {
679 struct gl_texture_object *t;
680 if (texName[i] == 0) {
681 gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
682 return GL_FALSE;
683 }
684 t = (struct gl_texture_object *)
685 _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
686 if (t) {
687 if (ctx->Driver.IsTextureResident) {
688 residences[i] = ctx->Driver.IsTextureResident(ctx, t);
689 if (!residences[i])
690 allResident = GL_FALSE;
691 }
692 else {
693 residences[i] = GL_TRUE;
694 }
695 }
696 else {
697 gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
698 return GL_FALSE;
699 }
700 }
701 return allResident;
702 }
703
704
705
706 /*
707 * Execute glIsTexture
708 */
709 GLboolean
710 _mesa_IsTexture( GLuint texture )
711 {
712 GET_CURRENT_CONTEXT(ctx);
713 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glIsTextures",
714 GL_FALSE);
715 if (texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture)) {
716 return GL_TRUE;
717 }
718 else {
719 return GL_FALSE;
720 }
721 }
722