texobj.h File Reference

#include "types.h"

Include dependency graph for texobj.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
struct gl_texture_object *	gl_alloc_texture_object (struct gl_shared_state *shared, GLuint name, GLuint dimensions)
void	gl_free_texture_object (struct gl_shared_state *shared, struct gl_texture_object *t)
void	gl_test_texture_object_completeness (struct gl_texture_object *t)
void	gl_GenTextures (GLcontext *ctx, GLsizei n, GLuint *textures)
void	gl_DeleteTextures (GLcontext *ctx, GLsizei n, const GLuint *textures)
void	gl_BindTexture (GLcontext *ctx, GLenum target, GLuint texture)
void	gl_PrioritizeTextures (GLcontext *ctx, GLsizei n, const GLuint *textures, const GLclampf *priorities)
GLboolean	gl_AreTexturesResident (GLcontext *ctx, GLsizei n, const GLuint *textures, GLboolean *residences)
GLboolean	gl_IsTexture (GLcontext *ctx, GLuint texture)

Function Documentation

gl_alloc_texture_object()

struct gl_texture_object * gl_alloc_texture_object	(	struct gl_shared_state *	shared,
		GLuint	name,
		GLuint	dimensions
	)

Definition at line 118 of file texobj.c.

{
   struct gl_texture_object *obj;
 
   assert(dimensions >= 0 && dimensions <= 2);
 
   obj = (struct gl_texture_object *)
                     calloc(1,sizeof(struct gl_texture_object));
   if (obj) {
      /* init the non-zero fields */
      obj->Name = name;
      obj->Dimensions = dimensions;
      obj->WrapS = GL_REPEAT;
      obj->WrapT = GL_REPEAT;
      obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
      obj->MagFilter = GL_LINEAR;
      obj->MinMagThresh = 0.0F;
      obj->Palette[0] = 255;
      obj->Palette[1] = 255;
      obj->Palette[2] = 255;
      obj->Palette[3] = 255;
      obj->PaletteSize = 1;
      obj->PaletteIntFormat = GL_RGBA;
      obj->PaletteFormat = GL_RGBA;
 
      /* insert into linked list */
      if (shared) {
         obj->Next = shared->TexObjectList;
         shared->TexObjectList = obj;
      }
 
      if (name > 0) {
         /* insert into hash table */
         HashInsert(shared->TexObjects, name, obj);
      }
   }
   return obj;
}

Referenced by alloc_proxy_textures(), alloc_shared_state(), gl_BindTexture(), and gl_GenTextures().

gl_AreTexturesResident()

GLboolean gl_AreTexturesResident	(	GLcontext *	ctx,
		GLsizei	n,
		const GLuint *	textures,
		GLboolean *	residences
	)

Definition at line 543 of file texobj.c.

{
   GLboolean resident = GL_TRUE;
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glAreTexturesResident" );
      return GL_FALSE;
   }
   if (n<0) {
      gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)" );
      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)" );
         return GL_FALSE;
      }
      t = (struct gl_texture_object *)
         HashLookup(ctx->Shared->TexObjects, texName[i]);
      if (t) {
         /* we consider all valid texture objects to be resident */
         residences[i] = GL_TRUE;
      }
      else {
         gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)" );
         return GL_FALSE;
      }
   }
   return resident;
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_BindTexture()

void gl_BindTexture	(	GLcontext *	ctx,
		GLenum	target,
		GLuint	texture
	)

Definition at line 402 of file texobj.c.

