mesa: Use bitmask/ffs to iterate enabled clip planes.

Replaces an iterate and test bit in a bitmask loop by a
loop only iterating over the bits set in the bitmask.

v2: Use _mesa_bit_scan{,64} instead of open coding.
v3: Use u_bit_scan{,64} instead of _mesa_bit_scan{,64}.

Reviewed-by: Brian Paul <brianp@vmware.com>
Signed-off-by: Mathias Fröhlich <Mathias.Froehlich@web.de>

diff --git a/src/mesa/drivers/common/meta.c b/src/mesa/drivers/common/meta.c
index 3c86305d77febabfb5cc900f9ff80e26ad2c995d..be671b4b629c63e0fe268e24b3161cd6d650f374 100644 (file)
--- a/src/mesa/drivers/common/meta.c
+++ b/src/mesa/drivers/common/meta.c
@@ -85,6 +85,7 @@
 #include "drivers/common/meta.h"
 #include "main/enums.h"
 #include "main/glformats.h"
+#include "util/bitscan.h"
 #include "util/ralloc.h"
 
 /** Return offset in bytes of the field within a vertex struct */
@@ -682,12 +683,12 @@ _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
    }
 
    if (state & MESA_META_CLIP) {
+      GLbitfield mask;
       save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
-      if (ctx->Transform.ClipPlanesEnabled) {
-         GLuint i;
-         for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
-            _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
-         }
+      mask = ctx->Transform.ClipPlanesEnabled;
+      while (mask) {
+         const int i = u_bit_scan(&mask);
+         _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
       }
    }
 
@@ -1090,13 +1091,10 @@ _mesa_meta_end(struct gl_context *ctx)
    }
 
    if (state & MESA_META_CLIP) {
-      if (save->ClipPlanesEnabled) {
-         GLuint i;
-         for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
-            if (save->ClipPlanesEnabled & (1 << i)) {
-               _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
-            }
-         }
+      GLbitfield mask = save->ClipPlanesEnabled;
+      while (mask) {
+         const int i = u_bit_scan(&mask);
+         _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
       }
    }
 

diff --git a/src/mesa/main/matrix.c b/src/mesa/main/matrix.c
index 5ff5ac5bfe13fb17ce50acb923e8b3967c86b82b..293d50c33595b06e077e541646162a6ae24340ef 100644 (file)
--- a/src/mesa/main/matrix.c
+++ b/src/mesa/main/matrix.c
@@ -43,6 +43,7 @@
 #include "matrix.h"
 #include "mtypes.h"
 #include "math/m_matrix.h"
+#include "util/bitscan.h"
 
 
 /**
@@ -554,20 +555,20 @@ _mesa_MultTransposeMatrixd( const GLdouble *m )
 static void
 update_projection( struct gl_context *ctx )
 {
+   GLbitfield mask;
+
    _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
 
    /* Recompute clip plane positions in clipspace.  This is also done
     * in _mesa_ClipPlane().
     */
-   if (ctx->Transform.ClipPlanesEnabled) {
-      GLuint p;
-      for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
-        if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
-           _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
-                                ctx->Transform.EyeUserPlane[p],
-                                ctx->ProjectionMatrixStack.Top->inv );
-        }
-      }
+   mask = ctx->Transform.ClipPlanesEnabled;
+   while (mask) {
+      const int p = u_bit_scan(&mask);
+
+      _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
+                              ctx->Transform.EyeUserPlane[p],
+                              ctx->ProjectionMatrixStack.Top->inv );
    }
 }
 

