/*
* Mesa 3-D graphics library
- * Version: 6.1
+ * Version: 6.3
*
- * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2005 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"),
_mesa_new_texture_object( GLcontext *ctx, GLuint name, GLenum target )
{
struct gl_texture_object *obj;
+ (void) ctx;
obj = MALLOC_STRUCT(gl_texture_object);
_mesa_initialize_texture_object(obj, name, target);
return obj;
/**
- * Initialize a texture object to default values.
+ * Initialize a new texture object to default values.
* \param obj the texture object
* \param name the texture name
* \param target the texture target
target == GL_TEXTURE_CUBE_MAP_ARB ||
target == GL_TEXTURE_RECTANGLE_NV);
+ _mesa_bzero(obj, sizeof(*obj));
/* init the non-zero fields */
_glthread_INIT_MUTEX(obj->Mutex);
- _mesa_bzero(obj, sizeof(*obj));
obj->RefCount = 1;
obj->Name = name;
obj->Target = target;
(void) ctx;
- assert(texObj);
-
_mesa_free_colortable_data(&texObj->Palette);
/* free the texture images */
}
-/**
- * Add the given texture object to the texture object pool.
- */
-void
-_mesa_save_texture_object( GLcontext *ctx, struct gl_texture_object *texObj )
-{
- /* insert into linked list */
- _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
- texObj->Next = ctx->Shared->TexObjectList;
- ctx->Shared->TexObjectList = texObj;
- _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-
- if (texObj->Name > 0) {
- /* insert into hash table */
- _mesa_HashInsert(ctx->Shared->TexObjects, texObj->Name, texObj);
- }
-}
-
-
-/**
- * Remove the given texture object from the texture object pool.
- * Do not deallocate the texture object though.
- */
-void
-_mesa_remove_texture_object( GLcontext *ctx, struct gl_texture_object *texObj )
-{
- struct gl_texture_object *tprev, *tcurr;
-
- _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
- /* unlink from the linked list */
- tprev = NULL;
- tcurr = ctx->Shared->TexObjectList;
- while (tcurr) {
- if (tcurr == texObj) {
- if (tprev) {
- tprev->Next = texObj->Next;
- }
- else {
- ctx->Shared->TexObjectList = texObj->Next;
- }
- break;
- }
- tprev = tcurr;
- tcurr = tcurr->Next;
- }
-
- _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
- if (texObj->Name > 0) {
- /* remove from hash table */
- _mesa_HashRemove(ctx->Shared->TexObjects, texObj->Name);
- }
-}
/**
* Copy texture object state from one texture object to another.
+ * Use for glPush/PopAttrib.
*
* \param dest destination texture object.
* \param src source texture object.
* Generate texture names.
*
* \param n number of texture names to be generated.
- * \param texName an array in which will hold the generated texture names.
+ * \param textures an array in which will hold the generated texture names.
*
* \sa glGenTextures().
*
* While holding the GenTexturesLock lock, calls _mesa_HashFindFreeKeyBlock()
- * to find a block of free texture IDs which are stored in \p texName.
+ * to find a block of free texture IDs which are stored in \p textures.
* Corresponding empty texture objects are also generated.
*/
void GLAPIENTRY
-_mesa_GenTextures( GLsizei n, GLuint *texName )
+_mesa_GenTextures( GLsizei n, GLuint *textures )
{
GET_CURRENT_CONTEXT(ctx);
GLuint first;
return;
}
- if (!texName)
+ if (!textures)
return;
/*
GLenum target = 0;
texObj = (*ctx->Driver.NewTextureObject)( ctx, name, target);
if (!texObj) {
+ _glthread_UNLOCK_MUTEX(GenTexturesLock);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTextures");
return;
}
- _mesa_save_texture_object(ctx, texObj);
- texName[i] = name;
+
+ /* insert into hash table */
+ _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+ _mesa_HashInsert(ctx->Shared->TexObjects, texObj->Name, texObj);
+ _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+
+ textures[i] = name;
}
_glthread_UNLOCK_MUTEX(GenTexturesLock);
}
+
/**
* Delete named textures.
*
* \param n number of textures to be deleted.
- * \param texName array of textures names to be deleted.
+ * \param textures array of texture IDs to be deleted.
*
* \sa glDeleteTextures().
*
- * For each texture checks if its bound to any of the texture units, unbinding
- * it and decrementing the reference count if so. If the texture reference
- * count is zero, delete its object.
+ * If we're about to delete a texture that's currently bound to any
+ * texture unit, unbind the texture first. Decrement the reference
+ * count on the texture object and delete it if it's zero.
+ * Recall that texture objects can be shared among several rendering
+ * contexts.
*/
void GLAPIENTRY
-_mesa_DeleteTextures( GLsizei n, const GLuint *texName)
+_mesa_DeleteTextures( GLsizei n, const GLuint *textures)
{
GET_CURRENT_CONTEXT(ctx);
GLint i;
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
- if (!texName)
+ if (!textures)
return;
- for (i=0;i<n;i++) {
- if (texName[i] > 0) {
+ for (i = 0; i < n; i++) {
+ if (textures[i] > 0) {
struct gl_texture_object *delObj = (struct gl_texture_object *)
- _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
+ _mesa_HashLookup(ctx->Shared->TexObjects, textures[i]);
if (delObj) {
/* First check if this texture is currently bound.
* If so, unbind it and decrement the reference count.
+ * XXX all RefCount accesses should be protected by a mutex.
*/
GLuint u;
for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) {
}
ctx->NewState |= _NEW_TEXTURE;
- /* Decrement reference count and delete if zero */
- delObj->RefCount--;
- ASSERT(delObj->RefCount >= 0);
+ /* The texture _name_ is now free for re-use.
+ * Remove it from the hash table now.
+ */
+ _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+ _mesa_HashRemove(ctx->Shared->TexObjects, delObj->Name);
+ _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+ /* The actual texture object will not be freed until it's no
+ * longer bound in any context.
+ * XXX all RefCount accesses should be protected by a mutex.
+ */
+ delObj->RefCount--;
if (delObj->RefCount == 0) {
- ASSERT(delObj->Name != 0);
- _mesa_remove_texture_object(ctx, delObj);
+ ASSERT(delObj->Name != 0); /* Never delete default tex objs */
ASSERT(ctx->Driver.DeleteTexture);
(*ctx->Driver.DeleteTexture)(ctx, delObj);
}
}
}
+
/**
* Bind a named texture to a texturing target.
*
GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
struct gl_texture_object *oldTexObj;
- struct gl_texture_object *newTexObj = 0;
+ struct gl_texture_object *newTexObj = NULL;
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
_mesa_debug(ctx, "glBindTexture %s %d\n",
_mesa_lookup_enum_by_nr(target), (GLint) texName);
+ /*
+ * Get pointer to currently bound texture object (oldTexObj)
+ */
switch (target) {
case GL_TEXTURE_1D:
oldTexObj = texUnit->Current1D;
}
if (oldTexObj->Name == texName)
+ /* XXX this might be wrong. If the texobj is in use by another
+ * context and a texobj parameter was changed, this might be our
+ * only chance to update this context's hardware state.
+ */
return; /* rebinding the same texture- no change */
/*
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindTexture");
return;
}
- _mesa_save_texture_object(ctx, newTexObj);
+
+ /* and insert it into hash table */
+ _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+ _mesa_HashInsert(ctx->Shared->TexObjects, texName, newTexObj);
+ _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
}
newTexObj->Target = target;
}
+ /* XXX all RefCount accesses should be protected by a mutex. */
newTexObj->RefCount++;
/* do the actual binding, but first flush outstanding vertices:
if (ctx->Driver.BindTexture)
(*ctx->Driver.BindTexture)( ctx, target, newTexObj );
+ /* Decrement the reference count on the old texture and check if it's
+ * time to delete it.
+ */
+ /* XXX all RefCount accesses should be protected by a mutex. */
oldTexObj->RefCount--;
- assert(oldTexObj->RefCount >= 0);
+ ASSERT(oldTexObj->RefCount >= 0);
if (oldTexObj->RefCount == 0) {
- assert(oldTexObj->Name != 0);
- _mesa_remove_texture_object(ctx, oldTexObj);
+ ASSERT(oldTexObj->Name != 0);
ASSERT(ctx->Driver.DeleteTexture);
(*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
}
}
+
/**
* Set texture priorities.
*
GLboolean GLAPIENTRY
_mesa_IsTexture( GLuint texture )
{
+ struct gl_texture_object *t;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
- return texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture);
+
+ if (!texture)
+ return GL_FALSE;
+
+ t = (struct gl_texture_object *)
+ _mesa_HashLookup(ctx->Shared->TexObjects, texture);
+
+ /* IsTexture is true only after object has been bound once. */
+ return t && t->Target;
}
/*@}*/