{
   struct gl_texture_object *oldTexObj;
   struct gl_texture_object *newTexObj;
   struct gl_texture_object **targetPointer;
   GLuint targetDimensions;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glAreTexturesResident" );
      return;
   }
   switch (target) {
      case GL_TEXTURE_1D:
         oldTexObj = ctx->Texture.Current1D;
         targetPointer = &ctx->Texture.Current1D;
         targetDimensions = 1;
         break;
      case GL_TEXTURE_2D:
         oldTexObj = ctx->Texture.Current2D;
         targetPointer = &ctx->Texture.Current2D;
         targetDimensions = 2;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glBindTexture" );
         return;
   }
 
   if (texName==0) {
      /* use default n-D texture */
      switch (target) {
         case GL_TEXTURE_1D:
            newTexObj = ctx->Shared->Default1D;
            break;
         case GL_TEXTURE_2D:
            newTexObj = ctx->Shared->Default2D;
            break;
         default:
            gl_problem(ctx, "Bad target in gl_BindTexture");
            return;
      }
   }
   else {
      newTexObj = (struct gl_texture_object *)
                             HashLookup(ctx->Shared->TexObjects, texName);
      if (newTexObj) {
         if (newTexObj->Dimensions == 0) {
            /* first time bound */
            newTexObj->Dimensions = targetDimensions;
         }
         else if (newTexObj->Dimensions != targetDimensions) {
            /* wrong dimensionality */
            gl_error( ctx, GL_INVALID_OPERATION, "glBindTextureEXT" );
            return;
         }
      }
      else {
         /* create new texture object */
         newTexObj = gl_alloc_texture_object(ctx->Shared, texName,
                                             targetDimensions);
      }
   }
 
   /* Update the Texture.Current[123]D pointer */
   *targetPointer = newTexObj;
 
   /* Tidy up reference counting */
   if (*targetPointer != oldTexObj && oldTexObj->Name>0) {
      /* decrement reference count of the prev texture object */
      oldTexObj->RefCount--;
      assert( oldTexObj->RefCount >= 0 );
   }
 
   if (newTexObj->Name>0) {
      newTexObj->RefCount++;
   }
 
   /* Check if we may have to use a new triangle rasterizer */
   if (   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))
       || !newTexObj->Complete) {
      ctx->NewState |= NEW_RASTER_OPS;
   }
 
   /* If we've changed the Current[123]D texture object then update the
    * ctx->Texture.Current pointer to point to the new texture object.
    */
   if (oldTexObj==ctx->Texture.Current) {
      ctx->Texture.Current = newTexObj;
   }
 
   /* The current n-D texture object can never be NULL! */
   assert(*targetPointer);
 
   /* Pass BindTexture call to device driver */
   if (ctx->Driver.BindTexture) {
      (*ctx->Driver.BindTexture)( ctx, target, newTexObj );
   }
}

Referenced by execute_list(), and init_exec_pointers().

gl_DeleteTextures()

void gl_DeleteTextures	(	GLcontext *	ctx,
		GLsizei	n,
		const GLuint *	textures
	)

Definition at line 356 of file texobj.c.

{
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glAreTexturesResident" );
      return;
   }
 
   for (i=0;i<n;i++) {
      struct gl_texture_object *t;
      if (texName[i]>0) {
         t = (struct gl_texture_object *)
            HashLookup(ctx->Shared->TexObjects, texName[i]);
         if (t) {
            if (ctx->Texture.Current1D==t) {
               /* revert to default 1-D texture */
               ctx->Texture.Current1D = ctx->Shared->Default1D;
               t->RefCount--;
               assert( t->RefCount >= 0 );
            }
            else if (ctx->Texture.Current2D==t) {
               /* revert to default 2-D texture */
               ctx->Texture.Current2D = ctx->Shared->Default2D;
               t->RefCount--;
               assert( t->RefCount >= 0 );
            }
 
            /* tell device driver to delete texture */
            if (ctx->Driver.DeleteTexture) {
               (*ctx->Driver.DeleteTexture)( ctx, t );
            }
 
            if (t->RefCount==0) {
               gl_free_texture_object(ctx->Shared, t);
            }
         }
      }
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_free_texture_object()

void gl_free_texture_object	(	struct gl_shared_state *	shared,
		struct gl_texture_object *	t
	)

Definition at line 165 of file texobj.c.

{
   struct gl_texture_object *tprev, *tcurr;
 
   assert(t);
 
   /* unlink t from the linked list */
   if (shared) {
      tprev = NULL;
      tcurr = shared->TexObjectList;
      while (tcurr) {
         if (tcurr==t) {
            if (tprev) {
               tprev->Next = t->Next;
            }
            else {
               shared->TexObjectList = t->Next;
            }
            break;
         }
         tprev = tcurr;
         tcurr = tcurr->Next;
      }
   }
 
   if (t->Name) {
      /* remove from hash table */
      HashRemove(shared->TexObjects, t->Name);
   }
 
   /* free texture image */
   {
      GLuint i;
      for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
         if (t->Image[i]) {
            gl_free_texture_image( t->Image[i] );
         }
      }
   }
   /* free this object */
   free( t );
}

Referenced by alloc_proxy_textures(), alloc_shared_state(), free_shared_state(), gl_DeleteTextures(), and gl_destroy_context().

gl_GenTextures()

