-/* $Id: teximage.c,v 1.80 2001/02/27 22:16:27 brianp Exp $ */
+/* $Id: teximage.c,v 1.100 2001/07/13 20:07:37 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2001 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 "mem.h"
#include "mmath.h"
#include "state.h"
+#include "texformat.h"
#include "teximage.h"
#include "texstate.h"
+#include "texstore.h"
#include "mtypes.h"
#include "swrast/s_span.h" /* XXX SWRAST hack */
#endif
#ifdef DEBUG
static void PrintTexture(const struct gl_texture_image *img)
{
- int i, j, c;
- GLchan *data = img->Data;
-
- if (!data) {
- printf("No texture data\n");
- return;
- }
-
- switch (img->Format) {
- case GL_ALPHA:
- case GL_LUMINANCE:
- case GL_INTENSITY:
- case GL_COLOR_INDEX:
- c = 1;
- break;
- case GL_LUMINANCE_ALPHA:
- c = 2;
- break;
- case GL_RGB:
- c = 3;
- break;
- case GL_RGBA:
- c = 4;
- break;
- default:
- gl_problem(NULL, "error in PrintTexture\n");
- return;
- }
-
-
- for (i = 0; i < img->Height; i++) {
- for (j = 0; j < img->Width; j++) {
- if (c==1)
- printf("%02x ", data[0]);
- else if (c==2)
- printf("%02x%02x ", data[0], data[1]);
- else if (c==3)
- printf("%02x%02x%02x ", data[0], data[1], data[2]);
- else if (c==4)
- printf("%02x%02x%02x%02x ", data[0], data[1], data[2], data[3]);
- data += c;
- }
- printf("\n");
- }
+#if CHAN_TYPE == GL_FLOAT
+ _mesa_problem(NULL, "PrintTexture doesn't support float channels");
+#else
+ GLuint i, j, c;
+ const GLchan *data = (const GLchan *) img->Data;
+
+ if (!data) {
+ printf("No texture data\n");
+ return;
+ }
+
+ switch (img->Format) {
+ case GL_ALPHA:
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ case GL_COLOR_INDEX:
+ c = 1;
+ break;
+ case GL_LUMINANCE_ALPHA:
+ c = 2;
+ break;
+ case GL_RGB:
+ c = 3;
+ break;
+ case GL_RGBA:
+ c = 4;
+ break;
+ default:
+ _mesa_problem(NULL, "error in PrintTexture\n");
+ return;
+ }
+
+ for (i = 0; i < img->Height; i++) {
+ for (j = 0; j < img->Width; j++) {
+ if (c==1)
+ printf("%02x ", data[0]);
+ else if (c==2)
+ printf("%02x%02x ", data[0], data[1]);
+ else if (c==3)
+ printf("%02x%02x%02x ", data[0], data[1], data[2]);
+ else if (c==4)
+ printf("%02x%02x%02x%02x ", data[0], data[1], data[2], data[3]);
+ data += c;
+ }
+ printf("\n");
+ }
+#endif
}
#endif
/*
* Compute log base 2 of n.
* If n isn't an exact power of two return -1.
- * If n<0 return -1.
+ * If n < 0 return -1.
*/
static int
logbase2( int n )
GLint i = 1;
GLint log2 = 0;
- if (n<0) {
+ if (n < 0) {
return -1;
}
GLint
_mesa_base_tex_format( GLcontext *ctx, GLint format )
{
- /*
- * Ask the driver for the base format, if it doesn't
- * know, it will return -1;
- */
+ /*
+ * Ask the driver for the base format, if it doesn't
+ * know, it will return -1;
+ */
if (ctx->Driver.BaseCompressedTexFormat) {
GLint ifmt = (*ctx->Driver.BaseCompressedTexFormat)(ctx, format);
if (ifmt >= 0) {
static GLboolean
is_compressed_format(GLcontext *ctx, GLenum internalFormat)
{
- if (ctx->Driver.IsCompressedFormat) {
- return (*ctx->Driver.IsCompressedFormat)(ctx, internalFormat);
- }
- return GL_FALSE;
+ if (ctx->Driver.BaseCompressedTexFormat) {
+ GLint b = (*ctx->Driver.BaseCompressedTexFormat)(ctx, internalFormat);
+ if (b > 0)
+ return GL_TRUE;
+ else
+ return GL_FALSE;
+ }
+ return GL_FALSE;
}
* according to the target and level parameters.
* This was basically prompted by the introduction of cube maps.
*/
-static void
-set_tex_image(struct gl_texture_object *tObj,
- GLenum target, GLint level,
- struct gl_texture_image *texImage)
+void
+_mesa_set_tex_image(struct gl_texture_object *tObj,
+ GLenum target, GLint level,
+ struct gl_texture_image *texImage)
{
ASSERT(tObj);
ASSERT(texImage);
switch (target) {
+ case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
+ case GL_TEXTURE_3D:
tObj->Image[level] = texImage;
return;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
tObj->NegZ[level] = texImage;
return;
default:
- gl_problem(NULL, "bad target in set_tex_image()");
+ _mesa_problem(NULL, "bad target in _mesa_set_tex_image()");
return;
}
}
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
+ case GL_TEXTURE_CUBE_MAP_ARB:
return ctx->Extensions.ARB_texture_cube_map
? texUnit->CurrentCubeMap : NULL;
case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
return ctx->Extensions.ARB_texture_cube_map
? ctx->Texture.ProxyCubeMap : NULL;
default:
- gl_problem(NULL, "bad target in _mesa_select_tex_object()");
+ _mesa_problem(NULL, "bad target in _mesa_select_tex_object()");
return NULL;
}
}
GLenum target, GLint level)
{
ASSERT(texUnit);
+ ASSERT(level < MAX_TEXTURE_LEVELS);
switch (target) {
case GL_TEXTURE_1D:
return texUnit->Current1D->Image[level];
else
return NULL;
default:
- gl_problem(ctx, "bad target in _mesa_select_tex_image()");
+ _mesa_problem(ctx, "bad target in _mesa_select_tex_image()");
return NULL;
}
}
{
ASSERT(img);
img->Format = 0;
- img->Type = 0;
img->IntFormat = 0;
- img->RedBits = 0;
- img->GreenBits = 0;
- img->BlueBits = 0;
- img->AlphaBits = 0;
- img->IntensityBits = 0;
- img->LuminanceBits = 0;
- img->IndexBits = 0;
img->Border = 0;
img->Width = 0;
img->Height = 0;
img->HeightLog2 = 0;
img->DepthLog2 = 0;
img->Data = NULL;
+ img->TexFormat = &_mesa_null_texformat;
+ img->FetchTexel = NULL;
img->IsCompressed = 0;
img->CompressedSize = 0;
- img->FetchTexel = NULL;
}
/*
* Initialize basic fields of the gl_texture_image struct.
*/
-static void
-init_teximage_fields(GLcontext *ctx,
- struct gl_texture_image *img,
- GLsizei width, GLsizei height, GLsizei depth,
- GLint border, GLenum internalFormat)
+void
+_mesa_init_teximage_fields(GLcontext *ctx,
+ struct gl_texture_image *img,
+ GLsizei width, GLsizei height, GLsizei depth,
+ GLint border, GLenum internalFormat)
{
ASSERT(img);
-
+ img->Format = _mesa_base_tex_format( ctx, internalFormat );
+ ASSERT(img->Format > 0);
img->IntFormat = internalFormat;
img->Border = border;
img->Width = width;
{
GLboolean isProxy;
GLint iformat;
+ GLint maxLevels = 0, maxTextureSize;
if (dimensions == 1) {
isProxy = (GLboolean) (target == GL_PROXY_TEXTURE_1D);
if (target != GL_TEXTURE_1D && !isProxy) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.MaxTextureLevels;
}
else if (dimensions == 2) {
isProxy = (GLboolean) (target == GL_PROXY_TEXTURE_2D ||
!(ctx->Extensions.ARB_texture_cube_map &&
target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
return GL_TRUE;
}
+ if (target == GL_PROXY_TEXTURE_2D && target == GL_TEXTURE_2D)
+ maxLevels = ctx->Const.MaxTextureLevels;
+ else
+ maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else if (dimensions == 3) {
isProxy = (GLboolean) (target == GL_PROXY_TEXTURE_3D);
if (target != GL_TEXTURE_3D && !isProxy) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.Max3DTextureLevels;
}
else {
- gl_problem( ctx, "bad dims in texture_error_check" );
+ _mesa_problem( ctx, "bad dims in texture_error_check" );
return GL_TRUE;
}
+ ASSERT(maxLevels > 0);
+ maxTextureSize = 1 << (maxLevels - 1);
+
/* Border */
if (border != 0 && border != 1) {
if (!isProxy) {
char message[100];
sprintf(message, "glTexImage%dD(border=%d)", dimensions, border);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
}
return GL_TRUE;
}
/* Width */
- if (width < 2 * border || width > 2 + ctx->Const.MaxTextureSize
+ if (width < 2 * border || width > 2 + maxTextureSize
|| logbase2( width - 2 * border ) < 0) {
if (!isProxy) {
char message[100];
sprintf(message, "glTexImage%dD(width=%d)", dimensions, width);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
}
return GL_TRUE;
}
/* Height */
if (dimensions >= 2) {
- if (height < 2 * border || height > 2 + ctx->Const.MaxTextureSize
+ if (height < 2 * border || height > 2 + maxTextureSize
|| logbase2( height - 2 * border ) < 0) {
if (!isProxy) {
char message[100];
sprintf(message, "glTexImage%dD(height=%d)", dimensions, height);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
}
return GL_TRUE;
}
target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
if (width != height) {
if (!isProxy) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
}
return GL_TRUE;
}
/* Depth */
if (dimensions >= 3) {
- if (depth < 2 * border || depth > 2 + ctx->Const.MaxTextureSize
+ if (depth < 2 * border || depth > 2 + maxTextureSize
|| logbase2( depth - 2 * border ) < 0) {
if (!isProxy) {
char message[100];
sprintf(message, "glTexImage3D(depth=%d)", depth );
- gl_error( ctx, GL_INVALID_VALUE, message );
+ _mesa_error( ctx, GL_INVALID_VALUE, message );
}
return GL_TRUE;
}
}
/* Level */
- if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
+ if (level < 0 || level >= maxLevels) {
if (!isProxy) {
char message[100];
sprintf(message, "glTexImage%dD(level=%d)", dimensions, level);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
}
return GL_TRUE;
}
if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
if (width != height) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
return GL_TRUE;
}
}
char message[100];
sprintf(message, "glTexImage%dD(internalFormat=0x%x)", dimensions,
internalFormat);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
}
return GL_TRUE;
}
- if (!is_compressed_format(ctx, internalFormat)) {
- if (!_mesa_is_legal_format_and_type( format, type )) {
- /* Yes, generate GL_INVALID_OPERATION, not GL_INVALID_ENUM, if there
- * is a type/format mismatch. See 1.2 spec page 94, sec 3.6.4.
- */
- if (!isProxy) {
- char message[100];
- sprintf(message, "glTexImage%dD(format or type)", dimensions);
- gl_error(ctx, GL_INVALID_OPERATION, message);
- }
- return GL_TRUE;
+ ASSERT(iformat > 0);
+
+ if (!is_compressed_format( ctx, internalFormat ) &&
+ !_mesa_is_legal_format_and_type( format, type )) {
+ /* Yes, generate GL_INVALID_OPERATION, not GL_INVALID_ENUM, if there
+ * is a type/format mismatch. See 1.2 spec page 94, sec 3.6.4.
+ */
+ if (!isProxy) {
+ char message[100];
+ sprintf(message, "glTexImage%dD(format or type)", dimensions);
+ _mesa_error(ctx, GL_INVALID_OPERATION, message);
}
+ return GL_TRUE;
}
/* if we get here, the parameters are OK */
{
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
struct gl_texture_image *destTex;
+ GLint maxLevels = 0;
+ GLboolean compressed;
if (dimensions == 1) {
if (target != GL_TEXTURE_1D) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage1D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage1D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.MaxTextureLevels;
}
else if (dimensions == 2) {
if (ctx->Extensions.ARB_texture_cube_map) {
if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
target != GL_TEXTURE_2D) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
return GL_TRUE;
}
}
else if (target != GL_TEXTURE_2D) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
return GL_TRUE;
}
+ if (target == GL_PROXY_TEXTURE_2D && target == GL_TEXTURE_2D)
+ maxLevels = ctx->Const.MaxTextureLevels;
+ else
+ maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else if (dimensions == 3) {
if (target != GL_TEXTURE_3D) {
- gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage3D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage3D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.Max3DTextureLevels;
}
else {
- gl_problem( ctx, "bad dims in texture_error_check" );
+ _mesa_problem( ctx, "bad dims in texture_error_check" );
return GL_TRUE;
}
- if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
+ ASSERT(maxLevels > 0);
+
+ if (level < 0 || level >= maxLevels) {
char message[100];
sprintf(message, "glTexSubImage2D(level=%d)", level);
- gl_error(ctx, GL_INVALID_ENUM, message);
+ _mesa_error(ctx, GL_INVALID_ENUM, message);
return GL_TRUE;
}
if (width < 0) {
char message[100];
sprintf(message, "glTexSubImage%dD(width=%d)", dimensions, width);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
if (height < 0 && dimensions > 1) {
char message[100];
sprintf(message, "glTexSubImage%dD(height=%d)", dimensions, height);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
if (depth < 0 && dimensions > 2) {
char message[100];
sprintf(message, "glTexSubImage%dD(depth=%d)", dimensions, depth);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
destTex = _mesa_select_tex_image(ctx, texUnit, target, level);
if (!destTex) {
- gl_error(ctx, GL_INVALID_OPERATION, "glTexSubImage2D");
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage2D");
return GL_TRUE;
}
if (xoffset < -((GLint)destTex->Border)) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset)");
return GL_TRUE;
}
if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset+width)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset+width)");
return GL_TRUE;
}
if (dimensions > 1) {
if (yoffset < -((GLint)destTex->Border)) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset)");
return GL_TRUE;
}
if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset+height)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset+height)");
return GL_TRUE;
}
}
if (dimensions > 2) {
if (zoffset < -((GLint)destTex->Border)) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
return GL_TRUE;
}
- if (zoffset + depth > (GLint) (destTex->Depth+destTex->Border)) {
- gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
+ if (zoffset + depth > (GLint) (destTex->Depth + destTex->Border)) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
return GL_TRUE;
}
}
- if (!is_compressed_format(ctx, destTex->IntFormat)) {
- if (!_mesa_is_legal_format_and_type(format, type)) {
- char message[100];
- sprintf(message, "glTexSubImage%dD(format or type)", dimensions);
- gl_error(ctx, GL_INVALID_ENUM, message);
+ compressed = is_compressed_format(ctx, destTex->IntFormat);
+
+ if (!compressed && !_mesa_is_legal_format_and_type(format, type)) {
+ char message[100];
+ sprintf(message, "glTexSubImage%dD(format or type)", dimensions);
+ _mesa_error(ctx, GL_INVALID_ENUM, message);
+ return GL_TRUE;
+ }
+
+ if (compressed) {
+ if (xoffset != -destTex->Border) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glTexSubImage1/2/3D(xoffset != -border");
+ return GL_TRUE;
+ }
+ if (dimensions > 1 && yoffset != -destTex->Border) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glTexSubImage2/3D(yoffset != -border");
+ return GL_TRUE;
+ }
+ if (dimensions > 2 && zoffset != -destTex->Border) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glTexSubImage3D(zoffset != -border");
return GL_TRUE;
}
}
GLint width, GLint height, GLint border )
{
GLint iformat;
+ GLint maxLevels = 0, maxTextureSize;
if (dimensions == 1) {
if (target != GL_TEXTURE_1D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexImage1D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage1D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.MaxTextureLevels;
}
else if (dimensions == 2) {
if (ctx->Extensions.ARB_texture_cube_map) {
if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
target != GL_TEXTURE_2D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
return GL_TRUE;
}
}
else if (target != GL_TEXTURE_2D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
return GL_TRUE;
}
+ if (target == GL_PROXY_TEXTURE_2D && target == GL_TEXTURE_2D)
+ maxLevels = ctx->Const.MaxTextureLevels;
+ else
+ maxLevels = ctx->Const.MaxCubeTextureLevels;
}
+ ASSERT(maxLevels > 0);
+ maxTextureSize = 1 << (maxLevels - 1);
+
/* Border */
- if (border!=0 && border!=1) {
+ if (border != 0 && border != 1) {
char message[100];
sprintf(message, "glCopyTexImage%dD(border)", dimensions);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
/* Width */
- if (width < 2 * border || width > 2 + ctx->Const.MaxTextureSize
+ if (width < 2 * border || width > 2 + maxTextureSize
|| logbase2( width - 2 * border ) < 0) {
char message[100];
sprintf(message, "glCopyTexImage%dD(width=%d)", dimensions, width);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
/* Height */
if (dimensions >= 2) {
- if (height < 2 * border || height > 2 + ctx->Const.MaxTextureSize
+ if (height < 2 * border || height > 2 + maxTextureSize
|| logbase2( height - 2 * border ) < 0) {
char message[100];
sprintf(message, "glCopyTexImage%dD(height=%d)", dimensions, height);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
}
if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
if (width != height) {
- gl_error(ctx, GL_INVALID_VALUE, "glCopyTexImage2D(width != height)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glCopyTexImage2D(width != height)");
return GL_TRUE;
}
}
/* Level */
- if (level<0 || level>=ctx->Const.MaxTextureLevels) {
+ if (level < 0 || level >= maxLevels) {
char message[100];
sprintf(message, "glCopyTexImage%dD(level=%d)", dimensions, level);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
- iformat = _mesa_base_tex_format( ctx, internalFormat );
+ iformat = _mesa_base_tex_format(ctx, internalFormat);
if (iformat < 0) {
char message[100];
sprintf(message, "glCopyTexImage%dD(internalFormat)", dimensions);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
{
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
struct gl_texture_image *teximage;
+ GLint maxLevels = 0;
+ GLboolean compressed;
if (dimensions == 1) {
if (target != GL_TEXTURE_1D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage1D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage1D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.MaxTextureLevels;
}
else if (dimensions == 2) {
if (ctx->Extensions.ARB_texture_cube_map) {
if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
target != GL_TEXTURE_2D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
return GL_TRUE;
}
}
else if (target != GL_TEXTURE_2D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
return GL_TRUE;
}
+ if (target == GL_PROXY_TEXTURE_2D && target == GL_TEXTURE_2D)
+ maxLevels = ctx->Const.MaxTextureLevels;
+ else
+ maxLevels = ctx->Const.MaxCubeTextureLevels;
}
else if (dimensions == 3) {
if (target != GL_TEXTURE_3D) {
- gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage3D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage3D(target)" );
return GL_TRUE;
}
+ maxLevels = ctx->Const.Max3DTextureLevels;
}
- if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
+ ASSERT(maxLevels > 0);
+
+ if (level < 0 || level >= maxLevels) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(level=%d)", dimensions, level);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
if (width < 0) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(width=%d)", dimensions, width);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
if (dimensions > 1 && height < 0) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(height=%d)", dimensions, height);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
if (!teximage) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(undefined texture)", dimensions);
- gl_error(ctx, GL_INVALID_OPERATION, message);
+ _mesa_error(ctx, GL_INVALID_OPERATION, message);
return GL_TRUE;
}
if (xoffset < -((GLint)teximage->Border)) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
- if (xoffset+width > (GLint) (teximage->Width+teximage->Border)) {
+ if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(xoffset+width)", dimensions);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
if (dimensions > 1) {
if (yoffset < -((GLint)teximage->Border)) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
/* NOTE: we're adding the border here, not subtracting! */
- if (yoffset+height > (GLint) (teximage->Height+teximage->Border)) {
+ if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(yoffset+height)", dimensions);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
}
if (zoffset < -((GLint)teximage->Border)) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(zoffset)", dimensions);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
return GL_TRUE;
}
- if (zoffset > (GLint) (teximage->Depth+teximage->Border)) {
+ if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {
char message[100];
sprintf(message, "glCopyTexSubImage%dD(zoffset+depth)", dimensions);
- gl_error(ctx, GL_INVALID_VALUE, message);
+ _mesa_error(ctx, GL_INVALID_VALUE, message);
+ return GL_TRUE;
+ }
+ }
+
+ compressed = is_compressed_format(ctx, teximage->IntFormat);
+ if (compressed) {
+ if (xoffset != -teximage->Border) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glCopyTexSubImage1/2/3D(xoffset != -border");
+ return GL_TRUE;
+ }
+ if (dimensions > 1 && yoffset != -teximage->Border) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glCopyTexSubImage2/3D(yoffset != -border");
+ return GL_TRUE;
+ }
+ if (dimensions > 2 && zoffset != -teximage->Border) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glCopyTexSubImage3D(zoffset != -border");
return GL_TRUE;
}
}
_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
GLenum type, GLvoid *pixels )
{
- GET_CURRENT_CONTEXT(ctx);
const struct gl_texture_unit *texUnit;
const struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
-
+ GLint maxLevels = 0;
+ GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
- gl_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
+ texUnit = &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]);
+ texObj = _mesa_select_tex_object(ctx, texUnit, target);
+ if (!texObj || is_proxy_target(target)) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
+ return;
+ }
+
+ if (target == GL_TEXTURE_1D || target == GL_TEXTURE_2D) {
+ maxLevels = ctx->Const.MaxTextureLevels;
+ }
+ else if (target == GL_TEXTURE_3D) {
+ maxLevels = ctx->Const.Max3DTextureLevels;
+ }
+ else {
+ maxLevels = ctx->Const.MaxCubeTextureLevels;
+ }
+
+ ASSERT(maxLevels > 0);
+
+ if (level < 0 || level >= maxLevels) {
+ _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
return;
}
if (_mesa_sizeof_type(type) <= 0) {
- gl_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
return;
}
if (_mesa_components_in_format(format) <= 0 ||
format == GL_STENCIL_INDEX) {
- gl_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
return;
}
if (!ctx->Extensions.EXT_paletted_texture && is_index_format(format)) {
- gl_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
}
if (!ctx->Extensions.SGIX_depth_texture && format == GL_DEPTH_COMPONENT) {
- gl_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
}
/* XXX what if format/type doesn't match texture format/type? */
if (!pixels)
return;
- texUnit = &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]);
- texObj = _mesa_select_tex_object(ctx, texUnit, target);
- if (!texObj || is_proxy_target(target)) {
- gl_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
- return;
- }
-
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
if (!texImage) {
/* invalid mipmap level, not an error */
return;
}
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
-
- if (is_color_format(format) &&
- ctx->_ImageTransferState & IMAGE_CONVOLUTION_BIT) {
- /* convert texture image to GL_RGBA, GL_FLOAT */
- GLint width = texImage->Width;
- GLint height = texImage->Height;
- GLint depth = texImage->Depth;
- GLint img, row;
- GLfloat *tmpImage, *convImage;
- tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
- if (!tmpImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
- return;
- }
- convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
- if (!convImage) {
- FREE(tmpImage);
- gl_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
- return;
- }
-
- for (img = 0; img < depth; img++) {
- GLint convWidth, convHeight;
-
- /* convert texture data to GLfloat/GL_RGBA */
- for (row = 0; row < height; row++) {
- GLchan texels[1 << MAX_TEXTURE_LEVELS][4];
- GLint col;
- GLfloat *dst = tmpImage + row * width * 4;
- for (col = 0; col < width; col++) {
- (*texImage->FetchTexel)(texImage, col, row, img,
- texels[col]);
- }
- _mesa_unpack_float_color_span(ctx, width, GL_RGBA, dst,
- GL_RGBA, CHAN_TYPE, texels,
- &_mesa_native_packing,
- ctx->_ImageTransferState & IMAGE_PRE_CONVOLUTION_BITS,
- GL_FALSE);
- }
-
- convWidth = width;
- convHeight = height;
-
- /* convolve */
- if (target == GL_TEXTURE_1D) {
- if (ctx->Pixel.Convolution1DEnabled) {
- _mesa_convolve_1d_image(ctx, &convWidth, tmpImage, convImage);
- }
- }
- else {
- if (ctx->Pixel.Convolution2DEnabled) {
- _mesa_convolve_2d_image(ctx, &convWidth, &convHeight,
- tmpImage, convImage);
- }
- else if (ctx->Pixel.Separable2DEnabled) {
- _mesa_convolve_sep_image(ctx, &convWidth, &convHeight,
- tmpImage, convImage);
- }
- }
-
- /* pack convolved image */
- for (row = 0; row < convHeight; row++) {
- const GLfloat *src = convImage + row * convWidth * 4;
- GLvoid *dest = _mesa_image_address(&ctx->Pack, pixels,
- convWidth, convHeight,
- format, type, img, row, 0);
- _mesa_pack_float_rgba_span(ctx, convWidth,
- (const GLfloat(*)[4]) src,
- format, type, dest, &ctx->Pack,
- ctx->_ImageTransferState & IMAGE_POST_CONVOLUTION_BITS);
- }
- }
-
- FREE(tmpImage);
- FREE(convImage);
- }
- else {
- /* no convolution, or non-rgba image */
- GLint width = texImage->Width;
- GLint height = texImage->Height;
- GLint depth = texImage->Depth;
+ {
+ const GLint width = texImage->Width;
+ const GLint height = texImage->Height;
+ const GLint depth = texImage->Depth;
GLint img, row;
for (img = 0; img < depth; img++) {
for (row = 0; row < height; row++) {
}
_mesa_pack_index_span(ctx, width, type, dest,
indexRow, &ctx->Pack,
- ctx->_ImageTransferState);
+ 0 /* no image transfer */);
}
else if (format == GL_DEPTH_COMPONENT) {
GLfloat depthRow[MAX_WIDTH];
}
_mesa_pack_rgba_span(ctx, width, (const GLchan (*)[4])rgba,
format, type, dest, &ctx->Pack,
- ctx->_ImageTransferState);
+ 0 /* no image transfer */);
} /* format */
} /* row */
} /* img */
- } /* convolution */
+ }
}
texImage = _mesa_alloc_texture_image();
texObj->Image[level] = texImage;
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
return;
}
}
texImage->Data = NULL;
}
clear_teximage_fields(texImage); /* not really needed, but helpful */
- init_teximage_fields(ctx, texImage, postConvWidth, 1, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, postConvWidth, 1, 1,
+ border, internalFormat);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
ASSERT(ctx->Driver.TexImage1D);
if (pixels) {
}
}
- /* one of these has to be non-zero! */
- ASSERT(texImage->RedBits || texImage->IndexBits || texImage->AlphaBits ||
- texImage->LuminanceBits || texImage->IntensityBits ||
- texImage->DepthBits);
+ ASSERT(texImage->TexFormat);
+ if (!texImage->FetchTexel) {
+ /* If driver didn't explicitly set this, use the default */
+ texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
+ }
ASSERT(texImage->FetchTexel);
+ if (texImage->IsCompressed) {
+ ASSERT(texImage->CompressedSize > 0);
+ }
+
/* state update */
texObj->Complete = GL_FALSE;
ctx->NewState |= _NEW_TEXTURE;
struct gl_texture_image *texImage;
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
- init_teximage_fields(ctx, texImage, postConvWidth, 1, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, postConvWidth, 1, 1,
+ border, internalFormat);
ASSERT(ctx->Driver.TestProxyTexImage);
error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
internalFormat, format, type,
}
}
else {
- gl_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
return;
}
}
if (is_color_format(internalFormat)) {
_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
- &postConvHeight);
+ &postConvHeight);
}
if (target == GL_TEXTURE_2D ||
if (!texImage) {
texImage = _mesa_alloc_texture_image();
- set_tex_image(texObj, target, level, texImage);
+ _mesa_set_tex_image(texObj, target, level, texImage);
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
return;
}
}
texImage->Data = NULL;
}
clear_teximage_fields(texImage); /* not really needed, but helpful */
- init_teximage_fields(ctx, texImage, postConvWidth, postConvHeight, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, postConvWidth, postConvHeight,
+ 1, border, internalFormat);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
ASSERT(ctx->Driver.TexImage2D);
if (pixels) {
}
}
- /* one of these has to be non-zero! */
- ASSERT(texImage->RedBits || texImage->IndexBits || texImage->AlphaBits ||
- texImage->LuminanceBits || texImage->IntensityBits ||
- texImage->DepthBits);
+ ASSERT(texImage->TexFormat);
+ if (!texImage->FetchTexel) {
+ /* If driver didn't explicitly set this, use the default */
+ texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
+ }
ASSERT(texImage->FetchTexel);
+ if (texImage->IsCompressed) {
+ ASSERT(texImage->CompressedSize > 0);
+ }
+
/* state update */
texObj->Complete = GL_FALSE;
ctx->NewState |= _NEW_TEXTURE;
else if (target == GL_PROXY_TEXTURE_2D) {
/* Proxy texture: check for errors and update proxy state */
GLenum error = texture_error_check(ctx, target, level, internalFormat,
- format, type, 2,
- postConvWidth, postConvHeight, 1, border);
+ format, type, 2,
+ postConvWidth, postConvHeight, 1, border);
if (!error) {
struct gl_texture_unit *texUnit;
struct gl_texture_image *texImage;
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
- init_teximage_fields(ctx, texImage, postConvWidth, postConvHeight, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, postConvWidth,
+ postConvHeight, 1, border, internalFormat);
ASSERT(ctx->Driver.TestProxyTexImage);
error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
internalFormat, format, type,
}
if (error) {
/* if error, clear all proxy texture image parameters */
- if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
+ const GLint maxLevels = (target == GL_PROXY_TEXTURE_2D) ?
+ ctx->Const.MaxTextureLevels : ctx->Const.MaxCubeTextureLevels;
+ if (level >= 0 && level < maxLevels) {
clear_teximage_fields(ctx->Texture.Proxy2D->Image[level]);
}
}
}
else {
- gl_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
return;
}
}
* Note that width and height include the border.
*/
void
-_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
+_mesa_TexImage3D( GLenum target, GLint level, GLenum internalFormat,
GLsizei width, GLsizei height, GLsizei depth,
GLint border, GLenum format, GLenum type,
const GLvoid *pixels )
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
- if (texture_error_check(ctx, target, level, internalFormat,
+ if (texture_error_check(ctx, target, level, (GLint) internalFormat,
format, type, 3, width, height, depth, border)) {
return; /* error was recorded */
}
texImage = _mesa_alloc_texture_image();
texObj->Image[level] = texImage;
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
return;
}
}
texImage->Data = NULL;
}
clear_teximage_fields(texImage); /* not really needed, but helpful */
- init_teximage_fields(ctx, texImage, width, height, depth, border,
- internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, height, depth, border,
+ internalFormat);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
ASSERT(ctx->Driver.TexImage3D);
if (pixels) {
- (*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
+ (*ctx->Driver.TexImage3D)(ctx, target, level, (GLint) internalFormat,
width, height, depth, border,
format, type, pixels,
&ctx->Unpack, texObj, texImage);
else {
GLubyte *dummy = make_null_texture(width, height, depth, format);
if (dummy) {
- (*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
+ (*ctx->Driver.TexImage3D)(ctx, target, level,
+ (GLint) internalFormat,
width, height, depth, border,
format, GL_UNSIGNED_BYTE, dummy,
&_mesa_native_packing, texObj, texImage);
}
}
- /* one of these has to be non-zero! */
- ASSERT(texImage->RedBits || texImage->IndexBits || texImage->AlphaBits ||
- texImage->LuminanceBits || texImage->IntensityBits ||
- texImage->DepthBits);
+ ASSERT(texImage->TexFormat);
+ if (!texImage->FetchTexel) {
+ /* If driver didn't explicitly set this, use the default */
+ texImage->FetchTexel = texImage->TexFormat->FetchTexel3D;
+ }
ASSERT(texImage->FetchTexel);
+ if (texImage->IsCompressed) {
+ ASSERT(texImage->CompressedSize > 0);
+ }
+
/* state update */
texObj->Complete = GL_FALSE;
ctx->NewState |= _NEW_TEXTURE;
struct gl_texture_image *texImage;
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
- init_teximage_fields(ctx, texImage, width, height, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, height, 1,
+ border, internalFormat);
ASSERT(ctx->Driver.TestProxyTexImage);
error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
internalFormat, format, type,
}
if (error) {
/* if error, clear all proxy texture image parameters */
- if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
+ if (level >= 0 && level < ctx->Const.Max3DTextureLevels) {
clear_teximage_fields(ctx->Texture.Proxy3D->Image[level]);
}
}
}
else {
- gl_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
+ _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
return;
}
}
GLint border, GLenum format, GLenum type,
const GLvoid *pixels )
{
- _mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,
+ _mesa_TexImage3D(target, level, internalFormat, width, height,
depth, border, format, type, pixels);
}
const GLvoid *pixels )
{
GLsizei postConvWidth = width;
- GET_CURRENT_CONTEXT(ctx);
struct gl_texture_unit *texUnit;
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
/* XXX should test internal format */
if (is_color_format(format)) {
if (width == 0 || !pixels)
return; /* no-op, not an error */
+ /* If we have a border, xoffset=-1 is legal. Bias by border width */
+ xoffset += texImage->Border;
+
ASSERT(ctx->Driver.TexSubImage1D);
(*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
format, type, pixels, &ctx->Unpack,
const GLvoid *pixels )
{
GLsizei postConvWidth = width, postConvHeight = height;
- GET_CURRENT_CONTEXT(ctx);
struct gl_texture_unit *texUnit;
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
/* XXX should test internal format */
if (is_color_format(format)) {
if (width == 0 || height == 0 || !pixels)
return; /* no-op, not an error */
+ /* If we have a border, xoffset=-1 is legal. Bias by border width */
+ xoffset += texImage->Border;
+ yoffset += texImage->Border;
+
ASSERT(ctx->Driver.TexSubImage2D);
(*ctx->Driver.TexSubImage2D)(ctx, target, level, xoffset, yoffset,
width, height, format, type, pixels,
GLenum format, GLenum type,
const GLvoid *pixels )
{
- GET_CURRENT_CONTEXT(ctx);
struct gl_texture_unit *texUnit;
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
if (subtexture_error_check(ctx, 3, target, level, xoffset, yoffset, zoffset,
width, height, depth, format, type)) {
if (width == 0 || height == 0 || height == 0 || !pixels)
return; /* no-op, not an error */
+ /* If we have a border, xoffset=-1 is legal. Bias by border width */
+ xoffset += texImage->Border;
+ yoffset += texImage->Border;
+ zoffset += texImage->Border;
+
ASSERT(ctx->Driver.TexSubImage3D);
(*ctx->Driver.TexSubImage3D)(ctx, target, level,
xoffset, yoffset, zoffset,
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
if (is_color_format(internalFormat)) {
_mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
if (!texImage) {
texImage = _mesa_alloc_texture_image();
- set_tex_image(texObj, target, level, texImage);
+ _mesa_set_tex_image(texObj, target, level, texImage);
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
return;
}
}
}
clear_teximage_fields(texImage); /* not really needed, but helpful */
- init_teximage_fields(ctx, texImage, postConvWidth, 1, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, postConvWidth, 1, 1,
+ border, internalFormat);
ASSERT(ctx->Driver.CopyTexImage1D);
(*ctx->Driver.CopyTexImage1D)(ctx, target, level, internalFormat,
x, y, width, border);
+ ASSERT(texImage->TexFormat);
+ if (!texImage->FetchTexel) {
+ /* If driver didn't explicitly set this, use the default */
+ texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
+ }
+ ASSERT(texImage->FetchTexel);
+
/* state update */
texObj->Complete = GL_FALSE;
ctx->NewState |= _NEW_TEXTURE;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
if (is_color_format(internalFormat)) {
_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
if (!texImage) {
texImage = _mesa_alloc_texture_image();
- set_tex_image(texObj, target, level, texImage);
+ _mesa_set_tex_image(texObj, target, level, texImage);
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
return;
}
}
}
clear_teximage_fields(texImage); /* not really needed, but helpful */
- init_teximage_fields(ctx, texImage, postConvWidth, postConvHeight, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, postConvWidth, postConvHeight, 1,
+ border, internalFormat);
ASSERT(ctx->Driver.CopyTexImage2D);
(*ctx->Driver.CopyTexImage2D)(ctx, target, level, internalFormat,
x, y, width, height, border);
+ ASSERT(texImage->TexFormat);
+ if (!texImage->FetchTexel) {
+ /* If driver didn't explicitly set this, use the default */
+ texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
+ }
+ ASSERT(texImage->FetchTexel);
+
/* state update */
texObj->Complete = GL_FALSE;
ctx->NewState |= _NEW_TEXTURE;
_mesa_CopyTexSubImage1D( GLenum target, GLint level,
GLint xoffset, GLint x, GLint y, GLsizei width )
{
+ struct gl_texture_unit *texUnit;
+ struct gl_texture_object *texObj;
+ struct gl_texture_image *texImage;
GLsizei postConvWidth = width;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
/* XXX should test internal format */
_mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
xoffset, 0, 0, postConvWidth, 1))
return;
+ texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+ texObj = _mesa_select_tex_object(ctx, texUnit, target);
+ texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+
+ /* If we have a border, xoffset=-1 is legal. Bias by border width */
+ xoffset += texImage->Border;
+
ASSERT(ctx->Driver.CopyTexSubImage1D);
(*ctx->Driver.CopyTexSubImage1D)(ctx, target, level, xoffset, x, y, width);
ctx->NewState |= _NEW_TEXTURE;
GLint xoffset, GLint yoffset,
GLint x, GLint y, GLsizei width, GLsizei height )
{
+ struct gl_texture_unit *texUnit;
+ struct gl_texture_object *texObj;
+ struct gl_texture_image *texImage;
GLsizei postConvWidth = width, postConvHeight = height;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
/* XXX should test internal format */
_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, &postConvHeight);
postConvWidth, postConvHeight))
return;
+ texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+ texObj = _mesa_select_tex_object(ctx, texUnit, target);
+ texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+
+ /* If we have a border, xoffset=-1 is legal. Bias by border width */
+ xoffset += texImage->Border;
+ yoffset += texImage->Border;
+
ASSERT(ctx->Driver.CopyTexSubImage2D);
(*ctx->Driver.CopyTexSubImage2D)(ctx, target, level,
xoffset, yoffset, x, y, width, height);
GLint xoffset, GLint yoffset, GLint zoffset,
GLint x, GLint y, GLsizei width, GLsizei height )
{
+ struct gl_texture_unit *texUnit;
+ struct gl_texture_object *texObj;
+ struct gl_texture_image *texImage;
GLsizei postConvWidth = width, postConvHeight = height;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (ctx->NewState & _NEW_PIXEL)
- gl_update_state(ctx);
+ if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+ _mesa_update_state(ctx);
/* XXX should test internal format */
_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, &postConvHeight);
zoffset, postConvWidth, postConvHeight))
return;
+ texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+ texObj = _mesa_select_tex_object(ctx, texUnit, target);
+ texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+
+ /* If we have a border, xoffset=-1 is legal. Bias by border width */
+ xoffset += texImage->Border;
+ yoffset += texImage->Border;
+ zoffset += texImage->Border;
+
ASSERT(ctx->Driver.CopyTexSubImage3D);
(*ctx->Driver.CopyTexSubImage3D)(ctx, target, level,
xoffset, yoffset, zoffset,
case GL_COMPRESSED_INTENSITY_ARB:
case GL_COMPRESSED_RGB_ARB:
case GL_COMPRESSED_RGBA_ARB:
- gl_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB");
return;
default:
/* silence compiler warning */
texImage = _mesa_alloc_texture_image();
texObj->Image[level] = texImage;
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
return;
}
}
texImage->Data = NULL;
}
- init_teximage_fields(ctx, texImage, width, 1, 1, border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, 1, 1,
+ border, internalFormat);
if (ctx->Extensions.ARB_texture_compression) {
ASSERT(ctx->Driver.CompressedTexImage1D);
struct gl_texture_image *texImage;
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
- init_teximage_fields(ctx, texImage, width, 1, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, 1, 1,
+ border, internalFormat);
ASSERT(ctx->Driver.TestProxyTexImage);
error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
internalFormat, GL_NONE, GL_NONE,
}
}
else {
- gl_error( ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB(target)" );
+ _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB(target)");
return;
}
}
case GL_COMPRESSED_INTENSITY_ARB:
case GL_COMPRESSED_RGB_ARB:
case GL_COMPRESSED_RGBA_ARB:
- gl_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB");
return;
default:
/* silence compiler warning */
texImage = _mesa_alloc_texture_image();
texObj->Image[level] = texImage;
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
return;
}
}
texImage->Data = NULL;
}
- init_teximage_fields(ctx, texImage, width, height, 1, border,
- internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, height, 1, border,
+ internalFormat);
if (ctx->Extensions.ARB_texture_compression) {
ASSERT(ctx->Driver.CompressedTexImage2D);
struct gl_texture_image *texImage;
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
- init_teximage_fields(ctx, texImage, width, height, 1,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, height, 1,
+ border, internalFormat);
ASSERT(ctx->Driver.TestProxyTexImage);
error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
internalFormat, GL_NONE, GL_NONE,
}
if (error) {
/* if error, clear all proxy texture image parameters */
- if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
+ const GLint maxLevels = (target == GL_PROXY_TEXTURE_2D) ?
+ ctx->Const.MaxTextureLevels : ctx->Const.MaxCubeTextureLevels;
+ if (level >= 0 && level < maxLevels) {
clear_teximage_fields(ctx->Texture.Proxy2D->Image[level]);
}
}
}
else {
- gl_error( ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB(target)" );
+ _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB(target)");
return;
}
}
case GL_COMPRESSED_INTENSITY_ARB:
case GL_COMPRESSED_RGB_ARB:
case GL_COMPRESSED_RGBA_ARB:
- gl_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB");
return;
default:
/* silence compiler warning */
texImage = _mesa_alloc_texture_image();
texObj->Image[level] = texImage;
if (!texImage) {
- gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
return;
}
}
texImage->Data = NULL;
}
- init_teximage_fields(ctx, texImage, width, height, depth, border,
- internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, height, depth, border,
+ internalFormat);
if (ctx->Extensions.ARB_texture_compression) {
ASSERT(ctx->Driver.CompressedTexImage3D);
struct gl_texture_image *texImage;
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
- init_teximage_fields(ctx, texImage, width, height, depth,
- border, internalFormat);
+ _mesa_init_teximage_fields(ctx, texImage, width, height, depth,
+ border, internalFormat);
ASSERT(ctx->Driver.TestProxyTexImage);
error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
internalFormat, GL_NONE, GL_NONE,
}
if (error) {
/* if error, clear all proxy texture image parameters */
- if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
+ if (level >= 0 && level < ctx->Const.Max3DTextureLevels) {
clear_teximage_fields(ctx->Texture.Proxy3D->Image[level]);
}
}
}
else {
- gl_error( ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB(target)" );
+ _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB(target)");
return;
}
}
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (subtexture_error_check(ctx, 1, target, level, xoffset, 0, 0,
width, 1, 1, format, GL_NONE)) {
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (subtexture_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
width, height, 1, format, GL_NONE)) {
struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (subtexture_error_check(ctx, 3, target, level, xoffset, yoffset, zoffset,
width, height, depth, format, GL_NONE)) {
const struct gl_texture_unit *texUnit;
const struct gl_texture_object *texObj;
struct gl_texture_image *texImage;
+ GLint maxLevels;
GET_CURRENT_CONTEXT(ctx);
-
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
- if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
- gl_error( ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)" );
+ texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+ texObj = _mesa_select_tex_object(ctx, texUnit, target);
+ if (!texObj) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB");
+ return;
+ }
+
+ if (target == GL_TEXTURE_1D || target == GL_TEXTURE_2D) {
+ maxLevels = ctx->Const.MaxTextureLevels;
+ }
+ else if (target == GL_TEXTURE_3D) {
+ maxLevels = ctx->Const.Max3DTextureLevels;
+ }
+ else {
+ maxLevels = ctx->Const.MaxCubeTextureLevels;
+ }
+
+ ASSERT(maxLevels > 0);
+
+ if (level < 0 || level >= maxLevels) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
return;
}
if (is_proxy_target(target)) {
- gl_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
return;
}
- texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
- texObj = _mesa_select_tex_object(ctx, texUnit, target);
texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-
if (!texImage) {
- /* invalid mipmap level */
- gl_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
+ /* probably invalid mipmap level */
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
return;
}
if (!texImage->IsCompressed) {
- gl_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
return;
}
projects / mesa.git / blobdiff