+/* $Id: texobj.c,v 1.45 2001/03/18 08:53:49 gareth Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
- *
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
- *
+ *
+ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
+ *
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
- *
+ *
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
- *
+ *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
#include "context.h"
#include "enums.h"
#include "hash.h"
+#include "macros.h"
#include "mem.h"
#include "teximage.h"
#include "texstate.h"
#include "texobj.h"
-#include "types.h"
+#include "mtypes.h"
#endif
* Input: shared - the shared GL state structure to contain the texture object
* name - integer name for the texture object
* dimensions - either 1, 2, 3 or 6 (cube map)
+ * zero is ok for the sake of GenTextures()
* Return: pointer to new texture object
*/
struct gl_texture_object *
-gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
- GLuint dimensions)
+_mesa_alloc_texture_object( struct gl_shared_state *shared,
+ GLuint name, GLuint dimensions )
{
struct gl_texture_object *obj;
if (obj) {
/* init the non-zero fields */
+ _glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
obj->Name = name;
obj->Dimensions = dimensions;
obj->Priority = 1.0F;
obj->WrapS = GL_REPEAT;
obj->WrapT = GL_REPEAT;
+ obj->WrapR = GL_REPEAT;
obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
obj->MagFilter = GL_LINEAR;
obj->MinLod = -1000.0;
obj->MaxLod = 1000.0;
obj->BaseLevel = 0;
obj->MaxLevel = 1000;
- obj->MinMagThresh = 0.0F;
+ obj->MaxAnisotropy = 1.0;
+ obj->CompareFlag = GL_FALSE;
+ obj->CompareOperator = GL_TEXTURE_LEQUAL_R_SGIX;
+ obj->ShadowAmbient = 0;
_mesa_init_colortable(&obj->Palette);
/* insert into linked list */
* Input: shared - the shared GL state to which the object belongs
* t - the texture object to delete
*/
-void gl_free_texture_object( struct gl_shared_state *shared,
- struct gl_texture_object *t )
+void _mesa_free_texture_object( struct gl_shared_state *shared,
+ struct gl_texture_object *t )
{
struct gl_texture_object *tprev, *tcurr;
assert(t);
- /* Remove t from dirty list so we don't touch free'd memory later.
- * Test for shared since Proxy texture aren't in global linked list.
- */
- if (shared)
- gl_remove_texobj_from_dirty_list( shared, t );
-
/* unlink t from the linked list */
if (shared) {
_glthread_LOCK_MUTEX(shared->Mutex);
_mesa_free_colortable_data(&t->Palette);
- /* free texture images */
+ /* free the texture images */
{
GLuint i;
for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
}
}
}
+
/* free this object */
FREE( t );
}
+/*
+ * Report why a texture object is incomplete. (for debug only)
+ */
+#if 0
+static void
+incomplete(const struct gl_texture_object *t, const char *why)
+{
+ printf("Texture Obj %d incomplete because: %s\n", t->Name, why);
+}
+#else
+#define incomplete(a, b)
+#endif
+
/*
- * Examine a texture object to determine if it is complete or not.
+ * Examine a texture object to determine if it is complete.
* The t->Complete flag will be set to GL_TRUE or GL_FALSE accordingly.
*/
void
struct gl_texture_object *t )
{
const GLint baseLevel = t->BaseLevel;
+ GLint maxLog2 = 0;
t->Complete = GL_TRUE; /* be optimistic */
- /* Always need level zero image */
+ /* Always need the base level image */
if (!t->Image[baseLevel]) {
+ incomplete(t, "Image[baseLevel] == NULL");
t->Complete = GL_FALSE;
return;
}
- /* Compute number of mipmap levels */
+ /* Compute _MaxLevel */
if (t->Dimensions == 1) {
- t->P = t->Image[baseLevel]->WidthLog2;
+ maxLog2 = t->Image[baseLevel]->WidthLog2;
}
else if (t->Dimensions == 2 || t->Dimensions == 6) {
- t->P = MAX2(t->Image[baseLevel]->WidthLog2,
- t->Image[baseLevel]->HeightLog2);
+ maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
+ t->Image[baseLevel]->HeightLog2);
}
else if (t->Dimensions == 3) {
GLint max = MAX2(t->Image[baseLevel]->WidthLog2,
t->Image[baseLevel]->HeightLog2);
- max = MAX2(max, (GLint)(t->Image[baseLevel]->DepthLog2));
- t->P = max;
+ maxLog2 = MAX2(max, (GLint)(t->Image[baseLevel]->DepthLog2));
}
- /* Compute M (see the 1.2 spec) used during mipmapping */
- t->M = (GLfloat) (MIN2(t->MaxLevel, t->P) - t->BaseLevel);
+ t->_MaxLevel = baseLevel + maxLog2;
+ t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel);
+ t->_MaxLevel = MIN2(t->_MaxLevel, ctx->Const.MaxTextureLevels - 1);
+ /* Compute _MaxLambda = q - b (see the 1.2 spec) used during mipmapping */
+ t->_MaxLambda = (GLfloat) (t->_MaxLevel - t->BaseLevel);
if (t->Dimensions == 6) {
- /* make sure all six level 0 images are same size */
- const GLint w = t->Image[baseLevel]->Width2;
- const GLint h = t->Image[baseLevel]->Height2;
+ /* make sure that all six cube map level 0 images are the same size */
+ const GLuint w = t->Image[baseLevel]->Width2;
+ const GLuint h = t->Image[baseLevel]->Height2;
if (!t->NegX[baseLevel] ||
t->NegX[baseLevel]->Width2 != w ||
t->NegX[baseLevel]->Height2 != h ||
t->NegZ[baseLevel]->Width2 != w ||
t->NegZ[baseLevel]->Height2 != h) {
t->Complete = GL_FALSE;
+ incomplete(t, "Non-quare cubemap image");
return;
}
}
*/
GLint i;
GLint minLevel = baseLevel;
- GLint maxLevel = MIN2(t->P, ctx->Const.MaxTextureLevels-1);
- maxLevel = MIN2(maxLevel, t->MaxLevel);
+ GLint maxLevel = t->_MaxLevel;
if (minLevel > maxLevel) {
t->Complete = GL_FALSE;
+ incomplete(t, "minLevel > maxLevel");
return;
}
if (t->Image[i]) {
if (t->Image[i]->Format != t->Image[baseLevel]->Format) {
t->Complete = GL_FALSE;
+ incomplete(t, "Format[i] != Format[baseLevel]");
return;
}
if (t->Image[i]->Border != t->Image[baseLevel]->Border) {
t->Complete = GL_FALSE;
+ incomplete(t, "Border[i] != Border[baseLevel]");
return;
}
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[i]) {
t->Complete = GL_FALSE;
+ incomplete(t, "1D Image[i] == NULL");
return;
}
if (t->Image[i]->Width2 != width ) {
t->Complete = GL_FALSE;
+ incomplete(t, "1D Image[i] bad width");
return;
}
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[i]) {
t->Complete = GL_FALSE;
+ incomplete(t, "2D Image[i] == NULL");
return;
}
if (t->Image[i]->Width2 != width) {
t->Complete = GL_FALSE;
+ incomplete(t, "2D Image[i] bad width");
return;
}
if (t->Image[i]->Height2 != height) {
t->Complete = GL_FALSE;
+ incomplete(t, "2D Image[i] bad height");
return;
}
if (width==1 && height==1) {
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[i]) {
+ incomplete(t, "3D Image[i] == NULL");
t->Complete = GL_FALSE;
return;
}
if (t->Image[i]->Width2 != width) {
t->Complete = GL_FALSE;
+ incomplete(t, "3D Image[i] bad width");
return;
}
if (t->Image[i]->Height2 != height) {
t->Complete = GL_FALSE;
+ incomplete(t, "3D Image[i] bad height");
return;
}
if (t->Image[i]->Depth2 != depth) {
t->Complete = GL_FALSE;
+ incomplete(t, "3D Image[i] bad depth");
return;
}
}
!t->PosY[i] || !t->NegY[i] ||
!t->PosZ[i] || !t->NegZ[i]) {
t->Complete = GL_FALSE;
+ incomplete(t, "CubeMap Image[i] == NULL");
return;
}
/* check that all six images have same size */
t->PosZ[i]->Width2!=width || t->PosZ[i]->Height2!=height ||
t->NegZ[i]->Width2!=width || t->NegZ[i]->Height2!=height) {
t->Complete = GL_FALSE;
+ incomplete(t, "CubeMap Image[i] bad size");
return;
}
}
}
else {
/* Dimensions = ??? */
- gl_problem(NULL, "Bug in gl_test_texture_object_completeness\n");
+ _mesa_problem(ctx, "Bug in gl_test_texture_object_completeness\n");
}
}
}
GET_CURRENT_CONTEXT(ctx);
GLuint first;
GLint i;
+ ASSERT_OUTSIDE_BEGIN_END(ctx);
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGenTextures");
- if (n<0) {
- gl_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
+ if (n < 0) {
+ _mesa_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
return;
}
+ if (!texName)
+ return;
/*
* This must be atomic (generation and allocation of texture IDs)
for (i=0;i<n;i++) {
GLuint name = first + i;
GLuint dims = 0;
- (void) gl_alloc_texture_object(ctx->Shared, name, dims);
+ (void) _mesa_alloc_texture_object( ctx->Shared, name, dims);
}
_glthread_UNLOCK_MUTEX(GenTexturesLock);
{
GET_CURRENT_CONTEXT(ctx);
GLint i;
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteTextures");
+ if (!texName)
+ return;
for (i=0;i<n;i++) {
- struct gl_texture_object *t;
- if (texName[i]>0) {
- t = (struct gl_texture_object *)
+ if (texName[i] > 0) {
+ struct gl_texture_object *delObj = (struct gl_texture_object *)
_mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
- if (t) {
+ if (delObj) {
/* First check if this texture is currently bound.
* If so, unbind it and decrement the reference count.
*/
GLuint u;
for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
- GLuint d;
- for (d = 1 ; d <= 3 ; d++) {
- if (unit->CurrentD[d] == t) {
- unit->CurrentD[d] = ctx->Shared->DefaultD[d];
- ctx->Shared->DefaultD[d]->RefCount++;
- t->RefCount--;
- ASSERT( t->RefCount >= 0 );
- }
- }
+ if (delObj == unit->Current1D) {
+ unit->Current1D = ctx->Shared->Default1D;
+ ctx->Shared->Default1D->RefCount++;
+ }
+ else if (delObj == unit->Current2D) {
+ unit->Current2D = ctx->Shared->Default2D;
+ ctx->Shared->Default2D->RefCount++;
+ }
+ else if (delObj == unit->Current3D) {
+ unit->Current3D = ctx->Shared->Default3D;
+ ctx->Shared->Default3D->RefCount++;
+ }
+ else if (delObj == unit->CurrentCubeMap) {
+ unit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
+ ctx->Shared->DefaultCubeMap->RefCount++;
+ }
}
+ ctx->NewState |= _NEW_TEXTURE;
/* Decrement reference count and delete if zero */
- t->RefCount--;
- ASSERT( t->RefCount >= 0 );
- if (t->RefCount == 0) {
+ delObj->RefCount--;
+ ASSERT( delObj->RefCount >= 0 );
+ if (delObj->RefCount == 0) {
if (ctx->Driver.DeleteTexture)
- (*ctx->Driver.DeleteTexture)( ctx, t );
- gl_free_texture_object(ctx->Shared, t);
+ (*ctx->Driver.DeleteTexture)( ctx, delObj );
+ _mesa_free_texture_object(ctx->Shared, delObj);
}
}
}
GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
struct gl_texture_object *oldTexObj;
- struct gl_texture_object *newTexObj;
- GLuint dim;
+ struct gl_texture_object *newTexObj = 0;
+ GLuint targetDim;
+ ASSERT_OUTSIDE_BEGIN_END(ctx);
if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
fprintf(stderr, "glBindTexture %s %d\n",
- gl_lookup_enum_by_nr(target), (GLint) texName);
-
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBindTexture");
+ _mesa_lookup_enum_by_nr(target), (GLint) texName);
switch (target) {
case GL_TEXTURE_1D:
- dim = 1;
- oldTexObj = texUnit->CurrentD[1];
+ targetDim = 1;
+ oldTexObj = texUnit->Current1D;
break;
case GL_TEXTURE_2D:
- dim = 2;
- oldTexObj = texUnit->CurrentD[2];
+ targetDim = 2;
+ oldTexObj = texUnit->Current2D;
break;
case GL_TEXTURE_3D:
- dim = 3;
- oldTexObj = texUnit->CurrentD[3];
+ targetDim = 3;
+ oldTexObj = texUnit->Current3D;
break;
case GL_TEXTURE_CUBE_MAP_ARB:
- if (ctx->Extensions.HaveTextureCubeMap) {
- dim = 6;
+ if (ctx->Extensions.ARB_texture_cube_map) {
+ targetDim = 6;
oldTexObj = texUnit->CurrentCubeMap;
break;
}
/* fallthrough */
default:
- gl_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
return;
}
if (oldTexObj->Name == texName)
- return;
+ return; /* rebinding the same texture- no change */
+ /*
+ * Get pointer to new texture object (newTexObj)
+ */
if (texName == 0) {
- if (target == GL_TEXTURE_CUBE_MAP_ARB)
- newTexObj = ctx->Shared->DefaultCubeMap;
- else
- newTexObj = ctx->Shared->DefaultD[dim];
+ /* newTexObj = a default texture object */
+ switch (target) {
+ case GL_TEXTURE_1D:
+ newTexObj = ctx->Shared->Default1D;
+ break;
+ case GL_TEXTURE_2D:
+ newTexObj = ctx->Shared->Default2D;
+ break;
+ case GL_TEXTURE_3D:
+ newTexObj = ctx->Shared->Default3D;
+ break;
+ case GL_TEXTURE_CUBE_MAP_ARB:
+ newTexObj = ctx->Shared->DefaultCubeMap;
+ break;
+ default:
+ ; /* Bad targets are caught above */
+ }
}
else {
- struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
+ /* non-default texture object */
+ const struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
newTexObj = (struct gl_texture_object *) _mesa_HashLookup(hash, texName);
-
- if (!newTexObj)
- newTexObj = gl_alloc_texture_object(ctx->Shared, texName, dim);
-
- if (newTexObj->Dimensions != dim) {
- if (newTexObj->Dimensions) {
+ if (newTexObj) {
+ /* error checking */
+ if (newTexObj->Dimensions > 0 && newTexObj->Dimensions != targetDim) {
/* the named texture object's dimensions don't match the target */
- gl_error( ctx, GL_INVALID_OPERATION, "glBindTexture" );
- return;
- }
- newTexObj->Dimensions = dim;
+ _mesa_error( ctx, GL_INVALID_OPERATION, "glBindTexture" );
+ return;
+ }
+ }
+ else {
+ /* if this is a new texture id, allocate a texture object now */
+ newTexObj = _mesa_alloc_texture_object( ctx->Shared, texName,
+ targetDim);
+ if (!newTexObj) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindTexture");
+ return;
+ }
}
+ newTexObj->Dimensions = targetDim;
}
newTexObj->RefCount++;
+
+ /* do the actual binding, but first flush outstanding vertices:
+ */
+ FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+
switch (target) {
case GL_TEXTURE_1D:
- texUnit->CurrentD[1] = newTexObj;
+ texUnit->Current1D = newTexObj;
break;
case GL_TEXTURE_2D:
- texUnit->CurrentD[2] = newTexObj;
+ texUnit->Current2D = newTexObj;
break;
case GL_TEXTURE_3D:
- texUnit->CurrentD[3] = newTexObj;
+ texUnit->Current3D = newTexObj;
break;
case GL_TEXTURE_CUBE_MAP_ARB:
texUnit->CurrentCubeMap = newTexObj;
break;
default:
- gl_problem(ctx, "bad target in BindTexture");
+ _mesa_problem(ctx, "bad target in BindTexture");
}
- /* If we've changed the CurrentD[123] texture object then update the
- * ctx->Texture.Current pointer to point to the new texture object.
- */
- texUnit->Current = texUnit->CurrentD[texUnit->CurrentDimension];
-
- /* Check if we may have to use a new triangle rasterizer */
- if ((ctx->IndirectTriangles & DD_SW_RASTERIZE) &&
- ( oldTexObj->WrapS != newTexObj->WrapS
- || oldTexObj->WrapT != newTexObj->WrapT
- || oldTexObj->WrapR != newTexObj->WrapR
- || oldTexObj->MinFilter != newTexObj->MinFilter
- || oldTexObj->MagFilter != newTexObj->MagFilter
- || (oldTexObj->Image[0] && newTexObj->Image[0] &&
- (oldTexObj->Image[0]->Format!=newTexObj->Image[0]->Format))))
- {
- ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
- }
-
- if (oldTexObj->Complete != newTexObj->Complete)
- ctx->NewState |= NEW_TEXTURING;
-
/* Pass BindTexture call to device driver */
- if (ctx->Driver.BindTexture) {
+ if (ctx->Driver.BindTexture)
(*ctx->Driver.BindTexture)( ctx, target, newTexObj );
- }
if (oldTexObj->Name > 0) {
/* never delete default (id=0) texture objects */
if (ctx->Driver.DeleteTexture) {
(*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
}
- gl_free_texture_object(ctx->Shared, oldTexObj);
+ _mesa_free_texture_object(ctx->Shared, oldTexObj);
}
}
}
{
GET_CURRENT_CONTEXT(ctx);
GLint i;
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPrioritizeTextures");
if (n < 0) {
- gl_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
+ _mesa_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
return;
}
+ if (!priorities)
+ return;
+
for (i = 0; i < n; i++) {
if (texName[i] > 0) {
struct gl_texture_object *t = (struct gl_texture_object *)
}
}
}
+
+ ctx->NewState |= _NEW_TEXTURE;
}
/*
- * Execute glAreTexturesResident
+ * Execute glAreTexturesResident
*/
GLboolean
-_mesa_AreTexturesResident( GLsizei n, const GLuint *texName,
- GLboolean *residences )
+_mesa_AreTexturesResident(GLsizei n, const GLuint *texName,
+ GLboolean *residences)
{
GET_CURRENT_CONTEXT(ctx);
- GLboolean resident = GL_TRUE;
+ GLboolean allResident = GL_TRUE;
GLint i;
+ ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx,
- "glAreTexturesResident",
- GL_FALSE);
- if (n<0) {
- gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)" );
+ if (n < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)");
return GL_FALSE;
}
- for (i=0;i<n;i++) {
+ if (!texName || !residences)
+ return GL_FALSE;
+
+ for (i = 0; i < n; i++) {
struct gl_texture_object *t;
- if (texName[i]==0) {
- gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)" );
+ if (texName[i] == 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
return GL_FALSE;
}
t = (struct gl_texture_object *)
_mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
if (t) {
- if (ctx->Driver.IsTextureResident)
- residences[i] = ctx->Driver.IsTextureResident( ctx, t );
- else
+ if (ctx->Driver.IsTextureResident) {
+ residences[i] = ctx->Driver.IsTextureResident(ctx, t);
+ if (!residences[i])
+ allResident = GL_FALSE;
+ }
+ else {
residences[i] = GL_TRUE;
+ }
}
else {
- gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)" );
+ _mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
return GL_FALSE;
}
}
- return resident;
+ return allResident;
}
_mesa_IsTexture( GLuint texture )
{
GET_CURRENT_CONTEXT(ctx);
- ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glIsTextures",
- GL_FALSE);
- if (texture>0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture)) {
- return GL_TRUE;
- }
- else {
- return GL_FALSE;
- }
+ ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+ return texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture);
}
-
projects / mesa.git / blobdiff