1 files changed, 132 insertions, 73 deletions

diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index 4f41530c16..67e09362d8 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -395,13 +395,13 @@ static void r300_set_clip_state(struct pipe_context* pipe,
     if (r300->screen->caps.has_tcl) {
         memcpy(r300->clip_state.state, state, sizeof(struct pipe_clip_state));
         r300->clip_state.size = 29;
+
+        r300->clip_state.dirty = TRUE;
     } else {
         draw_flush(r300->draw);
         draw_set_clip_state(r300->draw, state);
         r300->clip_state.size = 2;
     }
-
-    r300->clip_state.dirty = TRUE;
 }
 
 static void
@@ -573,13 +573,35 @@ static void r300_fb_set_tiling_flags(struct r300_context *r300,
     }
 }
 
+static void r300_print_fb_surf_info(struct pipe_surface *surf, unsigned index,
+                                    const char *binding)
+{
+    struct pipe_resource *tex = surf->texture;
+    struct r300_texture *rtex = r300_texture(tex);
+
+    fprintf(stderr,
+            "r300:   %s[%i] Dim: %ix%i, Offset: %i, ZSlice: %i, "
+            "Face: %i, Level: %i, Format: %s\n"
+
+            "r300:     TEX: Macro: %s, Micro: %s, Pitch: %i, "
+            "Dim: %ix%ix%i, LastLevel: %i, Format: %s\n",
+
+            binding, index, surf->width, surf->height, surf->offset,
+            surf->zslice, surf->face, surf->level,
+            util_format_short_name(surf->format),
+
+            rtex->macrotile ? "YES" : " NO", rtex->microtile ? "YES" : " NO",
+            rtex->hwpitch[0], tex->width0, tex->height0, tex->depth0,
+            tex->last_level, util_format_short_name(tex->format));
+}
+
 static void
     r300_set_framebuffer_state(struct pipe_context* pipe,
                                const struct pipe_framebuffer_state* state)
 {
     struct r300_context* r300 = r300_context(pipe);
     struct pipe_framebuffer_state *old_state = r300->fb_state.state;
-    unsigned max_width, max_height;
+    unsigned max_width, max_height, i;
     uint32_t zbuffer_bpp = 0;
 
     if (state->nr_cbufs > 4) {
@@ -623,7 +645,7 @@ static void
     memcpy(r300->fb_state.state, state, sizeof(struct pipe_framebuffer_state));
 
     r300->fb_state.size = (10 * state->nr_cbufs) + (2 * (4 - state->nr_cbufs)) +
-                          (state->zsbuf ? 10 : 0) + 11;
+                          (state->zsbuf ? 10 : 0) + 9;
 
     /* Polygon offset depends on the zbuffer bit depth. */
     if (state->zsbuf && r300->polygon_offset_enabled) {
@@ -641,6 +663,16 @@ static void
             r300->rs_state.dirty = TRUE;
         }
     }
+
+    if (DBG_ON(r300, DBG_FB)) {
+        fprintf(stderr, "r300: set_framebuffer_state:\n");
+        for (i = 0; i < state->nr_cbufs; i++) {
+            r300_print_fb_surf_info(state->cbufs[i], i, "CB");
+        }
+        if (state->zsbuf) {
+            r300_print_fb_surf_info(state->zsbuf, 0, "ZB");
+        }
+    }
 }
 
 /* Create fragment shader state. */
@@ -729,9 +761,14 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
 {
     struct r300_rs_state* rs = CALLOC_STRUCT(r300_rs_state);
     int i;
+    float psiz;
 
-    /* Copy rasterizer state for Draw. */
+    /* Copy rasterizer state. */
     rs->rs = *state;
+    rs->rs_draw = *state;
+
+    /* Override some states for Draw. */
+    rs->rs_draw.sprite_coord_enable = 0; /* We can do this in HW. */
 
 #ifdef PIPE_ARCH_LITTLE_ENDIAN
     rs->vap_control_status = R300_VC_NO_SWAP;
@@ -744,60 +781,64 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
         rs->vap_control_status |= R300_VAP_TCL_BYPASS;
     }
 
-    rs->point_size = pack_float_16_6x(state->point_size) |
+    /* Point size width and height. */
+    rs->point_size =
+        pack_float_16_6x(state->point_size) |
         (pack_float_16_6x(state->point_size) << R300_POINTSIZE_X_SHIFT);
 
