From 0a40033047373d9c16039cff9e63130478e78e0f Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Fri, 23 Jan 2009 13:44:12 -0700 Subject: mesa: refactor _mesa_TexEnvfv() code with helper functions --- src/mesa/main/texenv.c | 721 +++++++++++++++++++++++++------------------------ 1 file changed, 373 insertions(+), 348 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index e072cea136..2f38ee8852 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.1 + * Version: 7.5 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -37,6 +38,370 @@ #include "math/m_xform.h" +#define TE_ERROR(errCode, msg, value) \ + _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value)); + + +/** Set texture env mode */ +static void +set_env_mode(GLcontext *ctx, + struct gl_texture_unit *texUnit, + GLenum mode) +{ + GLboolean legal; + + if (texUnit->EnvMode == mode) + return; + + switch (mode) { + case GL_MODULATE: + case GL_BLEND: + case GL_DECAL: + case GL_REPLACE: + legal = GL_TRUE; + break; + case GL_REPLACE_EXT: + mode = GL_REPLACE; /* GL_REPLACE_EXT != GL_REPLACE */ + legal = GL_TRUE; + break; + case GL_ADD: + legal = ctx->Extensions.EXT_texture_env_add; + break; + case GL_COMBINE: + legal = (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine); + break; + case GL_COMBINE4_NV: + legal = ctx->Extensions.NV_texture_env_combine4; + break; + default: + legal = GL_FALSE; + } + + if (legal) { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->EnvMode = mode; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); + } +} + + +static void +set_env_color(GLcontext *ctx, + struct gl_texture_unit *texUnit, + const GLfloat *color) +{ + GLfloat tmp[4]; + tmp[0] = CLAMP(color[0], 0.0F, 1.0F); + tmp[1] = CLAMP(color[1], 0.0F, 1.0F); + tmp[2] = CLAMP(color[2], 0.0F, 1.0F); + tmp[3] = CLAMP(color[3], 0.0F, 1.0F); + if (TEST_EQ_4V(tmp, texUnit->EnvColor)) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + COPY_4FV(texUnit->EnvColor, tmp); +} + + +/** Set an RGB or A combiner mode/function */ +static void +set_combiner_mode(GLcontext *ctx, + struct gl_texture_unit *texUnit, + GLenum pname, GLenum mode) +{ + GLboolean legal; + + if (!ctx->Extensions.EXT_texture_env_combine && + !ctx->Extensions.ARB_texture_env_combine) { + _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); + return; + } + + switch (mode) { + case GL_REPLACE: + case GL_MODULATE: + case GL_ADD: + case GL_ADD_SIGNED: + case GL_INTERPOLATE: + legal = GL_TRUE; + break; + case GL_SUBTRACT: + legal = ctx->Extensions.ARB_texture_env_combine; + break; + case GL_DOT3_RGB_EXT: + case GL_DOT3_RGBA_EXT: + legal = (ctx->Extensions.EXT_texture_env_dot3 && + pname == GL_COMBINE_RGB); + break; + case GL_DOT3_RGB: + case GL_DOT3_RGBA: + legal = (ctx->Extensions.ARB_texture_env_dot3 && + pname == GL_COMBINE_RGB); + break; + case GL_MODULATE_ADD_ATI: + case GL_MODULATE_SIGNED_ADD_ATI: + case GL_MODULATE_SUBTRACT_ATI: + legal =ctx->Extensions.ATI_texture_env_combine3; + break; + default: + legal = GL_FALSE; + } + + if (!legal) { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); + return; + } + + switch (pname) { + case GL_COMBINE_RGB: + if (texUnit->Combine.ModeRGB == mode) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->Combine.ModeRGB = mode; + break; + + case GL_COMBINE_ALPHA: + if (texUnit->Combine.ModeA == mode) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->Combine.ModeA = mode; + break; + default: + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + } +} + + + +/** Set an RGB or A combiner source term */ +static void +set_combiner_source(GLcontext *ctx, + struct gl_texture_unit *texUnit, + GLenum pname, GLenum param) +{ + GLuint src; + GLboolean alpha, legal; + + if (!ctx->Extensions.EXT_texture_env_combine && + !ctx->Extensions.ARB_texture_env_combine) { + _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); + return; + } + + /* + * Translate pname to (src, alpha). + */ + switch (pname) { + case GL_SOURCE0_RGB: + src = 0; + alpha = GL_FALSE; + break; + case GL_SOURCE1_RGB: + src = 1; + alpha = GL_FALSE; + break; + case GL_SOURCE2_RGB: + src = 2; + alpha = GL_FALSE; + break; + case GL_SOURCE0_ALPHA: + src = 0; + alpha = GL_TRUE; + break; + case GL_SOURCE1_ALPHA: + src = 1; + alpha = GL_TRUE; + break; + case GL_SOURCE2_ALPHA: + src = 2; + alpha = GL_TRUE; + break; + default: + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + + /* + * Error-check param (the source term) + */ + switch (param) { + case GL_TEXTURE: + case GL_CONSTANT: + case GL_PRIMARY_COLOR: + case GL_PREVIOUS: + legal = GL_TRUE; + break; + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: + legal = (ctx->Extensions.ARB_texture_env_crossbar && + param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits); + break; + case GL_ZERO: + case GL_ONE: + legal = ctx->Extensions.ATI_texture_env_combine3; + break; + default: + legal = GL_FALSE; + } + + if (!legal) { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param); + return; + } + + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + + assert(src < 4); + if (alpha) + texUnit->Combine.SourceA[src] = param; + else + texUnit->Combine.SourceRGB[src] = param; +} + + +/** Set an RGB or A combiner operand term */ +static void +set_combiner_operand(GLcontext *ctx, + struct gl_texture_unit *texUnit, + GLenum pname, GLenum param) +{ + GLuint op; + GLboolean alpha, legal; + + if (!ctx->Extensions.EXT_texture_env_combine && + !ctx->Extensions.ARB_texture_env_combine) { + _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); + return; + } + + switch (pname) { + case GL_OPERAND0_RGB: + op = 0; + alpha = GL_FALSE; + break; + case GL_OPERAND1_RGB: + op = 1; + alpha = GL_FALSE; + break; + case GL_OPERAND2_RGB: + if (ctx->Extensions.ARB_texture_env_combine) { + op = 2; + alpha = GL_FALSE; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + break; + case GL_OPERAND0_ALPHA: + op = 0; + alpha = GL_TRUE; + break; + case GL_OPERAND1_ALPHA: + op = 1; + alpha = GL_TRUE; + break; + case GL_OPERAND2_ALPHA: + if (ctx->Extensions.ARB_texture_env_combine) { + op = 2; + alpha = GL_TRUE; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + break; + default: + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + + /* + * Error-check param (the source operand) + */ + switch (param) { + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + legal = !alpha; + break; + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + legal = GL_TRUE; + break; + default: + legal = GL_FALSE; + } + + if (!legal) { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param); + return; + } + + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + + if (alpha) + texUnit->Combine.OperandA[op] = param; + else + texUnit->Combine.OperandRGB[op] = param; +} + + +static void +set_combiner_scale(GLcontext *ctx, + struct gl_texture_unit *texUnit, + GLenum pname, GLfloat scale) +{ + GLuint shift; + + if (!ctx->Extensions.EXT_texture_env_combine && + !ctx->Extensions.ARB_texture_env_combine) { + _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); + return; + } + + if (scale == 1.0F) { + shift = 0; + } + else if (scale == 2.0F) { + shift = 1; + } + else if (scale == 4.0F) { + shift = 2; + } + else { + _mesa_error( ctx, GL_INVALID_VALUE, + "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" ); + return; + } + + switch (pname) { + case GL_RGB_SCALE: + if (texUnit->Combine.ScaleShiftRGB == shift) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->Combine.ScaleShiftRGB = shift; + break; + case GL_ALPHA_SCALE: + if (texUnit->Combine.ScaleShiftA == shift) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->Combine.ScaleShiftA = shift; + break; + default: + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } +} + + void GLAPIENTRY _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) @@ -55,377 +420,37 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; -#define TE_ERROR(errCode, msg, value) \ - _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value)); - if (target == GL_TEXTURE_ENV) { switch (pname) { case GL_TEXTURE_ENV_MODE: - { - GLenum mode = (GLenum) (GLint) *param; - if (mode == GL_REPLACE_EXT) - mode = GL_REPLACE; - if (texUnit->EnvMode == mode) - return; - if (mode == GL_MODULATE || - mode == GL_BLEND || - mode == GL_DECAL || - mode == GL_REPLACE || - (mode == GL_ADD && ctx->Extensions.EXT_texture_env_add) || - (mode == GL_COMBINE && - (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine))) { - /* legal */ - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->EnvMode = mode; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - } + set_env_mode(ctx, texUnit, (GLenum) (GLint) param[0]); break; case GL_TEXTURE_ENV_COLOR: - { - GLfloat tmp[4]; - tmp[0] = CLAMP( param[0], 0.0F, 1.0F ); - tmp[1] = CLAMP( param[1], 0.0F, 1.0F ); - tmp[2] = CLAMP( param[2], 0.0F, 1.0F ); - tmp[3] = CLAMP( param[3], 0.0F, 1.0F ); - if (TEST_EQ_4V(tmp, texUnit->EnvColor)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->EnvColor, tmp); - } + set_env_color(ctx, texUnit, param); break; case GL_COMBINE_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const GLenum mode = (GLenum) (GLint) *param; - if (texUnit->Combine.ModeRGB == mode) - return; - switch (mode) { - case GL_REPLACE: - case GL_MODULATE: - case GL_ADD: - case GL_ADD_SIGNED: - case GL_INTERPOLATE: - /* OK */ - break; - case GL_SUBTRACT: - if (!ctx->Extensions.ARB_texture_env_combine) { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - break; - case GL_DOT3_RGB_EXT: - case GL_DOT3_RGBA_EXT: - if (!ctx->Extensions.EXT_texture_env_dot3) { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - break; - case GL_DOT3_RGB: - case GL_DOT3_RGBA: - if (!ctx->Extensions.ARB_texture_env_dot3) { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - break; - case GL_MODULATE_ADD_ATI: - case GL_MODULATE_SIGNED_ADD_ATI: - case GL_MODULATE_SUBTRACT_ATI: - if (!ctx->Extensions.ATI_texture_env_combine3) { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - break; - default: - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.ModeRGB = mode; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } - break; case GL_COMBINE_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const GLenum mode = (GLenum) (GLint) *param; - if (texUnit->Combine.ModeA == mode) - return; - switch (mode) { - case GL_REPLACE: - case GL_MODULATE: - case GL_ADD: - case GL_ADD_SIGNED: - case GL_INTERPOLATE: - /* OK */ - break; - case GL_SUBTRACT: - if (!ctx->Extensions.ARB_texture_env_combine) { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - break; - case GL_MODULATE_ADD_ATI: - case GL_MODULATE_SIGNED_ADD_ATI: - case GL_MODULATE_SUBTRACT_ATI: - if (!ctx->Extensions.ATI_texture_env_combine3) { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - break; - default: - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); - return; - } - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.ModeA = mode; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } + set_combiner_mode(ctx, texUnit, pname, (GLenum) (GLint) param[0]); break; case GL_SOURCE0_RGB: case GL_SOURCE1_RGB: case GL_SOURCE2_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const GLenum source = (GLenum) (GLint) *param; - const GLuint s = pname - GL_SOURCE0_RGB; - if (texUnit->Combine.SourceRGB[s] == source) - return; - if (source == GL_TEXTURE || - source == GL_CONSTANT || - source == GL_PRIMARY_COLOR || - source == GL_PREVIOUS || - (ctx->Extensions.ARB_texture_env_crossbar && - source >= GL_TEXTURE0 && - source < GL_TEXTURE0 + ctx->Const.MaxTextureUnits) || - (ctx->Extensions.ATI_texture_env_combine3 && - (source == GL_ZERO || source == GL_ONE))) { - /* legal */ - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.SourceRGB[s] = source; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source); - return; - } - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } - break; case GL_SOURCE0_ALPHA: case GL_SOURCE1_ALPHA: case GL_SOURCE2_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const GLenum source = (GLenum) (GLint) *param; - const GLuint s = pname - GL_SOURCE0_ALPHA; - if (texUnit->Combine.SourceA[s] == source) - return; - if (source == GL_TEXTURE || - source == GL_CONSTANT || - source == GL_PRIMARY_COLOR || - source == GL_PREVIOUS || - (ctx->Extensions.ARB_texture_env_crossbar && - source >= GL_TEXTURE0 && - source < GL_TEXTURE0 + ctx->Const.MaxTextureUnits) || - (ctx->Extensions.ATI_texture_env_combine3 && - (source == GL_ZERO || source == GL_ONE))) { - /* legal */ - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.SourceA[s] = source; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source); - return; - } - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } + set_combiner_source(ctx, texUnit, pname, (GLenum) (GLint) param[0]); break; case GL_OPERAND0_RGB: case GL_OPERAND1_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const GLenum operand = (GLenum) (GLint) *param; - const GLuint s = pname - GL_OPERAND0_RGB; - if (texUnit->Combine.OperandRGB[s] == operand) - return; - switch (operand) { - case GL_SRC_COLOR: - case GL_ONE_MINUS_SRC_COLOR: - case GL_SRC_ALPHA: - case GL_ONE_MINUS_SRC_ALPHA: - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.OperandRGB[s] = operand; - break; - default: - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand); - return; - } - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } - break; + case GL_OPERAND2_RGB: case GL_OPERAND0_ALPHA: case GL_OPERAND1_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const GLenum operand = (GLenum) (GLint) *param; - if (texUnit->Combine.OperandA[pname-GL_OPERAND0_ALPHA] == operand) - return; - switch (operand) { - case GL_SRC_ALPHA: - case GL_ONE_MINUS_SRC_ALPHA: - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.OperandA[pname-GL_OPERAND0_ALPHA] = operand; - break; - default: - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand); - return; - } - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } - break; - case GL_OPERAND2_RGB: - if (ctx->Extensions.ARB_texture_env_combine) { - const GLenum operand = (GLenum) (GLint) *param; - if (texUnit->Combine.OperandRGB[2] == operand) - return; - switch (operand) { - case GL_SRC_COLOR: /* ARB combine only */ - case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */ - case GL_SRC_ALPHA: - case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */ - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.OperandRGB[2] = operand; - break; - default: - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand); - return; - } - } - else if (ctx->Extensions.EXT_texture_env_combine) { - const GLenum operand = (GLenum) (GLint) *param; - if (texUnit->Combine.OperandRGB[2] == operand) - return; - /* operand must be GL_SRC_ALPHA which is the initial value - thus - don't need to actually compare the operand to the possible value */ - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand); - return; - } - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } - break; case GL_OPERAND2_ALPHA: - if (ctx->Extensions.ARB_texture_env_combine) { - const GLenum operand = (GLenum) (GLint) *param; - if (texUnit->Combine.OperandA[2] == operand) - return; - switch (operand) { - case GL_SRC_ALPHA: - case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */ - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.OperandA[2] = operand; - break; - default: - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand); - return; - } - } - else if (ctx->Extensions.EXT_texture_env_combine) { - const GLenum operand = (GLenum) (GLint) *param; - if (texUnit->Combine.OperandA[2] == operand) - return; - /* operand must be GL_SRC_ALPHA which is the initial value - thus - don't need to actually compare the operand to the possible value */ - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand); - return; - } - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } + set_combiner_operand(ctx, texUnit, pname, (GLenum) (GLint) param[0]); break; case GL_RGB_SCALE: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - GLuint newshift; - if (*param == 1.0) { - newshift = 0; - } - else if (*param == 2.0) { - newshift = 1; - } - else if (*param == 4.0) { - newshift = 2; - } - else { - _mesa_error( ctx, GL_INVALID_VALUE, - "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" ); - return; - } - if (texUnit->Combine.ScaleShiftRGB == newshift) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.ScaleShiftRGB = newshift; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } - break; case GL_ALPHA_SCALE: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - GLuint newshift; - if (*param == 1.0) { - newshift = 0; - } - else if (*param == 2.0) { - newshift = 1; - } - else if (*param == 4.0) { - newshift = 2; - } - else { - _mesa_error( ctx, GL_INVALID_VALUE, - "glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" ); - return; - } - if (texUnit->Combine.ScaleShiftA == newshift) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->Combine.ScaleShiftA = newshift; - } - else { - TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; - } + set_combiner_scale(ctx, texUnit, pname, param[0]); break; default: _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" ); -- cgit v1.2.3 From ad338c14c2aca87199da7ec1ae08ceb5062a9954 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Fri, 23 Jan 2009 14:15:45 -0700 Subject: mesa: consolidate glGetTexEnvi/f() code with new get_texenvi() helper --- src/mesa/main/texenv.c | 339 ++++++++++++++++++------------------------------- 1 file changed, 125 insertions(+), 214 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 2f38ee8852..d94bd9f313 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -558,6 +558,112 @@ _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param ) } + +/** + * Helper for glGetTexEnvi/f() + * \return value of queried pname or -1 if error. + */ +static GLint +get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, + GLenum pname) +{ + switch (pname) { + case GL_TEXTURE_ENV_MODE: + return texUnit->EnvMode; + break; + case GL_COMBINE_RGB: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + return texUnit->Combine.ModeRGB; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_COMBINE_ALPHA: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + return texUnit->Combine.ModeA; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_SOURCE0_RGB: + case GL_SOURCE1_RGB: + case GL_SOURCE2_RGB: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + const unsigned rgb_idx = pname - GL_SOURCE0_RGB; + return texUnit->Combine.SourceRGB[rgb_idx]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_SOURCE0_ALPHA: + case GL_SOURCE1_ALPHA: + case GL_SOURCE2_ALPHA: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA; + return texUnit->Combine.SourceA[alpha_idx]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_OPERAND0_RGB: + case GL_OPERAND1_RGB: + case GL_OPERAND2_RGB: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + const unsigned op_rgb = pname - GL_OPERAND0_RGB; + return texUnit->Combine.OperandRGB[op_rgb]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_OPERAND0_ALPHA: + case GL_OPERAND1_ALPHA: + case GL_OPERAND2_ALPHA: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + const unsigned op_alpha = pname - GL_OPERAND0_ALPHA; + return texUnit->Combine.OperandA[op_alpha]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_RGB_SCALE: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + return 1 << texUnit->Combine.ScaleShiftRGB; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + case GL_ALPHA_SCALE: + if (ctx->Extensions.EXT_texture_env_combine || + ctx->Extensions.ARB_texture_env_combine) { + return 1 << texUnit->Combine.ScaleShiftA; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + default: + ; + } + + return -1; /* error */ +} + + + void GLAPIENTRY _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) { @@ -576,111 +682,14 @@ _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; if (target == GL_TEXTURE_ENV) { - switch (pname) { - case GL_TEXTURE_ENV_MODE: - *params = ENUM_TO_FLOAT(texUnit->EnvMode); - break; - case GL_TEXTURE_ENV_COLOR: - COPY_4FV( params, texUnit->EnvColor ); - break; - case GL_COMBINE_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - *params = (GLfloat) texUnit->Combine.ModeRGB; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - } - break; - case GL_COMBINE_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - *params = (GLfloat) texUnit->Combine.ModeA; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - } - break; - case GL_SOURCE0_RGB: - case GL_SOURCE1_RGB: - case GL_SOURCE2_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned rgb_idx = pname - GL_SOURCE0_RGB; - *params = (GLfloat) texUnit->Combine.SourceRGB[rgb_idx]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - } - break; - case GL_SOURCE0_ALPHA: - case GL_SOURCE1_ALPHA: - case GL_SOURCE2_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA; - *params = (GLfloat) texUnit->Combine.SourceA[alpha_idx]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - } - break; - case GL_OPERAND0_RGB: - case GL_OPERAND1_RGB: - case GL_OPERAND2_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned op_rgb = pname - GL_OPERAND0_RGB; - *params = (GLfloat) texUnit->Combine.OperandRGB[op_rgb]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - } - break; - case GL_OPERAND0_ALPHA: - case GL_OPERAND1_ALPHA: - case GL_OPERAND2_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned op_alpha = pname - GL_OPERAND0_ALPHA; - *params = (GLfloat) texUnit->Combine.OperandA[op_alpha]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - } - break; - case GL_RGB_SCALE: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - if (texUnit->Combine.ScaleShiftRGB == 0) - *params = 1.0; - else if (texUnit->Combine.ScaleShiftRGB == 1) - *params = 2.0; - else - *params = 4.0; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - return; - } - break; - case GL_ALPHA_SCALE: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - if (texUnit->Combine.ScaleShiftA == 0) - *params = 1.0; - else if (texUnit->Combine.ScaleShiftA == 1) - *params = 2.0; - else - *params = 4.0; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); - return; - } - break; - default: - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname=0x%x)", pname); + if (pname == GL_TEXTURE_ENV_COLOR) { + COPY_4FV( params, texUnit->EnvColor ); + } + else { + GLint val = get_texenvi(ctx, texUnit, pname); + if (val >= 0) { + *params = (GLfloat) val; + } } } else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) { @@ -737,115 +746,17 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; if (target == GL_TEXTURE_ENV) { - switch (pname) { - case GL_TEXTURE_ENV_MODE: - *params = (GLint) texUnit->EnvMode; - break; - case GL_TEXTURE_ENV_COLOR: - params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] ); - params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] ); - params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] ); - params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] ); - break; - case GL_COMBINE_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - *params = (GLint) texUnit->Combine.ModeRGB; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - } - break; - case GL_COMBINE_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - *params = (GLint) texUnit->Combine.ModeA; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - } - break; - case GL_SOURCE0_RGB: - case GL_SOURCE1_RGB: - case GL_SOURCE2_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned rgb_idx = pname - GL_SOURCE0_RGB; - *params = (GLint) texUnit->Combine.SourceRGB[rgb_idx]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - } - break; - case GL_SOURCE0_ALPHA: - case GL_SOURCE1_ALPHA: - case GL_SOURCE2_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA; - *params = (GLint) texUnit->Combine.SourceA[alpha_idx]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - } - break; - case GL_OPERAND0_RGB: - case GL_OPERAND1_RGB: - case GL_OPERAND2_RGB: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned op_rgb = pname - GL_OPERAND0_RGB; - *params = (GLint) texUnit->Combine.OperandRGB[op_rgb]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - } - break; - case GL_OPERAND0_ALPHA: - case GL_OPERAND1_ALPHA: - case GL_OPERAND2_ALPHA: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - const unsigned op_alpha = pname - GL_OPERAND0_ALPHA; - *params = (GLint) texUnit->Combine.OperandA[op_alpha]; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - } - break; - case GL_RGB_SCALE: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - if (texUnit->Combine.ScaleShiftRGB == 0) - *params = 1; - else if (texUnit->Combine.ScaleShiftRGB == 1) - *params = 2; - else - *params = 4; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - return; - } - break; - case GL_ALPHA_SCALE: - if (ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine) { - if (texUnit->Combine.ScaleShiftA == 0) - *params = 1; - else if (texUnit->Combine.ScaleShiftA == 1) - *params = 2; - else - *params = 4; - } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)"); - return; - } - break; - default: - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname=0x%x)", - pname); + if (pname == GL_TEXTURE_ENV_COLOR) { + params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] ); + params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] ); + params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] ); + params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] ); + } + else { + GLint val = get_texenvi(ctx, texUnit, pname); + if (val >= 0) { + *params = val; + } } } else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) { -- cgit v1.2.3 From 08fbbdd4dceb8ca7ac15f0ce469f59e13e0ba82b Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Fri, 23 Jan 2009 17:30:03 -0700 Subject: mesa: update glTexEnv(), glGetTexEnv() for GL_NV_texture_env_combine4 --- src/mesa/main/texenv.c | 85 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 83 insertions(+), 2 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index d94bd9f313..097923182a 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -206,6 +206,16 @@ set_combiner_source(GLcontext *ctx, src = 2; alpha = GL_FALSE; break; + case GL_SOURCE3_RGB_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + src = 3; + alpha = GL_FALSE; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + break; case GL_SOURCE0_ALPHA: src = 0; alpha = GL_TRUE; @@ -218,11 +228,23 @@ set_combiner_source(GLcontext *ctx, src = 2; alpha = GL_TRUE; break; + case GL_SOURCE3_ALPHA_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + src = 3; + alpha = GL_TRUE; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + break; default: TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); return; } + assert(src < 4); + /* * Error-check param (the source term) */ @@ -245,6 +267,9 @@ set_combiner_source(GLcontext *ctx, param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits); break; case GL_ZERO: + legal = (ctx->Extensions.ATI_texture_env_combine3 || + ctx->Extensions.NV_texture_env_combine4); + break; case GL_ONE: legal = ctx->Extensions.ATI_texture_env_combine3; break; @@ -259,7 +284,6 @@ set_combiner_source(GLcontext *ctx, FLUSH_VERTICES(ctx, _NEW_TEXTURE); - assert(src < 4); if (alpha) texUnit->Combine.SourceA[src] = param; else @@ -301,6 +325,16 @@ set_combiner_operand(GLcontext *ctx, return; } break; + case GL_OPERAND3_RGB_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + op = 3; + alpha = GL_FALSE; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + break; case GL_OPERAND0_ALPHA: op = 0; alpha = GL_TRUE; @@ -319,11 +353,23 @@ set_combiner_operand(GLcontext *ctx, return; } break; + case GL_OPERAND3_ALPHA_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + op = 3; + alpha = GL_TRUE; + } + else { + TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); + return; + } + break; default: TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); return; } + assert(op < 4); + /* * Error-check param (the source operand) */ @@ -397,7 +443,6 @@ set_combiner_scale(GLcontext *ctx, break; default: TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); - return; } } @@ -435,17 +480,21 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) case GL_SOURCE0_RGB: case GL_SOURCE1_RGB: case GL_SOURCE2_RGB: + case GL_SOURCE3_RGB_NV: case GL_SOURCE0_ALPHA: case GL_SOURCE1_ALPHA: case GL_SOURCE2_ALPHA: + case GL_SOURCE3_ALPHA_NV: set_combiner_source(ctx, texUnit, pname, (GLenum) (GLint) param[0]); break; case GL_OPERAND0_RGB: case GL_OPERAND1_RGB: case GL_OPERAND2_RGB: + case GL_OPERAND3_RGB_NV: case GL_OPERAND0_ALPHA: case GL_OPERAND1_ALPHA: case GL_OPERAND2_ALPHA: + case GL_OPERAND3_ALPHA_NV: set_combiner_operand(ctx, texUnit, pname, (GLenum) (GLint) param[0]); break; case GL_RGB_SCALE: @@ -601,6 +650,14 @@ get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); } break; + case GL_SOURCE3_RGB_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + return texUnit->Combine.SourceRGB[3]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; case GL_SOURCE0_ALPHA: case GL_SOURCE1_ALPHA: case GL_SOURCE2_ALPHA: @@ -613,6 +670,14 @@ get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); } break; + case GL_SOURCE3_ALPHA_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + return texUnit->Combine.SourceA[3]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; case GL_OPERAND0_RGB: case GL_OPERAND1_RGB: case GL_OPERAND2_RGB: @@ -625,6 +690,14 @@ get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); } break; + case GL_OPERAND3_RGB_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + return texUnit->Combine.OperandRGB[3]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; case GL_OPERAND0_ALPHA: case GL_OPERAND1_ALPHA: case GL_OPERAND2_ALPHA: @@ -637,6 +710,14 @@ get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); } break; + case GL_OPERAND3_ALPHA_NV: + if (ctx->Extensions.NV_texture_env_combine4) { + return texUnit->Combine.OperandA[3]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; case GL_RGB_SCALE: if (ctx->Extensions.EXT_texture_env_combine || ctx->Extensions.ARB_texture_env_combine) { -- cgit v1.2.3 From 19dff5efc1e348d037b1b3cdfb9ac91020ecde4d Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Thu, 12 Feb 2009 09:21:50 -0700 Subject: mesa: don't include m_xform.h where not needed --- src/mesa/main/attrib.c | 2 +- src/mesa/main/clip.c | 1 - src/mesa/main/dlist.c | 1 - src/mesa/main/enable.c | 1 - src/mesa/main/matrix.c | 1 - src/mesa/main/texenv.c | 1 - src/mesa/main/texstate.c | 1 - 7 files changed, 1 insertion(+), 7 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c index 218e0aeb6b..add0045959 100644 --- a/src/mesa/main/attrib.c +++ b/src/mesa/main/attrib.c @@ -56,7 +56,7 @@ #include "texstate.h" #include "varray.h" #include "mtypes.h" -#include "math/m_xform.h" + /** * Special struct for saving/restoring texture state (GL_TEXTURE_BIT) diff --git a/src/mesa/main/clip.c b/src/mesa/main/clip.c index 43ef55ee3b..96c80e6ef8 100644 --- a/src/mesa/main/clip.c +++ b/src/mesa/main/clip.c @@ -29,7 +29,6 @@ #include "macros.h" #include "mtypes.h" -#include "math/m_xform.h" #include "math/m_matrix.h" diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c index db1415bc06..76b3315034 100644 --- a/src/mesa/main/dlist.c +++ b/src/mesa/main/dlist.c @@ -85,7 +85,6 @@ #endif #include "math/m_matrix.h" -#include "math/m_xform.h" #include "glapi/dispatch.h" diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c index 2b54fac694..7ff3b15c84 100644 --- a/src/mesa/main/enable.c +++ b/src/mesa/main/enable.c @@ -37,7 +37,6 @@ #include "mtypes.h" #include "enums.h" #include "math/m_matrix.h" -#include "math/m_xform.h" #include "api_arrayelt.h" diff --git a/src/mesa/main/matrix.c b/src/mesa/main/matrix.c index 0f96f94909..90d142278d 100644 --- a/src/mesa/main/matrix.c +++ b/src/mesa/main/matrix.c @@ -42,7 +42,6 @@ #include "matrix.h" #include "mtypes.h" #include "math/m_matrix.h" -#include "math/m_xform.h" /** diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 097923182a..95547a500e 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -35,7 +35,6 @@ #include "main/enums.h" #include "main/macros.h" #include "main/texenv.h" -#include "math/m_xform.h" #define TE_ERROR(errCode, msg, value) \ diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c index 7761af7589..6586a48646 100644 --- a/src/mesa/main/texstate.c +++ b/src/mesa/main/texstate.c @@ -42,7 +42,6 @@ #include "texstate.h" #include "texenvprogram.h" #include "mtypes.h" -#include "math/m_xform.h" -- cgit v1.2.3 From 114152e068ec919feb0a57a1259c2ada970b9f02 Mon Sep 17 00:00:00 2001 From: Roland Scheidegger Date: Thu, 12 Mar 2009 15:01:16 +0100 Subject: mesa: add support for ATI_envmap_bumpmap add new entrypoints, new texture format, etc translate in texenvprogram.c for drivers using the mesa-generated tex env fragment program also handled in swrast, but not tested (cannot work due to negative texel results not handled correctly) --- src/mesa/glapi/gl_API.xml | 50 +++++++++++ src/mesa/main/api_exec.c | 6 ++ src/mesa/main/config.h | 3 +- src/mesa/main/context.c | 3 + src/mesa/main/dlist.c | 46 +++++++++++ src/mesa/main/extensions.c | 2 + src/mesa/main/image.c | 153 +++++++++++++++++++++++++++++++++- src/mesa/main/image.h | 7 ++ src/mesa/main/macros.h | 7 +- src/mesa/main/mipmap.c | 14 +++- src/mesa/main/mtypes.h | 5 ++ src/mesa/main/texenv.c | 174 ++++++++++++++++++++++++++++++++++++++- src/mesa/main/texenv.h | 11 +++ src/mesa/main/texenvprogram.c | 99 ++++++++++++++++++++-- src/mesa/main/texformat.c | 42 ++++++++++ src/mesa/main/texformat.h | 14 +++- src/mesa/main/texformat_tmp.h | 17 +++- src/mesa/main/teximage.c | 39 ++++++++- src/mesa/main/texstate.c | 20 +++++ src/mesa/main/texstore.c | 91 +++++++++++++++++++- src/mesa/main/texstore.h | 2 +- src/mesa/shader/prog_statevars.c | 28 +++++++ src/mesa/shader/prog_statevars.h | 2 + src/mesa/swrast/s_texcombine.c | 95 ++++++++++++++++++++- 24 files changed, 906 insertions(+), 24 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/glapi/gl_API.xml b/src/mesa/glapi/gl_API.xml index 8212fc2477..cc3e3ae6bf 100644 --- a/src/mesa/glapi/gl_API.xml +++ b/src/mesa/glapi/gl_API.xml @@ -11681,6 +11681,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/mesa/main/api_exec.c b/src/mesa/main/api_exec.c index e0715817ad..6f66ff47a0 100644 --- a/src/mesa/main/api_exec.c +++ b/src/mesa/main/api_exec.c @@ -839,6 +839,12 @@ _mesa_init_exec_table(struct _glapi_table *exec) SET_SetFragmentShaderConstantATI(exec, _mesa_SetFragmentShaderConstantATI); #endif + /* GL_ATI_envmap_bumpmap */ + SET_GetTexBumpParameterivATI(exec, _mesa_GetTexBumpParameterivATI); + SET_GetTexBumpParameterfvATI(exec, _mesa_GetTexBumpParameterfvATI); + SET_TexBumpParameterivATI(exec, _mesa_TexBumpParameterivATI); + SET_TexBumpParameterfvATI(exec, _mesa_TexBumpParameterfvATI); + #if FEATURE_EXT_framebuffer_object SET_IsRenderbufferEXT(exec, _mesa_IsRenderbufferEXT); SET_BindRenderbufferEXT(exec, _mesa_BindRenderbufferEXT); diff --git a/src/mesa/main/config.h b/src/mesa/main/config.h index 282ad9514c..fc31155b35 100644 --- a/src/mesa/main/config.h +++ b/src/mesa/main/config.h @@ -232,7 +232,8 @@ #define MAX_COLOR_ATTACHMENTS 8 /*@}*/ - +/** For GL_ATI_envmap_bump - support bump mapping on first 8 units */ +#define SUPPORTED_ATI_BUMP_UNITS 0xff /** * \name Mesa-specific parameters diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c index 9fd9e769d2..84bf0205a8 100644 --- a/src/mesa/main/context.c +++ b/src/mesa/main/context.c @@ -589,6 +589,9 @@ _mesa_init_constants(GLcontext *ctx) /* GL_ARB_framebuffer_object */ ctx->Const.MaxSamples = 0; + /* GL_ATI_envmap_bumpmap */ + ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS; + /* sanity checks */ ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits)); diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c index d4bd56be83..ebcef0268a 100644 --- a/src/mesa/main/dlist.c +++ b/src/mesa/main/dlist.c @@ -320,6 +320,8 @@ typedef enum /* GL_ARB_draw_buffers */ OPCODE_DRAW_BUFFERS_ARB, /* GL_ATI_fragment_shader */ + OPCODE_TEX_BUMP_PARAMETER_ATI, + /* GL_ATI_fragment_shader */ OPCODE_BIND_FRAGMENT_SHADER_ATI, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, /* OpenGL 2.0 */ @@ -4803,6 +4805,36 @@ save_DrawBuffersARB(GLsizei count, const GLenum * buffers) } } +static void GLAPIENTRY +save_TexBumpParameterfvATI(GLenum pname, const GLfloat *param) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + + n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_BUMP_PARAMETER_ATI, 5); + if (n) { + n[1].ui = pname; + n[2].f = param[0]; + n[3].f = param[1]; + n[4].f = param[2]; + n[5].f = param[3]; + } + if (ctx->ExecuteFlag) { + CALL_TexBumpParameterfvATI(ctx->Exec, (pname, param)); + } +} + +static void GLAPIENTRY +save_TexBumpParameterivATI(GLenum pname, const GLint *param) +{ + GLfloat p[4]; + p[0] = INT_TO_FLOAT(param[0]); + p[1] = INT_TO_FLOAT(param[1]); + p[2] = INT_TO_FLOAT(param[2]); + p[3] = INT_TO_FLOAT(param[3]); + save_TexBumpParameterfvATI(pname, p); +} + #if FEATURE_ATI_fragment_shader static void GLAPIENTRY save_BindFragmentShaderATI(GLuint id) @@ -6505,6 +6537,16 @@ execute_list(GLcontext *ctx, GLuint list) n[9].i, n[10].e)); break; #endif + case OPCODE_TEX_BUMP_PARAMETER_ATI: + { + GLfloat values[4]; + GLuint i, pname = n[1].ui; + + for (i = 0; i < 4; i++) + values[i] = n[1 + i].f; + CALL_TexBumpParameterfvATI(ctx->Exec, (pname, values)); + } + break; #if FEATURE_ATI_fragment_shader case OPCODE_BIND_FRAGMENT_SHADER_ATI: CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i)); @@ -8043,6 +8085,10 @@ _mesa_init_dlist_table(struct _glapi_table *table) SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV); #endif + /* 244. GL_ATI_envmap_bumpmap */ + SET_TexBumpParameterivATI(table, save_TexBumpParameterivATI); + SET_TexBumpParameterfvATI(table, save_TexBumpParameterfvATI); + /* 245. GL_ATI_fragment_shader */ #if FEATURE_ATI_fragment_shader SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI); diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c index fbca924ad3..2d2bf51784 100644 --- a/src/mesa/main/extensions.c +++ b/src/mesa/main/extensions.c @@ -137,6 +137,7 @@ static const struct { { ON, "GL_APPLE_packed_pixels", F(APPLE_packed_pixels) }, { OFF, "GL_APPLE_vertex_array_object", F(APPLE_vertex_array_object) }, { OFF, "GL_ATI_blend_equation_separate", F(EXT_blend_equation_separate) }, + { OFF, "GL_ATI_envmap_bumpmap", F(ATI_envmap_bumpmap) }, { OFF, "GL_ATI_texture_env_combine3", F(ATI_texture_env_combine3)}, { OFF, "GL_ATI_texture_mirror_once", F(ATI_texture_mirror_once)}, { OFF, "GL_ATI_fragment_shader", F(ATI_fragment_shader)}, @@ -229,6 +230,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx) /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/ #endif ctx->Extensions.APPLE_vertex_array_object = GL_TRUE; + ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE; #if FEATURE_ATI_fragment_shader ctx->Extensions.ATI_fragment_shader = GL_TRUE; #endif diff --git a/src/mesa/main/image.c b/src/mesa/main/image.c index 4d86c54777..ed0811660d 100644 --- a/src/mesa/main/image.c +++ b/src/mesa/main/image.c @@ -293,6 +293,8 @@ _mesa_components_in_format( GLenum format ) return 2; case GL_DEPTH_STENCIL_EXT: return 2; + case GL_DUDV_ATI: + return 2; default: return -1; } @@ -503,6 +505,20 @@ _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type ) return GL_TRUE; else return GL_FALSE; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_TRUE; + default: + return GL_FALSE; + } default: ; /* fall-through */ } @@ -1674,8 +1690,19 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], GLfloat luminance[MAX_WIDTH]; const GLint comps = _mesa_components_in_format(dstFormat); GLuint i; - - if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) { + /* clamping only applies to colors, not the dudv values, but still need + it if converting to unsigned values (which doesn't make much sense) */ + if (dstFormat == GL_DUDV_ATI || dstFormat == GL_DU8DV8_ATI) { + switch (dstType) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_INT: + transferOps |= IMAGE_CLAMP_BIT; + break; + /* actually might want clamp to [-1,1] otherwise but shouldn't matter? */ + } + } + else if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) { /* need to clamp to [0, 1] */ transferOps |= IMAGE_CLAMP_BIT; } @@ -1774,6 +1801,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i 0); + + /* + * Extract image data and convert to RGBA floats + */ + assert(n <= MAX_WIDTH); + extract_float_rgba(n, rgba, srcFormat, srcType, source, + srcPacking->SwapBytes); + + + /* Now determine which color channels we need to produce. + * And determine the dest index (offset) within each color tuple. + */ + + /* Now pack results in the requested dstFormat */ + GLbyte *dst = dest; + GLuint i; + for (i = 0; i < n; i++) { + /* not sure - need clamp[-1,1] here? */ + dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); + dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); + dst += dstComponents; + } + } +} /* * Unpack a row of color index data from a client buffer according to diff --git a/src/mesa/main/image.h b/src/mesa/main/image.h index 0e0bbd96d8..b26c27e5a8 100644 --- a/src/mesa/main/image.h +++ b/src/mesa/main/image.h @@ -198,6 +198,13 @@ _mesa_unpack_color_span_float( GLcontext *ctx, const struct gl_pixelstore_attrib *srcPacking, GLbitfield transferOps ); +extern void +_mesa_unpack_dudv_span_byte( GLcontext *ctx, + GLuint n, GLenum dstFormat, GLbyte dest[], + GLenum srcFormat, GLenum srcType, + const GLvoid *source, + const struct gl_pixelstore_attrib *srcPacking, + GLbitfield transferOps ); extern void _mesa_unpack_index_span( const GLcontext *ctx, GLuint n, diff --git a/src/mesa/main/macros.h b/src/mesa/main/macros.h index 2630855a0e..bfd740870e 100644 --- a/src/mesa/main/macros.h +++ b/src/mesa/main/macros.h @@ -54,13 +54,16 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256]; #define FLOAT_TO_BYTE(X) ( (((GLint) (255.0F * (X))) - 1) / 2 ) -/** Convert GLushort in [0,65536] to GLfloat in [0.0,1.0] */ +/** Convert GLushort in [0,65535] to GLfloat in [0.0,1.0] */ #define USHORT_TO_FLOAT(S) ((GLfloat) (S) * (1.0F / 65535.0F)) +/** Convert GLfloat in [0.0,1.0] to GLushort in [0, 65535] */ +#define FLOAT_TO_USHORT(X) ((GLuint) ((X) * 65535.0)) + /** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */ #define SHORT_TO_FLOAT(S) ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)) -/** Convert GLfloat in [0.0,1.0] to GLshort in [-32768,32767] */ +/** Convert GLfloat in [-1.0,1.0] to GLshort in [-32768,32767] */ #define FLOAT_TO_SHORT(X) ( (((GLint) (65535.0F * (X))) - 1) / 2 ) diff --git a/src/mesa/main/mipmap.c b/src/mesa/main/mipmap.c index 3dd4b3391b..af2bf8fe22 100644 --- a/src/mesa/main/mipmap.c +++ b/src/mesa/main/mipmap.c @@ -85,7 +85,7 @@ bytes_per_pixel(GLenum datatype, GLuint comps) rowC[j][e], rowC[k][e], \ rowD[j][e], rowD[k][e]); \ } while(0) - + #define FILTER_F_3D(e) \ do { \ dst[i][e] = (rowA[j][e] + rowA[k][e] \ @@ -226,7 +226,6 @@ do_row(GLenum datatype, GLuint comps, GLint srcWidth, dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4; } } - else if (datatype == GL_FLOAT && comps == 4) { GLuint i, j, k; const GLfloat(*rowA)[4] = (const GLfloat(*)[4]) srcRowA; @@ -471,6 +470,17 @@ do_row(GLenum datatype, GLuint comps, GLint srcWidth, dst[i] = (blue << 5) | (green << 2) | red; } } + else if (datatype == GL_BYTE && comps == 2) { + GLuint i, j, k; + const GLbyte(*rowA)[2] = (const GLbyte(*)[2]) srcRowA; + const GLbyte(*rowB)[2] = (const GLbyte(*)[2]) srcRowB; + GLbyte(*dst)[2] = (GLbyte(*)[2]) dstRow; + for (i = j = 0, k = k0; i < (GLuint) dstWidth; + i++, j += colStride, k += colStride) { + dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) >> 2; + dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) >> 2; + } + } else { _mesa_problem(NULL, "bad format in do_row()"); } diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 9080c83da4..169f1af057 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -1390,6 +1390,8 @@ struct gl_texture_unit GLbitfield _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */ GLfloat LodBias; /**< for biasing mipmap levels */ + GLenum BumpTarget; + GLfloat RotMatrix[4]; /* 2x2 matrix */ /** * \name GL_EXT_texture_env_combine @@ -2388,6 +2390,8 @@ struct gl_constants GLuint MaxSamples; /**< GL_ARB_framebuffer_object */ GLuint MaxVarying; /**< Number of float[4] varying parameters */ + + GLbitfield SupportedBumpUnits; /**> units supporting GL_ATI_envmap_bumpmap as targets */ }; @@ -2484,6 +2488,7 @@ struct gl_extensions GLboolean APPLE_client_storage; GLboolean APPLE_packed_pixels; GLboolean APPLE_vertex_array_object; + GLboolean ATI_envmap_bumpmap; GLboolean ATI_texture_mirror_once; GLboolean ATI_texture_env_combine3; GLboolean ATI_fragment_shader; diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 95547a500e..c2960fc820 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -142,7 +142,11 @@ set_combiner_mode(GLcontext *ctx, case GL_MODULATE_ADD_ATI: case GL_MODULATE_SIGNED_ADD_ATI: case GL_MODULATE_SUBTRACT_ATI: - legal =ctx->Extensions.ATI_texture_env_combine3; + legal = ctx->Extensions.ATI_texture_env_combine3; + break; + case GL_BUMP_ENVMAP_ATI: + legal = (ctx->Extensions.ATI_envmap_bumpmap && + pname == GL_COMBINE_RGB); break; default: legal = GL_FALSE; @@ -500,6 +504,26 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) case GL_ALPHA_SCALE: set_combiner_scale(ctx, texUnit, pname, param[0]); break; + case GL_BUMP_TARGET_ATI: + if (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname ); + return; + } + if (((GLenum) (GLint) param[0] < GL_TEXTURE0) || + ((GLenum) (GLint) param[0] > GL_TEXTURE31)) { + /* spec doesn't say this but it seems logical */ + _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param=0x%x)", (GLenum) (GLint) param[0]); + return; + } + if (!((1 << ((GLenum) (GLint) param[0] - GL_TEXTURE0)) & ctx->Const.SupportedBumpUnits)) { + _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", (GLenum) (GLint) param[0]); + return; + } + else { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->BumpTarget = (GLenum) (GLint) param[0]; + } + break; default: _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" ); return; @@ -735,6 +759,16 @@ get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); } break; + case GL_BUMP_TARGET_ATI: + /* spec doesn't say so, but I think this should be queryable */ + if (ctx->Extensions.ATI_envmap_bumpmap) { + return texUnit->BumpTarget; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + default: ; } @@ -874,4 +908,142 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) } } +/* why does ATI_envmap_bumpmap require new entrypoints? Should just + reuse TexEnv ones... */ +void GLAPIENTRY +_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ) +{ + GLfloat p[4]; + if (pname == GL_BUMP_ROT_MATRIX_ATI) { + /* hope that conversion is correct here */ + p[0] = INT_TO_FLOAT( param[0] ); + p[1] = INT_TO_FLOAT( param[1] ); + p[2] = INT_TO_FLOAT( param[2] ); + p[3] = INT_TO_FLOAT( param[3] ); + } + else { + p[0] = (GLfloat) param[0]; + p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */ + } + _mesa_TexBumpParameterfvATI( pname, p ); +} + +void GLAPIENTRY +_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) +{ + struct gl_texture_unit *texUnit; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* should return error if extension not supported? */ + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + if (pname == GL_BUMP_ROT_MATRIX_ATI) { + if (TEST_EQ_4V(param, texUnit->RotMatrix)) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + COPY_4FV(texUnit->RotMatrix, param); + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glTexBumpParameter(pname)" ); + return; + } + /* Drivers might want to know about this, instead of dedicated function + just shove it into TexEnv where it really belongs anyway */ + if (ctx->Driver.TexEnv) { + (*ctx->Driver.TexEnv)( ctx, 0, pname, param ); + } +} + +void GLAPIENTRY +_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) +{ + const struct gl_texture_unit *texUnit; + GLint i; + GLint temp = 0; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* should return error if extension not supported? */ + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { + /* spec leaves open to support larger matrices. + Don't think anyone would ever want to use it + (and apps almost certainly would not understand it and + thus fail to submit matrices correctly) so hardcode this. */ + *param = 4; + } + else if (pname == GL_BUMP_ROT_MATRIX_ATI) { + /* hope that conversion is correct here */ + param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]); + param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]); + param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]); + param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]); + } + else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + temp++; + } + } + *param = temp; + } + else if (pname == GL_BUMP_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + *param++ = i + GL_TEXTURE0; + } + } + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" ); + return; + } +} + +void GLAPIENTRY +_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) +{ + const struct gl_texture_unit *texUnit; + GLint i; + GLint temp = 0; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* should return error if extension not supported? */ + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { + /* spec leaves open to support larger matrices. + Don't think anyone would ever want to use it + (and apps might not understand it) so hardcode this. */ + *param = (GLfloat) 4; + } + else if (pname == GL_BUMP_ROT_MATRIX_ATI) { + param[0] = texUnit->RotMatrix[0]; + param[1] = texUnit->RotMatrix[1]; + param[2] = texUnit->RotMatrix[2]; + param[3] = texUnit->RotMatrix[3]; + } + else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + temp++; + } + } + *param = (GLfloat) temp; + } + else if (pname == GL_BUMP_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + *param++ = (GLfloat) (i + GL_TEXTURE0); + } + } + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" ); + return; + } +} diff --git a/src/mesa/main/texenv.h b/src/mesa/main/texenv.h index bdff7fdb82..1e9c5faed7 100644 --- a/src/mesa/main/texenv.h +++ b/src/mesa/main/texenv.h @@ -48,5 +48,16 @@ _mesa_TexEnvi( GLenum target, GLenum pname, GLint param ); extern void GLAPIENTRY _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param ); +extern void GLAPIENTRY +_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ); + +extern void GLAPIENTRY +_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ); + +extern void GLAPIENTRY +_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ); + +extern void GLAPIENTRY +_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ); #endif /* TEXENV_H */ diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c index 51c13a563d..3fbd119b34 100644 --- a/src/mesa/main/texenvprogram.c +++ b/src/mesa/main/texenvprogram.c @@ -94,11 +94,11 @@ struct state_key { GLuint ScaleShiftA:2; GLuint NumArgsRGB:3; - GLuint ModeRGB:4; + GLuint ModeRGB:5; struct mode_opt OptRGB[MAX_TERMS]; GLuint NumArgsA:3; - GLuint ModeA:4; + GLuint ModeA:5; struct mode_opt OptA[MAX_TERMS]; } unit[8]; }; @@ -194,7 +194,8 @@ static GLuint translate_source( GLenum src ) #define MODE_MODULATE_SUBTRACT_ATI 12 /* r = a0 * a2 - a1 */ #define MODE_ADD_PRODUCTS 13 /* r = a0 * a1 + a2 * a3 */ #define MODE_ADD_PRODUCTS_SIGNED 14 /* r = a0 * a1 + a2 * a3 - 0.5 */ -#define MODE_UNKNOWN 15 +#define MODE_BUMP_ENVMAP_ATI 15 /* special */ +#define MODE_UNKNOWN 16 /** * Translate GL combiner state into a MODE_x value @@ -223,6 +224,7 @@ static GLuint translate_mode( GLenum envMode, GLenum mode ) case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI; case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI; case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI; + case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI; default: assert(0); return MODE_UNKNOWN; @@ -383,7 +385,7 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) translate_mode(texUnit->EnvMode, texUnit->_CurrentCombine->ModeRGB); key->unit[i].ModeA = translate_mode(texUnit->EnvMode, texUnit->_CurrentCombine->ModeA); - + key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB; key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftA; @@ -397,8 +399,18 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) key->unit[i].OptA[j].Source = translate_source(texUnit->_CurrentCombine->SourceA[j]); } + + if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) { + /* requires some special translation */ + key->unit[i].NumArgsRGB = 2; + key->unit[i].ScaleShiftRGB = 0; + key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR; + key->unit[i].OptRGB[0].Source = SRC_TEXTURE; + key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR; + key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0; + } } - + if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) { key->separate_specular = 1; inputs_referenced |= FRAG_BIT_COL1; @@ -464,6 +476,11 @@ struct texenv_fragment_program { * else undef. */ + struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS]; + /* Reg containing texcoord for a texture unit, + * needed for bump mapping, else undef. + */ + struct ureg src_previous; /**< Reg containing color from previous * stage. May need to be decl'd. */ @@ -756,6 +773,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p, */ reserve_temp(p, dest); +#if 0 /* Is this a texture indirection? */ if ((coord.file == PROGRAM_TEMPORARY && @@ -767,6 +785,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p, p->alu_temps = 0; assert(0); /* KW: texture env crossbar */ } +#endif return dest; } @@ -1052,6 +1071,10 @@ static struct ureg emit_combine( struct texenv_fragment_program *p, emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef ); } return dest; + case MODE_BUMP_ENVMAP_ATI: + /* special - not handled here */ + assert(0); + return src[0]; default: assert(0); return src[0]; @@ -1074,6 +1097,10 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) if (!key->unit[unit].enabled) { return get_source(p, SRC_PREVIOUS, 0); } + if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) { + /* this isn't really a env stage delivering a color and handled elsewhere */ + return get_source(p, SRC_PREVIOUS, 0); + } switch (key->unit[unit].ModeRGB) { case MODE_DOT3_RGB_EXT: @@ -1163,9 +1190,17 @@ static void load_texture( struct texenv_fragment_program *p, GLuint unit ) { if (is_undef(p->src_texture[unit])) { GLuint texTarget = p->state->unit[unit].source_index; - struct ureg texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit); + struct ureg texcoord; struct ureg tmp = get_tex_temp( p ); + if (is_undef(p->texcoord_tex[unit])) { + texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit); + } + else { + /* might want to reuse this reg for tex output actually */ + texcoord = p->texcoord_tex[unit]; + } + if (texTarget == TEXTURE_UNKNOWN_INDEX) program_error(p, "TexSrcBit"); @@ -1233,7 +1268,7 @@ load_texunit_sources( struct texenv_fragment_program *p, int unit ) GLuint i; for (i = 0; i < key->unit[unit].NumArgsRGB; i++) { - load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit); + load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit ); } for (i = 0; i < key->unit[unit].NumArgsA; i++) { @@ -1243,6 +1278,40 @@ load_texunit_sources( struct texenv_fragment_program *p, int unit ) return GL_TRUE; } +/** + * Generate instructions for loading bump map textures. + */ +static GLboolean +load_texunit_bumpmap( struct texenv_fragment_program *p, int unit ) +{ + struct state_key *key = p->state; + GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0; + struct ureg texcDst, bumpMapRes; + struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0); + struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr); + struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit ); + struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit ); + + load_texenv_source( p, unit + SRC_TEXTURE0, unit ); + + bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit); + texcDst = get_tex_temp( p ); + p->texcoord_tex[bumpedUnitNr] = texcDst; + + /* apply rot matrix and add coords to be available in next phase */ + /* dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1) */ + /* note only 2 coords are affected the rest are left unchanged (mul by 0) */ + emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0, + swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc ); + emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0, + swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst ); + + /* move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish + enough to access this later, should optimize away */ + emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0, constdudvcolor, undef, undef ); + + return GL_TRUE; +} /** * Generate a new fragment program which implements the context's @@ -1267,7 +1336,7 @@ create_new_program(GLcontext *ctx, struct state_key *key, */ p.program->Base.Instructions = instBuffer; p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB; - p.program->Base.NumTexIndirections = 1; /* correct? */ + p.program->Base.NumTexIndirections = 1; p.program->Base.NumTexInstructions = 0; p.program->Base.NumAluInstructions = 0; p.program->Base.String = NULL; @@ -1280,8 +1349,10 @@ create_new_program(GLcontext *ctx, struct state_key *key, p.program->Base.InputsRead = 0; p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR; - for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { p.src_texture[unit] = undef; + p.texcoord_tex[unit] = undef; + } p.src_previous = undef; p.half = undef; @@ -1292,6 +1363,16 @@ create_new_program(GLcontext *ctx, struct state_key *key, release_temps(ctx, &p); if (key->enabled_units) { + GLboolean needbumpstage = GL_FALSE; + /* Zeroth pass - bump map textures first */ + for (unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++) + if (key->unit[unit].enabled && key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) { + needbumpstage = GL_TRUE; + load_texunit_bumpmap( &p, unit ); + } + if (needbumpstage) + p.program->Base.NumTexIndirections++; + /* First pass - to support texture_env_crossbar, first identify * all referenced texture sources and emit texld instructions * for each: diff --git a/src/mesa/main/texformat.c b/src/mesa/main/texformat.c index 16d05cc7d0..61a12493a6 100644 --- a/src/mesa/main/texformat.c +++ b/src/mesa/main/texformat.c @@ -696,6 +696,33 @@ const struct gl_texture_format _mesa_texformat_intensity_float16 = { store_texel_intensity_f16 /* StoreTexel */ }; +const struct gl_texture_format _mesa_texformat_dudv8 = { + MESA_FORMAT_DUDV8, /* MesaFormat */ + GL_DUDV_ATI, /* BaseFormat */ + /* FIXME: spec doesn't say since that parameter didn't exist then, + but this should be something like SIGNED_NORMALIZED */ + GL_UNSIGNED_NORMALIZED_ARB, /* DataType */ + /* maybe should add dudvBits field, but spec seems to be + lacking the ability to query with GetTexLevelParameter anyway */ + 0, /* RedBits */ + 0, /* GreenBits */ + 0, /* BlueBits */ + 0, /* AlphaBits */ + 0, /* LuminanceBits */ + 0, /* IntensityBits */ + 0, /* IndexBits */ + 0, /* DepthBits */ + 0, /* StencilBits */ + 2, /* TexelBytes */ + _mesa_texstore_dudv8, /* StoreTexImageFunc */ + NULL, /* FetchTexel1D */ + NULL, /* FetchTexel2D */ + NULL, /* FetchTexel3D */ + NULL, /* FetchTexel1Df */ + fetch_texel_2d_dudv8, /* FetchTexel2Df */ + NULL, /* FetchTexel3Df */ + NULL /* StoreTexel */ +}; /*@}*/ @@ -1634,6 +1661,16 @@ _mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat, } } + if (ctx->Extensions.ATI_envmap_bumpmap) { + switch (internalFormat) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return &_mesa_texformat_dudv8; + default: + ; /* fallthrough */ + } + } + #if FEATURE_EXT_texture_sRGB if (ctx->Extensions.EXT_texture_sRGB) { switch (internalFormat) { @@ -1778,6 +1815,11 @@ _mesa_format_to_type_and_comps(const struct gl_texture_format *format, *comps = 1; return; + case MESA_FORMAT_DUDV8: + *datatype = GL_BYTE; + *comps = 2; + return; + #if FEATURE_EXT_texture_sRGB case MESA_FORMAT_SRGB8: *datatype = GL_UNSIGNED_BYTE; diff --git a/src/mesa/main/texformat.h b/src/mesa/main/texformat.h index 31364c36b1..7fa70ad4fe 100644 --- a/src/mesa/main/texformat.h +++ b/src/mesa/main/texformat.h @@ -161,7 +161,14 @@ enum _format { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, MESA_FORMAT_INTENSITY_FLOAT32, - MESA_FORMAT_INTENSITY_FLOAT16 + MESA_FORMAT_INTENSITY_FLOAT16, + /*@}*/ + + /** + * \name Signed fixed point texture formats. + */ + /*@{*/ + MESA_FORMAT_DUDV8 /*@}*/ }; @@ -209,6 +216,11 @@ extern const struct gl_texture_format _mesa_texformat_intensity_float32; extern const struct gl_texture_format _mesa_texformat_intensity_float16; /*@}*/ +/** Signed fixed point texture formats */ +/*@{*/ +extern const struct gl_texture_format _mesa_texformat_dudv8; +/*@}*/ + /** \name Assorted hardware-friendly formats */ /*@{*/ extern const struct gl_texture_format _mesa_texformat_rgba8888; diff --git a/src/mesa/main/texformat_tmp.h b/src/mesa/main/texformat_tmp.h index 275340cabd..f9f9d5b1f8 100644 --- a/src/mesa/main/texformat_tmp.h +++ b/src/mesa/main/texformat_tmp.h @@ -1269,7 +1269,7 @@ static void FETCH(sl8)(const struct gl_texture_image *texImage, texel[RCOMP] = texel[GCOMP] = texel[BCOMP] = nonlinear_to_linear(src[0]); - texel[ACOMP] = CHAN_MAX; + texel[ACOMP] = 1.0F; } #if DIM == 3 @@ -1308,7 +1308,22 @@ static void store_texel_sla8(struct gl_texture_image *texImage, #endif /* FEATURE_EXT_texture_sRGB */ +#if DIM == 2 +/* MESA_FORMAT_DUDV8 ********************************************************/ + +/* this format by definition produces 0,0,0,1 as rgba values, + however we'll return the dudv values as rg and fix up elsewhere */ +static void FETCH(dudv8)(const struct gl_texture_image *texImage, + GLint i, GLint j, GLint k, GLfloat *texel ) +{ + const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2); + texel[RCOMP] = BYTE_TO_FLOAT(src[0]); + texel[GCOMP] = BYTE_TO_FLOAT(src[1]); + texel[BCOMP] = 0; + texel[ACOMP] = 0; +} +#endif /* MESA_FORMAT_YCBCR *********************************************************/ diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c index e3d4404759..2ed72280ec 100644 --- a/src/mesa/main/teximage.c +++ b/src/mesa/main/teximage.c @@ -339,6 +339,17 @@ _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat ) } } + if (ctx->Extensions.ATI_envmap_bumpmap) { + switch (internalFormat) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return GL_DUDV_ATI; + default: + ; /* fallthrough */ + } + } + + if (ctx->Extensions.EXT_packed_depth_stencil) { switch (internalFormat) { case GL_DEPTH_STENCIL_EXT: @@ -568,6 +579,20 @@ is_depthstencil_format(GLenum format) } } +/** + * Test if the given image format is a dudv format. + */ +static GLboolean +is_dudv_format(GLenum format) +{ + switch (format) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return GL_TRUE; + default: + return GL_FALSE; + } +} /** @@ -1539,7 +1564,8 @@ texture_error_check( GLcontext *ctx, GLenum target, (is_index_format(internalFormat) && !indexFormat) || (is_depth_format(internalFormat) != is_depth_format(format)) || (is_ycbcr_format(internalFormat) != is_ycbcr_format(format)) || - (is_depthstencil_format(internalFormat) != is_depthstencil_format(format))) { + (is_depthstencil_format(internalFormat) != is_depthstencil_format(format)) || + (is_dudv_format(internalFormat) != is_dudv_format(format))) { if (!isProxy) _mesa_error(ctx, GL_INVALID_OPERATION, "glTexImage(internalFormat/format)"); @@ -2273,6 +2299,12 @@ _mesa_GetTexImage( GLenum target, GLint level, GLenum format, return; } + if (!ctx->Extensions.ATI_envmap_bumpmap + && is_dudv_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return; + } + _mesa_lock_texture(ctx, texObj); { texImage = _mesa_select_tex_image(ctx, texObj, target, level); @@ -2313,6 +2345,11 @@ _mesa_GetTexImage( GLenum target, GLint level, GLenum format, _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); goto out; } + else if (is_dudv_format(format) + && !is_dudv_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + goto out; + } if (ctx->Pack.BufferObj->Name) { /* packing texture image into a PBO */ diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c index d71f9530cb..a5af622910 100644 --- a/src/mesa/main/texstate.c +++ b/src/mesa/main/texstate.c @@ -95,6 +95,11 @@ _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst ) /* GL_EXT_texture_env_combine */ dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine; + /* GL_ATI_envmap_bumpmap - need this? */ + dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget; + COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix); + + /* copy texture object bindings, not contents of texture objects */ _mesa_lock_context_textures(dst); @@ -411,6 +416,10 @@ update_tex_combine(GLcontext *ctx, struct gl_texture_unit *texUnit) case GL_MODULATE_SUBTRACT_ATI: combine->_NumArgsRGB = 3; break; + case GL_BUMP_ENVMAP_ATI: + /* no real arguments for this case */ + combine->_NumArgsRGB = 0; + break; default: combine->_NumArgsRGB = 0; _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state"); @@ -682,6 +691,7 @@ init_texture_unit( GLcontext *ctx, GLuint unit ) texUnit->Combine = default_combine_state; texUnit->_EnvMode = default_combine_state; texUnit->_CurrentCombine = & texUnit->_EnvMode; + texUnit->BumpTarget = GL_TEXTURE0; texUnit->TexGenEnabled = 0x0; texUnit->GenS.Mode = GL_EYE_LINEAR; @@ -702,6 +712,16 @@ init_texture_unit( GLcontext *ctx, GLuint unit ) ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 ); ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 ); ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + /* no mention of this in spec, but maybe id matrix expected? */ + ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 ); /* initialize current texture object ptrs to the shared default objects */ for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { diff --git a/src/mesa/main/texstore.c b/src/mesa/main/texstore.c index 6360ca15f8..cc3c6958c7 100644 --- a/src/mesa/main/texstore.c +++ b/src/mesa/main/texstore.c @@ -2471,6 +2471,95 @@ _mesa_texstore_ycbcr(TEXSTORE_PARAMS) return GL_TRUE; } +GLboolean +_mesa_texstore_dudv8(TEXSTORE_PARAMS) +{ + const GLboolean littleEndian = _mesa_little_endian(); + + ASSERT(dstFormat == &_mesa_texformat_dudv8); + ASSERT(dstFormat->TexelBytes == 2); + ASSERT(ctx->Extensions.ATI_envmap_bumpmap); + ASSERT((srcFormat == GL_DU8DV8_ATI) || + (srcFormat == GL_DUDV_ATI)); + ASSERT(baseInternalFormat == GL_DUDV_ATI); + + if (!srcPacking->SwapBytes && srcType == GL_BYTE && + littleEndian) { + /* simple memcpy path */ + memcpy_texture(ctx, dims, + dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset, + dstRowStride, + dstImageOffsets, + srcWidth, srcHeight, srcDepth, srcFormat, srcType, + srcAddr, srcPacking); + } + else if (srcType == GL_BYTE) { + + GLubyte dstmap[4]; + + /* dstmap - how to swizzle from RGBA to dst format: + */ + if (littleEndian) { + dstmap[0] = 0; + dstmap[1] = 3; + } + else { + dstmap[0] = 3; + dstmap[1] = 0; + } + dstmap[2] = ZERO; /* ? */ + dstmap[3] = ONE; /* ? */ + + _mesa_swizzle_ubyte_image(ctx, dims, + GL_LUMINANCE_ALPHA, /* hack */ + GL_UNSIGNED_BYTE, /* hack */ + GL_LUMINANCE_ALPHA, /* hack */ + dstmap, 2, + dstAddr, dstXoffset, dstYoffset, dstZoffset, + dstRowStride, dstImageOffsets, + srcWidth, srcHeight, srcDepth, srcAddr, + srcPacking); + } + else { + /* general path - note this is defined for 2d textures only */ + const GLint components = _mesa_components_in_format(baseInternalFormat); + const GLint srcStride = _mesa_image_row_stride(srcPacking, + srcWidth, srcFormat, srcType); + GLbyte *tempImage, *dst, *src; + GLint row; + + tempImage = (GLbyte *) _mesa_malloc(srcWidth * srcHeight * srcDepth + * components * sizeof(GLbyte)); + if (!tempImage) + return GL_FALSE; + + src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr, + srcWidth, srcHeight, + srcFormat, srcType, + 0, 0, 0); + + dst = tempImage; + for (row = 0; row < srcHeight; row++) { + _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat, + dst, srcFormat, srcType, src, + srcPacking, 0); + dst += srcWidth * components; + src += srcStride; + } + + src = tempImage; + dst = (GLbyte *) dstAddr + + dstYoffset * dstRowStride + + dstXoffset * dstFormat->TexelBytes; + for (row = 0; row < srcHeight; row++) { + memcpy(dst, src, srcWidth * dstFormat->TexelBytes); + dst += dstRowStride; + src += srcWidth * dstFormat->TexelBytes; + } + _mesa_free((void *) tempImage); + } + return GL_TRUE; +} /** @@ -3882,7 +3971,7 @@ _mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level, GLint col; GLbitfield transferOps = 0x0; - if (type == GL_FLOAT && + if (type == GL_FLOAT && texImage->TexFormat->BaseFormat != GL_DUDV_ATI && ((ctx->Color.ClampReadColor == GL_TRUE) || (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB && texImage->TexFormat->DataType != GL_FLOAT))) diff --git a/src/mesa/main/texstore.h b/src/mesa/main/texstore.h index b03386b2ac..c9e639be4e 100644 --- a/src/mesa/main/texstore.h +++ b/src/mesa/main/texstore.h @@ -78,7 +78,7 @@ extern GLboolean _mesa_texstore_sargb8(TEXSTORE_PARAMS); extern GLboolean _mesa_texstore_sl8(TEXSTORE_PARAMS); extern GLboolean _mesa_texstore_sla8(TEXSTORE_PARAMS); #endif - +extern GLboolean _mesa_texstore_dudv8(TEXSTORE_PARAMS); extern GLchan * _mesa_make_temp_chan_image(GLcontext *ctx, GLuint dims, diff --git a/src/mesa/shader/prog_statevars.c b/src/mesa/shader/prog_statevars.c index 1f7d87ccc9..f51d9e2651 100644 --- a/src/mesa/shader/prog_statevars.c +++ b/src/mesa/shader/prog_statevars.c @@ -506,6 +506,26 @@ _mesa_fetch_state(GLcontext *ctx, const gl_state_index state[], } } return; + case STATE_ROT_MATRIX_0: + { + const int unit = (int) state[2]; + GLfloat *rotMat22 = ctx->Texture.Unit[unit].RotMatrix; + value[0] = rotMat22[0]; + value[1] = rotMat22[2]; + value[2] = 0.0; + value[3] = 0.0; + } + break; + case STATE_ROT_MATRIX_1: + { + const int unit = (int) state[2]; + GLfloat *rotMat22 = ctx->Texture.Unit[unit].RotMatrix; + value[0] = rotMat22[1]; + value[1] = rotMat22[3]; + value[2] = 0.0; + value[3] = 0.0; + } + break; /* XXX: make sure new tokens added here are also handled in the * _mesa_program_state_flags() switch, below. @@ -591,6 +611,8 @@ _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH]) case STATE_TEXRECT_SCALE: case STATE_SHADOW_AMBIENT: + case STATE_ROT_MATRIX_0: + case STATE_ROT_MATRIX_1: return _NEW_TEXTURE; case STATE_FOG_PARAMS_OPTIMIZED: return _NEW_FOG; @@ -806,6 +828,12 @@ append_token(char *dst, gl_state_index k) case STATE_SHADOW_AMBIENT: append(dst, "CompareFailValue"); break; + case STATE_ROT_MATRIX_0: + append(dst, "rotMatrixRow0"); + break; + case STATE_ROT_MATRIX_1: + append(dst, "rotMatrixRow1"); + break; default: /* probably STATE_INTERNAL_DRIVER+i (driver private state) */ append(dst, "driverState"); diff --git a/src/mesa/shader/prog_statevars.h b/src/mesa/shader/prog_statevars.h index d5358a1d04..d563080db1 100644 --- a/src/mesa/shader/prog_statevars.h +++ b/src/mesa/shader/prog_statevars.h @@ -117,6 +117,8 @@ typedef enum gl_state_index_ { STATE_PCM_SCALE, /**< Post color matrix RGBA scale */ STATE_PCM_BIAS, /**< Post color matrix RGBA bias */ STATE_SHADOW_AMBIENT, /**< ARB_shadow_ambient fail value; token[2] is texture unit index */ + STATE_ROT_MATRIX_0, /**< ATI_envmap_bumpmap, rot matrix row 0 */ + STATE_ROT_MATRIX_1, /**< ATI_envmap_bumpmap, rot matrix row 1 */ STATE_INTERNAL_DRIVER /* first available state index for drivers (must be last) */ } gl_state_index; diff --git a/src/mesa/swrast/s_texcombine.c b/src/mesa/swrast/s_texcombine.c index 38b5633887..aa28311672 100644 --- a/src/mesa/swrast/s_texcombine.c +++ b/src/mesa/swrast/s_texcombine.c @@ -591,6 +591,25 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, } } break; + case GL_BUMP_ENVMAP_ATI: + { + /* this produces a fixed rgba color, and the coord calc is done elsewhere */ + for (i = 0; i < n; i++) { + /* rgba result is 0,0,0,1 */ +#if CHAN_TYPE == GL_FLOAT + rgba[i][RCOMP] = 0.0; + rgba[i][GCOMP] = 0.0; + rgba[i][BCOMP] = 0.0; + rgba[i][ACOMP] = 1.0; +#else + rgba[i][RCOMP] = 0; + rgba[i][GCOMP] = 0; + rgba[i][BCOMP] = 0; + rgba[i][ACOMP] = CHAN_MAX; +#endif + } + } + return; /* no alpha processing */ default: _mesa_problem(ctx, "invalid combine mode"); } @@ -1218,12 +1237,86 @@ _swrast_texture_span( GLcontext *ctx, SWspan *span ) if (swrast->_AnyTextureCombine) MEMCPY(primary_rgba, span->array->rgba, 4 * span->end * sizeof(GLchan)); + /* First must sample all bump maps */ + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { + if (ctx->Texture.Unit[unit]._ReallyEnabled && + ctx->Texture.Unit[unit]._CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) { + const GLfloat (*texcoords)[4] + = (const GLfloat (*)[4]) + span->array->attribs[FRAG_ATTRIB_TEX0 + unit]; + GLfloat (*targetcoords)[4] + = (GLfloat (*)[4]) + span->array->attribs[FRAG_ATTRIB_TEX0 + + ctx->Texture.Unit[unit].BumpTarget - GL_TEXTURE0]; + + const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + const struct gl_texture_object *curObj = texUnit->_Current; + GLfloat *lambda = span->array->lambda[unit]; + GLchan (*texels)[4] = (GLchan (*)[4]) + (swrast->TexelBuffer + unit * (span->end * 4 * sizeof(GLchan))); + GLuint i; + GLfloat rotMatrix00 = ctx->Texture.Unit[unit].RotMatrix[0]; + GLfloat rotMatrix01 = ctx->Texture.Unit[unit].RotMatrix[1]; + GLfloat rotMatrix10 = ctx->Texture.Unit[unit].RotMatrix[2]; + GLfloat rotMatrix11 = ctx->Texture.Unit[unit].RotMatrix[3]; + + /* adjust texture lod (lambda) */ + if (span->arrayMask & SPAN_LAMBDA) { + if (texUnit->LodBias + curObj->LodBias != 0.0F) { + /* apply LOD bias, but don't clamp yet */ + const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias, + -ctx->Const.MaxTextureLodBias, + ctx->Const.MaxTextureLodBias); + GLuint i; + for (i = 0; i < span->end; i++) { + lambda[i] += bias; + } + } + + if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) { + /* apply LOD clamping to lambda */ + const GLfloat min = curObj->MinLod; + const GLfloat max = curObj->MaxLod; + GLuint i; + for (i = 0; i < span->end; i++) { + GLfloat l = lambda[i]; + lambda[i] = CLAMP(l, min, max); + } + } + } + + /* Sample the texture (span->end = number of fragments) */ + swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end, + texcoords, lambda, texels ); + + /* manipulate the span values of the bump target + not sure this can work correctly even ignoring + the problem that channel is unsigned */ + for (i = 0; i < span->end; i++) { +#if CHAN_TYPE == GL_FLOAT + targetcoords[i][0] += (texels[i][0] * rotMatrix00 + texels[i][1] * + rotMatrix01) / targetcoords[i][3]; + targetcoords[i][1] += (texels[i][0] * rotMatrix10 + texels[i][1] * + rotMatrix11) / targetcoords[i][3]; +#else + targetcoords[i][0] += (CHAN_TO_FLOAT(texels[i][1]) * rotMatrix00 + + CHAN_TO_FLOAT(texels[i][1]) * rotMatrix01) / + targetcoords[i][3]; + targetcoords[i][1] += (CHAN_TO_FLOAT(texels[i][0]) * rotMatrix10 + + CHAN_TO_FLOAT(texels[i][1]) * rotMatrix11) / + targetcoords[i][3]; +#endif + } + } + } + /* * Must do all texture sampling before combining in order to * accomodate GL_ARB_texture_env_crossbar. */ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit]._ReallyEnabled) { + if (ctx->Texture.Unit[unit]._ReallyEnabled && + ctx->Texture.Unit[unit]._CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) { const GLfloat (*texcoords)[4] = (const GLfloat (*)[4]) span->array->attribs[FRAG_ATTRIB_TEX0 + unit]; -- cgit v1.2.3 From bd9b2be8284fda3f8aac235908ded118b5648a38 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Sun, 8 Mar 2009 17:58:54 -0600 Subject: mesa: texture combine clean-ups Use MAX_COMBINER_TERMS instead of 4. Rename some vars. Update comments. --- src/mesa/main/mtypes.h | 15 +++-- src/mesa/main/texenv.c | 50 +++++++-------- src/mesa/main/texenvprogram.c | 13 ++-- src/mesa/swrast/s_fragprog.c | 2 - src/mesa/swrast/s_texcombine.c | 140 ++++++++++++++++++++--------------------- 5 files changed, 108 insertions(+), 112 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index e77dd1d226..c1f06885ec 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -1338,18 +1338,23 @@ struct gl_texture_object }; +/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */ +#define MAX_COMBINER_TERMS 4 + + /** * Texture combine environment state. - * Up to four combiner sources are possible with GL_NV_texture_env_combine4. */ struct gl_tex_env_combine_state { GLenum ModeRGB; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */ GLenum ModeA; /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */ - GLenum SourceRGB[4]; /**< GL_PRIMARY_COLOR, GL_TEXTURE, etc. */ - GLenum SourceA[4]; /**< GL_PRIMARY_COLOR, GL_TEXTURE, etc. */ - GLenum OperandRGB[4]; /**< SRC_COLOR, ONE_MINUS_SRC_COLOR, etc */ - GLenum OperandA[4]; /**< SRC_ALPHA, ONE_MINUS_SRC_ALPHA, etc */ + /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */ + GLenum SourceRGB[MAX_COMBINER_TERMS]; + GLenum SourceA[MAX_COMBINER_TERMS]; + /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */ + GLenum OperandRGB[MAX_COMBINER_TERMS]; + GLenum OperandA[MAX_COMBINER_TERMS]; GLuint ScaleShiftRGB; /**< 0, 1 or 2 */ GLuint ScaleShiftA; /**< 0, 1 or 2 */ GLuint _NumArgsRGB; /**< Number of inputs used for the RGB combiner */ diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index c2960fc820..4d511f2f7e 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -184,7 +184,7 @@ set_combiner_source(GLcontext *ctx, struct gl_texture_unit *texUnit, GLenum pname, GLenum param) { - GLuint src; + GLuint term; GLboolean alpha, legal; if (!ctx->Extensions.EXT_texture_env_combine && @@ -194,24 +194,24 @@ set_combiner_source(GLcontext *ctx, } /* - * Translate pname to (src, alpha). + * Translate pname to (term, alpha). */ switch (pname) { case GL_SOURCE0_RGB: - src = 0; + term = 0; alpha = GL_FALSE; break; case GL_SOURCE1_RGB: - src = 1; + term = 1; alpha = GL_FALSE; break; case GL_SOURCE2_RGB: - src = 2; + term = 2; alpha = GL_FALSE; break; case GL_SOURCE3_RGB_NV: if (ctx->Extensions.NV_texture_env_combine4) { - src = 3; + term = 3; alpha = GL_FALSE; } else { @@ -220,20 +220,20 @@ set_combiner_source(GLcontext *ctx, } break; case GL_SOURCE0_ALPHA: - src = 0; + term = 0; alpha = GL_TRUE; break; case GL_SOURCE1_ALPHA: - src = 1; + term = 1; alpha = GL_TRUE; break; case GL_SOURCE2_ALPHA: - src = 2; + term = 2; alpha = GL_TRUE; break; case GL_SOURCE3_ALPHA_NV: if (ctx->Extensions.NV_texture_env_combine4) { - src = 3; + term = 3; alpha = GL_TRUE; } else { @@ -246,7 +246,7 @@ set_combiner_source(GLcontext *ctx, return; } - assert(src < 4); + assert(term < MAX_COMBINER_TERMS); /* * Error-check param (the source term) @@ -288,9 +288,9 @@ set_combiner_source(GLcontext *ctx, FLUSH_VERTICES(ctx, _NEW_TEXTURE); if (alpha) - texUnit->Combine.SourceA[src] = param; + texUnit->Combine.SourceA[term] = param; else - texUnit->Combine.SourceRGB[src] = param; + texUnit->Combine.SourceRGB[term] = param; } @@ -300,7 +300,7 @@ set_combiner_operand(GLcontext *ctx, struct gl_texture_unit *texUnit, GLenum pname, GLenum param) { - GLuint op; + GLuint term; GLboolean alpha, legal; if (!ctx->Extensions.EXT_texture_env_combine && @@ -311,16 +311,16 @@ set_combiner_operand(GLcontext *ctx, switch (pname) { case GL_OPERAND0_RGB: - op = 0; + term = 0; alpha = GL_FALSE; break; case GL_OPERAND1_RGB: - op = 1; + term = 1; alpha = GL_FALSE; break; case GL_OPERAND2_RGB: if (ctx->Extensions.ARB_texture_env_combine) { - op = 2; + term = 2; alpha = GL_FALSE; } else { @@ -330,7 +330,7 @@ set_combiner_operand(GLcontext *ctx, break; case GL_OPERAND3_RGB_NV: if (ctx->Extensions.NV_texture_env_combine4) { - op = 3; + term = 3; alpha = GL_FALSE; } else { @@ -339,16 +339,16 @@ set_combiner_operand(GLcontext *ctx, } break; case GL_OPERAND0_ALPHA: - op = 0; + term = 0; alpha = GL_TRUE; break; case GL_OPERAND1_ALPHA: - op = 1; + term = 1; alpha = GL_TRUE; break; case GL_OPERAND2_ALPHA: if (ctx->Extensions.ARB_texture_env_combine) { - op = 2; + term = 2; alpha = GL_TRUE; } else { @@ -358,7 +358,7 @@ set_combiner_operand(GLcontext *ctx, break; case GL_OPERAND3_ALPHA_NV: if (ctx->Extensions.NV_texture_env_combine4) { - op = 3; + term = 3; alpha = GL_TRUE; } else { @@ -371,7 +371,7 @@ set_combiner_operand(GLcontext *ctx, return; } - assert(op < 4); + assert(term < MAX_COMBINER_TERMS); /* * Error-check param (the source operand) @@ -397,9 +397,9 @@ set_combiner_operand(GLcontext *ctx, FLUSH_VERTICES(ctx, _NEW_TEXTURE); if (alpha) - texUnit->Combine.OperandA[op] = param; + texUnit->Combine.OperandA[term] = param; else - texUnit->Combine.OperandRGB[op] = param; + texUnit->Combine.OperandRGB[term] = param; } diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c index 3fbd119b34..4a124bf27e 100644 --- a/src/mesa/main/texenvprogram.c +++ b/src/mesa/main/texenvprogram.c @@ -39,9 +39,6 @@ #include "texenvprogram.h" -#define MAX_TERMS 4 - - /* * Note on texture units: * @@ -95,11 +92,11 @@ struct state_key { GLuint NumArgsRGB:3; GLuint ModeRGB:5; - struct mode_opt OptRGB[MAX_TERMS]; + struct mode_opt OptRGB[MAX_COMBINER_TERMS]; GLuint NumArgsA:3; GLuint ModeA:5; - struct mode_opt OptA[MAX_TERMS]; + struct mode_opt OptA[MAX_COMBINER_TERMS]; } unit[8]; }; @@ -389,7 +386,7 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB; key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftA; - for (j = 0; j < MAX_TERMS; j++) { + for (j = 0; j < MAX_COMBINER_TERMS; j++) { key->unit[i].OptRGB[j].Operand = translate_operand(texUnit->_CurrentCombine->OperandRGB[j]); key->unit[i].OptA[j].Operand = @@ -972,11 +969,11 @@ static struct ureg emit_combine( struct texenv_fragment_program *p, GLuint mode, const struct mode_opt *opt) { - struct ureg src[MAX_TERMS]; + struct ureg src[MAX_COMBINER_TERMS]; struct ureg tmp, half; GLuint i; - assert(nr <= MAX_TERMS); + assert(nr <= MAX_COMBINER_TERMS); tmp = undef; /* silence warning (bug 5318) */ diff --git a/src/mesa/swrast/s_fragprog.c b/src/mesa/swrast/s_fragprog.c index 5f032bbd69..b71fb9eae9 100644 --- a/src/mesa/swrast/s_fragprog.c +++ b/src/mesa/swrast/s_fragprog.c @@ -74,7 +74,6 @@ fetch_texel_lod( GLcontext *ctx, const GLfloat texcoord[4], GLfloat lambda, lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod); - /* XXX use a float-valued TextureSample routine here!!! */ swrast->TextureSample[unit](ctx, texObj, 1, (const GLfloat (*)[4]) texcoord, &lambda, &rgba); @@ -116,7 +115,6 @@ fetch_texel_deriv( GLcontext *ctx, const GLfloat texcoord[4], lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod); - /* XXX use a float-valued TextureSample routine here!!! */ swrast->TextureSample[unit](ctx, texObj, 1, (const GLfloat (*)[4]) texcoord, &lambda, &rgba); diff --git a/src/mesa/swrast/s_texcombine.c b/src/mesa/swrast/s_texcombine.c index 27c5c15cf1..76b95e8ae7 100644 --- a/src/mesa/swrast/s_texcombine.c +++ b/src/mesa/swrast/s_texcombine.c @@ -37,23 +37,23 @@ #include "s_texcombine.h" -#define MAX_COMBINER_TERMS 4 - - /** - * Do texture application for GL_ARB/EXT_texture_env_combine. - * This function also supports GL_{EXT,ARB}_texture_env_dot3 and - * GL_ATI_texture_env_combine3. Since "classic" texture environments are - * implemented using GL_ARB_texture_env_combine-like state, this same function - * is used for classic texture environment application as well. + * Do texture application for: + * GL_EXT_texture_env_combine + * GL_ARB_texture_env_combine + * GL_EXT_texture_env_dot3 + * GL_ARB_texture_env_dot3 + * GL_ATI_texture_env_combine3 + * GL_NV_texture_env_combine4 + * conventional GL texture env modes * * \param ctx rendering context - * \param textureUnit the texture unit to apply + * \param unit the texture combiner unit * \param n number of fragments to process (span width) * \param primary_rgba incoming fragment color array * \param texelBuffer pointer to texel colors for all texture units * - * \param rgba incoming colors, which get modified here + * \param rgba incoming/result fragment colors */ static void texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, @@ -65,16 +65,14 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, const struct gl_tex_env_combine_state *combine = textureUnit->_CurrentCombine; const GLfloat (*argRGB [MAX_COMBINER_TERMS])[4]; const GLfloat (*argA [MAX_COMBINER_TERMS])[4]; - const GLfloat RGBmult = (GLfloat) (1 << combine->ScaleShiftRGB); - const GLfloat Amult = (GLfloat) (1 << combine->ScaleShiftA); - const GLuint numColorArgs = combine->_NumArgsRGB; - const GLuint numAlphaArgs = combine->_NumArgsA; + const GLfloat scaleRGB = (GLfloat) (1 << combine->ScaleShiftRGB); + const GLfloat scaleA = (GLfloat) (1 << combine->ScaleShiftA); + const GLuint numArgsRGB = combine->_NumArgsRGB; + const GLuint numArgsA = combine->_NumArgsA; GLfloat ccolor[MAX_COMBINER_TERMS][MAX_WIDTH][4]; /* temp color buffers */ GLfloat rgba[MAX_WIDTH][4]; GLuint i, term; - ASSERT(ctx->Extensions.EXT_texture_env_combine || - ctx->Extensions.ARB_texture_env_combine); ASSERT(CONST_SWRAST_CONTEXT(ctx)->_AnyTextureCombine); for (i = 0; i < n; i++) { @@ -97,7 +95,7 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, /* * Do operand setup for up to 4 operands. Loop over the terms. */ - for (term = 0; term < numColorArgs; term++) { + for (term = 0; term < numArgsRGB; term++) { const GLenum srcRGB = combine->SourceRGB[term]; const GLenum operandRGB = combine->OperandRGB[term]; @@ -193,9 +191,9 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, } /* - * Set up the argA[i] pointers + * Set up the argA[term] pointers */ - for (term = 0; term < numAlphaArgs; term++) { + for (term = 0; term < numArgsA; term++) { const GLenum srcA = combine->SourceA[term]; const GLenum operandA = combine->OperandA[term]; @@ -269,16 +267,16 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, switch (combine->ModeRGB) { case GL_REPLACE: for (i = 0; i < n; i++) { - rgba[i][RCOMP] = arg0[i][RCOMP] * RGBmult; - rgba[i][GCOMP] = arg0[i][GCOMP] * RGBmult; - rgba[i][BCOMP] = arg0[i][BCOMP] * RGBmult; + rgba[i][RCOMP] = arg0[i][RCOMP] * scaleRGB; + rgba[i][GCOMP] = arg0[i][GCOMP] * scaleRGB; + rgba[i][BCOMP] = arg0[i][BCOMP] * scaleRGB; } break; case GL_MODULATE: for (i = 0; i < n; i++) { - rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * RGBmult; - rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * RGBmult; - rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * RGBmult; + rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * scaleRGB; + rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * scaleRGB; + rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * scaleRGB; } break; case GL_ADD: @@ -286,19 +284,19 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, /* (a * b) + (c * d) */ for (i = 0; i < n; i++) { rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] + - arg2[i][RCOMP] * arg3[i][RCOMP]) * RGBmult; + arg2[i][RCOMP] * arg3[i][RCOMP]) * scaleRGB; rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] + - arg2[i][GCOMP] * arg3[i][GCOMP]) * RGBmult; + arg2[i][GCOMP] * arg3[i][GCOMP]) * scaleRGB; rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] + - arg2[i][BCOMP] * arg3[i][BCOMP]) * RGBmult; + arg2[i][BCOMP] * arg3[i][BCOMP]) * scaleRGB; } } else { /* 2-term addition */ for (i = 0; i < n; i++) { - rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * RGBmult; - rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * RGBmult; - rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * RGBmult; + rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * scaleRGB; + rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * scaleRGB; + rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * scaleRGB; } } break; @@ -307,45 +305,45 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, /* (a * b) + (c * d) - 0.5 */ for (i = 0; i < n; i++) { rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] * - arg2[i][RCOMP] + arg3[i][RCOMP] - 0.5) * RGBmult; + arg2[i][RCOMP] + arg3[i][RCOMP] - 0.5) * scaleRGB; rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] * - arg2[i][GCOMP] + arg3[i][GCOMP] - 0.5) * RGBmult; + arg2[i][GCOMP] + arg3[i][GCOMP] - 0.5) * scaleRGB; rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] * - arg2[i][BCOMP] + arg3[i][BCOMP] - 0.5) * RGBmult; + arg2[i][BCOMP] + arg3[i][BCOMP] - 0.5) * scaleRGB; } } else { for (i = 0; i < n; i++) { - rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5) * RGBmult; - rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5) * RGBmult; - rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5) * RGBmult; + rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5) * scaleRGB; + rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5) * scaleRGB; + rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5) * scaleRGB; } } break; case GL_INTERPOLATE: for (i = 0; i < n; i++) { rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] + - arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * RGBmult; + arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * scaleRGB; rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] + - arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * RGBmult; + arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * scaleRGB; rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] + - arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * RGBmult; + arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * scaleRGB; } break; case GL_SUBTRACT: for (i = 0; i < n; i++) { - rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * RGBmult; - rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * RGBmult; - rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * RGBmult; + rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * scaleRGB; + rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * scaleRGB; + rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * scaleRGB; } break; case GL_DOT3_RGB_EXT: case GL_DOT3_RGBA_EXT: /* Do not scale the result by 1 2 or 4 */ for (i = 0; i < n; i++) { - GLfloat dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) + - (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) + - (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F)) + GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) + + (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) + + (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F)) * 4.0F; dot = CLAMP(dot, 0.0F, 1.0F); rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLfloat) dot; @@ -355,10 +353,10 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, case GL_DOT3_RGBA: /* DO scale the result by 1 2 or 4 */ for (i = 0; i < n; i++) { - GLfloat dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) + - (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) + - (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F)) - * 4.0F * RGBmult; + GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) + + (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) + + (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F)) + * 4.0F * scaleRGB; dot = CLAMP(dot, 0.0, 1.0F); rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLfloat) dot; } @@ -366,31 +364,31 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, case GL_MODULATE_ADD_ATI: for (i = 0; i < n; i++) { rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) + - arg1[i][RCOMP]) * RGBmult; + arg1[i][RCOMP]) * scaleRGB; rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) + - arg1[i][GCOMP]) * RGBmult; + arg1[i][GCOMP]) * scaleRGB; rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) + - arg1[i][BCOMP]) * RGBmult; + arg1[i][BCOMP]) * scaleRGB; } break; case GL_MODULATE_SIGNED_ADD_ATI: for (i = 0; i < n; i++) { rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) + - arg1[i][RCOMP] - 0.5) * RGBmult; + arg1[i][RCOMP] - 0.5) * scaleRGB; rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) + - arg1[i][GCOMP] - 0.5) * RGBmult; + arg1[i][GCOMP] - 0.5) * scaleRGB; rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) + - arg1[i][BCOMP] - 0.5) * RGBmult; + arg1[i][BCOMP] - 0.5) * scaleRGB; } break; case GL_MODULATE_SUBTRACT_ATI: for (i = 0; i < n; i++) { rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) - - arg1[i][RCOMP]) * RGBmult; + arg1[i][RCOMP]) * scaleRGB; rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) - - arg1[i][GCOMP]) * RGBmult; + arg1[i][GCOMP]) * scaleRGB; rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) - - arg1[i][BCOMP]) * RGBmult; + arg1[i][BCOMP]) * scaleRGB; } break; case GL_BUMP_ENVMAP_ATI: @@ -427,13 +425,13 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, switch (combine->ModeA) { case GL_REPLACE: for (i = 0; i < n; i++) { - GLfloat a = arg0[i][ACOMP] * Amult; + GLfloat a = arg0[i][ACOMP] * scaleA; rgba[i][ACOMP] = (GLfloat) MIN2(a, 1.0F); } break; case GL_MODULATE: for (i = 0; i < n; i++) { - rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * Amult; + rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * scaleA; } break; case GL_ADD: @@ -441,13 +439,13 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, /* (a * b) + (c * d) */ for (i = 0; i < n; i++) { rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] + - arg2[i][ACOMP] * arg3[i][ACOMP]) * Amult; + arg2[i][ACOMP] * arg3[i][ACOMP]) * scaleA; } } else { /* two-term add */ for (i = 0; i < n; i++) { - rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * Amult; + rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * scaleA; } } break; @@ -457,13 +455,13 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, for (i = 0; i < n; i++) { rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] + arg2[i][ACOMP] * arg3[i][ACOMP] - - 0.5) * Amult; + 0.5) * scaleA; } } else { /* a + b - 0.5 */ for (i = 0; i < n; i++) { - rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * Amult; + rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * scaleA; } } break; @@ -471,30 +469,30 @@ texture_combine( const GLcontext *ctx, GLuint unit, GLuint n, for (i=0; i Date: Mon, 15 Jun 2009 19:17:07 +0100 Subject: mesa: Use integer type with appropriate sign. --- src/mesa/main/api_validate.c | 4 ++-- src/mesa/main/texenv.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/api_validate.c b/src/mesa/main/api_validate.c index 42d1e579e0..2c6f370df9 100644 --- a/src/mesa/main/api_validate.c +++ b/src/mesa/main/api_validate.c @@ -40,7 +40,7 @@ max_buffer_index(GLcontext *ctx, GLuint count, GLenum type, { const GLubyte *map = NULL; GLuint max = 0; - GLint i; + GLuint i; if (elementBuf->Name) { /* elements are in a user-defined buffer object. need to map it */ @@ -224,7 +224,7 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode, /* Vertex buffer object tests */ if (ctx->Array.ElementArrayBufferObj->Name) { /* use indices in the buffer object */ - GLuint indexBytes; + GLsizei indexBytes; if (type == GL_UNSIGNED_INT) { indexBytes = count * sizeof(GLuint); diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 4d511f2f7e..4c04a7ed37 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -959,7 +959,7 @@ void GLAPIENTRY _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) { const struct gl_texture_unit *texUnit; - GLint i; + GLuint i; GLint temp = 0; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -1006,7 +1006,7 @@ void GLAPIENTRY _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) { const struct gl_texture_unit *texUnit; - GLint i; + GLuint i; GLint temp = 0; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); -- cgit v1.2.3 From 6aa7a03d856f4cfdbed493c976387b2164a0c922 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Thu, 13 Aug 2009 09:55:34 -0600 Subject: mesa: use _mesa_get_current_tex_unit() in more places --- src/mesa/main/texenv.c | 16 ++++++++------ src/mesa/main/texgetimage.c | 19 ++++------------- src/mesa/main/teximage.c | 52 +++++++++++++++++---------------------------- src/mesa/main/texparam.c | 9 ++++---- src/mesa/main/texstate.h | 18 ++++++++++++---- 5 files changed, 53 insertions(+), 61 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 4c04a7ed37..1eab78c74c 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -35,6 +35,7 @@ #include "main/enums.h" #include "main/macros.h" #include "main/texenv.h" +#include "main/texstate.h" #define TE_ERROR(errCode, msg, value) \ @@ -466,7 +467,7 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); if (target == GL_TEXTURE_ENV) { switch (pname) { @@ -793,7 +794,7 @@ _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); if (target == GL_TEXTURE_ENV) { if (pname == GL_TEXTURE_ENV_COLOR) { @@ -857,7 +858,7 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); if (target == GL_TEXTURE_ENV) { if (pname == GL_TEXTURE_ENV_COLOR) { @@ -936,7 +937,8 @@ _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) ASSERT_OUTSIDE_BEGIN_END(ctx); /* should return error if extension not supported? */ - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + texUnit = _mesa_get_current_tex_unit(ctx); if (pname == GL_BUMP_ROT_MATRIX_ATI) { if (TEST_EQ_4V(param, texUnit->RotMatrix)) @@ -965,7 +967,8 @@ _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) ASSERT_OUTSIDE_BEGIN_END(ctx); /* should return error if extension not supported? */ - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + texUnit = _mesa_get_current_tex_unit(ctx); if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { /* spec leaves open to support larger matrices. @@ -1012,7 +1015,8 @@ _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) ASSERT_OUTSIDE_BEGIN_END(ctx); /* should return error if extension not supported? */ - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + texUnit = _mesa_get_current_tex_unit(ctx); if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { /* spec leaves open to support larger matrices. diff --git a/src/mesa/main/texgetimage.c b/src/mesa/main/texgetimage.c index 8800ee22ea..2d3b82dd38 100644 --- a/src/mesa/main/texgetimage.c +++ b/src/mesa/main/texgetimage.c @@ -37,6 +37,7 @@ #include "texformat.h" #include "texgetimage.h" #include "teximage.h" +#include "texstate.h" @@ -106,18 +107,6 @@ type_with_negative_values(GLenum type) } -/** - * Return pointer to current texture unit. - * This the texture unit set by glActiveTexture(), not glClientActiveTexture(). - */ -static INLINE struct gl_texture_unit * -get_current_tex_unit(GLcontext *ctx) -{ - ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->Texture.Unit)); - return &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]); -} - - /** * This is the software fallback for Driver.GetTexImage(). * All error checking will have been done before this routine is called. @@ -429,7 +418,7 @@ getteximage_error_check(GLcontext *ctx, GLenum target, GLint level, return GL_TRUE; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); if (!texObj || _mesa_is_proxy_texture(target)) { @@ -519,7 +508,7 @@ _mesa_GetTexImage( GLenum target, GLint level, GLenum format, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -545,7 +534,7 @@ _mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img) GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); if (!texObj) { _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB"); diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c index 56d3790408..19e47b460f 100644 --- a/src/mesa/main/teximage.c +++ b/src/mesa/main/teximage.c @@ -575,18 +575,6 @@ _mesa_is_proxy_texture(GLenum target) } -/** - * Return pointer to current texture unit. - * This the texture unit set by glActiveTexture(), not glClientActiveTexture(). - */ -static INLINE struct gl_texture_unit * -get_current_tex_unit(GLcontext *ctx) -{ - ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->Texture.Unit)); - return &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]); -} - - /** * Get the texture object that corresponds to the target of the given texture unit. * @@ -2163,7 +2151,7 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat, if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2271,7 +2259,7 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat, if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2374,7 +2362,7 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat, if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2480,7 +2468,7 @@ _mesa_TexSubImage1D( GLenum target, GLint level, } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); assert(texObj); @@ -2540,7 +2528,7 @@ _mesa_TexSubImage2D( GLenum target, GLint level, return; /* error was detected */ } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2592,7 +2580,7 @@ _mesa_TexSubImage3D( GLenum target, GLint level, return; /* error was detected */ } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -2653,7 +2641,7 @@ _mesa_CopyTexImage1D( GLenum target, GLint level, postConvWidth, 1, border)) return; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2719,7 +2707,7 @@ _mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, postConvWidth, postConvHeight, border)) return; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -2779,7 +2767,7 @@ _mesa_CopyTexSubImage1D( GLenum target, GLint level, if (copytexsubimage_error_check1(ctx, 1, target, level)) return; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -2834,7 +2822,7 @@ _mesa_CopyTexSubImage2D( GLenum target, GLint level, if (copytexsubimage_error_check1(ctx, 2, target, level)) return; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -2889,7 +2877,7 @@ _mesa_CopyTexSubImage3D( GLenum target, GLint level, if (copytexsubimage_error_check1(ctx, 3, target, level)) return; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3143,7 +3131,7 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3197,7 +3185,7 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level, struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; struct gl_texture_image *texImage; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3240,7 +3228,7 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3296,7 +3284,7 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level, struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; struct gl_texture_image *texImage; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3336,7 +3324,7 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3390,7 +3378,7 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level, struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; struct gl_texture_image *texImage; - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3429,7 +3417,7 @@ _mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3486,7 +3474,7 @@ _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3543,7 +3531,7 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, return; } - texUnit = get_current_tex_unit(ctx); + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { diff --git a/src/mesa/main/texparam.c b/src/mesa/main/texparam.c index d27c59381c..d9ba6007a0 100644 --- a/src/mesa/main/texparam.c +++ b/src/mesa/main/texparam.c @@ -38,6 +38,7 @@ #include "main/texcompress.h" #include "main/texparam.h" #include "main/teximage.h" +#include "main/texstate.h" #include "shader/prog_instruction.h" @@ -88,7 +89,7 @@ get_texobj(GLcontext *ctx, GLenum target) return NULL; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); switch (target) { case GL_TEXTURE_1D: @@ -773,7 +774,7 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); /* this will catch bad target values */ dimensions = tex_image_dimensions(ctx, target); /* 1, 2 or 3 */ @@ -1002,7 +1003,7 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); obj = _mesa_select_tex_object(ctx, texUnit, target); if (!obj) { @@ -1169,7 +1170,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); obj = _mesa_select_tex_object(ctx, texUnit, target); if (!obj) { diff --git a/src/mesa/main/texstate.h b/src/mesa/main/texstate.h index a7d7088c62..17ac68000c 100644 --- a/src/mesa/main/texstate.h +++ b/src/mesa/main/texstate.h @@ -35,6 +35,18 @@ #include "mtypes.h" +/** + * Return pointer to current texture unit. + * This the texture unit set by glActiveTexture(), not glClientActiveTexture(). + */ +static INLINE struct gl_texture_unit * +_mesa_get_current_tex_unit(GLcontext *ctx) +{ + ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->Texture.Unit)); + return &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]); +} + + extern void _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst ); @@ -48,16 +60,14 @@ _mesa_print_texunit_state( GLcontext *ctx, GLuint unit ); */ /*@{*/ - -/* - * GL_ARB_multitexture - */ extern void GLAPIENTRY _mesa_ActiveTextureARB( GLenum target ); extern void GLAPIENTRY _mesa_ClientActiveTextureARB( GLenum target ); +/*@}*/ + /** * \name Initialization, state maintenance -- cgit v1.2.3 From 47a385b43be9cf2ef0d0b24b1d588dc26940dfe6 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Thu, 13 Aug 2009 10:01:38 -0600 Subject: mesa: minor clean-ups in bumpmap functions --- src/mesa/main/texenv.c | 53 +++++++++++++++++++++++++++++++++++++------------- 1 file changed, 39 insertions(+), 14 deletions(-) (limited to 'src/mesa/main/texenv.c') diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 1eab78c74c..6d86a4275c 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -909,12 +909,26 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) } } -/* why does ATI_envmap_bumpmap require new entrypoints? Should just - reuse TexEnv ones... */ + +/** + * Why does ATI_envmap_bumpmap require new entrypoints? Should just + * reuse TexEnv ones... + */ void GLAPIENTRY _mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ) { GLfloat p[4]; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (!ctx->Extensions.ATI_envmap_bumpmap) { + /* This isn't an "official" error case, but let's tell the user + * that something's wrong. + */ + _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterivATI"); + return; + } + if (pname == GL_BUMP_ROT_MATRIX_ATI) { /* hope that conversion is correct here */ p[0] = INT_TO_FLOAT( param[0] ); @@ -924,11 +938,12 @@ _mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ) } else { p[0] = (GLfloat) param[0]; - p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */ + p[1] = p[2] = p[3] = 0.0F; /* init to zero, just to be safe */ } _mesa_TexBumpParameterfvATI( pname, p ); } + void GLAPIENTRY _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) { @@ -936,7 +951,10 @@ _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - /* should return error if extension not supported? */ + if (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterfvATI"); + return; + } texUnit = _mesa_get_current_tex_unit(ctx); @@ -957,16 +975,19 @@ _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) } } + void GLAPIENTRY _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) { const struct gl_texture_unit *texUnit; GLuint i; - GLint temp = 0; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - /* should return error if extension not supported? */ + if (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI"); + return; + } texUnit = _mesa_get_current_tex_unit(ctx); @@ -985,12 +1006,13 @@ _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]); } else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + GLint count = 0; for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { if (ctx->Const.SupportedBumpUnits & (1 << i)) { - temp++; + count++; } } - *param = temp; + *param = count; } else if (pname == GL_BUMP_TEX_UNITS_ATI) { for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { @@ -1005,16 +1027,19 @@ _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) } } + void GLAPIENTRY _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) { const struct gl_texture_unit *texUnit; GLuint i; - GLint temp = 0; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - /* should return error if extension not supported? */ + if (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterfvATI"); + return; + } texUnit = _mesa_get_current_tex_unit(ctx); @@ -1022,7 +1047,7 @@ _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) /* spec leaves open to support larger matrices. Don't think anyone would ever want to use it (and apps might not understand it) so hardcode this. */ - *param = (GLfloat) 4; + *param = 4.0F; } else if (pname == GL_BUMP_ROT_MATRIX_ATI) { param[0] = texUnit->RotMatrix[0]; @@ -1031,12 +1056,13 @@ _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) param[3] = texUnit->RotMatrix[3]; } else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + GLint count = 0; for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { if (ctx->Const.SupportedBumpUnits & (1 << i)) { - temp++; + count++; } } - *param = (GLfloat) temp; + *param = (GLfloat) count; } else if (pname == GL_BUMP_TEX_UNITS_ATI) { for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { @@ -1050,4 +1076,3 @@ _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) return; } } - -- cgit v1.2.3