diff --git a/src/mesa/main/rastpos.c b/src/mesa/main/rastpos.c
index 8f971f5b8d4037e1c302ce90984ed6938e06164b..4fddad16f1b5ada6f2c18a56f56c3ed228a1c1d3 100644 (file)
--- a/src/mesa/main/rastpos.c
+++ b/src/mesa/main/rastpos.c
@@ -91,17 +91,16 @@ viewclip_point_z( const GLfloat v[] )
 static GLuint
 userclip_point( struct gl_context *ctx, const GLfloat v[] )
 {
-   GLuint p;
-
-   for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
-      if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
-        GLfloat dot = v[0] * ctx->Transform._ClipUserPlane[p][0]
-                    + v[1] * ctx->Transform._ClipUserPlane[p][1]
-                    + v[2] * ctx->Transform._ClipUserPlane[p][2]
-                    + v[3] * ctx->Transform._ClipUserPlane[p][3];
-         if (dot < 0.0F) {
-            return 0;
-         }
+   GLbitfield mask = ctx->Transform.ClipPlanesEnabled;
+   while (mask) {
+      const int p = u_bit_scan(&mask);
+      GLfloat dot = v[0] * ctx->Transform._ClipUserPlane[p][0]
+         + v[1] * ctx->Transform._ClipUserPlane[p][1]
+         + v[2] * ctx->Transform._ClipUserPlane[p][2]
+         + v[3] * ctx->Transform._ClipUserPlane[p][3];
+
+      if (dot < 0.0F) {
+         return 0;
       }
    }
 

diff --git a/src/mesa/tnl/t_vb_cliptmp.h b/src/mesa/tnl/t_vb_cliptmp.h
index 12181f085bcb568b963d23b56ffe04b5f70aeceb..c6546668806eda497499200b3d259e5ccbc08386 100644 (file)
--- a/src/mesa/tnl/t_vb_cliptmp.h
+++ b/src/mesa/tnl/t_vb_cliptmp.h
@@ -124,7 +124,6 @@ TAG(clip_line)( struct gl_context *ctx, GLuint v0, GLuint v1, GLubyte mask )
    GLuint newvert = VB->Count;
    GLfloat t0 = 0;
    GLfloat t1 = 0;
-   GLuint p;
    const GLuint v0_orig = v0;
 
    if (mask & CLIP_FRUSTUM_BITS) {
@@ -137,14 +136,14 @@ TAG(clip_line)( struct gl_context *ctx, GLuint v0, GLuint v1, GLubyte mask )
    }
 
    if (mask & CLIP_USER_BIT) {
-      for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
-        if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
-            const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
-            const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
-            const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
-            const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
-           LINE_CLIP( CLIP_USER_BIT, a, b, c, d );
-        }
+      GLbitfield enabled = ctx->Transform.ClipPlanesEnabled;
+      while (enabled) {
+         const int p = u_bit_scan(&enabled);
+         const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+         const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+         const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+         const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+         LINE_CLIP( CLIP_USER_BIT, a, b, c, d );
       }
    }
 
@@ -194,7 +193,6 @@ TAG(clip_tri)( struct gl_context *ctx, GLuint v0, GLuint v1, GLuint v2, GLubyte
    GLuint pv = v2;
    GLuint vlist[2][MAX_CLIPPED_VERTICES];
    GLuint *inlist = vlist[0], *outlist = vlist[1];
-   GLuint p;
    GLuint n = 3;
 
    ASSIGN_3V(inlist, v2, v0, v1 ); /* pv rotated to slot zero */
@@ -226,14 +224,14 @@ TAG(clip_tri)( struct gl_context *ctx, GLuint v0, GLuint v1, GLuint v2, GLubyte
    }
 
    if (mask & CLIP_USER_BIT) {
-      for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
-         if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
-            const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
-            const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
-            const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
-            const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
-            POLY_CLIP( CLIP_USER_BIT, a, b, c, d );
-         }
+      GLbitfield enabled = ctx->Transform.ClipPlanesEnabled;
+      while (enabled) {
+         const int p = u_bit_scan(&enabled);
+         const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+         const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+         const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+         const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+         POLY_CLIP( CLIP_USER_BIT, a, b, c, d );
       }
    }
 
