#include "glheader.h"
#include "colortab.h"
#include "context.h"
#include "enums.h"
#include "hash.h"
#include "imports.h"
#include "macros.h"
#include "teximage.h"
#include "texstate.h"
#include "texobj.h"
#include "mtypes.h"
struct gl_texture_object *
_mesa_alloc_texture_object( struct gl_shared_state *shared,
GLuint name, GLenum target )
{
struct gl_texture_object *obj;
ASSERT(target == 0 ||
target == GL_TEXTURE_1D ||
target == GL_TEXTURE_2D ||
target == GL_TEXTURE_3D ||
target == GL_TEXTURE_CUBE_MAP_ARB ||
target == GL_TEXTURE_RECTANGLE_NV);
obj = CALLOC_STRUCT(gl_texture_object);
if (obj) {
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
obj->Name = name;
obj->Target = target;
obj->Priority = 1.0F;
if (target == GL_TEXTURE_RECTANGLE_NV) {
obj->WrapS = GL_CLAMP_TO_EDGE;
obj->WrapT = GL_CLAMP_TO_EDGE;
obj->WrapR = GL_CLAMP_TO_EDGE;
obj->MinFilter = GL_LINEAR;
}
else {
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->LodBias = 0.0;
obj->MaxLevel = 1000;
obj->MaxAnisotropy = 1.0;
obj->CompareFlag = GL_FALSE;
obj->CompareOperator = GL_TEXTURE_LEQUAL_R_SGIX;
obj->CompareMode = GL_NONE;
obj->CompareFunc = GL_LEQUAL;
obj->DepthMode = GL_LUMINANCE;
obj->ShadowAmbient = 0.0F;
_mesa_init_colortable(&obj->Palette);
if (shared) {
_glthread_LOCK_MUTEX(shared->Mutex);
obj->Next = shared->TexObjectList;
shared->TexObjectList = obj;
_glthread_UNLOCK_MUTEX(shared->Mutex);
}
if (name > 0) {
_mesa_HashInsert(shared->TexObjects, name, obj);
}
}
return obj;
}
void _mesa_free_texture_object( struct gl_shared_state *shared,
struct gl_texture_object *t )
{
struct gl_texture_object *tprev, *tcurr;
assert(t);
if (shared) {
_glthread_LOCK_MUTEX(shared->Mutex);
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;
}
_glthread_UNLOCK_MUTEX(shared->Mutex);
}
if (t->Name) {
_mesa_HashRemove(shared->TexObjects, t->Name);
}
_mesa_free_colortable_data(&t->Palette);
{
GLuint i;
for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
if (t->Image[i]) {
_mesa_free_texture_image( t->Image[i] );
}
}
}
_glthread_DESTROY_MUTEX(t->Mutex);
FREE( t );
}
void
_mesa_copy_texture_object( struct gl_texture_object *dest,
const struct gl_texture_object *src )
{
dest->Name = src->Name;
dest->Priority = src->Priority;
dest->BorderColor[0] = src->BorderColor[0];
dest->BorderColor[1] = src->BorderColor[1];
dest->BorderColor[2] = src->BorderColor[2];
dest->BorderColor[3] = src->BorderColor[3];
dest->WrapS = src->WrapS;
dest->WrapT = src->WrapT;
dest->WrapR = src->WrapR;
dest->MinFilter = src->MinFilter;
dest->MagFilter = src->MagFilter;
dest->MinLod = src->MinLod;
dest->MaxLod = src->MaxLod;
dest->LodBias = src->LodBias;
dest->BaseLevel = src->BaseLevel;
dest->MaxLevel = src->MaxLevel;
dest->MaxAnisotropy = src->MaxAnisotropy;
dest->CompareFlag = src->CompareFlag;
dest->CompareOperator = src->CompareOperator;
dest->ShadowAmbient = src->ShadowAmbient;
dest->CompareMode = src->CompareMode;
dest->CompareFunc = src->CompareFunc;
dest->DepthMode = src->DepthMode;
dest->_MaxLevel = src->_MaxLevel;
dest->_MaxLambda = src->_MaxLambda;
dest->GenerateMipmap = src->GenerateMipmap;
dest->Palette = src->Palette;
dest->Complete = src->Complete;
}
#if 0
static void
incomplete(const struct gl_texture_object *t, const char *why)
{
_mesa_printf("Texture Obj %d incomplete because: %s\n", t->Name, why);
}
#else
#define incomplete(a, b)
#endif
void
_mesa_test_texobj_completeness( const GLcontext *ctx,
struct gl_texture_object *t )
{
const GLint baseLevel = t->BaseLevel;
GLint maxLog2 = 0, maxLevels = 0;
t->Complete = GL_TRUE;
if (!t->Image[baseLevel]) {
incomplete(t, "Image[baseLevel] == NULL");
t->Complete = GL_FALSE;
return;
}
if (t->Target == GL_TEXTURE_1D) {
maxLog2 = t->Image[baseLevel]->WidthLog2;
maxLevels = ctx->Const.MaxTextureLevels;
}
else if (t->Target == GL_TEXTURE_2D) {
maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
t->Image[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));
maxLevels = ctx->Const.Max3DTextureLevels;
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
t->Image[baseLevel]->HeightLog2);
maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
maxLog2 = 0;
maxLevels = 1;
}
else {
_mesa_problem(ctx, "Bad t->Target in _mesa_test_texobj_completeness");
return;
}
ASSERT(maxLevels > 0);
t->_MaxLevel = baseLevel + maxLog2;
t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel);
t->_MaxLevel = MIN2(t->_MaxLevel, maxLevels - 1);
t->_MaxLambda = (GLfloat) (t->_MaxLevel - t->BaseLevel);
if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
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;
}
}
if (t->MinFilter != GL_NEAREST && t->MinFilter != GL_LINEAR) {
GLint i;
GLint minLevel = baseLevel;
GLint maxLevel = t->_MaxLevel;
if (minLevel > maxLevel) {
t->Complete = GL_FALSE;
incomplete(t, "minLevel > maxLevel");
return;
}
for (i = minLevel; i <= maxLevel; i++) {
if (t->Image[i]) {
if (t->Image[i]->TexFormat != t->Image[baseLevel]->TexFormat) {
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 (t->Target == GL_TEXTURE_1D) {
GLuint width = t->Image[baseLevel]->Width2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
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 (width == 1) {
return;
}
}
}
else if (t->Target == GL_TEXTURE_2D) {
GLuint width = t->Image[baseLevel]->Width2;
GLuint height = t->Image[baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
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) {
return;
}
}
}
}
else if (t->Target == GL_TEXTURE_3D) {
GLuint width = t->Image[baseLevel]->Width2;
GLuint height = t->Image[baseLevel]->Height2;
GLuint depth = t->Image[baseLevel]->Depth2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (depth > 1) {
depth /= 2;
}
if (i >= minLevel && i <= maxLevel) {
if (!t->Image[i]) {
incomplete(t, "3D Image[i] == NULL");
t->Complete = GL_FALSE;
return;
}
if (t->Image[i]->Format == 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) {
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;
}
}
if (width == 1 && height == 1 && depth == 1) {
return;
}
}
}
else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
GLuint width = t->Image[baseLevel]->Width2;
GLuint height = t->Image[baseLevel]->Height2;
for (i = baseLevel + 1; i < maxLevels; i++) {
if (width > 1) {
width /= 2;
}
if (height > 1) {
height /= 2;
}
if (i >= minLevel && i <= maxLevel) {
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;
}
if (t->Image[i]->Format == GL_DEPTH_COMPONENT) {
t->Complete = GL_FALSE;
incomplete(t, "GL_DEPTH_COMPONENT only works with 1/2D tex");
return;
}
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;
}
}
}
else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
}
else {
_mesa_problem(ctx, "Bug in gl_test_texture_object_completeness\n");
}
}
}
_glthread_DECLARE_STATIC_MUTEX(GenTexturesLock);
void
_mesa_GenTextures( GLsizei n, GLuint *texName )
{
GET_CURRENT_CONTEXT(ctx);
GLuint first;
GLint i;
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (n < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
return;
}
if (!texName)
return;
_glthread_LOCK_MUTEX(GenTexturesLock);
first = _mesa_HashFindFreeKeyBlock(ctx->Shared->TexObjects, n);
for (i=0;i<n;i++) {
GLuint name = first + i;
GLenum target = 0;
struct gl_texture_object *texObj;
texObj = _mesa_alloc_texture_object( ctx->Shared, name, target);
if (!texObj) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTextures");
break;
}
texName[i] = name;
}
_glthread_UNLOCK_MUTEX(GenTexturesLock);
}
void
_mesa_DeleteTextures( GLsizei n, const GLuint *texName)
{
GET_CURRENT_CONTEXT(ctx);
GLint i;
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (!texName)
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]);
if (delObj) {
GLuint u;
for (u = 0; u < MAX_TEXTURE_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;
}
}
ctx->NewState |= _NEW_TEXTURE;
delObj->RefCount--;
ASSERT(delObj->RefCount >= 0);
if (delObj->RefCount == 0) {
ASSERT(delObj->Name != 0);
if (ctx->Driver.DeleteTexture)
(*ctx->Driver.DeleteTexture)( ctx, delObj );
_mesa_free_texture_object(ctx->Shared, delObj);
}
}
}
}
}
void
_mesa_BindTexture( GLenum target, GLuint texName )
{
GET_CURRENT_CONTEXT(ctx);
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;
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);
switch (target) {
case GL_TEXTURE_1D:
oldTexObj = texUnit->Current1D;
break;
case GL_TEXTURE_2D:
oldTexObj = texUnit->Current2D;
break;
case GL_TEXTURE_3D:
oldTexObj = texUnit->Current3D;
break;
case GL_TEXTURE_CUBE_MAP_ARB:
if (!ctx->Extensions.ARB_texture_cube_map) {
_mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
return;
}
oldTexObj = texUnit->CurrentCubeMap;
break;
case GL_TEXTURE_RECTANGLE_NV:
if (!ctx->Extensions.NV_texture_rectangle) {
_mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
return;
}
oldTexObj = texUnit->CurrentRect;
break;
default:
_mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
return;
}
if (oldTexObj->Name == texName)
return;
if (texName == 0) {
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;
case GL_TEXTURE_RECTANGLE_NV:
newTexObj = ctx->Shared->DefaultRect;
break;
default:
;
}
}
else {
const struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
newTexObj = (struct gl_texture_object *) _mesa_HashLookup(hash, texName);
if (newTexObj) {
if (newTexObj->Target != 0 && newTexObj->Target != target) {
_mesa_error( ctx, GL_INVALID_OPERATION,
"glBindTexture(wrong dimensionality)" );
return;
}
if (newTexObj->Target == 0 && target == GL_TEXTURE_RECTANGLE_NV) {
newTexObj->WrapS = GL_CLAMP_TO_EDGE;
newTexObj->WrapT = GL_CLAMP_TO_EDGE;
newTexObj->WrapR = GL_CLAMP_TO_EDGE;
newTexObj->MinFilter = GL_LINEAR;
}
}
else {
newTexObj = _mesa_alloc_texture_object( ctx->Shared, texName,
target);
if (!newTexObj) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindTexture");
return;
}
}
newTexObj->Target = target;
}
newTexObj->RefCount++;
FLUSH_VERTICES(ctx, _NEW_TEXTURE);
switch (target) {
case GL_TEXTURE_1D:
texUnit->Current1D = newTexObj;
break;
case GL_TEXTURE_2D:
texUnit->Current2D = newTexObj;
break;
case GL_TEXTURE_3D:
texUnit->Current3D = newTexObj;
break;
case GL_TEXTURE_CUBE_MAP_ARB:
texUnit->CurrentCubeMap = newTexObj;
break;
case GL_TEXTURE_RECTANGLE_NV:
texUnit->CurrentRect = newTexObj;
break;
default:
_mesa_problem(ctx, "bad target in BindTexture");
return;
}
if (ctx->Driver.BindTexture)
(*ctx->Driver.BindTexture)( ctx, target, newTexObj );
oldTexObj->RefCount--;
assert(oldTexObj->RefCount >= 0);
if (oldTexObj->RefCount == 0) {
assert(oldTexObj->Name != 0);
if (ctx->Driver.DeleteTexture) {
(*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
}
_mesa_free_texture_object(ctx->Shared, oldTexObj);
}
}
void
_mesa_PrioritizeTextures( GLsizei n, const GLuint *texName,
const GLclampf *priorities )
{
GET_CURRENT_CONTEXT(ctx);
GLint i;
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (n < 0) {
_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 *)
_mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
if (t) {
t->Priority = CLAMP( priorities[i], 0.0F, 1.0F );
if (ctx->Driver.PrioritizeTexture)
ctx->Driver.PrioritizeTexture( ctx, t, t->Priority );
}
}
}
ctx->NewState |= _NEW_TEXTURE;
}
GLboolean
_mesa_AreTexturesResident(GLsizei n, const GLuint *texName,
GLboolean *residences)
{
GET_CURRENT_CONTEXT(ctx);
GLboolean allResident = GL_TRUE;
GLint i, j;
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
if (n < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)");
return GL_FALSE;
}
if (!texName || !residences)
return GL_FALSE;
for (i = 0; i < n; i++) {
struct gl_texture_object *t;
if (texName[i] == 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident");
return GL_FALSE;
}
t = (struct gl_texture_object *)
_mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
if (!t) {
_mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident");
return GL_FALSE;
}
if (!ctx->Driver.IsTextureResident ||
ctx->Driver.IsTextureResident(ctx, t)) {
if (!allResident)
residences[i] = GL_TRUE;
}
else {
if (allResident) {
allResident = GL_FALSE;
for (j = 0; j < i; j++)
residences[j] = GL_TRUE;
}
residences[i] = GL_FALSE;
}
}
return allResident;
}
GLboolean
_mesa_IsTexture( GLuint texture )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
return texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture);
}