/* $Id: s_fog.c,v 1.20 2002/01/28 03:42:28 brianp Exp $ */ /* * Mesa 3-D graphics library * Version: 3.5 * * 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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include "glheader.h" #include "colormac.h" #include "context.h" #include "macros.h" #include "mmath.h" #include "s_context.h" #include "s_fog.h" #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->interpMask & SPAN_FOG); ASSERT(span->arrayMask & SPAN_RGBA); 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->arrayMask & SPAN_RGBA); 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 fog factors in [0,1] * red, green, blue, alpha - pixel colors * Output: red, green, blue, alpha - fogged pixel colors */ void _old_fog_rgba_pixels( const GLcontext *ctx, GLuint n, const GLfloat fog[], GLchan rgba[][4] ) { GLuint i; GLchan rFog, gFog, bFog; 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 < n; 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 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->interpMask & SPAN_FOG); ASSERT(span->arrayMask & SPAN_INDEX); 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; } } /** * 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->arrayMask & SPAN_INDEX); 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 * fog - array of fog factors in [0,1] * index - pixel color indexes * Output: index - fogged pixel color indexes */ void _old_fog_ci_pixels( const GLcontext *ctx, GLuint n, const GLfloat fog[], GLuint index[] ) { GLuint idx = (GLuint) ctx->Fog.Index; GLuint i; 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 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? */ static void compute_fog_factors_from_z( const GLcontext *ctx, GLuint n, const GLdepth z[], GLfloat fogFact[] ) { 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]; 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: * * p[10] * eyeZ + p[14] * eyeW * ndcZ = --------------------------- * p[11] * eyeZ + p[15] * eyeW * * Thus: * * p[14] * eyeW - p[15] * eyeW * ndcZ * eyeZ = ---------------------------------- * p[11] * ndcZ - p[10] * * If we note: * a) if using an orthographic projection, p[11] = 0 and p[15] = 1. * b) if using a perspective projection, p[11] = -1 and p[15] = 0. * c) we assume eyeW = 1 (not always true- glVertex4) * * Then we can simplify the calculation of eyeZ quite a bit. We do * separate calculations for the orthographic and perspective cases below. * Note that we drop a negative sign or two since they don't matter. */ switch (ctx->Fog.Mode) { case GL_LINEAR: { GLfloat fogEnd = ctx->Fog.End; 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;iFog.Density * eyez ); } } else { /* perspective */ for (i=0;iFog.Density * eyez ); } } break; case GL_EXP2: { GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density; if (ortho) { for (i=0;izArray 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->arrayMask & SPAN_Z); ASSERT(span->end <= PB_SIZE); compute_fog_factors_from_z(ctx, span->end, span->zArray, 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 * red, green, blue, alpha - pixel colors * Output: red, green, blue, alpha - fogged pixel colors */ void _old_depth_fog_rgba_pixels( const GLcontext *ctx, GLuint n, const GLdepth z[], GLchan rgba[][4] ) { GLfloat fogFact[PB_SIZE]; ASSERT(n <= PB_SIZE); 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->zArray 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->arrayMask & SPAN_Z); ASSERT(span->end <= PB_SIZE); compute_fog_factors_from_z(ctx, span->end, span->zArray, 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 * index - pixel color indexes * Output: index - fogged pixel color indexes */ void _old_depth_fog_ci_pixels( const GLcontext *ctx, GLuint n, const GLdepth z[], GLuint index[] ) { GLfloat fogFact[PB_SIZE]; ASSERT(n <= PB_SIZE); compute_fog_factors_from_z( ctx, n, z, fogFact ); _old_fog_ci_pixels( ctx, n, fogFact, index ); }