@@ -274,7 +272,6 @@ TAG(clip_quad)( struct gl_context *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint
    GLuint pv = v3;
    GLuint vlist[2][MAX_CLIPPED_VERTICES];
    GLuint *inlist = vlist[0], *outlist = vlist[1];
-   GLuint p;
    GLuint n = 4;
 
    ASSIGN_4V(inlist, v3, v0, v1, v2 ); /* pv rotated to slot zero */
@@ -289,14 +286,14 @@ TAG(clip_quad)( struct gl_context *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint
    }
 
    if (mask & CLIP_USER_BIT) {
-      for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
-        if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
-            const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
-            const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
-            const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
-            const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
-           POLY_CLIP( CLIP_USER_BIT, a, b, c, d );
-        }
+      GLbitfield enabled = ctx->Transform.ClipPlanesEnabled;
+      while (enabled) {
+         const int p = u_bit_scan(&enabled);
+         const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+         const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+         const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+         const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+         POLY_CLIP( CLIP_USER_BIT, a, b, c, d );
       }
    }
 

diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
index 21fd6cd1a0680da1df0584af363f8956a7efabbd..55c44d1845b06e9e6d310af8b492ee4ccc320ffa 100644 (file)
--- a/src/mesa/tnl/t_vb_program.c
+++ b/src/mesa/tnl/t_vb_program.c
@@ -40,6 +40,7 @@
 #include "program/prog_statevars.h"
 #include "program/prog_execute.h"
 #include "swrast/s_context.h"
+#include "util/bitscan.h"
 
 #include "tnl/tnl.h"
 #include "tnl/t_context.h"
@@ -84,40 +85,38 @@ userclip( struct gl_context *ctx,
           GLubyte *clipormask,
           GLubyte *clipandmask )
 {
-   GLuint p;
-
-   for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
-      if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
-        GLuint nr, i;
-        const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
-        const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
-        const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
-        const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
-         GLfloat *coord = (GLfloat *)clip->data;
-         GLuint stride = clip->stride;
-         GLuint count = clip->count;
-
-        for (nr = 0, i = 0 ; i < count ; i++) {
-           GLfloat dp = (coord[0] * a + 
-                         coord[1] * b +
-                         coord[2] * c +
-                         coord[3] * d);
-
-           if (dp < 0) {
-              nr++;
-              clipmask[i] |= CLIP_USER_BIT;
-           }
-
-           STRIDE_F(coord, stride);
-        }
+   GLbitfield mask = ctx->Transform.ClipPlanesEnabled;
+   while (mask) {
+      const int p = u_bit_scan(&mask);
+      GLuint nr, i;
+      const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+      const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+      const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+      const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+      GLfloat *coord = (GLfloat *)clip->data;
+      GLuint stride = clip->stride;
+      GLuint count = clip->count;
+
+      for (nr = 0, i = 0 ; i < count ; i++) {
+         GLfloat dp = (coord[0] * a +
+                       coord[1] * b +
+                       coord[2] * c +
+                       coord[3] * d);
+
+         if (dp < 0) {
+            nr++;
+            clipmask[i] |= CLIP_USER_BIT;
+         }
+
+         STRIDE_F(coord, stride);
+      }
 
-        if (nr > 0) {
-           *clipormask |= CLIP_USER_BIT;
-           if (nr == count) {
-              *clipandmask |= CLIP_USER_BIT;
-              return;
-           }
-        }
+      if (nr > 0) {
+         *clipormask |= CLIP_USER_BIT;
+         if (nr == count) {
+            *clipandmask |= CLIP_USER_BIT;
+            return;
+         }
       }
    }
 }

diff --git a/src/mesa/tnl/t_vb_render.c b/src/mesa/tnl/t_vb_render.c
index 03e8fcfa19683f1c8d80d545d2e46ee548870e82..9ff1f18f53b59b6416a216c649c277ebf4e3a8ef 100644 (file)
--- a/src/mesa/tnl/t_vb_render.c
+++ b/src/mesa/tnl/t_vb_render.c
@@ -46,6 +46,7 @@
 #include "main/imports.h"
 #include "main/mtypes.h"
 #include "math/m_xform.h"
