/*
* Mesa 3-D graphics library
- * Version: 6.1
+ * Version: 6.5
*
- * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2006 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"),
#include "colortab.h"
#include "context.h"
#include "enums.h"
+#include "fbobject.h"
#include "hash.h"
#include "imports.h"
#include "macros.h"
#include "mtypes.h"
+#ifdef __VMS
+#define _mesa_sprintf sprintf
+#endif
+
/**********************************************************************/
/** \name Internal functions */
/*@{*/
+
+/**
+ * Return the gl_texture_object for a given ID.
+ */
+struct gl_texture_object *
+_mesa_lookup_texture(GLcontext *ctx, GLuint id)
+{
+ return (struct gl_texture_object *)
+ _mesa_HashLookup(ctx->Shared->TexObjects, id);
+}
+
+
+
/**
* Allocate and initialize a new texture object. But don't put it into the
* texture object hash table.
_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
_mesa_delete_texture_object( GLcontext *ctx, struct gl_texture_object *texObj )
{
- GLuint i;
+ GLuint i, face;
(void) ctx;
- assert(texObj);
-
_mesa_free_colortable_data(&texObj->Palette);
/* free the texture images */
- for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
- if (texObj->Image[i]) {
- _mesa_delete_texture_image( texObj->Image[i] );
+ for (face = 0; face < 6; face++) {
+ for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
+ if (texObj->Image[face][i]) {
+ _mesa_delete_texture_image( ctx, texObj->Image[face][i] );
+ }
}
}
}
-/**
- * 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.
dest->GenerateMipmap = src->GenerateMipmap;
dest->Palette = src->Palette;
dest->Complete = src->Complete;
- dest->_IsPowerOfTwo = src->_IsPowerOfTwo;
}
GLint maxLog2 = 0, maxLevels = 0;
t->Complete = GL_TRUE; /* be optimistic */
- t->_IsPowerOfTwo = GL_TRUE; /* may be set FALSE below */
/* Always need the base level image */
- if (!t->Image[baseLevel]) {
+ if (!t->Image[0][baseLevel]) {
char s[100];
- sprintf(s, "obj %p (%d) Image[baseLevel=%d] == NULL",
+ _mesa_sprintf(s, "obj %p (%d) Image[baseLevel=%d] == NULL",
(void *) t, t->Name, baseLevel);
incomplete(t, s);
t->Complete = GL_FALSE;
}
/* Check width/height/depth for zero */
- if (t->Image[baseLevel]->Width == 0 ||
- t->Image[baseLevel]->Height == 0 ||
- t->Image[baseLevel]->Depth == 0) {
+ if (t->Image[0][baseLevel]->Width == 0 ||
+ t->Image[0][baseLevel]->Height == 0 ||
+ t->Image[0][baseLevel]->Depth == 0) {
incomplete(t, "texture width = 0");
t->Complete = GL_FALSE;
return;
/* Compute _MaxLevel */
if (t->Target == GL_TEXTURE_1D) {
- maxLog2 = t->Image[baseLevel]->WidthLog2;
+ maxLog2 = t->Image[0][baseLevel]->WidthLog2;
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_2D) {
- maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
- t->Image[baseLevel]->HeightLog2);
+ maxLog2 = MAX2(t->Image[0][baseLevel]->WidthLog2,
+ t->Image[0][baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_3D) {
- GLint max = MAX2(t->Image[baseLevel]->WidthLog2,
- t->Image[baseLevel]->HeightLog2);
- maxLog2 = MAX2(max, (GLint)(t->Image[baseLevel]->DepthLog2));
+ GLint max = MAX2(t->Image[0][baseLevel]->WidthLog2,
+ t->Image[0][baseLevel]->HeightLog2);
+ maxLog2 = MAX2(max, (GLint)(t->Image[0][baseLevel]->DepthLog2));
maxLevels = ctx->Const.Max3DTextureLevels;
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
- maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
- t->Image[baseLevel]->HeightLog2);
+ maxLog2 = MAX2(t->Image[0][baseLevel]->WidthLog2,
+ t->Image[0][baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* 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->PosY[baseLevel] ||
- t->PosY[baseLevel]->Width2 != w ||
- t->PosY[baseLevel]->Height2 != h ||
- !t->NegY[baseLevel] ||
- t->NegY[baseLevel]->Width2 != w ||
- t->NegY[baseLevel]->Height2 != h ||
- !t->PosZ[baseLevel] ||
- t->PosZ[baseLevel]->Width2 != w ||
- t->PosZ[baseLevel]->Height2 != h ||
- !t->NegZ[baseLevel] ||
- t->NegZ[baseLevel]->Width2 != w ||
- t->NegZ[baseLevel]->Height2 != h) {
- t->Complete = GL_FALSE;
- incomplete(t, "Non-quare cubemap image");
- return;
+ const GLuint w = t->Image[0][baseLevel]->Width2;
+ const GLuint h = t->Image[0][baseLevel]->Height2;
+ GLuint face;
+ for (face = 1; face < 6; face++) {
+ if (t->Image[face][baseLevel] == NULL ||
+ t->Image[face][baseLevel]->Width2 != w ||
+ t->Image[face][baseLevel]->Height2 != h) {
+ t->Complete = GL_FALSE;
+ incomplete(t, "Non-quare cubemap image");
+ return;
+ }
}
}
- /* check for non power of two */
- if (!t->Image[baseLevel]->_IsPowerOfTwo) {
- t->_IsPowerOfTwo = GL_FALSE;
- }
-
/* extra checking for mipmaps */
if (t->MinFilter != GL_NEAREST && t->MinFilter != GL_LINEAR) {
/*
/* Test dimension-independent attributes */
for (i = minLevel; i <= maxLevel; i++) {
- if (t->Image[i]) {
- if (t->Image[i]->TexFormat != t->Image[baseLevel]->TexFormat) {
+ if (t->Image[0][i]) {
+ if (t->Image[0][i]->TexFormat != t->Image[0][baseLevel]->TexFormat) {
t->Complete = GL_FALSE;
incomplete(t, "Format[i] != Format[baseLevel]");
return;
}
- if (t->Image[i]->Border != t->Image[baseLevel]->Border) {
+ if (t->Image[0][i]->Border != t->Image[0][baseLevel]->Border) {
t->Complete = GL_FALSE;
incomplete(t, "Border[i] != Border[baseLevel]");
return;
/* Test things which depend on number of texture image dimensions */
if (t->Target == GL_TEXTURE_1D) {
/* Test 1-D mipmaps */
- GLuint width = t->Image[baseLevel]->Width2;
+ GLuint width = t->Image[0][baseLevel]->Width2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (i >= minLevel && i <= maxLevel) {
- if (!t->Image[i]) {
+ if (!t->Image[0][i]) {
t->Complete = GL_FALSE;
- incomplete(t, "1D Image[i] == NULL");
+ incomplete(t, "1D Image[0][i] == NULL");
return;
}
- if (t->Image[i]->Width2 != width ) {
+ if (t->Image[0][i]->Width2 != width ) {
t->Complete = GL_FALSE;
- incomplete(t, "1D Image[i] bad width");
+ incomplete(t, "1D Image[0][i] bad width");
return;
}
}
}
else if (t->Target == GL_TEXTURE_2D) {
/* Test 2-D mipmaps */
- GLuint width = t->Image[baseLevel]->Width2;
- GLuint height = t->Image[baseLevel]->Height2;
+ GLuint width = t->Image[0][baseLevel]->Width2;
+ GLuint height = t->Image[0][baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
- if (!t->Image[i]) {
+ if (!t->Image[0][i]) {
t->Complete = GL_FALSE;
- incomplete(t, "2D Image[i] == NULL");
+ incomplete(t, "2D Image[0][i] == NULL");
return;
}
- if (t->Image[i]->Width2 != width) {
+ if (t->Image[0][i]->Width2 != width) {
t->Complete = GL_FALSE;
- incomplete(t, "2D Image[i] bad width");
+ incomplete(t, "2D Image[0][i] bad width");
return;
}
- if (t->Image[i]->Height2 != height) {
+ if (t->Image[0][i]->Height2 != height) {
t->Complete = GL_FALSE;
- incomplete(t, "2D Image[i] bad height");
+ incomplete(t, "2D Image[0][i] bad height");
return;
}
if (width==1 && height==1) {
}
else if (t->Target == GL_TEXTURE_3D) {
/* Test 3-D mipmaps */
- GLuint width = t->Image[baseLevel]->Width2;
- GLuint height = t->Image[baseLevel]->Height2;
- GLuint depth = t->Image[baseLevel]->Depth2;
+ GLuint width = t->Image[0][baseLevel]->Width2;
+ GLuint height = t->Image[0][baseLevel]->Height2;
+ GLuint depth = t->Image[0][baseLevel]->Depth2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
depth /= 2;
}
if (i >= minLevel && i <= maxLevel) {
- if (!t->Image[i]) {
- incomplete(t, "3D Image[i] == NULL");
+ if (!t->Image[0][i]) {
+ incomplete(t, "3D Image[0][i] == NULL");
t->Complete = GL_FALSE;
return;
}
- if (t->Image[i]->Format == GL_DEPTH_COMPONENT) {
+ if (t->Image[0][i]->_BaseFormat == GL_DEPTH_COMPONENT) {
t->Complete = GL_FALSE;
incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
return;
}
- if (t->Image[i]->Width2 != width) {
+ if (t->Image[0][i]->Width2 != width) {
t->Complete = GL_FALSE;
- incomplete(t, "3D Image[i] bad width");
+ incomplete(t, "3D Image[0][i] bad width");
return;
}
- if (t->Image[i]->Height2 != height) {
+ if (t->Image[0][i]->Height2 != height) {
t->Complete = GL_FALSE;
- incomplete(t, "3D Image[i] bad height");
+ incomplete(t, "3D Image[0][i] bad height");
return;
}
- if (t->Image[i]->Depth2 != depth) {
+ if (t->Image[0][i]->Depth2 != depth) {
t->Complete = GL_FALSE;
- incomplete(t, "3D Image[i] bad depth");
+ incomplete(t, "3D Image[0][i] bad depth");
return;
}
}
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
/* make sure 6 cube faces are consistant */
- GLuint width = t->Image[baseLevel]->Width2;
- GLuint height = t->Image[baseLevel]->Height2;
+ GLuint width = t->Image[0][baseLevel]->Width2;
+ GLuint height = t->Image[0][baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
- /* check that we have images defined */
- if (!t->Image[i] || !t->NegX[i] ||
- !t->PosY[i] || !t->NegY[i] ||
- !t->PosZ[i] || !t->NegZ[i]) {
- t->Complete = GL_FALSE;
- incomplete(t, "CubeMap Image[i] == NULL");
- return;
- }
- /* Don't support GL_DEPTH_COMPONENT for cube maps */
- if (t->Image[i]->Format == GL_DEPTH_COMPONENT) {
- t->Complete = GL_FALSE;
- incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
- return;
- }
- /* check that all six images have same size */
- if (t->NegX[i]->Width2!=width || t->NegX[i]->Height2!=height ||
- t->PosY[i]->Width2!=width || t->PosY[i]->Height2!=height ||
- t->NegY[i]->Width2!=width || t->NegY[i]->Height2!=height ||
- 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;
- }
- }
- if (width == 1 && height == 1) {
- return; /* found smallest needed mipmap, all done! */
+ GLuint face;
+ for (face = 0; face < 6; face++) {
+ /* check that we have images defined */
+ if (!t->Image[face][i]) {
+ t->Complete = GL_FALSE;
+ incomplete(t, "CubeMap Image[n][i] == NULL");
+ return;
+ }
+ /* Don't support GL_DEPTH_COMPONENT for cube maps */
+ if (t->Image[face][i]->_BaseFormat == GL_DEPTH_COMPONENT) {
+ t->Complete = GL_FALSE;
+ incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
+ return;
+ }
+ /* check that all six images have same size */
+ if (t->Image[face][i]->Width2!=width ||
+ t->Image[face][i]->Height2!=height) {
+ t->Complete = GL_FALSE;
+ incomplete(t, "CubeMap Image[n][i] bad size");
+ return;
+ }
+ }
+ }
+ if (width == 1 && height == 1) {
+ return; /* found smallest needed mipmap, all done! */
}
}
}
* 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);
}
+
+/**
+ * Check if the given texture object is bound to the current draw or
+ * read framebuffer. If so, Unbind it.
+ */
+static void
+unbind_texobj_from_fbo(GLcontext *ctx, struct gl_texture_object *texObj)
+{
+ const GLuint n = (ctx->DrawBuffer == ctx->ReadBuffer) ? 1 : 2;
+ GLuint i;
+
+ for (i = 0; i < n; i++) {
+ struct gl_framebuffer *fb = (i == 0) ? ctx->DrawBuffer : ctx->ReadBuffer;
+ if (fb->Name) {
+ GLuint j;
+ for (j = 0; j < BUFFER_COUNT; j++) {
+ if (fb->Attachment[j].Type == GL_TEXTURE &&
+ fb->Attachment[j].Texture == texObj) {
+ _mesa_remove_attachment(ctx, fb->Attachment + j);
+ }
+ }
+ }
+ }
+}
+
+
+/**
+ * Check if the given texture object is bound to any texture image units and
+ * unbind it if so.
+ * XXX all RefCount accesses should be protected by a mutex.
+ */
+static void
+unbind_texobj_from_texunits(GLcontext *ctx, struct gl_texture_object *texObj)
+{
+ GLuint u;
+
+ for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) {
+ struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
+ if (texObj == unit->Current1D) {
+ unit->Current1D = ctx->Shared->Default1D;
+ ctx->Shared->Default1D->RefCount++;
+ texObj->RefCount--;
+ if (texObj == unit->_Current)
+ unit->_Current = unit->Current1D;
+ }
+ else if (texObj == unit->Current2D) {
+ unit->Current2D = ctx->Shared->Default2D;
+ ctx->Shared->Default2D->RefCount++;
+ texObj->RefCount--;
+ if (texObj == unit->_Current)
+ unit->_Current = unit->Current2D;
+ }
+ else if (texObj == unit->Current3D) {
+ unit->Current3D = ctx->Shared->Default3D;
+ ctx->Shared->Default3D->RefCount++;
+ texObj->RefCount--;
+ if (texObj == unit->_Current)
+ unit->_Current = unit->Current3D;
+ }
+ else if (texObj == unit->CurrentCubeMap) {
+ unit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
+ ctx->Shared->DefaultCubeMap->RefCount++;
+ texObj->RefCount--;
+ if (texObj == unit->_Current)
+ unit->_Current = unit->CurrentCubeMap;
+ }
+ else if (texObj == unit->CurrentRect) {
+ unit->CurrentRect = ctx->Shared->DefaultRect;
+ ctx->Shared->DefaultRect->RefCount++;
+ texObj->RefCount--;
+ if (texObj == unit->_Current)
+ unit->_Current = unit->CurrentRect;
+ }
+ }
+}
+
+
/**
* 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) {
- struct gl_texture_object *delObj = (struct gl_texture_object *)
- _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
+ for (i = 0; i < n; i++) {
+ if (textures[i] > 0) {
+ struct gl_texture_object *delObj
+ = _mesa_lookup_texture(ctx, textures[i]);
+
if (delObj) {
- /* First check if this texture is currently bound.
+ GLboolean deleted;
+
+ _mesa_lock_texture(ctx, delObj);
+
+ /* Check if texture is bound to any framebuffer objects.
+ * If so, unbind.
+ * See section 4.4.2.3 of GL_EXT_framebuffer_object.
+ */
+ unbind_texobj_from_fbo(ctx, delObj);
+
+ /* Check if this texture is currently bound to any texture units.
* If so, unbind it and decrement the reference count.
*/
- GLuint u;
- for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) {
- struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
- if (delObj == unit->Current1D) {
- unit->Current1D = ctx->Shared->Default1D;
- ctx->Shared->Default1D->RefCount++;
- delObj->RefCount--;
- if (delObj == unit->_Current)
- unit->_Current = unit->Current1D;
- }
- else if (delObj == unit->Current2D) {
- unit->Current2D = ctx->Shared->Default2D;
- ctx->Shared->Default2D->RefCount++;
- delObj->RefCount--;
- if (delObj == unit->_Current)
- unit->_Current = unit->Current2D;
- }
- else if (delObj == unit->Current3D) {
- unit->Current3D = ctx->Shared->Default3D;
- ctx->Shared->Default3D->RefCount++;
- delObj->RefCount--;
- if (delObj == unit->_Current)
- unit->_Current = unit->Current3D;
- }
- else if (delObj == unit->CurrentCubeMap) {
- unit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
- ctx->Shared->DefaultCubeMap->RefCount++;
- delObj->RefCount--;
- if (delObj == unit->_Current)
- unit->_Current = unit->CurrentCubeMap;
- }
- else if (delObj == unit->CurrentRect) {
- unit->CurrentRect = ctx->Shared->DefaultRect;
- ctx->Shared->DefaultRect->RefCount++;
- delObj->RefCount--;
- if (delObj == unit->_Current)
- unit->_Current = unit->CurrentRect;
- }
- }
+ unbind_texobj_from_texunits(ctx, delObj);
+
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);
- if (delObj->RefCount == 0) {
- ASSERT(delObj->Name != 0);
- _mesa_remove_texture_object(ctx, delObj);
+ /* 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--;
+ deleted = (delObj->RefCount == 0);
+ _mesa_unlock_texture(ctx, delObj);
+
+ /* We know that refcount went to zero above, so this is
+ * the only pointer left to delObj, so we don't have to
+ * worry about locking any more:
+ */
+ if (deleted) {
+ 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.
*
_mesa_BindTexture( GLenum target, GLuint texName )
{
GET_CURRENT_CONTEXT(ctx);
- GLuint unit = ctx->Texture.CurrentUnit;
+ const 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;
return;
}
- if (oldTexObj->Name == texName)
+ 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.
+ * Note that some applications re-bind the same texture a lot so we
+ * want to handle that case quickly.
+ */
return; /* rebinding the same texture- no change */
+ }
/*
* Get pointer to new texture object (newTexObj)
}
else {
/* non-default texture object */
- const struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
- newTexObj = (struct gl_texture_object *) _mesa_HashLookup(hash, texName);
+ newTexObj = _mesa_lookup_texture(ctx, texName);
if (newTexObj) {
/* error checking */
if (newTexObj->Target != 0 && newTexObj->Target != target) {
newTexObj->WrapT = GL_CLAMP_TO_EDGE;
newTexObj->WrapR = GL_CLAMP_TO_EDGE;
newTexObj->MinFilter = GL_LINEAR;
+ if (ctx->Driver.TexParameter) {
+ static const GLfloat fparam_wrap[1] = {(GLfloat) GL_CLAMP_TO_EDGE};
+ static const GLfloat fparam_filter[1] = {(GLfloat) GL_LINEAR};
+ (*ctx->Driver.TexParameter)( ctx, target, newTexObj, GL_TEXTURE_WRAP_S, fparam_wrap );
+ (*ctx->Driver.TexParameter)( ctx, target, newTexObj, GL_TEXTURE_WRAP_T, fparam_wrap );
+ (*ctx->Driver.TexParameter)( ctx, target, newTexObj, GL_TEXTURE_WRAP_R, fparam_wrap );
+ (*ctx->Driver.TexParameter)( ctx, target, newTexObj, GL_TEXTURE_MIN_FILTER, fparam_filter );
+ }
}
}
else {
_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.
*
for (i = 0; i < n; i++) {
if (texName[i] > 0) {
- struct gl_texture_object *t = (struct gl_texture_object *)
- _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
+ struct gl_texture_object *t = _mesa_lookup_texture(ctx, texName[i]);
if (t) {
t->Priority = CLAMP( priorities[i], 0.0F, 1.0F );
if (ctx->Driver.PrioritizeTexture)
_mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident");
return GL_FALSE;
}
- t = (struct gl_texture_object *)
- _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
+ t = _mesa_lookup_texture(ctx, texName[i]);
if (!t) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident");
return GL_FALSE;
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 = _mesa_lookup_texture(ctx, texture);
+
+ /* IsTexture is true only after object has been bound once. */
+ return t && t->Target;
+}
+
+/* Simplest implementation of texture locking: Grab the a new mutex in
+ * the shared context. Examine the shared context state timestamp and
+ * if there has been a change, set the appropriate bits in
+ * ctx->NewState.
+ *
+ * See also _mesa_lock/unlock_texture in texobj.h
+ */
+void _mesa_lock_context_textures( GLcontext *ctx )
+{
+ _glthread_LOCK_MUTEX(ctx->Shared->TexMutex);
+
+ if (ctx->Shared->TextureStateStamp != ctx->TextureStateTimestamp) {
+ ctx->NewState |= _NEW_TEXTURE;
+ ctx->TextureStateTimestamp = ctx->Shared->TextureStateStamp;
+ }
+}
+
+
+void _mesa_unlock_context_textures( GLcontext *ctx )
+{
+ assert(ctx->Shared->TextureStateStamp == ctx->TextureStateTimestamp);
+ _glthread_UNLOCK_MUTEX(ctx->Shared->TexMutex);
}
/*@}*/
+
+
projects / mesa.git / blobdiff