-/* $Id: s_fog.c,v 1.7 2001/01/03 15:59:30 brianp Exp $ */
+/* $Id: s_fog.c,v 1.17 2002/01/21 18:12:34 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
- *
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
- *
+ *
+ * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
+ *
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
- *
+ *
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
- *
+ *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
#include "s_pb.h"
-/*
+
+
+/**
+ * Used to convert current raster distance to a fog factor in [0,1].
+ */
+GLfloat
+_mesa_z_to_fogfactor(GLcontext *ctx, GLfloat z)
+{
+ GLfloat d, f;
+
+ switch (ctx->Fog.Mode) {
+ case GL_LINEAR:
+ if (ctx->Fog.Start == ctx->Fog.End)
+ d = 1.0F;
+ else
+ d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+ f = (ctx->Fog.End - z) * d;
+ return CLAMP(f, 0.0F, 1.0F);
+ case GL_EXP:
+ d = ctx->Fog.Density;
+ f = (GLfloat) exp(-d * z);
+ return f;
+ case GL_EXP2:
+ d = ctx->Fog.Density;
+ f = (GLfloat) exp(-(d * d * z * z));
+ return f;
+ default:
+ _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
+ return 0.0;
+ }
+}
+
+
+
+/**
+ * Apply fog to a span of RGBA pixels.
+ * Input: ctx -
+ * span - where span->fog and span->fogStep have to be set.
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLchan rgba[][4] )
+{
+ GLuint i;
+ GLfloat fog = span->fog, Dfog = span->fogStep;
+ GLchan rFog, gFog, bFog;
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_FOG);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ UNCLAMPED_FLOAT_TO_CHAN(rFog, ctx->Fog.Color[RCOMP]);
+ UNCLAMPED_FLOAT_TO_CHAN(gFog, ctx->Fog.Color[GCOMP]);
+ UNCLAMPED_FLOAT_TO_CHAN(bFog, ctx->Fog.Color[BCOMP]);
+
+ for (i = 0; i < span->end; i++) {
+ const GLfloat one_min_fog = 1.0F - fog;
+ rgba[i][RCOMP] = (GLchan) (fog * rgba[i][RCOMP] + one_min_fog * rFog);
+ rgba[i][GCOMP] = (GLchan) (fog * rgba[i][GCOMP] + one_min_fog * gFog);
+ rgba[i][BCOMP] = (GLchan) (fog * rgba[i][BCOMP] + one_min_fog * bFog);
+ fog += Dfog;
+ }
+}
+
+
+/**
+ * Apply fog given in an array to RGBA pixels.
+ * Input: ctx -
+ * span -
+ * fog - array of fog factors in [0,1]
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_fog_rgba_pixels_with_array( const GLcontext *ctx, struct sw_span *span,
+ const GLfloat fog[], GLchan rgba[][4] )
+{
+ GLuint i;
+ GLchan rFog, gFog, bFog;
+
+ ASSERT(fog != NULL);
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ UNCLAMPED_FLOAT_TO_CHAN(rFog, ctx->Fog.Color[RCOMP]);
+ UNCLAMPED_FLOAT_TO_CHAN(gFog, ctx->Fog.Color[GCOMP]);
+ UNCLAMPED_FLOAT_TO_CHAN(bFog, ctx->Fog.Color[BCOMP]);
+
+ for (i = span->start; i < span->end; i++) {
+ const GLfloat f = fog[i];
+ const GLfloat g = 1.0F - f;
+ rgba[i][RCOMP] = (GLchan) (f * rgba[i][RCOMP] + g * rFog);
+ rgba[i][GCOMP] = (GLchan) (f * rgba[i][GCOMP] + g * gFog);
+ rgba[i][BCOMP] = (GLchan) (f * rgba[i][BCOMP] + g * bFog);
+ }
+}
+
+/**
* Apply fog to an array of RGBA pixels.
* Input: n - number of pixels
- * fog - array of interpolated screen-space fog coordinates in [0..1]
+ * fog - array of fog factors in [0,1]
* red, green, blue, alpha - pixel colors
* Output: red, green, blue, alpha - fogged pixel colors
*/
void
-_mesa_fog_rgba_pixels( const GLcontext *ctx,
- GLuint n,
- const GLfixed fog[],
+_old_fog_rgba_pixels( const GLcontext *ctx,
+ GLuint n,
+ const GLfloat fog[],
GLchan rgba[][4] )
{
GLuint i;
UNCLAMPED_FLOAT_TO_CHAN(gFog, ctx->Fog.Color[GCOMP]);
UNCLAMPED_FLOAT_TO_CHAN(bFog, ctx->Fog.Color[BCOMP]);
-#if CHAN_TYPE == GL_FLOAT
for (i = 0; i < n; i++) {
- const GLfixed cf = CLAMP(fog[i], 0, FIXED_ONE);
- const GLfloat f = FixedToFloat(cf);
+ const GLfloat f = fog[i];
const GLfloat g = 1.0F - f;
- rgba[i][RCOMP] = f * rgba[i][RCOMP] + g * rFog;
- rgba[i][GCOMP] = f * rgba[i][GCOMP] + g * gFog;
- rgba[i][BCOMP] = f * rgba[i][BCOMP] + g * bFog;
+ rgba[i][RCOMP] = (GLchan) (f * rgba[i][RCOMP] + g * rFog);
+ rgba[i][GCOMP] = (GLchan) (f * rgba[i][GCOMP] + g * gFog);
+ rgba[i][BCOMP] = (GLchan) (f * rgba[i][BCOMP] + g * bFog);
}
-#else
- for (i = 0; i < n; i++) {
- const GLfixed f = CLAMP(fog[i], 0, FIXED_ONE);
- const GLfixed g = FIXED_ONE - f;
- rgba[i][0] = (f * rgba[i][0] + g * rFog) >> FIXED_SHIFT;
- rgba[i][1] = (f * rgba[i][1] + g * gFog) >> FIXED_SHIFT;
- rgba[i][2] = (f * rgba[i][2] + g * bFog) >> FIXED_SHIFT;
+}
+
+
+/**
+ * Apply fog to a span of color index pixels.
+ * Input: ctx -
+ * span - where span->fog and span->fogStep have to be set.
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLuint index[] )
+{
+ GLuint idx = (GLuint) ctx->Fog.Index;
+ GLuint i;
+ GLfloat fog = span->fog, Dfog = span->fogStep;
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_FOG);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ for (i = 0; i < span->end; i++) {
+ const GLfloat f = CLAMP(fog, 0.0F, 1.0F);
+ index[i] = (GLuint) ((GLfloat) index[i] + (1.0F - f) * idx);
+ fog += Dfog;
}
-#endif
}
+/**
+ * Apply fog given in an array to a span of color index pixels.
+ * Input: ctx -
+ * span -
+ * fog - array of fog factors in [0,1]
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_fog_ci_pixels_with_array( const GLcontext *ctx, struct sw_span *span,
+ const GLfloat fog[], GLuint index[] )
+{
+ GLuint idx = (GLuint) ctx->Fog.Index;
+ GLuint i;
+
+ ASSERT(fog != NULL);
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->filledColor == GL_TRUE);
-/*
+ for (i = span->start; i < span->end; i++) {
+ const GLfloat f = CLAMP(fog[i], 0.0F, 1.0F);
+ index[i] = (GLuint) ((GLfloat) index[i] + (1.0F - f) * idx);
+ }
+}
+
+/**
* Apply fog to an array of color index pixels.
* Input: n - number of pixels
- * z - array of integer depth values
+ * fog - array of fog factors in [0,1]
* index - pixel color indexes
* Output: index - fogged pixel color indexes
*/
void
-_mesa_fog_ci_pixels( const GLcontext *ctx,
- GLuint n, const GLfixed fog[], GLuint index[] )
+_old_fog_ci_pixels( const GLcontext *ctx,
+ GLuint n, const GLfloat fog[], GLuint index[] )
{
- GLuint idx = ctx->Fog.Index;
+ GLuint idx = (GLuint) ctx->Fog.Index;
GLuint i;
- for (i=0;i<n;i++) {
- GLfloat f = FixedToFloat(CLAMP(fog[i], 0, FIXED_ONE));
- index[i] = (GLuint) ((GLfloat) index[i] + (1.0F-f) * idx);
+ for (i = 0; i < n; i++) {
+ const GLfloat f = CLAMP(fog[i], 0.0F, 1.0F);
+ index[i] = (GLuint) ((GLfloat) index[i] + (1.0F - f) * idx);
}
}
-/*
- * Calculate fog coords from window z values
+/**
+ * Calculate fog factors (in [0,1]) from window z values
* Input: n - number of pixels
* z - array of integer depth values
* red, green, blue, alpha - pixel colors
* Output: red, green, blue, alpha - fogged pixel colors
*
- * Use lookup table & interpolation?
+ * Use lookup table & interpolation?
*/
-void
-_mesa_win_fog_coords_from_z( const GLcontext *ctx,
- GLuint n,
- const GLdepth z[],
- GLfixed fogcoord[] )
+static void
+compute_fog_factors_from_z( const GLcontext *ctx,
+ GLuint n,
+ const GLdepth z[],
+ GLfloat fogFact[] )
{
- const GLboolean ortho = (ctx->ProjectionMatrix.m[15] != 0.0F);
- const GLfloat p10 = ctx->ProjectionMatrix.m[10];
- const GLfloat p14 = ctx->ProjectionMatrix.m[14];
+ const GLfloat *proj = ctx->ProjectionMatrixStack.Top->m;
+ const GLboolean ortho = (proj[15] != 0.0F);
+ const GLfloat p10 = proj[10];
+ const GLfloat p14 = proj[14];
const GLfloat tz = ctx->Viewport._WindowMap.m[MAT_TZ];
- const GLfloat szInv = 1.0F / ctx->Viewport._WindowMap.m[MAT_SZ];
+ GLfloat szInv;
GLuint i;
+ if (ctx->Viewport._WindowMap.m[MAT_SZ] == 0.0)
+ szInv = 1.0F;
+ else
+ szInv = 1.0F / ctx->Viewport._WindowMap.m[MAT_SZ];
+
/*
* Note: to compute eyeZ from the ndcZ we have to solve the following:
*
case GL_LINEAR:
{
GLfloat fogEnd = ctx->Fog.End;
- GLfloat fogScale = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+ GLfloat fogScale;
+ if (ctx->Fog.Start == ctx->Fog.End)
+ fogScale = 1.0;
+ else
+ fogScale = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
if (ortho) {
for (i=0;i<n;i++) {
GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
GLfloat eyez = (ndcz - p14) / p10;
if (eyez < 0.0)
eyez = -eyez;
- fogcoord[i] = FloatToFixed((fogEnd - eyez) * fogScale);
+ fogFact[i] = (fogEnd - eyez) * fogScale;
}
}
else {
GLfloat eyez = p14 / (ndcz + p10);
if (eyez < 0.0)
eyez = -eyez;
- fogcoord[i] = FloatToFixed((fogEnd - eyez) * fogScale);
+ fogFact[i] = (fogEnd - eyez) * fogScale;
}
}
}
GLfloat eyez = (ndcz - p14) / p10;
if (eyez < 0.0)
eyez = -eyez;
- fogcoord[i] = FloatToFixed(exp( -ctx->Fog.Density * eyez ));
+ fogFact[i] = (GLfloat) exp( -ctx->Fog.Density * eyez );
}
}
else {
GLfloat eyez = p14 / (ndcz + p10);
if (eyez < 0.0)
eyez = -eyez;
- fogcoord[i] = FloatToFixed(exp( -ctx->Fog.Density * eyez ));
+ fogFact[i] = (GLfloat) exp( -ctx->Fog.Density * eyez );
}
}
break;
if (tmp < FLT_MIN_10_EXP)
tmp = FLT_MIN_10_EXP;
#endif
- fogcoord[i] = FloatToFixed(exp( tmp ));
+ fogFact[i] = (GLfloat) exp( tmp );
}
}
else {
if (tmp < FLT_MIN_10_EXP)
tmp = FLT_MIN_10_EXP;
#endif
- fogcoord[i] = FloatToFixed(exp( tmp ));
+ fogFact[i] = (GLfloat) exp( tmp );
}
}
}
break;
default:
- gl_problem(ctx, "Bad fog mode in _mesa_win_fog_coords_from_z");
+ _mesa_problem(ctx, "Bad fog mode in compute_fog_factors_from_z");
return;
}
}
-/*
+/**
+ * Apply fog to a span of RGBA pixels.
+ * Input: ctx -
+ * span - where span->depth has to be filled.
+ * red, green, blue, alpha - pixel colors
+ * Output: red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_depth_fog_rgba_pixels(const GLcontext *ctx, struct sw_span *span,
+ GLchan rgba[][4])
+{
+ GLfloat fogFact[PB_SIZE];
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_Z);
+ ASSERT(span->end <= PB_SIZE);
+ ASSERT(span->filledDepth == GL_TRUE);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ compute_fog_factors_from_z(ctx, span->end, span->depth, fogFact );
+ _mesa_fog_rgba_pixels_with_array( ctx, span, fogFact, rgba );
+}
+
+
+/**
* Apply fog to an array of RGBA pixels.
* Input: n - number of pixels
* z - array of integer depth values
* Output: red, green, blue, alpha - fogged pixel colors
*/
void
-_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+_old_depth_fog_rgba_pixels( const GLcontext *ctx,
GLuint n, const GLdepth z[], GLchan rgba[][4] )
{
- GLfixed fog[PB_SIZE];
+ GLfloat fogFact[PB_SIZE];
ASSERT(n <= PB_SIZE);
- _mesa_win_fog_coords_from_z( ctx, n, z, fog );
- _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+ compute_fog_factors_from_z( ctx, n, z, fogFact );
+ _old_fog_rgba_pixels( ctx, n, fogFact, rgba );
}
-/*
+/**
+ * Apply fog to a span of color index pixels.
+ * Input: ctx -
+ * span - where span->depth has to be filled.
+ * index - pixel color indexes
+ * Output: index - fogged pixel color indexes
+ */
+void
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
+ GLuint index[] )
+{
+ GLfloat fogFact[PB_SIZE];
+
+ ASSERT(ctx->Fog.Enabled);
+ ASSERT(span->activeMask & SPAN_Z);
+ ASSERT(span->end <= PB_SIZE);
+ ASSERT(span->filledDepth == GL_TRUE);
+ ASSERT(span->filledColor == GL_TRUE);
+
+ compute_fog_factors_from_z(ctx, span->end, span->depth, fogFact );
+ _mesa_fog_ci_pixels_with_array( ctx, span, fogFact, index );
+}
+
+
+/**
* Apply fog to an array of color index pixels.
* Input: n - number of pixels
* z - array of integer depth values
* Output: index - fogged pixel color indexes
*/
void
-_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
+_old_depth_fog_ci_pixels( const GLcontext *ctx,
GLuint n, const GLdepth z[], GLuint index[] )
{
- GLfixed fog[PB_SIZE];
+ GLfloat fogFact[PB_SIZE];
ASSERT(n <= PB_SIZE);
- _mesa_win_fog_coords_from_z( ctx, n, z, fog );
- _mesa_fog_ci_pixels( ctx, n, fog, index );
+ compute_fog_factors_from_z( ctx, n, z, fogFact );
+ _old_fog_ci_pixels( ctx, n, fogFact, index );
}
-
projects / mesa.git / blobdiff