+    /* Point size clamping. */
+    if (state->point_size_per_vertex) {
+        /* Per-vertex point size.
+         * Clamp to [0, max FB size] */
+        psiz = pipe->screen->get_paramf(pipe->screen,
+                                        PIPE_CAP_MAX_POINT_WIDTH);
+        rs->point_minmax =
+            pack_float_16_6x(psiz) << R300_GA_POINT_MINMAX_MAX_SHIFT;
+    } else {
+        /* We cannot disable the point-size vertex output,
+         * so clamp it. */
+        psiz = state->point_size;
+        rs->point_minmax =
+            (pack_float_16_6x(psiz) << R300_GA_POINT_MINMAX_MIN_SHIFT) |
+            (pack_float_16_6x(psiz) << R300_GA_POINT_MINMAX_MAX_SHIFT);
+    }
+
+    /* Line control. */
     rs->line_control = pack_float_16_6x(state->line_width) |
         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;
     }
 
@@ -856,24 +897,30 @@ static void r300_bind_rs_state(struct pipe_context* pipe, void* state)
     struct r300_context* r300 = r300_context(pipe);
     struct r300_rs_state* rs = (struct r300_rs_state*)state;
     int last_sprite_coord_enable = r300->sprite_coord_enable;
+    boolean last_two_sided_color = r300->two_sided_color;
 
