mesa: Prefix main includes with dir to avoid conflicts.

[mesa.git] / src / mesa / tnl / t_vb_fog.c

diff --git a/src/mesa/tnl/t_vb_fog.c b/src/mesa/tnl/t_vb_fog.c
index bbee44ebea03141a8bb608f21e4cdeed5acfe25f..00c0979f3f627b1c05a575d89656eb760b1bc12f 100644 (file)
--- a/src/mesa/tnl/t_vb_fog.c
+++ b/src/mesa/tnl/t_vb_fog.c
@@ -26,12 +26,12 @@
  */
 
 
-#include "glheader.h"
-#include "colormac.h"
-#include "context.h"
-#include "macros.h"
-#include "imports.h"
-#include "mtypes.h"
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/context.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
 
 #include "math/m_xform.h"
 
@@ -114,7 +114,7 @@ compute_fog_blend_factors(GLcontext *ctx, GLvector4f *out, const GLvector4f *in)
       else
          d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
       for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
-         const GLfloat z = FABSF(*v);
+         const GLfloat z = *v;
          GLfloat f = (end - z) * d;
         data[i][0] = CLAMP(f, 0.0F, 1.0F);
       }
@@ -122,14 +122,14 @@ compute_fog_blend_factors(GLcontext *ctx, GLvector4f *out, const GLvector4f *in)
    case GL_EXP:
       d = ctx->Fog.Density;
       for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride)) {
-         const GLfloat z = FABSF(*v);
+         const GLfloat z = *v;
          NEG_EXP( data[i][0], d * z );
       }
       break;
    case GL_EXP2:
       d = ctx->Fog.Density*ctx->Fog.Density;
       for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
-         const GLfloat z = FABSF(*v);
+         const GLfloat z = *v;
          NEG_EXP( data[i][0], d * z * z );
       }
       break;
@@ -148,18 +148,17 @@ run_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
    struct fog_stage_data *store = FOG_STAGE_DATA(stage);
    GLvector4f *input;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (!ctx->Fog.Enabled || ctx->VertexProgram._Enabled)
+   if (!ctx->Fog.Enabled || ctx->VertexProgram._Current)
       return GL_TRUE;
 
 
    if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) {
+      GLuint i;
+      GLfloat *coord;
       /* Fog is computed from vertex or fragment Z values */
       /* source = VB->ObjPtr or VB->EyePtr coords */
-      /* dest = VB->FogCoordPtr = fog stage private storage */
-      VB->FogCoordPtr = &store->fogcoord;
+      /* dest = VB->AttribPtr[_TNL_ATTRIB_FOG] = fog stage private storage */
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;
 
       if (!ctx->_NeedEyeCoords) {
          /* compute fog coords from object coords */
@@ -171,6 +170,8 @@ run_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
         input = &store->fogcoord;
 
          /* NOTE: negate plane here so we get positive fog coords! */
+        /* NOTE2: this doesn't always work (tests/fog - all frag depth fog
+           coords will be negative). */
         plane[0] = -m[2];
         plane[1] = -m[6];
         plane[2] = -m[10];
@@ -183,42 +184,53 @@ run_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
                                              VB->ObjPtr, plane );
 
         input->count = VB->ObjPtr->count;
+
+        /* make sure coords are really positive
+           NOTE should avoid going through array twice */
+        coord = input->start;
+        for (i = 0; i < input->count; i++) {
+           input->data[i][0] = FABSF(*coord);
+           STRIDE_F(coord, input->stride);
+        }
       }
       else {
          /* fog coordinates = eye Z coordinates (use ABS later) */
-        input = &store->input;
+        input = &store->fogcoord;
 
         if (VB->EyePtr->size < 2)
            _mesa_vector4f_clean_elem( VB->EyePtr, VB->Count, 2 );
 
-        input->data = (GLfloat (*)[4]) &(VB->EyePtr->data[0][2]);
-        input->start = VB->EyePtr->start+2;
-        input->stride = VB->EyePtr->stride;
+        input->stride = 4 * sizeof(GLfloat);
         input->count = VB->EyePtr->count;
+        coord = VB->EyePtr->start;
+        for (i = 0 ; i < VB->EyePtr->count; i++) {
+           input->data[i][0] = FABSF(coord[2]);
+           STRIDE_F(coord, VB->EyePtr->stride);
+        }
       }
    }
    else {
       /* use glFogCoord() coordinates */
-      input = VB->FogCoordPtr;  /* source data */
+      input = VB->AttribPtr[_TNL_ATTRIB_FOG];  /* source data */
 
       /* input->count may be one if glFogCoord was only called once
        * before glBegin.  But we need to compute fog for all vertices.
        */
       input->count = VB->ObjPtr->count;
 
-      VB->FogCoordPtr = &store->fogcoord;  /* dest data */
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;  /* dest data */
    }
 
    if (tnl->_DoVertexFog) {
       /* compute blend factors from fog coordinates */
-      compute_fog_blend_factors( ctx, VB->FogCoordPtr, input );
+      compute_fog_blend_factors( ctx, VB->AttribPtr[_TNL_ATTRIB_FOG], input );
    }
    else {
       /* results = incoming fog coords (compute fog per-fragment later) */
-      VB->FogCoordPtr = input;
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = input;
    }
 
-   VB->AttribPtr[_TNL_ATTRIB_FOG] = VB->FogCoordPtr;
+   VB->FogCoordPtr = VB->AttribPtr[_TNL_ATTRIB_FOG];
    return GL_TRUE;
 }