source: trunk/src/opengl/mesa/texobj.c@ 3204

Last change on this file since 3204 was 2962, checked in by jeroen, 26 years ago

* empty log message *
File size: 16.2 KB
Line 
1/* $Id: texobj.c,v 1.2 2000-03-01 18:49:36 jeroen Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 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/* $XFree86: xc/lib/GL/mesa/src/texobj.c,v 1.3 1999/04/04 00:20:32 dawes Exp $ */
27
28
29
30
31#ifdef PC_HEADER
32#include "all.h"
33#else
34#ifndef XFree86Server
35#include <assert.h>
36#include <stdio.h>
37#include <stdlib.h>
38#else
39#include "GL/xf86glx.h"
40#endif
41#include "types.h"
42#include "context.h"
43#include "enums.h"
44#include "hash.h"
45#include "macros.h"
46#include "teximage.h"
47#include "texstate.h"
48#include "texobj.h"
49#endif
50
51
52
53/*
54 * Allocate a new texture object and add it to the linked list of texture
55 * objects. If name>0 then also insert the new texture object into the hash
56 * table.
57 * Input: shared - the shared GL state structure to contain the texture object
58 * name - integer name for the texture object
59 * dimensions - either 1, 2 or 3
60 * Return: pointer to new texture object
61 */
62struct gl_texture_object *
63gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
64 GLuint dimensions)
65{
66 struct gl_texture_object *obj;
67
68 ASSERT(dimensions <= 3);
69
70 obj = (struct gl_texture_object *)
71 calloc(1,sizeof(struct gl_texture_object));
72 if (obj) {
73 /* init the non-zero fields */
74 obj->RefCount = 1;
75 obj->Name = name;
76 obj->Dimensions = dimensions;
77 obj->WrapS = GL_REPEAT;
78 obj->WrapT = GL_REPEAT;
79 obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
80 obj->MagFilter = GL_LINEAR;
81 obj->MinLod = -1000.0;
82 obj->MaxLod = 1000.0;
83 obj->BaseLevel = 0;
84 obj->MaxLevel = 1000;
85 obj->MinMagThresh = 0.0F;
86 obj->Palette[0] = 255;
87 obj->Palette[1] = 255;
88 obj->Palette[2] = 255;
89 obj->Palette[3] = 255;
90 obj->PaletteSize = 1;
91 obj->PaletteIntFormat = GL_RGBA;
92 obj->PaletteFormat = GL_RGBA;
93
94 /* insert into linked list */
95 if (shared) {
96 obj->Next = shared->TexObjectList;
97 shared->TexObjectList = obj;
98 }
99
100 if (name > 0) {
101 /* insert into hash table */
102 HashInsert(shared->TexObjects, name, obj);
103 }
104 }
105 return obj;
106}
107
108
109/*
110 * Deallocate a texture object struct and remove it from the given
111 * shared GL state.
112 * Input: shared - the shared GL state to which the object belongs
113 * t - the texture object to delete
114 */
115void gl_free_texture_object( struct gl_shared_state *shared,
116 struct gl_texture_object *t )
117{
118 struct gl_texture_object *tprev, *tcurr;
119
120 assert(t);
121
122 /* Remove t from dirty list so we don't touch free'd memory later.
123 * Test for shared since Proxy texture aren't in global linked list.
124 */
125 if (shared)
126 gl_remove_texobj_from_dirty_list( shared, t );
127
128 /* unlink t from the linked list */
129 if (shared) {
130 tprev = NULL;
131 tcurr = shared->TexObjectList;
132 while (tcurr) {
133 if (tcurr==t) {
134 if (tprev) {
135 tprev->Next = t->Next;
136 }
137 else {
138 shared->TexObjectList = t->Next;
139 }
140 break;
141 }
142 tprev = tcurr;
143 tcurr = tcurr->Next;
144 }
145 }
146
147 if (t->Name) {
148 /* remove from hash table */
149 HashRemove(shared->TexObjects, t->Name);
150 }
151
152 /* free texture image */
153 {
154 GLuint i;
155 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
156 if (t->Image[i]) {
157 gl_free_texture_image( t->Image[i] );
158 }
159 }
160 }
161 /* free this object */
162 FREE( t );
163}
164
165
166
167/*
168 * Examine a texture object to determine if it is complete or not.
169 * The t->Complete flag will be set to GL_TRUE or GL_FALSE accordingly.
170 */
171void gl_test_texture_object_completeness( const GLcontext *ctx, struct gl_texture_object *t )
172{
173 t->Complete = GL_TRUE; /* be optimistic */
174
175 /* Always need level zero image */
176 if (!t->Image[0] || !t->Image[0]->Data) {
177 t->Complete = GL_FALSE;
178 return;
179 }
180
181 /* Compute number of mipmap levels */
182 if (t->Dimensions==1) {
183 t->P = t->Image[0]->WidthLog2;
184 }
185 else if (t->Dimensions==2) {
186 t->P = MAX2(t->Image[0]->WidthLog2, t->Image[0]->HeightLog2);
187 }
188 else if (t->Dimensions==3) {
189 GLint max = MAX2(t->Image[0]->WidthLog2, t->Image[0]->HeightLog2);
190 max = MAX2(max, (GLint)(t->Image[0]->DepthLog2));
191 t->P = max;
192 }
193
194 /* Compute M (see the 1.2 spec) used during mipmapping */
195 t->M = (GLfloat) (MIN2(t->MaxLevel, t->P) - t->BaseLevel);
196
197
198 if (t->MinFilter!=GL_NEAREST && t->MinFilter!=GL_LINEAR) {
199 /*
200 * Mipmapping: determine if we have a complete set of mipmaps
201 */
202 GLint i;
203 GLint minLevel = t->BaseLevel;
204 GLint maxLevel = MIN2(t->P, ctx->Const.MaxTextureLevels-1);
205 maxLevel = MIN2(maxLevel, t->MaxLevel);
206
207 if (minLevel > maxLevel) {
208 t->Complete = GL_FALSE;
209 return;
210 }
211
212 /* Test dimension-independent attributes */
213 for (i = minLevel; i <= maxLevel; i++) {
214 if (t->Image[i]) {
215 if (!t->Image[i]->Data) {
216 t->Complete = GL_FALSE;
217 return;
218 }
219 if (t->Image[i]->Format != t->Image[0]->Format) {
220 t->Complete = GL_FALSE;
221 return;
222 }
223 if (t->Image[i]->Border != t->Image[0]->Border) {
224 t->Complete = GL_FALSE;
225 return;
226 }
227 }
228 }
229
230 /* Test things which depend on number of texture image dimensions */
231 if (t->Dimensions==1) {
232 /* Test 1-D mipmaps */
233 GLuint width = t->Image[0]->Width2;
234 for (i=1; i<ctx->Const.MaxTextureLevels; i++) {
235 if (width>1) {
236 width /= 2;
237 }
238 if (i >= minLevel && i <= maxLevel) {
239 if (!t->Image[i]) {
240 t->Complete = GL_FALSE;
241 return;
242 }
243 if (!t->Image[i]->Data) {
244 t->Complete = GL_FALSE;
245 return;
246 }
247 if (t->Image[i]->Width2 != width ) {
248 t->Complete = GL_FALSE;
249 return;
250 }
251 }
252 if (width==1) {
253 return; /* found smallest needed mipmap, all done! */
254 }
255 }
256 }
257 else if (t->Dimensions==2) {
258 /* Test 2-D mipmaps */
259 GLuint width = t->Image[0]->Width2;
260 GLuint height = t->Image[0]->Height2;
261 for (i=1; i<ctx->Const.MaxTextureLevels; i++) {
262 if (width>1) {
263 width /= 2;
264 }
265 if (height>1) {
266 height /= 2;
267 }
268 if (i >= minLevel && i <= maxLevel) {
269 if (!t->Image[i]) {
270 t->Complete = GL_FALSE;
271 return;
272 }
273 if (t->Image[i]->Width2 != width) {
274 t->Complete = GL_FALSE;
275 return;
276 }
277 if (t->Image[i]->Height2 != height) {
278 t->Complete = GL_FALSE;
279 return;
280 }
281 if (width==1 && height==1) {
282 return; /* found smallest needed mipmap, all done! */
283 }
284 }
285 }
286 }
287 else if (t->Dimensions==3) {
288 /* Test 3-D mipmaps */
289 GLuint width = t->Image[0]->Width2;
290 GLuint height = t->Image[0]->Height2;
291 GLuint depth = t->Image[0]->Depth2;
292 for (i=1; i<ctx->Const.MaxTextureLevels; i++) {
293 if (width>1) {
294 width /= 2;
295 }
296 if (height>1) {
297 height /= 2;
298 }
299 if (depth>1) {
300 depth /= 2;
301 }
302 if (i >= minLevel && i <= maxLevel) {
303 if (!t->Image[i]) {
304 t->Complete = GL_FALSE;
305 return;
306 }
307 if (t->Image[i]->Width2 != width) {
308 t->Complete = GL_FALSE;
309 return;
310 }
311 if (t->Image[i]->Height2 != height) {
312 t->Complete = GL_FALSE;
313 return;
314 }
315 if (t->Image[i]->Depth2 != depth) {
316 t->Complete = GL_FALSE;
317 return;
318 }
319 }
320 if (width==1 && height==1 && depth==1) {
321 return; /* found smallest needed mipmap, all done! */
322 }
323 }
324 }
325 else {
326 /* Dimensions = ??? */
327 gl_problem(NULL, "Bug in gl_test_texture_object_completeness\n");
328 }
329 }
330}
331
332
333
334/*
335 * Execute glGenTextures
336 */
337void gl_GenTextures( GLcontext *ctx, GLsizei n, GLuint *texName )
338{
339 GLuint first;
340 GLint i;
341
342 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGenTextures");
343 if (n<0) {
344 gl_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
345 return;
346 }
347
348 first = HashFindFreeKeyBlock(ctx->Shared->TexObjects, n);
349
350 /* Return the texture names */
351 for (i=0;i<n;i++) {
352 texName[i] = first + i;
353 }
354
355 /* Allocate new, empty texture objects */
356 for (i=0;i<n;i++) {
357 GLuint name = first + i;
358 GLuint dims = 0;
359 (void) gl_alloc_texture_object(ctx->Shared, name, dims);
360 }
361}
362
363
364
365/*
366 * Execute glDeleteTextures
367 */
368void gl_DeleteTextures( GLcontext *ctx, GLsizei n, const GLuint *texName)
369{
370 GLint i;
371
372 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteTextures");
373
374 for (i=0;i<n;i++) {
375 struct gl_texture_object *t;
376 if (texName[i]>0) {
377 t = (struct gl_texture_object *)
378 HashLookup(ctx->Shared->TexObjects, texName[i]);
379 if (t) {
380 GLuint u;
381 for (u=0; u<MAX_TEXTURE_UNITS; u++) {
382 struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
383 GLuint d;
384 for (d = 1 ; d <= 3 ; d++) {
385 if (unit->CurrentD[d]==t) {
386 unit->CurrentD[d] = ctx->Shared->DefaultD[d];
387 ctx->Shared->DefaultD[d]->RefCount++;
388 t->RefCount--;
389 assert( t->RefCount >= 0 );
390 }
391 }
392 }
393
394 /* tell device driver to delete texture */
395 if (ctx->Driver.DeleteTexture) {
396 (*ctx->Driver.DeleteTexture)( ctx, t );
397 }
398
399 if (t->RefCount==0) {
400 gl_free_texture_object(ctx->Shared, t);
401 }
402 }
403 }
404 }
405}
406
407
408
409/*
410 * Execute glBindTexture
411 */
412void gl_BindTexture( GLcontext *ctx, GLenum target, GLuint texName )
413{
414 GLuint unit = ctx->Texture.CurrentUnit;
415 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
416 struct gl_texture_object *oldTexObj;
417 struct gl_texture_object *newTexObj;
418 GLuint dim;
419
420 if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
421 fprintf(stderr, "glBindTexture %s %d\n",
422 gl_lookup_enum_by_nr(target), (GLint) texName);
423
424 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBindTexture");
425
426 switch (target) {
427 case GL_TEXTURE_1D:
428 dim = 1;
429 break;
430 case GL_TEXTURE_2D:
431 dim = 2;
432 break;
433 case GL_TEXTURE_3D:
434 dim = 3;
435 break;
436 default:
437 gl_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
438 return;
439 }
440
441 oldTexObj = texUnit->CurrentD[dim];
442
443 if (oldTexObj->Name == texName)
444 return;
445
446 if (texName == 0)
447 newTexObj = ctx->Shared->DefaultD[dim];
448 else {
449 struct HashTable *hash = ctx->Shared->TexObjects;
450 newTexObj = (struct gl_texture_object *) HashLookup(hash, texName);
451
452 if (!newTexObj)
453 newTexObj = gl_alloc_texture_object(ctx->Shared, texName, dim);
454
455 if (newTexObj->Dimensions != dim) {
456 if (newTexObj->Dimensions) {
457 /* the named texture object's dimensions don't match the target */
458 gl_error( ctx, GL_INVALID_OPERATION, "glBindTexture" );
459 return;
460 }
461 newTexObj->Dimensions = dim;
462 }
463 }
464
465 newTexObj->RefCount++;
466
467 texUnit->CurrentD[dim] = newTexObj;
468
469 /* If we've changed the CurrentD[123] texture object then update the
470 * ctx->Texture.Current pointer to point to the new texture object.
471 */
472 texUnit->Current = texUnit->CurrentD[texUnit->CurrentDimension];
473
474 /* Check if we may have to use a new triangle rasterizer */
475 if ((ctx->IndirectTriangles & DD_SW_RASTERIZE) &&
476 ( oldTexObj->WrapS != newTexObj->WrapS
477 || oldTexObj->WrapT != newTexObj->WrapT
478 || oldTexObj->WrapR != newTexObj->WrapR
479 || oldTexObj->MinFilter != newTexObj->MinFilter
480 || oldTexObj->MagFilter != newTexObj->MagFilter
481 || (oldTexObj->Image[0] && newTexObj->Image[0] &&
482 (oldTexObj->Image[0]->Format!=newTexObj->Image[0]->Format))))
483 {
484 ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
485 }
486
487 if (oldTexObj->Complete != newTexObj->Complete)
488 ctx->NewState |= NEW_TEXTURING;
489
490 /* Pass BindTexture call to device driver */
491 if (ctx->Driver.BindTexture) {
492 (*ctx->Driver.BindTexture)( ctx, target, newTexObj );
493 }
494
495 if (oldTexObj->Name > 0) {
496 /* never delete default (id=0) texture objects */
497 oldTexObj->RefCount--;
498 if (oldTexObj->RefCount <= 0) {
499 if (ctx->Driver.DeleteTexture) {
500 (*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
501 }
502 gl_free_texture_object(ctx->Shared, oldTexObj);
503 }
504 }
505}
506
507
508
509/*
510 * Execute glPrioritizeTextures
511 */
512void gl_PrioritizeTextures( GLcontext *ctx,
513 GLsizei n, const GLuint *texName,
514 const GLclampf *priorities )
515{
516 GLint i;
517
518 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPrioritizeTextures");
519 if (n<0) {
520 gl_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
521 return;
522 }
523
524 for (i=0;i<n;i++) {
525 struct gl_texture_object *t;
526 if (texName[i]>0) {
527 t = (struct gl_texture_object *)
528 HashLookup(ctx->Shared->TexObjects, texName[i]);
529 if (t) {
530 t->Priority = CLAMP( priorities[i], 0.0F, 1.0F );
531
532 if (ctx->Driver.PrioritizeTexture)
533 ctx->Driver.PrioritizeTexture( ctx, t, t->Priority );
534 }
535 }
536 }
537}
538
539
540
541/*
542 * Execute glAreTexturesResident
543 */
544GLboolean gl_AreTexturesResident( GLcontext *ctx, GLsizei n,
545 const GLuint *texName,
546 GLboolean *residences )
547{
548 GLboolean resident = GL_TRUE;
549 GLint i;
550
551 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx,
552 "glAreTexturesResident",
553 GL_FALSE);
554 if (n<0) {
555 gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)" );
556 return GL_FALSE;
557 }
558
559 for (i=0;i<n;i++) {
560 struct gl_texture_object *t;
561 if (texName[i]==0) {
562 gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)" );
563 return GL_FALSE;
564 }
565 t = (struct gl_texture_object *)
566 HashLookup(ctx->Shared->TexObjects, texName[i]);
567 if (t) {
568 if (ctx->Driver.IsTextureResident)
569 residences[i] = ctx->Driver.IsTextureResident( ctx, t );
570 else
571 residences[i] = GL_TRUE;
572 }
573 else {
574 gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)" );
575 return GL_FALSE;
576 }
577 }
578 return resident;
579}
580
581
582
583/*
584 * Execute glIsTexture
585 */
586GLboolean gl_IsTexture( GLcontext *ctx, GLuint texture )
587{
588 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glIsTextures",
589 GL_FALSE);
590 if (texture>0 && HashLookup(ctx->Shared->TexObjects, texture)) {
591 return GL_TRUE;
592 }
593 else {
594 return GL_FALSE;
595 }
596}
597
Note: See TracBrowser for help on using the repository browser.