+#include "util/bitscan.h"
 
 #include "t_pipeline.h"
 

diff --git a/src/mesa/tnl/t_vb_vertex.c b/src/mesa/tnl/t_vb_vertex.c
index b56d6803c9990929a28db5f1fc79e293e6790e63..71a32b49528ec3a1a176181c2975d3a66c5c18ee 100644 (file)
--- a/src/mesa/tnl/t_vb_vertex.c
+++ b/src/mesa/tnl/t_vb_vertex.c
@@ -33,6 +33,8 @@
 
 #include "math/m_xform.h"
 
+#include "util/bitscan.h"
+
 #include "t_context.h"
 #include "t_pipeline.h"
 
@@ -63,40 +65,39 @@ static void NAME( struct gl_context *ctx,                           \
                  GLubyte *clipormask,                          \
                  GLubyte *clipandmask )                        \
 {                                                              \
-   GLuint p;                                                   \
-                                                               \
-   for (p = 0; p < ctx->Const.MaxClipPlanes; p++)              \
-      if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {       \
-        GLuint nr, i;                                          \
-        const GLfloat a = ctx->Transform._ClipUserPlane[p][0]; \
-        const GLfloat b = ctx->Transform._ClipUserPlane[p][1]; \
-        const GLfloat c = ctx->Transform._ClipUserPlane[p][2]; \
-        const GLfloat d = ctx->Transform._ClipUserPlane[p][3]; \
-         GLfloat *coord = (GLfloat *)clip->data;               \
-         GLuint stride = clip->stride;                         \
-         GLuint count = clip->count;                           \
+   GLbitfield mask = ctx->Transform.ClipPlanesEnabled;          \
+   while (mask) {                                               \
+      const int p = u_bit_scan(&mask);                          \
+      GLuint nr, i;                                            \
+      const GLfloat a = ctx->Transform._ClipUserPlane[p][0];   \
+      const GLfloat b = ctx->Transform._ClipUserPlane[p][1];   \
+      const GLfloat c = ctx->Transform._ClipUserPlane[p][2];   \
+      const GLfloat d = ctx->Transform._ClipUserPlane[p][3];   \
+      GLfloat *coord = (GLfloat *)clip->data;                   \
+      GLuint stride = clip->stride;                            \
+      GLuint count = clip->count;                              \
                                                                \
-        for (nr = 0, i = 0 ; i < count ; i++) {                \
-           GLfloat dp = coord[0] * a + coord[1] * b;           \
-           if (SZ > 2) dp += coord[2] * c;                     \
-           if (SZ > 3) dp += coord[3] * d; else dp += d;       \
+      for (nr = 0, i = 0 ; i < count ; i++) {                   \
+         GLfloat dp = coord[0] * a + coord[1] * b;             \
+         if (SZ > 2) dp += coord[2] * c;                       \
+         if (SZ > 3) dp += coord[3] * d; else dp += d;          \
                                                                \
-           if (dp < 0) {                                       \
-              nr++;                                            \
-              clipmask[i] |= CLIP_USER_BIT;                    \
-           }                                                   \
+         if (dp < 0) {                                          \
+            nr++;                                              \
+            clipmask[i] |= CLIP_USER_BIT;                      \
+         }                                                     \
                                                                \
-           STRIDE_F(coord, stride);                            \
-        }                                                      \
+         STRIDE_F(coord, stride);                              \
+      }                                                         \
                                                                \
-        if (nr > 0) {                                          \
-           *clipormask |= CLIP_USER_BIT;                       \
-           if (nr == count) {                                  \
-              *clipandmask |= CLIP_USER_BIT;                   \
-              return;                                          \
-           }                                                   \
-        }                                                      \
+      if (nr > 0) {                                            \
+         *clipormask |= CLIP_USER_BIT;                          \
+         if (nr == count) {                                    \
+            *clipandmask |= CLIP_USER_BIT;                     \
+            return;                                            \
+         }                                                     \
       }                                                                \
+   }                                                           \
 }