18 files changed, 221 insertions, 267 deletions

diff --git a/src/gallium/drivers/i915/i915_state.c b/src/gallium/drivers/i915/i915_state.c
index f883883852..cd963e4df7 100644
--- a/src/gallium/drivers/i915/i915_state.c
+++ b/src/gallium/drivers/i915/i915_state.c
@@ -686,17 +686,23 @@ i915_create_rasterizer_state(struct pipe_context *pipe,
    else
       cso->sc[0] = _3DSTATE_SCISSOR_ENABLE_CMD | DISABLE_SCISSOR_RECT;
 
-   switch (rasterizer->cull_mode) {
-   case PIPE_WINDING_NONE:
+   switch (rasterizer->cull_face) {
+   case PIPE_FACE_NONE:
       cso->LIS4 |= S4_CULLMODE_NONE;
       break;
-   case PIPE_WINDING_CW:
-      cso->LIS4 |= S4_CULLMODE_CW;
+   case PIPE_FACE_FRONT:
+      if (rasterizer->front_ccw)
+         cso->LIS4 |= S4_CULLMODE_CCW;
+      else 
+         cso->LIS4 |= S4_CULLMODE_CW;
       break;
-   case PIPE_WINDING_CCW:
-      cso->LIS4 |= S4_CULLMODE_CCW;
+   case PIPE_FACE_BACK:
+      if (rasterizer->front_ccw)
+         cso->LIS4 |= S4_CULLMODE_CW;
+      else 
+         cso->LIS4 |= S4_CULLMODE_CCW;
       break;
-   case PIPE_WINDING_BOTH:
+   case PIPE_FACE_FRONT_AND_BACK:
       cso->LIS4 |= S4_CULLMODE_BOTH;
       break;
    }
diff --git a/src/gallium/drivers/i965/brw_pipe_rast.c b/src/gallium/drivers/i965/brw_pipe_rast.c
index 2117e91a9e..4c1a6d7dcd 100644
--- a/src/gallium/drivers/i965/brw_pipe_rast.c
+++ b/src/gallium/drivers/i965/brw_pipe_rast.c
@@ -42,7 +42,7 @@ calculate_clip_key_rast( const struct brw_context *brw,
 
    key->do_flat_shading = templ->flatshade;
 
-   if (templ->cull_mode == PIPE_WINDING_BOTH) {
+   if (templ->cull_face == PIPE_FACE_FRONT_AND_BACK) {
       key->clip_mode = BRW_CLIPMODE_REJECT_ALL;
       return;
    }
@@ -50,12 +50,18 @@ calculate_clip_key_rast( const struct brw_context *brw,
    key->fill_ccw = CLIP_CULL;
    key->fill_cw = CLIP_CULL;
 
-   if (!(templ->cull_mode & PIPE_WINDING_CCW)) {
-      key->fill_ccw = translate_fill(templ->fill_ccw);
+   if (!(templ->cull_face & PIPE_FACE_FRONT)) {
+      if (templ->front_ccw)
+         key->fill_ccw = translate_fill(templ->fill_front);
+      else 
+         key->fill_cw = translate_fill(templ->fill_front);
    }
 
-   if (!(templ->cull_mode & PIPE_WINDING_CW)) {
-      key->fill_cw = translate_fill(templ->fill_cw);
+   if (!(templ->cull_face & PIPE_FACE_BACK)) {
+      if (templ->front_ccw)
+         key->fill_cw = translate_fill(templ->fill_back);
+      else 
+         key->fill_ccw = translate_fill(templ->fill_back);
    }
 
    if (key->fill_cw == CLIP_LINE ||
@@ -66,8 +72,29 @@ calculate_clip_key_rast( const struct brw_context *brw,
       key->clip_mode = BRW_CLIPMODE_CLIP_NON_REJECTED;
    }
 
-   key->offset_ccw = templ->offset_ccw;
-   key->offset_cw = templ->offset_cw;
+   switch (key->fill_cw) {
+   case CLIP_POINT:
+      key->offset_cw = templ->offset_point;
+      break;
+   case CLIP_LINE:
+      key->offset_cw = templ->offset_line;
+      break;
+   case CLIP_FILL:
+      key->offset_cw = templ->offset_tri;
+      break;
+   }
+
+   switch (key->fill_ccw) {
+   case CLIP_POINT:
+      key->offset_ccw = templ->offset_point;
+      break;
+   case CLIP_LINE:
+      key->offset_ccw = templ->offset_line;
+      break;
+   case CLIP_FILL:
+      key->offset_ccw = templ->offset_tri;
+      break;
+   }
 
    if (templ->light_twoside && key->fill_cw != CLIP_CULL) 
       key->copy_bfc_cw = 1;
@@ -111,12 +138,12 @@ static void *brw_create_rasterizer_state( struct pipe_context *pipe,
    /* Caclculate lookup value for WM IZ table.
     */
    if (templ->line_smooth) {
-      if (templ->fill_cw == PIPE_POLYGON_MODE_LINE &&
-	  templ->fill_ccw == PIPE_POLYGON_MODE_LINE) {
+      if (templ->fill_front == PIPE_POLYGON_MODE_LINE &&
+	  templ->fill_back == PIPE_POLYGON_MODE_LINE) {
 	 rast->unfilled_aa_line = AA_ALWAYS;
       }
-      else if (templ->fill_cw == PIPE_POLYGON_MODE_LINE ||
-	       templ->fill_ccw == PIPE_POLYGON_MODE_LINE) {
+      else if (templ->fill_front == PIPE_POLYGON_MODE_LINE ||
+	       templ->fill_back == PIPE_POLYGON_MODE_LINE) {
 	 rast->unfilled_aa_line = AA_SOMETIMES;
       }
       else {
diff --git a/src/gallium/drivers/i965/brw_sf.c b/src/gallium/drivers/i965/brw_sf.c
index 9cceb4dbe5..5abf3848ab 100644
--- a/src/gallium/drivers/i965/brw_sf.c
+++ b/src/gallium/drivers/i965/brw_sf.c
@@ -166,8 +166,8 @@ static enum pipe_error upload_sf_prog(struct brw_context *brw)
    case PIPE_PRIM_TRIANGLES: 
       /* PIPE_NEW_RAST
        */
-      if (rast->fill_cw != PIPE_POLYGON_MODE_FILL ||
-	  rast->fill_ccw != PIPE_POLYGON_MODE_FILL)
+      if (rast->fill_front != PIPE_POLYGON_MODE_FILL ||
+	  rast->fill_back != PIPE_POLYGON_MODE_FILL)
 	 key.primitive = SF_UNFILLED_TRIS;
       else
 	 key.primitive = SF_TRIANGLES;
@@ -187,7 +187,7 @@ static enum pipe_error upload_sf_prog(struct brw_context *brw)
    key.do_twoside_color = rast->light_twoside;
 
    if (key.do_twoside_color) {
-      key.frontface_ccw = (rast->front_winding == PIPE_WINDING_CCW);
+      key.frontface_ccw = rast->front_ccw;
    }
 
    if (brw_search_cache(&brw->cache, BRW_SF_PROG,
diff --git a/src/gallium/drivers/i965/brw_sf_state.c b/src/gallium/drivers/i965/brw_sf_state.c
index 0ad91e0307..6c299a86b4 100644
--- a/src/gallium/drivers/i965/brw_sf_state.c
+++ b/src/gallium/drivers/i965/brw_sf_state.c
@@ -89,8 +89,8 @@ struct brw_sf_unit_key {
    unsigned line_smooth:1;
    unsigned point_sprite:1;
    unsigned point_attenuated:1;
-   unsigned front_face:2;
-   unsigned cull_mode:2;
+   unsigned front_ccw:1;
+   unsigned cull_face:2;
    unsigned flatshade_first:1;
    unsigned gl_rasterization_rules:1;
    unsigned line_last_pixel_enable:1;
@@ -115,8 +115,8 @@ sf_unit_populate_key(struct brw_context *brw, struct brw_sf_unit_key *key)
 
    /* PIPE_NEW_RAST */
    key->scissor = rast->scissor;
-   key->front_face = rast->front_winding;
-   key->cull_mode = rast->cull_mode;
+   key->front_ccw = rast->front_ccw;
+   key->cull_face = rast->cull_face;
    key->line_smooth = rast->line_smooth;
    key->line_width = rast->line_width;
    key->flatshade_first = rast->flatshade_first;
@@ -183,22 +183,22 @@ sf_unit_create_from_key(struct brw_context *brw,
    if (key->scissor)
       sf.sf6.scissor = 1;
 
-   if (key->front_face == PIPE_WINDING_CCW)
+   if (key->front_ccw)
       sf.sf5.front_winding = BRW_FRONTWINDING_CCW;
    else
       sf.sf5.front_winding = BRW_FRONTWINDING_CW;
 
-   switch (key->cull_mode) {
-   case PIPE_WINDING_CCW:
-   case PIPE_WINDING_CW:
-      sf.sf6.cull_mode = (key->front_face == key->cull_mode ?
-			  BRW_CULLMODE_FRONT :
-			  BRW_CULLMODE_BACK);
+   switch (key->cull_face) {
+   case PIPE_FACE_FRONT:
+      sf.sf6.cull_mode = BRW_CULLMODE_FRONT;
       break;
-   case PIPE_WINDING_BOTH:
+   case PIPE_FACE_BACK:
+      sf.sf6.cull_mode = BRW_CULLMODE_BACK;
+      break;
+   case PIPE_FACE_FRONT_AND_BACK:
       sf.sf6.cull_mode = BRW_CULLMODE_BOTH;
       break;
-   case PIPE_WINDING_NONE:
+   case PIPE_FACE_NONE:
       sf.sf6.cull_mode = BRW_CULLMODE_NONE;
       break;
    default:
@@ -284,7 +284,7 @@ static enum pipe_error upload_sf_unit( struct brw_context *brw )
     */
    total_grf = (align(key.total_grf, 16) / 16 - 1);
    viewport_transform = 1;
-   front_winding = (key.front_face == PIPE_WINDING_CCW ?
+   front_winding = (key.front_ccw ?
                     BRW_FRONTWINDING_CCW :
                     BRW_FRONTWINDING_CW);
 
diff --git a/src/gallium/drivers/i965/brw_wm_state.c b/src/gallium/drivers/i965/brw_wm_state.c
index ee970ac75b..efc2d96be1 100644
--- a/src/gallium/drivers/i965/brw_wm_state.c
+++ b/src/gallium/drivers/i965/brw_wm_state.c
@@ -128,8 +128,9 @@ wm_unit_populate_key(struct brw_context *brw, struct brw_wm_unit_key *key)
    key->line_stipple = brw->curr.rast->templ.line_stipple_enable;
 
 
-   key->offset_enable = (brw->curr.rast->templ.offset_cw ||
-			 brw->curr.rast->templ.offset_ccw);
+   key->offset_enable = (brw->curr.rast->templ.offset_point ||
+			 brw->curr.rast->templ.offset_line ||
+			 brw->curr.rast->templ.offset_tri);
 
    key->offset_units = brw->curr.rast->templ.offset_units;
    key->offset_factor = brw->curr.rast->templ.offset_scale;
diff --git a/src/gallium/drivers/llvmpipe/lp_setup_tri.c b/src/gallium/drivers/llvmpipe/lp_setup_tri.c
index 53b91690b6..306cb6e27d 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup_tri.c
+++ b/src/gallium/drivers/llvmpipe/lp_setup_tri.c
@@ -671,14 +671,14 @@ void
 lp_setup_choose_triangle( struct lp_setup_context *setup )
 {
    switch (setup->cullmode) {
-   case PIPE_WINDING_NONE:
+   case PIPE_FACE_NONE:
       setup->triangle = triangle_both;
       break;
-   case PIPE_WINDING_CCW:
-      setup->triangle = triangle_cw;
+   case PIPE_FACE_BACK:
+      setup->triangle = setup->ccw_is_frontface ? triangle_ccw : triangle_cw;
       break;
-   case PIPE_WINDING_CW:
-      setup->triangle = triangle_ccw;
+   case PIPE_FACE_FRONT:
+      setup->triangle = setup->ccw_is_frontface ? triangle_cw : triangle_ccw;
       break;
    default:
       setup->triangle = triangle_nop;
diff --git a/src/gallium/drivers/llvmpipe/lp_state_rasterizer.c b/src/gallium/drivers/llvmpipe/lp_state_rasterizer.c
index 622eb47ff4..afd3e0b21c 100644
--- a/src/gallium/drivers/llvmpipe/lp_state_rasterizer.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_rasterizer.c
@@ -67,8 +67,8 @@ llvmpipe_bind_rasterizer_state(struct pipe_context *pipe, void *handle)
     */
    if (llvmpipe->rasterizer) {
       lp_setup_set_triangle_state( llvmpipe->setup,
-                   llvmpipe->rasterizer->cull_mode,
-                   llvmpipe->rasterizer->front_winding == PIPE_WINDING_CCW,
+                   llvmpipe->rasterizer->cull_face,
+                   llvmpipe->rasterizer->front_ccw,
                    llvmpipe->rasterizer->scissor,
                    llvmpipe->rasterizer->gl_rasterization_rules);
       lp_setup_set_flatshade_first( llvmpipe->setup,
diff --git a/src/gallium/drivers/nv50/nv50_state.c b/src/gallium/drivers/nv50/nv50_state.c
index e885a2b719..b20781fa1f 100644
--- a/src/gallium/drivers/nv50/nv50_state.c
+++ b/src/gallium/drivers/nv50/nv50_state.c
@@ -345,7 +345,7 @@ nv50_rasterizer_state_create(struct pipe_context *pipe,
 		CALLOC_STRUCT(nv50_rasterizer_stateobj);
 
 	/*XXX: ignored
-	 * 	- light_twosize
+	 * 	- light_twoside
 	 * 	- point_smooth
 	 * 	- multisample
 	 * 	- point_sprite / sprite_coord_mode
@@ -385,72 +385,44 @@ nv50_rasterizer_state_create(struct pipe_context *pipe,
 	so_data  (so, cso->point_quad_rasterization ? 1 : 0);
 
 	so_method(so, tesla, NV50TCL_POLYGON_MODE_FRONT, 3);
-	if (cso->front_winding == PIPE_WINDING_CCW) {
-		so_data(so, nvgl_polygon_mode(cso->fill_ccw));
-		so_data(so, nvgl_polygon_mode(cso->fill_cw));
-	} else {
-		so_data(so, nvgl_polygon_mode(cso->fill_cw));
-		so_data(so, nvgl_polygon_mode(cso->fill_ccw));
-	}
+        so_data(so, nvgl_polygon_mode(cso->fill_front));
+        so_data(so, nvgl_polygon_mode(cso->fill_back));
 	so_data(so, cso->poly_smooth ? 1 : 0);
 
 	so_method(so, tesla, NV50TCL_CULL_FACE_ENABLE, 3);
-	so_data  (so, cso->cull_mode != PIPE_WINDING_NONE);
-	if (cso->front_winding == PIPE_WINDING_CCW) {
+	so_data  (so, cso->cull_face != PIPE_FACE_NONE);
+	if (cso->front_ccw) {
 		so_data(so, NV50TCL_FRONT_FACE_CCW);
-		switch (cso->cull_mode) {
-		case PIPE_WINDING_CCW:
-			so_data(so, NV50TCL_CULL_FACE_FRONT);
-			break;
-		case PIPE_WINDING_CW:
-			so_data(so, NV50TCL_CULL_FACE_BACK);
-			break;
-		case PIPE_WINDING_BOTH:
-			so_data(so, NV50TCL_CULL_FACE_FRONT_AND_BACK);
-			break;
-		default:
-			so_data(so, NV50TCL_CULL_FACE_BACK);
-			break;
-		}
-	} else {
+        }
+        else {
 		so_data(so, NV50TCL_FRONT_FACE_CW);
-		switch (cso->cull_mode) {
-		case PIPE_WINDING_CCW:
-			so_data(so, NV50TCL_CULL_FACE_BACK);
-			break;
-		case PIPE_WINDING_CW:
-			so_data(so, NV50TCL_CULL_FACE_FRONT);
-			break;
-		case PIPE_WINDING_BOTH:
-			so_data(so, NV50TCL_CULL_FACE_FRONT_AND_BACK);
-			break;
-		default:
-			so_data(so, NV50TCL_CULL_FACE_BACK);
-			break;
-		}
+        }
+	switch (cso->cull_face) {
+	case PIPE_FACE_FRONT:
+		so_data(so, NV50TCL_CULL_FACE_FRONT);
+		break;
+	case PIPE_FACE_BACK:
+		so_data(so, NV50TCL_CULL_FACE_BACK);
+		break;
+	case PIPE_FACE_FRONT_AND_BACK:
+		so_data(so, NV50TCL_CULL_FACE_FRONT_AND_BACK);
+		break;
+	default:
+		so_data(so, NV50TCL_CULL_FACE_BACK);
+		break;
 	}
 
 	so_method(so, tesla, NV50TCL_POLYGON_STIPPLE_ENABLE, 1);
 	so_data  (so, cso->poly_stipple_enable ? 1 : 0);
 
 	so_method(so, tesla, NV50TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
-	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_POINT) ||
-	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_POINT))
-		so_data(so, 1);
-	else
-		so_data(so, 0);
-	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_LINE) ||
-	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_LINE))
-		so_data(so, 1);
-	else
-		so_data(so, 0);
-	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_FILL) ||
-	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_FILL))
-		so_data(so, 1);
-	else
-		so_data(so, 0);
+        so_data(so, cso->offset_point);
+        so_data(so, cso->offset_line);
+        so_data(so, cso->offset_tri);
 
-	if (cso->offset_cw || cso->offset_ccw) {
+	if (cso->offset_point ||
+            cso->offset_line ||
+            cso->offset_tri) {
 		so_method(so, tesla, NV50TCL_POLYGON_OFFSET_FACTOR, 1);
 		so_data  (so, fui(cso->offset_scale));
 		so_method(so, tesla, NV50TCL_POLYGON_OFFSET_UNITS, 1);
diff --git a/src/gallium/drivers/nvfx/nvfx_state.c b/src/gallium/drivers/nvfx/nvfx_state.c
index 315de492da..17f3f70140 100644
--- a/src/gallium/drivers/nvfx/nvfx_state.c
+++ b/src/gallium/drivers/nvfx/nvfx_state.c
@@ -216,66 +216,39 @@ nvfx_rasterizer_state_create(struct pipe_context *pipe,
 	sb_data(sb, fui(cso->point_size));
 
 	sb_method(sb, NV34TCL_POLYGON_MODE_FRONT, 6);
-	if (cso->front_winding == PIPE_WINDING_CCW) {
-		sb_data(sb, nvgl_polygon_mode(cso->fill_ccw));
-		sb_data(sb, nvgl_polygon_mode(cso->fill_cw));
-		switch (cso->cull_mode) {
-		case PIPE_WINDING_CCW:
-			sb_data(sb, NV34TCL_CULL_FACE_FRONT);
-			break;
-		case PIPE_WINDING_CW:
-			sb_data(sb, NV34TCL_CULL_FACE_BACK);
-			break;
-		case PIPE_WINDING_BOTH:
-			sb_data(sb, NV34TCL_CULL_FACE_FRONT_AND_BACK);
-			break;
-		default:
-			sb_data(sb, NV34TCL_CULL_FACE_BACK);
-			break;
-		}
+        sb_data(sb, nvgl_polygon_mode(cso->fill_front));
+        sb_data(sb, nvgl_polygon_mode(cso->fill_back));
+	switch (cso->cull_face) {
+	case PIPE_FACE_FRONT:
+		sb_data(sb, NV34TCL_CULL_FACE_FRONT);
+		break;
+	case PIPE_FACE_BACK:
+		sb_data(sb, NV34TCL_CULL_FACE_BACK);
+		break;
+	case PIPE_FACE_FRONT_AND_BACK:
+		sb_data(sb, NV34TCL_CULL_FACE_FRONT_AND_BACK);
+		break;
+	default:
+		sb_data(sb, NV34TCL_CULL_FACE_BACK);
+		break;
+	}
+	if (cso->front_ccw) {
 		sb_data(sb, NV34TCL_FRONT_FACE_CCW);
 	} else {
-		sb_data(sb, nvgl_polygon_mode(cso->fill_cw));
-		sb_data(sb, nvgl_polygon_mode(cso->fill_ccw));
-		switch (cso->cull_mode) {
-		case PIPE_WINDING_CCW:
-			sb_data(sb, NV34TCL_CULL_FACE_BACK);
-			break;
-		case PIPE_WINDING_CW:
-			sb_data(sb, NV34TCL_CULL_FACE_FRONT);
-			break;
-		case PIPE_WINDING_BOTH:
-			sb_data(sb, NV34TCL_CULL_FACE_FRONT_AND_BACK);
-			break;
-		default:
-			sb_data(sb, NV34TCL_CULL_FACE_BACK);
-			break;
-		}
 		sb_data(sb, NV34TCL_FRONT_FACE_CW);
 	}
 	sb_data(sb, cso->poly_smooth ? 1 : 0);
-	sb_data(sb, (cso->cull_mode != PIPE_WINDING_NONE) ? 1 : 0);
+	sb_data(sb, (cso->cull_face != PIPE_FACE_NONE) ? 1 : 0);
 
 	sb_method(sb, NV34TCL_POLYGON_STIPPLE_ENABLE, 1);
 	sb_data(sb, cso->poly_stipple_enable ? 1 : 0);
 
 	sb_method(sb, NV34TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
-	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_POINT) ||
-	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_POINT))
-		sb_data(sb, 1);
-	else
-		sb_data(sb, 0);
-	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_LINE) ||
-	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_LINE))
-		sb_data(sb, 1);
-	else
-		sb_data(sb, 0);
-	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_FILL) ||
-	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_FILL))
-		sb_data(sb, 1);
-	else
-		sb_data(sb, 0);
-	if (cso->offset_cw || cso->offset_ccw) {
+        sb_data(sb, cso->offset_point);
+        sb_data(sb, cso->offset_line);
+        sb_data(sb, cso->offset_tri);
+
+	if (cso->offset_point || cso->offset_line || cso->offset_tri) {
 		sb_method(sb, NV34TCL_POLYGON_OFFSET_FACTOR, 2);
 		sb_data(sb, fui(cso->offset_scale));
 		sb_data(sb, fui(cso->offset_units * 2));
diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index ac4e87abe0..11c10e2f2a 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -801,53 +801,37 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
         R300_GA_LINE_CNTL_END_TYPE_COMP;
 
     /* Enable polygon mode */
-    if (state->fill_cw != PIPE_POLYGON_MODE_FILL ||
-        state->fill_ccw != PIPE_POLYGON_MODE_FILL) {
+    if (state->fill_front != PIPE_POLYGON_MODE_FILL ||
+        state->fill_back != PIPE_POLYGON_MODE_FILL) {
         rs->polygon_mode = R300_GA_POLY_MODE_DUAL;
     }
 
-    /* Radeons don't think in "CW/CCW", they think in "front/back". */
-    if (state->front_winding == PIPE_WINDING_CW) {
-        rs->cull_mode = R300_FRONT_FACE_CW;
-
-        /* Polygon offset */
-        if (state->offset_cw) {
-            rs->polygon_offset_enable |= R300_FRONT_ENABLE;
-        }
-        if (state->offset_ccw) {
-            rs->polygon_offset_enable |= R300_BACK_ENABLE;
-        }
-
-        /* Polygon mode */
-        if (rs->polygon_mode) {
-            rs->polygon_mode |=
-                r300_translate_polygon_mode_front(state->fill_cw);
-            rs->polygon_mode |=
-                r300_translate_polygon_mode_back(state->fill_ccw);
-        }
-    } else {
+    /* Front face */
+    if (state->front_ccw) 
         rs->cull_mode = R300_FRONT_FACE_CCW;
+    else
+        rs->cull_mode = R300_FRONT_FACE_CW;
 
-        /* Polygon offset */
-        if (state->offset_ccw) {
-            rs->polygon_offset_enable |= R300_FRONT_ENABLE;
-        }
-        if (state->offset_cw) {
-            rs->polygon_offset_enable |= R300_BACK_ENABLE;
-        }
+    /* Polygon offset */
+    if (util_get_offset(state, state->fill_front)) {
+       rs->polygon_offset_enable |= R300_FRONT_ENABLE;
+    }
+    if (util_get_offset(state, state->fill_back)) {
+       rs->polygon_offset_enable |= R300_BACK_ENABLE;
+    }
 
-        /* Polygon mode */
-        if (rs->polygon_mode) {
-            rs->polygon_mode |=
-                r300_translate_polygon_mode_front(state->fill_ccw);
-            rs->polygon_mode |=
-                r300_translate_polygon_mode_back(state->fill_cw);
-        }
+    /* Polygon mode */
+    if (rs->polygon_mode) {
+       rs->polygon_mode |=
+          r300_translate_polygon_mode_front(state->fill_front);
+       rs->polygon_mode |=
+          r300_translate_polygon_mode_back(state->fill_back);
     }
-    if (state->front_winding & state->cull_mode) {
+
+    if (state->cull_face & PIPE_FACE_FRONT) {
         rs->cull_mode |= R300_CULL_FRONT;
     }
-    if (~(state->front_winding) & state->cull_mode) {
+    if (state->cull_face & PIPE_FACE_BACK) {
         rs->cull_mode |= R300_CULL_BACK;
     }
 
@@ -914,7 +898,9 @@ static void r300_bind_rs_state(struct pipe_context* pipe, void* state)
     }
 
     if (rs) {
-        r300->polygon_offset_enabled = rs->rs.offset_cw || rs->rs.offset_ccw;
+        r300->polygon_offset_enabled = (rs->rs.offset_point ||
+                                        rs->rs.offset_line ||
+                                        rs->rs.offset_tri);
         r300->sprite_coord_enable = rs->rs.sprite_coord_enable;
         r300->two_sided_color = rs->rs.light_twoside;
     } else {
diff --git a/src/gallium/drivers/softpipe/sp_context.h b/src/gallium/drivers/softpipe/sp_context.h
index aa69625768..b3d3fe620f 100644
--- a/src/gallium/drivers/softpipe/sp_context.h
+++ b/src/gallium/drivers/softpipe/sp_context.h
@@ -109,6 +109,9 @@ struct softpipe_context {
    /** The reduced version of the primitive supplied by the state tracker */
    unsigned reduced_api_prim;
 
+   /** Derived information about which winding orders to cull */
+   unsigned cull_mode;
+
    /**
     * The reduced primitive after unfilled triangles, wide-line decomposition,
     * etc, are taken into account.  This is the primitive type that's actually
diff --git a/src/gallium/drivers/softpipe/sp_setup.c b/src/gallium/drivers/softpipe/sp_setup.c
index 35ef9e698d..5d727dc00d 100644
--- a/src/gallium/drivers/softpipe/sp_setup.c
+++ b/src/gallium/drivers/softpipe/sp_setup.c
@@ -111,34 +111,13 @@ struct setup_context {
    uint numFragsWritten;  /**< per primitive */
 #endif
 
-   unsigned winding;		/* which winding to cull */
+   unsigned cull_face;		/* which faces cull */
    unsigned nr_vertex_attrs;
 };
 
 
 
 
-/**
- * Do triangle cull test using tri determinant (sign indicates orientation)
- * \return true if triangle is to be culled.
- */
-static INLINE boolean
-cull_tri(const struct setup_context *setup, float det)
-{
-   if (det != 0) {   
-      /* if (det < 0 then Z points toward camera and triangle is 
-       * counter-clockwise winding.
-       */
-      unsigned winding = (det < 0) ? PIPE_WINDING_CCW : PIPE_WINDING_CW;
-
-      if ((winding & setup->winding) == 0)
-	 return FALSE;
-   }
-
-   /* Culled:
-    */
-   return TRUE;
-}
 
 
 
@@ -393,8 +372,16 @@ setup_sort_vertices(struct setup_context *setup,
     * 0 = front-facing, 1 = back-facing
     */
    setup->facing = 
-      ((det > 0.0) ^ 
-       (setup->softpipe->rasterizer->front_winding == PIPE_WINDING_CW));
+      ((det < 0.0) ^ 
+       (setup->softpipe->rasterizer->front_ccw));
+
+   {
+      unsigned face = setup->facing == 0 ? PIPE_FACE_FRONT : PIPE_FACE_BACK;
+
+      if (face & setup->cull_face)
+	 return FALSE;
+   }
+
 
    /* Prepare pixel offset for rasterisation:
     *  - pixel center (0.5, 0.5) for GL, or
@@ -832,11 +819,9 @@ sp_setup_tri(struct setup_context *setup,
    setup->numFragsWritten = 0;
 #endif
 
-   if (cull_tri( setup, det ))
-      return;
-
    if (!setup_sort_vertices( setup, det, v0, v1, v2 ))
       return;
+
    setup_tri_coefficients( setup );
    setup_tri_edges( setup );
 
@@ -1420,14 +1405,14 @@ sp_setup_prepare(struct setup_context *setup)
    sp->quad.first->begin( sp->quad.first );
 
    if (sp->reduced_api_prim == PIPE_PRIM_TRIANGLES &&
-       sp->rasterizer->fill_cw == PIPE_POLYGON_MODE_FILL &&
-       sp->rasterizer->fill_ccw == PIPE_POLYGON_MODE_FILL) {
+       sp->rasterizer->fill_front == PIPE_POLYGON_MODE_FILL &&
+       sp->rasterizer->fill_back == PIPE_POLYGON_MODE_FILL) {
       /* we'll do culling */
-      setup->winding = sp->rasterizer->cull_mode;
+      setup->cull_face = sp->rasterizer->cull_face;
    }
    else {
       /* 'draw' will do culling */
-      setup->winding = PIPE_WINDING_NONE;
+      setup->cull_face = PIPE_FACE_NONE;
    }
 }
 
diff --git a/src/gallium/drivers/svga/svga_pipe_rasterizer.c b/src/gallium/drivers/svga/svga_pipe_rasterizer.c
index 5253c45cb2..660eb0757a 100644
--- a/src/gallium/drivers/svga/svga_pipe_rasterizer.c
+++ b/src/gallium/drivers/svga/svga_pipe_rasterizer.c
@@ -36,16 +36,17 @@
 /* Hardware frontwinding is always set up as SVGA3D_FRONTWINDING_CW.
  */
 static SVGA3dFace svga_translate_cullmode( unsigned mode,
-                                           unsigned front_winding )
+                                           unsigned front_ccw )
 {
+   const int hw_front_ccw = 0;  /* hardware is always CW */
    switch (mode) {
-   case PIPE_WINDING_NONE:
+   case PIPE_FACE_NONE:
       return SVGA3D_FACE_NONE;
-   case PIPE_WINDING_CCW:
-      return SVGA3D_FACE_BACK;
-   case PIPE_WINDING_CW:
-      return SVGA3D_FACE_FRONT;
-   case PIPE_WINDING_BOTH:
+   case PIPE_FACE_FRONT:
+      return front_ccw == hw_front_ccw ? SVGA3D_FACE_FRONT : SVGA3D_FACE_BACK;
+   case PIPE_FACE_BACK:
+      return front_ccw == hw_front_ccw ? SVGA3D_FACE_BACK : SVGA3D_FACE_FRONT;
+   case PIPE_FACE_FRONT_AND_BACK:
       return SVGA3D_FACE_FRONT_BACK;
    default:
       assert(0);
@@ -81,8 +82,8 @@ svga_create_rasterizer_state(struct pipe_context *pipe,
    /* fill_cw, fill_ccw      - draw module or index translation */
 
    rast->shademode = svga_translate_flatshade( templ->flatshade );
-   rast->cullmode = svga_translate_cullmode( templ->cull_mode, 
-                                             templ->front_winding );
+   rast->cullmode = svga_translate_cullmode( templ->cull_face, 
+                                             templ->front_ccw );
    rast->scissortestenable = templ->scissor;
    rast->multisampleantialias = templ->multisample;
    rast->antialiasedlineenable = templ->line_smooth;
@@ -117,31 +118,31 @@ svga_create_rasterizer_state(struct pipe_context *pipe,
       rast->need_pipeline |= SVGA_PIPELINE_FLAG_POINTS;
 
    {
-      boolean offset_cw = templ->offset_cw;
-      boolean offset_ccw = templ->offset_ccw;
-      boolean offset  = 0;
-      int fill_cw = templ->fill_cw;
-      int fill_ccw = templ->fill_ccw;
+      int fill_front = templ->fill_front;
+      int fill_back = templ->fill_back;
       int fill = PIPE_POLYGON_MODE_FILL;
+      boolean offset_front = util_get_offset(templ, fill_front);
+      boolean offset_back = util_get_offset(templ, fill_back);
+      boolean offset  = 0;
 
-      switch (templ->cull_mode) {
-      case PIPE_WINDING_BOTH:
+      switch (templ->cull_face) {
+      case PIPE_FACE_FRONT_AND_BACK:
          offset = 0;
          fill = PIPE_POLYGON_MODE_FILL;
          break;
 
-      case PIPE_WINDING_CW:
-         offset = offset_ccw;
-         fill = fill_ccw;
+      case PIPE_FACE_FRONT:
+         offset = offset_front;
+         fill = fill_front;
          break;
 
-      case PIPE_WINDING_CCW:
-         offset = offset_cw;
-         fill = fill_cw;
+      case PIPE_FACE_BACK:
+         offset = offset_back;
+         fill = fill_back;
          break;
 
-      case PIPE_WINDING_NONE:
-         if (fill_cw != fill_ccw || offset_cw != offset_ccw) 
+      case PIPE_FACE_NONE:
+         if (fill_front != fill_back || offset_front != offset_back) 
          {
             /* Always need the draw module to work out different
              * front/back fill modes:
@@ -149,8 +150,8 @@ svga_create_rasterizer_state(struct pipe_context *pipe,
             rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
          }
          else {
-            offset = offset_ccw;
-            fill = fill_ccw;
+            offset = offset_front;
+            fill = fill_front;
          }
          break;
 
@@ -167,7 +168,7 @@ svga_create_rasterizer_state(struct pipe_context *pipe,
           (templ->flatshade ||
            templ->light_twoside ||
            offset ||
-           templ->cull_mode != PIPE_WINDING_NONE)) 
+           templ->cull_face != PIPE_FACE_NONE)) 
       {
          fill = PIPE_POLYGON_MODE_FILL;
          rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
diff --git a/src/gallium/drivers/svga/svga_state_fs.c b/src/gallium/drivers/svga/svga_state_fs.c
index 1310fd9825..ad6f294713 100644
--- a/src/gallium/drivers/svga/svga_state_fs.c
+++ b/src/gallium/drivers/svga/svga_state_fs.c
@@ -131,8 +131,7 @@ static int make_fs_key( const struct svga_context *svga,
       /* SVGA_NEW_RAST
        */
       key->light_twoside = svga->curr.rast->templ.light_twoside;
-      key->front_cw = (svga->curr.rast->templ.front_winding == 
-                       PIPE_WINDING_CW);
+      key->front_ccw = svga->curr.rast->templ.front_ccw;
    }
 
    /* The blend workaround for simulating logicop xor behaviour
diff --git a/src/gallium/drivers/svga/svga_state_rss.c b/src/gallium/drivers/svga/svga_state_rss.c
index b7195d246b..ab13f3fdf1 100644
--- a/src/gallium/drivers/svga/svga_state_rss.c
+++ b/src/gallium/drivers/svga/svga_state_rss.c
@@ -146,13 +146,13 @@ static int emit_rss( struct svga_context *svga,
           * then our definition of front face agrees with hardware.
           * Otherwise need to flip.
           */
-         if (rast->templ.front_winding == PIPE_WINDING_CW) {
-            cw = 0;
-            ccw = 1;
+         if (rast->templ.front_ccw) {
+            ccw = 0;
+            cw = 1;
          }
          else {
-            cw = 1;
-            ccw = 0;
+            ccw = 1;
+            cw = 0;
          }
 
          /* Twoside stencil
diff --git a/src/gallium/drivers/svga/svga_tgsi.h b/src/gallium/drivers/svga/svga_tgsi.h
index 063c9cf422..7ea909c37b 100644
--- a/src/gallium/drivers/svga/svga_tgsi.h
+++ b/src/gallium/drivers/svga/svga_tgsi.h
@@ -48,7 +48,7 @@ struct svga_vs_compile_key
 struct svga_fs_compile_key
 {
    unsigned light_twoside:1;
-   unsigned front_cw:1;
+   unsigned front_ccw:1;
    unsigned white_fragments:1;
    unsigned num_textures:8;
    unsigned num_unnormalized_coords:8;
diff --git a/src/gallium/drivers/svga/svga_tgsi_insn.c b/src/gallium/drivers/svga/svga_tgsi_insn.c
index 7d7024c4a7..67e1f22a70 100644
--- a/src/gallium/drivers/svga/svga_tgsi_insn.c
+++ b/src/gallium/drivers/svga/svga_tgsi_insn.c
@@ -2588,10 +2588,10 @@ static boolean emit_light_twoside( struct svga_shader_emitter *emit )
    
    if_token = inst_token( SVGA3DOP_IFC );
 
-   if (emit->key.fkey.front_cw)
-      if_token.control = SVGA3DOPCOMP_GT;
-   else
+   if (emit->key.fkey.front_ccw)
       if_token.control = SVGA3DOPCOMP_LT;
+   else
+      if_token.control = SVGA3DOPCOMP_GT;
 
    zero = scalar(zero, TGSI_SWIZZLE_X);
 
@@ -2639,12 +2639,12 @@ static boolean emit_frontface( struct svga_shader_emitter *emit )
    temp = dst_register( SVGA3DREG_TEMP,
                         emit->nr_hw_temp++ );
 
-   if (emit->key.fkey.front_cw) {
-      pass = scalar( zero, TGSI_SWIZZLE_W );
-      fail = scalar( zero, TGSI_SWIZZLE_X );
-   } else {
+   if (emit->key.fkey.front_ccw) {
       pass = scalar( zero, TGSI_SWIZZLE_X );
       fail = scalar( zero, TGSI_SWIZZLE_W );
+   } else {
+      pass = scalar( zero, TGSI_SWIZZLE_W );
+      fail = scalar( zero, TGSI_SWIZZLE_X );
    }
 
    if (!emit_conditional(emit, PIPE_FUNC_GREATER,
diff --git a/src/gallium/drivers/trace/tr_dump_state.c b/src/gallium/drivers/trace/tr_dump_state.c
index f148a859ff..1727c2a020 100644
--- a/src/gallium/drivers/trace/tr_dump_state.c
+++ b/src/gallium/drivers/trace/tr_dump_state.c
@@ -136,12 +136,13 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
 
    trace_dump_member(bool, state, flatshade);
    trace_dump_member(bool, state, light_twoside);
-   trace_dump_member(uint, state, front_winding);
-   trace_dump_member(uint, state, cull_mode);
-   trace_dump_member(uint, state, fill_cw);
-   trace_dump_member(uint, state, fill_ccw);
-   trace_dump_member(bool, state, offset_cw);
-   trace_dump_member(bool, state, offset_ccw);
+   trace_dump_member(uint, state, front_ccw);
+   trace_dump_member(uint, state, cull_face);
+   trace_dump_member(uint, state, fill_front);
+   trace_dump_member(uint, state, fill_back);
+   trace_dump_member(bool, state, offset_point);
+   trace_dump_member(bool, state, offset_line);
+   trace_dump_member(bool, state, offset_tri);
    trace_dump_member(bool, state, scissor);
    trace_dump_member(bool, state, poly_smooth);
    trace_dump_member(bool, state, poly_stipple_enable);