Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-28 10:04:49 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/dll/opengl/mesa/texobj.c
Jérôme Gardou 5f2bebf7a5 [OPENGL32][MESA] Downgrade Mesa library to version 2.6 
With this commit, we now use a forked version of MESA which only supports OpenGL 1.1, like the windows implementation does.
It exposes :
  - The same pixel formats
  - The same set of extensions
  - Nothing more
All of this without taking 10% of your build time.
If you need a more modern option, look at the MESA package from Rapps, which is (and must be) maintained outside of this code tree.
CORE-7499
2019-01-19 14:23:54 +01:00

597 lines
16 KiB
C
Raw Blame History

/* $Id: texobj.c,v 1.21 1998/01/16 01:09:44 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 2.6
* Copyright (C) 1995-1997 Brian Paul
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* $Log: texobj.c,v $
* Revision 1.21 1998/01/16 01:09:44 brianp
* glGenTextures() didn't reserve the returned texture IDs
*
* Revision 1.20 1997/12/07 17:34:05 brianp
* added DavidB's v0.21 fxmesa driver patch
*
* Revision 1.19 1997/11/07 03:38:07 brianp
* added stdio.h include for SunOS 4.x
*
* Revision 1.18 1997/10/13 23:57:59 brianp
* added target parameter to Driver.BindTexture()
*
* Revision 1.17 1997/09/29 23:28:14 brianp
* updated for new device driver texture functions
*
* Revision 1.16 1997/09/27 00:14:39 brianp
* added GL_EXT_paletted_texture extension
*
* Revision 1.15 1997/09/23 00:58:15 brianp
* now using hash table for texture objects
*
* Revision 1.14 1997/08/23 18:41:40 brianp
* fixed bug in glBindTexture() when binding an incomplete texture image
*
* Revision 1.13 1997/08/23 17:14:44 brianp
* fixed bug: glBindTexture(target, 0) caused segfault
*
* Revision 1.12 1997/07/24 01:25:34 brianp
* changed precompiled header symbol from PCH to PC_HEADER
*
* Revision 1.11 1997/05/28 03:26:49 brianp
* added precompiled header (PCH) support
*
* Revision 1.10 1997/05/17 03:41:49 brianp
* added code to update ctx->Texture.Current in gl_BindTexture()
*
* Revision 1.9 1997/05/03 00:52:52 brianp
* removed a few unused variables
*
* Revision 1.8 1997/05/01 02:08:12 brianp
* new implementation of gl_BindTexture()
*
* Revision 1.7 1997/04/28 23:38:45 brianp
* added gl_test_texture_object_completeness()
*
* Revision 1.6 1997/04/14 02:03:05 brianp
* added MinMagThresh to texture object
*
* Revision 1.5 1997/02/09 18:52:15 brianp
* added GL_EXT_texture3D support
*
* Revision 1.4 1997/01/16 03:35:34 brianp
* added calls to device driver DeleteTexture() and BindTexture() functions
*
* Revision 1.3 1997/01/09 19:49:47 brianp
* added a check to switch rasterizers if needed in glBindTexture()
*
* Revision 1.2 1996/09/27 17:09:42 brianp
* removed a redundant return statement
*
* Revision 1.1 1996/09/13 01:38:16 brianp
* Initial revision
*
*/
#ifdef PC_HEADER
#include "all.h"
#else
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "context.h"
#include "hash.h"
#include "macros.h"
#include "teximage.h"
#include "texobj.h"
#include "types.h"
#endif
/*
* Allocate a new texture object and add it to the linked list of texture
* objects. If name>0 then also insert the new texture object into the hash
* table.
* Input: shared - the shared GL state structure to contain the texture object
* name - integer name for the texture object
* dimensions - either 1, 2 or 3
* Return: pointer to new texture object
*/
struct gl_texture_object *
gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
GLuint dimensions)
{
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;
}
/*
* Deallocate a texture object struct and remove it from the given
* shared GL state.
* 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 )
{
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 );
}
/*
* Examine a texture object to determine if it is complete or not.
* The t->Complete flag will be set to GL_TRUE or GL_FALSE accordingly.
*/
void gl_test_texture_object_completeness( struct gl_texture_object *t )
{
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");
}
}
}
/*
* Execute glGenTextures
*/
void gl_GenTextures( GLcontext *ctx, GLsizei n, GLuint *texName )
{
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;
}
}
/*
* Execute glDeleteTextures
*/
void gl_DeleteTextures( GLcontext *ctx, GLsizei n, const GLuint *texName)
{
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);
}
}
}
}
}
/*
* Execute glBindTexture
*/
void gl_BindTexture( GLcontext *ctx, GLenum target, GLuint texName )
{
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 );
}
}
/*
* Execute glPrioritizeTextures
*/
void gl_PrioritizeTextures( GLcontext *ctx,
GLsizei n, const GLuint *texName,
const GLclampf *priorities )
{
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 );
}
}
}
}
/*
* Execute glAreTexturesResident
*/
GLboolean gl_AreTexturesResident( GLcontext *ctx, GLsizei n,
const GLuint *texName,
GLboolean *residences )
{
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;
}
/*
* Execute glIsTexture
*/
GLboolean gl_IsTexture( GLcontext *ctx, GLuint texture )
{
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;
}
}
Reference in a new issue View git blame Copy permalink