-    if (r300->draw) {
+    if (r300->draw && rs) {
         draw_flush(r300->draw);
-        draw_set_rasterizer_state(r300->draw, &rs->rs, state);
+        draw_set_rasterizer_state(r300->draw, &rs->rs_draw, 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 {
         r300->polygon_offset_enabled = FALSE;
         r300->sprite_coord_enable = 0;
+        r300->two_sided_color = FALSE;
     }
 
     UPDATE_STATE(state, r300->rs_state);
-    r300->rs_state.size = 26 + (r300->polygon_offset_enabled ? 5 : 0);
+    r300->rs_state.size = 27 + (r300->polygon_offset_enabled ? 5 : 0);
 
-    if (last_sprite_coord_enable != r300->sprite_coord_enable) {
+    if (last_sprite_coord_enable != r300->sprite_coord_enable ||
+        last_two_sided_color != r300->two_sided_color) {
         r300->rs_block_state.dirty = TRUE;
     }
 }
@@ -913,7 +960,7 @@ static void*
     sampler->min_lod = MAX2((unsigned)state->min_lod, 0);
     sampler->max_lod = MAX2((unsigned)ceilf(state->max_lod), 0);
 
-    lod_bias = CLAMP((int)(state->lod_bias * 32), -(1 << 9), (1 << 9) - 1);
+    lod_bias = CLAMP((int)(state->lod_bias * 32 + 1), -(1 << 9), (1 << 9) - 1);
 
     sampler->filter1 |= lod_bias << R300_LOD_BIAS_SHIFT;
 
@@ -1028,7 +1075,6 @@ r300_create_sampler_view(struct pipe_context *pipe,
 {
     struct r300_sampler_view *view = CALLOC_STRUCT(r300_sampler_view);
     struct r300_texture *tex = r300_texture(texture);
-    unsigned char swizzle[4];
 
     if (view) {
         view->base = *templ;
@@ -1037,14 +1083,14 @@ r300_create_sampler_view(struct pipe_context *pipe,
         view->base.texture = NULL;
         pipe_resource_reference(&view->base.texture, texture);
 
-        swizzle[0] = templ->swizzle_r;
-        swizzle[1] = templ->swizzle_g;
-        swizzle[2] = templ->swizzle_b;
-        swizzle[3] = templ->swizzle_a;
+        view->swizzle[0] = templ->swizzle_r;
+        view->swizzle[1] = templ->swizzle_g;
+        view->swizzle[2] = templ->swizzle_b;
+        view->swizzle[3] = templ->swizzle_a;
 
         view->format = tex->tx_format;
         view->format.format1 |= r300_translate_texformat(templ->format,
-                                                         swizzle);
+                                                         view->swizzle);
         if (r300_screen(pipe->screen)->caps.is_r500) {
             view->format.format2 |= r500_tx_format_msb_bit(templ->format);
         }
@@ -1081,6 +1127,13 @@ static void r300_set_viewport_state(struct pipe_context* pipe,
 
     r300->viewport = *state;
 
+    if (r300->draw) {
+        draw_flush(r300->draw);
+        draw_set_viewport_state(r300->draw, state);
+        viewport->vte_control = R300_VTX_XY_FMT | R300_VTX_Z_FMT;
+        return;
+    }
+
     /* Do the transform in HW. */
     viewport->vte_control = R300_VTX_W0_FMT;
 
@@ -1190,7 +1243,7 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
     }
 }
 
-/* Update the PSC tables. */
+/* Initialize the PSC tables. */
 static void r300_vertex_psc(struct r300_vertex_element_state *velems)
 {
     struct r300_vertex_stream_state *vstream = &velems->vertex_stream;
@@ -1329,7 +1382,6 @@ static void* r300_create_vertex_elements_state(struct pipe_context* pipe,
                     abort();
                 }
             }
-
         }
     }
     return velems;
@@ -1350,6 +1402,7 @@ static void r300_bind_vertex_elements_state(struct pipe_context *pipe,
     if (r300->draw) {
         draw_flush(r300->draw);
         draw_set_vertex_elements(r300->draw, velems->count, velems->velem);
+        return;
     }
 
     UPDATE_STATE(&velems->vertex_stream, r300->vertex_stream_state);
@@ -1372,8 +1425,10 @@ static void* r300_create_vs_state(struct pipe_context* pipe,
     vs->state = *shader;
     vs->state.tokens = tgsi_dup_tokens(shader->tokens);
 
+    r300_init_vs_outputs(vs);
+
     if (r300->screen->caps.has_tcl) {
-        r300_translate_vertex_shader(r300, vs, vs->state.tokens);
+        r300_translate_vertex_shader(r300, vs);
     } else {
         vs->draw_vs = draw_create_vertex_shader(r300->draw, shader);
     }
@@ -1443,7 +1498,7 @@ static void r300_set_constant_buffer(struct pipe_context *pipe,
     struct r300_constant_buffer *cbuf;
     struct pipe_transfer *tr;
     void *mapped;
-    int max_size = 0;
+    int max_size = 0, max_size_bytes = 0, clamped_size = 0;
 
     switch (shader) {
         case PIPE_SHADER_VERTEX:
@@ -1462,6 +1517,7 @@ static void r300_set_constant_buffer(struct pipe_context *pipe,
             assert(0);
             return;
     }
+    max_size_bytes = max_size * 4 * sizeof(float);
 
     if (buf == NULL || buf->width0 == 0 ||
         (mapped = pipe_buffer_map(pipe, buf, PIPE_TRANSFER_READ, &tr)) == NULL)
@@ -1470,19 +1526,21 @@ static void r300_set_constant_buffer(struct pipe_context *pipe,
         return;
     }
 
-    assert((buf->width0 % 4 * sizeof(float)) == 0);
+    if (shader == PIPE_SHADER_FRAGMENT ||
+        (shader == PIPE_SHADER_VERTEX && r300->screen->caps.has_tcl)) {
+        assert((buf->width0 % (4 * sizeof(float))) == 0);
 
-    /* Check the size of the constant buffer. */
-    /* XXX Subtract immediates and RC_STATE_* variables. */
-    if (buf->width0 > (sizeof(float) * 4 * max_size)) {
-        fprintf(stderr, "r300: Max size of the constant buffer is "
-                      "%i*4 floats.\n", max_size);
-        abort();
-    }
+        /* Check the size of the constant buffer. */
+        /* XXX Subtract immediates and RC_STATE_* variables. */
+        if (buf->width0 > max_size_bytes) {
+            fprintf(stderr, "r300: Max size of the constant buffer is "
+                          "%i*4 floats.\n", max_size);
+        }
+        clamped_size = MIN2(buf->width0, max_size_bytes);
 
-    memcpy(cbuf->constants, mapped, buf->width0);
-    cbuf->count = buf->width0 / (4 * sizeof(float));
-    pipe_buffer_unmap(pipe, buf, tr);
+        memcpy(cbuf->constants, mapped, clamped_size);
+        cbuf->count = clamped_size / (4 * sizeof(float));
+    }
 
     if (shader == PIPE_SHADER_VERTEX) {
         if (r300->screen->caps.has_tcl) {
@@ -1492,12 +1550,13 @@ static void r300_set_constant_buffer(struct pipe_context *pipe,
             r300->pvs_flush.dirty = TRUE;
         } else if (r300->draw) {
             draw_set_mapped_constant_buffer(r300->draw, PIPE_SHADER_VERTEX,
-                0, cbuf->constants,
-                buf->width0);
+                0, mapped, buf->width0);
         }
     } else if (shader == PIPE_SHADER_FRAGMENT) {
         r300->fs_constants.dirty = TRUE;
     }
+
+    pipe_buffer_unmap(pipe, buf, tr);
 }
 
 void r300_init_state_functions(struct r300_context* r300)