void gl_GenTextures	(	GLcontext *	ctx,
		GLsizei	n,
		GLuint *	textures
	)

Definition at line 322 of file texobj.c.

{
   GLuint first, i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGenTextures" );
      return;
   }
   if (n<0) {
      gl_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
      return;
   }
 
   first = HashFindFreeKeyBlock(ctx->Shared->TexObjects, n);
 
   /* Return the texture names */
   for (i=0;i<n;i++) {
      texName[i] = first + i;
   }
 
   /* Allocate new, empty texture objects */
   for (i=0;i<n;i++) {
      GLuint name = first + i;
      GLuint dims = 0;
      struct gl_texture_object *newTexObj = gl_alloc_texture_object(ctx->Shared, name, dims);
      (void)newTexObj;
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_IsTexture()

GLboolean gl_IsTexture	(	GLcontext *	ctx,
		GLuint	texture
	)

Definition at line 584 of file texobj.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glIsTextures" );
      return GL_FALSE;
   }
   if (texture>0 && HashLookup(ctx->Shared->TexObjects, texture)) {
      return GL_TRUE;
   }
   else {
      return GL_FALSE;
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_PrioritizeTextures()

void gl_PrioritizeTextures	(	GLcontext *	ctx,
		GLsizei	n,
		const GLuint *	textures,
		const GLclampf *	priorities
	)

Definition at line 511 of file texobj.c.

{
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glAreTexturesResident" );
      return;
   }
   if (n<0) {
      gl_error( ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)" );
      return;
   }
 
   for (i=0;i<n;i++) {
      struct gl_texture_object *t;
      if (texName[i]>0) {
         t = (struct gl_texture_object *)
            HashLookup(ctx->Shared->TexObjects, texName[i]);
         if (t) {
            t->Priority = CLAMP( priorities[i], 0.0F, 1.0F );
         }
      }
   }
}

Referenced by execute_list(), and init_exec_pointers().

gl_test_texture_object_completeness()

void gl_test_texture_object_completeness

(

struct gl_texture_object *

t

)

Definition at line 215 of file texobj.c.

{
   t->Complete = GL_TRUE;  /* be optimistic */
 
   /* Always need level zero image */
   if (!t->Image[0] || !t->Image[0]->Data) {
      t->Complete = GL_FALSE;
      return;
   }
 
   if (t->MinFilter!=GL_NEAREST && t->MinFilter!=GL_LINEAR) {
      /*
       * Mipmapping: determine if we have a complete set of mipmaps
       */
      int i;
 
      /* Test dimension-independent attributes */
      for (i=1; i<MAX_TEXTURE_LEVELS; i++) {
         if (t->Image[i]) {
            if (!t->Image[i]->Data) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Format != t->Image[0]->Format) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Border != t->Image[0]->Border) {
               t->Complete = GL_FALSE;
               return;
            }
         }
      }
 
      /* Test things which depend on number of texture image dimensions */
      if (t->Dimensions==1) {
         /* Test 1-D mipmaps */
         GLuint width = t->Image[0]->Width2;
         for (i=1; i<MAX_TEXTURE_LEVELS; i++) {
            if (width>1) {
               width /= 2;
            }
            if (!t->Image[i]) {
               t->Complete = GL_FALSE;
               return;
            }
            if (!t->Image[i]->Data) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Format != t->Image[0]->Format) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Border != t->Image[0]->Border) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Width2 != width ) {
               t->Complete = GL_FALSE;
               return;
            }
            if (width==1) {
               return;  /* found smallest needed mipmap, all done! */
            }
         }
      }
      else if (t->Dimensions==2) {
         /* Test 2-D mipmaps */
         GLuint width = t->Image[0]->Width2;
         GLuint height = t->Image[0]->Height2;
         for (i=1; i<MAX_TEXTURE_LEVELS; i++) {
            if (width>1) {
               width /= 2;
            }
            if (height>1) {
               height /= 2;
            }
            if (!t->Image[i]) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Width2 != width) {
               t->Complete = GL_FALSE;
               return;
            }
            if (t->Image[i]->Height2 != height) {
               t->Complete = GL_FALSE;
               return;
            }
            if (width==1 && height==1) {
               return;  /* found smallest needed mipmap, all done! */
            }
         }
      }
      else {
         /* Dimensions = ??? */
         gl_problem(NULL, "Bug in gl_test_texture_object_completeness\n");
      }
   }
}

Referenced by gl_update_texture_state().