From 438359597cd4254558f4d2fd5b54eb32c03e1b4c Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Sat, 27 Nov 2010 22:05:37 +0800
Subject: st/vega: Delay fb state update to vg_validate_state.

vg_manager_validate_framebuffer should mark the fb dirty and have
vg_validate_state call cso_set_framebuffer.  Rename VIEWPORT_DIRTY to
FRAMEBUFFER_DIRTY.
---
 src/gallium/state_trackers/vega/vg_context.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index 80a6c07c69..547674bd2a 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -81,11 +81,11 @@ enum dirty_state {
    NONE_DIRTY          = 0<<0,
    BLEND_DIRTY         = 1<<1,
    RASTERIZER_DIRTY    = 1<<2,
-   VIEWPORT_DIRTY      = 1<<3,
+   FRAMEBUFFER_DIRTY   = 1<<3,
    VS_DIRTY            = 1<<4,
    DEPTH_STENCIL_DIRTY = 1<<5,
    ALL_DIRTY           = BLEND_DIRTY | RASTERIZER_DIRTY |
-   VIEWPORT_DIRTY | VS_DIRTY | DEPTH_STENCIL_DIRTY
+   FRAMEBUFFER_DIRTY | VS_DIRTY | DEPTH_STENCIL_DIRTY
 };
 
 struct vg_context
-- 
cgit v1.2.3


From b730f0fc52a208b5f2a308199724ab02aa391fec Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Sun, 28 Nov 2010 01:58:05 +0800
Subject: st/vega: Move g3d states to renderer.

Let vg_context focus on OpenVG states and renderer focus on gallium
states.
---
 src/gallium/state_trackers/vega/renderer.c   | 224 ++++++++++++++++++++++++++-
 src/gallium/state_trackers/vega/renderer.h   |   7 +
 src/gallium/state_trackers/vega/vg_context.c | 187 +---------------------
 src/gallium/state_trackers/vega/vg_context.h |  12 --
 4 files changed, 230 insertions(+), 200 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
index 7543fa1d41..d3fdf906e4 100644
--- a/src/gallium/state_trackers/vega/renderer.c
+++ b/src/gallium/state_trackers/vega/renderer.c
@@ -40,6 +40,7 @@
 #include "util/u_simple_shaders.h"
 #include "util/u_memory.h"
 #include "util/u_sampler.h"
+#include "util/u_math.h"
 
 #include "cso_cache/cso_context.h"
 #include "tgsi/tgsi_ureg.h"
@@ -78,6 +79,16 @@ struct renderer {
 
    void *fs;
 
+   struct {
+      struct pipe_blend_state blend;
+      struct pipe_rasterizer_state rasterizer;
+      struct pipe_shader_state vs_state;
+      struct pipe_depth_stencil_alpha_state dsa;
+      struct pipe_framebuffer_state fb;
+   } g3d;
+
+   struct pipe_resource *vs_const_buffer;
+
    VGfloat vertices[4][2][4];
 
    void *cached_vs[NUM_RENDERER_VS];
@@ -248,6 +259,30 @@ static void renderer_set_fs(struct renderer *r, RendererFs id)
    cso_set_fragment_shader_handle(r->cso, r->cached_fs[id]);
 }
 
+typedef enum {
+   VEGA_Y0_TOP,
+   VEGA_Y0_BOTTOM
+} VegaOrientation;
+
+static void vg_set_viewport(struct vg_context *ctx,
+                            VegaOrientation orientation)
+{
+   struct st_framebuffer *stfb = ctx->draw_buffer;
+   struct pipe_viewport_state viewport;
+   VGfloat y_scale = (orientation == VEGA_Y0_BOTTOM) ? -2.f : 2.f;
+
+   viewport.scale[0] =  stfb->width / 2.f;
+   viewport.scale[1] =  stfb->height / y_scale;
+   viewport.scale[2] =  1.0;
+   viewport.scale[3] =  1.0;
+   viewport.translate[0] = stfb->width / 2.f;
+   viewport.translate[1] = stfb->height / 2.f;
+   viewport.translate[2] = 0.0;
+   viewport.translate[3] = 0.0;
+
+   cso_set_viewport(ctx->cso_context, &viewport);
+}
+
 /**
  * Set renderer target.
  *
@@ -930,8 +965,7 @@ void renderer_polygon_stencil(struct renderer *renderer,
       struct pipe_rasterizer_state raster;
       struct pipe_depth_stencil_alpha_state dsa;
 
-      /* TODO do not access owner state */
-      raster = renderer->owner->state.g3d.rasterizer;
+      raster = renderer->g3d.rasterizer;
       dsa = renderer->u.polygon_stencil.dsa;
 
       /* front */
@@ -998,8 +1032,7 @@ VGboolean renderer_polygon_fill_begin(struct renderer *renderer,
    dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
    dsa.stencil[0].valuemask = ~0;
    dsa.stencil[0].writemask = ~0;
-   /* TODO do not access owner state */
-   dsa.depth = renderer->owner->state.g3d.dsa.depth;
+   dsa.depth = renderer->g3d.dsa.depth;
    cso_set_depth_stencil_alpha(renderer->cso, &dsa);
 
    renderer->state = RENDERER_STATE_POLYGON_FILL;
@@ -1076,6 +1109,8 @@ void renderer_destroy(struct renderer *ctx)
          cso_delete_fragment_shader(ctx->cso, ctx->cached_fs[i]);
    }
 
+   pipe_resource_reference(&ctx->vs_const_buffer, NULL);
+
 #if 0
    if (ctx->fs) {
       cso_delete_fragment_shader(ctx->cso, ctx->fs);
@@ -1085,6 +1120,187 @@ void renderer_destroy(struct renderer *ctx)
    FREE(ctx);
 }
 
+static void update_clip_state(struct renderer *renderer,
+                              const struct vg_state *state)
+{
+   struct pipe_depth_stencil_alpha_state *dsa = &renderer->g3d.dsa;
+
+   memset(dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
+
+   if (state->scissoring) {
+      struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
+      int i;
+
+      renderer_scissor_begin(renderer, VG_FALSE);
+
+      for (i = 0; i < state->scissor_rects_num; ++i) {
+         const float x      = state->scissor_rects[i * 4 + 0].f;
+         const float y      = state->scissor_rects[i * 4 + 1].f;
+         const float width  = state->scissor_rects[i * 4 + 2].f;
+         const float height = state->scissor_rects[i * 4 + 3].f;
+         VGint x0, y0, x1, y1, iw, ih;
+
+         x0 = (VGint) x;
+         y0 = (VGint) y;
+         if (x0 < 0)
+            x0 = 0;
+         if (y0 < 0)
+            y0 = 0;
+
+         /* note that x1 and y1 are exclusive */
+         x1 = (VGint) ceilf(x + width);
+         y1 = (VGint) ceilf(y + height);
+         if (x1 > fb->width)
+            x1 = fb->width;
+         if (y1 > fb->height)
+            y1 = fb->height;
+
+         iw = x1 - x0;
+         ih = y1 - y0;
+         if (iw > 0 && ih> 0 )
+            renderer_scissor(renderer, x0, y0, iw, ih);
+      }
+
+      renderer_scissor_end(renderer);
+
+      dsa->depth.enabled = 1; /* glEnable(GL_DEPTH_TEST); */
+      dsa->depth.writemask = 0;/*glDepthMask(FALSE);*/
+      dsa->depth.func = PIPE_FUNC_GEQUAL;
+   }
+}
+
+/**
+ * Propogate OpenVG state changes to the renderer.  Only framebuffer, blending
+ * and scissoring states are relevant here.
+ */
+void renderer_validate(struct renderer *renderer,
+                       VGbitfield dirty,
+                       const struct st_framebuffer *stfb,
+                       const struct vg_state *state)
+{
+   assert(renderer->state == RENDERER_STATE_INIT);
+
+   if (dirty & BLEND_DIRTY) {
+      struct pipe_blend_state *blend = &renderer->g3d.blend;
+      memset(blend, 0, sizeof(struct pipe_blend_state));
+      blend->rt[0].blend_enable = 1;
+      blend->rt[0].colormask = PIPE_MASK_RGBA;
+
+      switch (state->blend_mode) {
+      case VG_BLEND_SRC:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].blend_enable = 0;
+         break;
+      case VG_BLEND_SRC_OVER:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_SRC_ALPHA;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
+         break;
+      case VG_BLEND_DST_OVER:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_INV_DST_ALPHA;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_INV_DST_ALPHA;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_DST_ALPHA;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_DST_ALPHA;
+         break;
+      case VG_BLEND_SRC_IN:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_DST_ALPHA;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_DST_ALPHA;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
+         break;
+      case VG_BLEND_DST_IN:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_SRC_ALPHA;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
+         break;
+      case VG_BLEND_MULTIPLY:
+      case VG_BLEND_SCREEN:
+      case VG_BLEND_DARKEN:
+      case VG_BLEND_LIGHTEN:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
+         blend->rt[0].blend_enable = 0;
+         break;
+      case VG_BLEND_ADDITIVE:
+         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ONE;
+         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
+         break;
+      default:
+         assert(!"not implemented blend mode");
+      }
+      cso_set_blend(renderer->cso, blend);
+   }
+
+   if (dirty & RASTERIZER_DIRTY) {
+      struct pipe_rasterizer_state *raster = &renderer->g3d.rasterizer;
+      memset(raster, 0, sizeof(struct pipe_rasterizer_state));
+      raster->gl_rasterization_rules = 1;
+      cso_set_rasterizer(renderer->cso, raster);
+   }
+
+   if (dirty & FRAMEBUFFER_DIRTY) {
+      struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
+      struct pipe_resource **cbuf = &renderer->vs_const_buffer;
+      VGfloat vs_consts[8];
+
+      memset(fb, 0, sizeof(struct pipe_framebuffer_state));
+      fb->width  = stfb->width;
+      fb->height = stfb->height;
+      fb->nr_cbufs = 1;
+      fb->cbufs[0] = stfb->strb->surface;
+      fb->zsbuf = stfb->dsrb->surface;
+
+      cso_set_framebuffer(renderer->cso, fb);
+      vg_set_viewport(renderer->owner, VEGA_Y0_BOTTOM);
+
+      /* surface coordinates to clipped coordinates */
+      vs_consts[0] = 2.0f / fb->width;
+      vs_consts[1] = 2.0f / fb->height;
+      vs_consts[2] = 1.0f;
+      vs_consts[3] = 1.0f;
+      vs_consts[4] = -1.0f;
+      vs_consts[5] = -1.0f;
+      vs_consts[6] = 0.0f;
+      vs_consts[7] = 0.0f;
+
+      pipe_resource_reference(cbuf, NULL);
+      *cbuf = pipe_buffer_create(renderer->pipe->screen, 
+				 PIPE_BIND_CONSTANT_BUFFER,
+				 sizeof(vs_consts));
+
+      if (*cbuf) {
+         pipe_buffer_write(renderer->pipe,
+               *cbuf, 0, sizeof(vs_consts), vs_consts);
+      }
+      renderer->pipe->set_constant_buffer(renderer->pipe,
+            PIPE_SHADER_VERTEX, 0, *cbuf);
+
+      /* we also got a new depth buffer */
+      if (dirty & DEPTH_STENCIL_DIRTY) {
+         renderer->pipe->clear(renderer->pipe,
+               PIPE_CLEAR_DEPTHSTENCIL, NULL, 0.0, 0);
+      }
+   }
+
+   if (dirty & VS_DIRTY)
+      renderer_set_vs(renderer, RENDERER_VS_PLAIN);
+
+   /* must be last because it renders to the depth buffer*/
+   if (dirty & DEPTH_STENCIL_DIRTY) {
+      update_clip_state(renderer, state);
+      cso_set_depth_stencil_alpha(renderer->cso, &renderer->g3d.dsa);
+   }
+}
+
 void renderer_draw_quad(struct renderer *r,
                         VGfloat x1, VGfloat y1,
                         VGfloat x2, VGfloat y2,
diff --git a/src/gallium/state_trackers/vega/renderer.h b/src/gallium/state_trackers/vega/renderer.h
index 8d13c02f3b..763e57def5 100644
--- a/src/gallium/state_trackers/vega/renderer.h
+++ b/src/gallium/state_trackers/vega/renderer.h
@@ -33,6 +33,8 @@
 struct renderer;
 
 struct vg_context;
+struct vg_state;
+struct st_framebuffer;
 struct pipe_resource;
 struct pipe_sampler_state;
 struct pipe_sampler_view;
@@ -43,6 +45,11 @@ struct pipe_vertex_buffer;
 struct renderer *renderer_create(struct vg_context *owner);
 void renderer_destroy(struct renderer *);
 
+void renderer_validate(struct renderer *renderer,
+                       VGbitfield dirty,
+                       const struct st_framebuffer *stfb,
+                       const struct vg_state *state);
+
 VGboolean renderer_copy_begin(struct renderer *renderer,
                               struct pipe_surface *dst,
                               VGboolean y0_top,
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index afb9579c1d..b9dbc4f00b 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -44,7 +44,6 @@
 #include "util/u_memory.h"
 #include "util/u_blit.h"
 #include "util/u_sampler.h"
-#include "util/u_math.h"
 
 struct vg_context *_vg_context = 0;
 
@@ -269,179 +268,17 @@ void vg_context_remove_object(struct vg_context *ctx,
    }
 }
 
-static void update_clip_state(struct vg_context *ctx)
-{
-   struct pipe_depth_stencil_alpha_state *dsa = &ctx->state.g3d.dsa;
-   struct vg_state *state =  &ctx->state.vg;
-
-   memset(dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
-
-   if (state->scissoring) {
-      struct pipe_framebuffer_state *fb = &ctx->state.g3d.fb;
-      int i;
-
-      renderer_scissor_begin(ctx->renderer, VG_FALSE);
-
-      for (i = 0; i < state->scissor_rects_num; ++i) {
-         const float x      = state->scissor_rects[i * 4 + 0].f;
-         const float y      = state->scissor_rects[i * 4 + 1].f;
-         const float width  = state->scissor_rects[i * 4 + 2].f;
-         const float height = state->scissor_rects[i * 4 + 3].f;
-         VGint x0, y0, x1, y1, iw, ih;
-
-         x0 = (VGint) x;
-         y0 = (VGint) y;
-         if (x0 < 0)
-            x0 = 0;
-         if (y0 < 0)
-            y0 = 0;
-
-         /* note that x1 and y1 are exclusive */
-         x1 = (VGint) ceilf(x + width);
-         y1 = (VGint) ceilf(y + height);
-         if (x1 > fb->width)
-            x1 = fb->width;
-         if (y1 > fb->height)
-            y1 = fb->height;
-
-         iw = x1 - x0;
-         ih = y1 - y0;
-         if (iw > 0 && ih> 0 )
-            renderer_scissor(ctx->renderer, x0, y0, iw, ih);
-      }
-
-      renderer_scissor_end(ctx->renderer);
-
-      dsa->depth.enabled = 1; /* glEnable(GL_DEPTH_TEST); */
-      dsa->depth.writemask = 0;/*glDepthMask(FALSE);*/
-      dsa->depth.func = PIPE_FUNC_GEQUAL;
-   }
-}
-
 void vg_validate_state(struct vg_context *ctx)
 {
    vg_manager_validate_framebuffer(ctx);
 
-   if ((ctx->state.dirty & BLEND_DIRTY)) {
-      struct pipe_blend_state *blend = &ctx->state.g3d.blend;
-      memset(blend, 0, sizeof(struct pipe_blend_state));
-      blend->rt[0].blend_enable = 1;
-      blend->rt[0].colormask = PIPE_MASK_RGBA;
-
-      switch (ctx->state.vg.blend_mode) {
-      case VG_BLEND_SRC:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].blend_enable = 0;
-         break;
-      case VG_BLEND_SRC_OVER:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_SRC_ALPHA;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
-         break;
-      case VG_BLEND_DST_OVER:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_INV_DST_ALPHA;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_INV_DST_ALPHA;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_DST_ALPHA;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_DST_ALPHA;
-         break;
-      case VG_BLEND_SRC_IN:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_DST_ALPHA;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_DST_ALPHA;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-         break;
-      case VG_BLEND_DST_IN:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_SRC_ALPHA;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
-         break;
-      case VG_BLEND_MULTIPLY:
-      case VG_BLEND_SCREEN:
-      case VG_BLEND_DARKEN:
-      case VG_BLEND_LIGHTEN:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-         blend->rt[0].blend_enable = 0;
-         break;
-      case VG_BLEND_ADDITIVE:
-         blend->rt[0].rgb_src_factor   = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].rgb_dst_factor   = PIPE_BLENDFACTOR_ONE;
-         blend->rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
-         break;
-      default:
-         assert(!"not implemented blend mode");
-      }
-      cso_set_blend(ctx->cso_context, &ctx->state.g3d.blend);
-   }
-   if ((ctx->state.dirty & RASTERIZER_DIRTY)) {
-      struct pipe_rasterizer_state *raster = &ctx->state.g3d.rasterizer;
-      memset(raster, 0, sizeof(struct pipe_rasterizer_state));
-      raster->gl_rasterization_rules = 1;
-      cso_set_rasterizer(ctx->cso_context, &ctx->state.g3d.rasterizer);
-   }
-   if ((ctx->state.dirty & FRAMEBUFFER_DIRTY)) {
-      struct pipe_framebuffer_state *fb = &ctx->state.g3d.fb;
-      struct pipe_resource **cbuf = &ctx->vs_const_buffer;
-      VGfloat vs_consts[8];
-
-      memset(fb, 0, sizeof(struct pipe_framebuffer_state));
-      fb->width  = ctx->draw_buffer->width;
-      fb->height = ctx->draw_buffer->height;
-      fb->nr_cbufs = 1;
-      fb->cbufs[0] = ctx->draw_buffer->strb->surface;
-      fb->zsbuf = ctx->draw_buffer->dsrb->surface;
-
-      cso_set_framebuffer(ctx->cso_context, fb);
-      vg_set_viewport(ctx, VEGA_Y0_BOTTOM);
-
-      /* surface coordinates to clipped coordinates */
-      vs_consts[0] = 2.0f / fb->width;
-      vs_consts[1] = 2.0f / fb->height;
-      vs_consts[2] = 1.0f;
-      vs_consts[3] = 1.0f;
-      vs_consts[4] = -1.0f;
-      vs_consts[5] = -1.0f;
-      vs_consts[6] = 0.0f;
-      vs_consts[7] = 0.0f;
+   renderer_validate(ctx->renderer, ctx->state.dirty,
+         ctx->draw_buffer, &ctx->state.vg);
 
-      pipe_resource_reference(cbuf, NULL);
-      *cbuf = pipe_buffer_create(ctx->pipe->screen, 
-				 PIPE_BIND_CONSTANT_BUFFER,
-				 sizeof(vs_consts));
-
-      if (*cbuf) {
-         st_no_flush_pipe_buffer_write(ctx, *cbuf,
-                                       0, sizeof(vs_consts), vs_consts);
-      }
-      ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_VERTEX, 0, *cbuf);
-
-      /* we also got a new depth buffer */
-      if ((ctx->state.dirty & DEPTH_STENCIL_DIRTY))
-         ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_DEPTHSTENCIL, NULL, 0.0, 0);
-   }
-   if ((ctx->state.dirty & VS_DIRTY)) {
-      cso_set_vertex_shader_handle(ctx->cso_context,
-                                   vg_plain_vs(ctx));
-   }
-
-   /* must be last because it renders to the depth buffer*/
-   if ((ctx->state.dirty & DEPTH_STENCIL_DIRTY)) {
-      update_clip_state(ctx);
-      cso_set_depth_stencil_alpha(ctx->cso_context, &ctx->state.g3d.dsa);
-   }
+   ctx->state.dirty = NONE_DIRTY;
 
    shader_set_masking(ctx->shader, ctx->state.vg.masking);
    shader_set_image_mode(ctx->shader, ctx->state.vg.image_mode);
-
-   ctx->state.dirty = NONE_DIRTY;
 }
 
 VGboolean vg_object_is_valid(void *ptr, enum vg_object_type type)
@@ -572,21 +409,3 @@ void * vg_texture_vs(struct vg_context *ctx)
 
    return ctx->texture_vs->driver;
 }
-
-void vg_set_viewport(struct vg_context *ctx, VegaOrientation orientation)
-{
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct pipe_viewport_state viewport;
-   VGfloat y_scale = (orientation == VEGA_Y0_BOTTOM) ? -2.f : 2.f;
-
-   viewport.scale[0] =  stfb->width / 2.f;
-   viewport.scale[1] =  stfb->height / y_scale;
-   viewport.scale[2] =  1.0;
-   viewport.scale[3] =  1.0;
-   viewport.translate[0] = stfb->width / 2.f;
-   viewport.translate[1] = stfb->height / 2.f;
-   viewport.translate[2] = 0.0;
-   viewport.translate[3] = 0.0;
-
-   cso_set_viewport(ctx->cso_context, &viewport);
-}
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index 547674bd2a..b3263cdef5 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -98,13 +98,6 @@ struct vg_context
 
    struct {
       struct vg_state vg;
-      struct {
-         struct pipe_blend_state blend;
-         struct pipe_rasterizer_state rasterizer;
-         struct pipe_shader_state vs_state;
-         struct pipe_depth_stencil_alpha_state dsa;
-         struct pipe_framebuffer_state fb;
-      } g3d;
       VGbitfield dirty;
    } state;
 
@@ -295,10 +288,5 @@ static INLINE void vg_bound_rect(VGfloat coords[4],
 void *vg_plain_vs(struct vg_context *ctx);
 void *vg_clear_vs(struct vg_context *ctx);
 void *vg_texture_vs(struct vg_context *ctx);
-typedef enum {
-   VEGA_Y0_TOP,
-   VEGA_Y0_BOTTOM
-} VegaOrientation;
-void vg_set_viewport(struct vg_context *ctx, VegaOrientation orientation);
 
 #endif
-- 
cgit v1.2.3


From ace4539e88f6ef90d8e9fd2f1543eca0ae854b82 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Sun, 28 Nov 2010 03:39:18 +0800
Subject: st/vega: Clean up vg_context fields and functions.

---
 src/gallium/state_trackers/vega/asm_util.h   | 51 -----------------
 src/gallium/state_trackers/vega/renderer.c   | 10 +++-
 src/gallium/state_trackers/vega/vg_context.c | 84 ----------------------------
 src/gallium/state_trackers/vega/vg_context.h | 27 ---------
 4 files changed, 9 insertions(+), 163 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/asm_util.h b/src/gallium/state_trackers/vega/asm_util.h
index 903bfc88a4..ae1842a62c 100644
--- a/src/gallium/state_trackers/vega/asm_util.h
+++ b/src/gallium/state_trackers/vega/asm_util.h
@@ -27,16 +27,6 @@
 #ifndef ASM_UTIL_H
 #define ASM_UTIL_H
 
-
-static const char pass_through_depth_asm[] =
-   "FRAG\n"
-   "DCL IN[0], POSITION, LINEAR\n"
-   "DCL OUT[0].z, POSITION, CONSTANT\n"
-   "0: MOV OUT[0].z, IN[0].zzzz\n"
-   "1: END\n";
-
-
-
 /* μnew = μmask */
 static const char set_mask_asm[] =
    "FRAG\n"
@@ -92,45 +82,4 @@ static const char subtract_mask_asm[] =
    "3: MUL OUT[0], TEMP[2].wwww, TEMP[0].wwww\n"
    "4: END\n";
 
-
-static const char vs_plain_asm[] =
-   "VERT\n"
-   "DCL IN[0]\n"
-   "DCL OUT[0], POSITION\n"
-   "DCL TEMP[0]\n"
-   "DCL CONST[0..1]\n"
-   "0: MUL TEMP[0], IN[0], CONST[0]\n"
-   "1: ADD TEMP[0], TEMP[0], CONST[1]\n"
-   "2: MOV OUT[0], TEMP[0]\n"
-   "3: END\n";
-
-static const char vs_clear_asm[] =
-   "VERT\n"
-   "DCL IN[0]\n"
-   "DCL IN[1]\n"
-   "DCL OUT[0], POSITION\n"
-   "DCL OUT[1], COLOR\n"
-   "DCL TEMP[0]\n"
-   "DCL CONST[0..1]\n"
-   "0: MUL TEMP[0], IN[0], CONST[0]\n"
-   "1: ADD TEMP[0], TEMP[0], CONST[1]\n"
-   "2: MOV OUT[0], TEMP[0]\n"
-   "3: MOV OUT[1], IN[1]\n"
-   "4: END\n";
-
-
-static const char vs_texture_asm[] =
-   "VERT\n"
-   "DCL IN[0]\n"
-   "DCL IN[1]\n"
-   "DCL OUT[0], POSITION\n"
-   "DCL OUT[1], GENERIC\n"
-   "DCL TEMP[0]\n"
-   "DCL CONST[0..1]\n"
-   "0: MUL TEMP[0], IN[0], CONST[0]\n"
-   "1: ADD TEMP[0], TEMP[0], CONST[1]\n"
-   "2: MOV OUT[0], TEMP[0]\n"
-   "3: MOV OUT[1], IN[1]\n"
-   "4: END\n";
-
 #endif
diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
index 2c5b5df880..c0d69ee2ba 100644
--- a/src/gallium/state_trackers/vega/renderer.c
+++ b/src/gallium/state_trackers/vega/renderer.c
@@ -89,6 +89,7 @@ struct renderer {
 
    struct pipe_resource *vs_const_buffer;
 
+   struct pipe_vertex_element velems[2];
    VGfloat vertices[4][2][4];
 
    void *cached_vs[NUM_RENDERER_VS];
@@ -489,7 +490,7 @@ static void renderer_quad_draw(struct renderer *r)
                                  sizeof(r->vertices),
                                  PIPE_BIND_VERTEX_BUFFER);
    if (buf) {
-      cso_set_vertex_elements(r->cso, 2, r->owner->velems);
+      cso_set_vertex_elements(r->cso, 2, r->velems);
       util_draw_vertex_buffer(r->pipe, buf, 0,
                               PIPE_PRIM_TRIANGLE_FAN,
                               Elements(r->vertices),     /* verts */
@@ -1091,6 +1092,13 @@ struct renderer * renderer_create(struct vg_context *owner)
    for (i = 0; i < 4; i++)
       renderer->vertices[i][0][3] = 1.0f; /* w */
 
+   for (i = 0; i < 2; i++) {
+      renderer->velems[i].src_offset = i * 4 * sizeof(float);
+      renderer->velems[i].instance_divisor = 0;
+      renderer->velems[i].vertex_buffer_index = 0;
+      renderer->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+   }
+
    renderer->state = RENDERER_STATE_INIT;
 
    return renderer;
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index e76a65604b..f2966fc72e 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -54,19 +54,6 @@ struct vg_context * vg_current_context(void)
    return _vg_context;
 }
 
-static void init_clear(struct vg_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-
-   /* rasterizer state: bypass clipping */
-   memset(&st->clear.raster, 0, sizeof(st->clear.raster));
-   st->clear.raster.gl_rasterization_rules = 1;
-
-   /* fragment shader state: color pass-through program */
-   st->clear.fs =
-      util_make_fragment_passthrough_shader(pipe);
-}
-
 /**
  * A depth/stencil rb will be needed regardless of what the visual says.
  */
@@ -103,7 +90,6 @@ struct vg_context * vg_create_context(struct pipe_context *pipe,
                                       struct vg_context *share)
 {
    struct vg_context *ctx;
-   unsigned i;
 
    ctx = CALLOC_STRUCT(vg_context);
 
@@ -120,8 +106,6 @@ struct vg_context * vg_create_context(struct pipe_context *pipe,
 
    ctx->cso_context = cso_create_context(pipe);
 
-   init_clear(ctx);
-
    ctx->default_paint = paint_create(ctx);
    ctx->state.vg.stroke_paint = ctx->default_paint;
    ctx->state.vg.fill_paint = ctx->default_paint;
@@ -143,13 +127,6 @@ struct vg_context * vg_create_context(struct pipe_context *pipe,
    ctx->blend_sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
    ctx->blend_sampler.normalized_coords = 0;
 
-   for (i = 0; i < 2; i++) {
-      ctx->velems[i].src_offset = i * 4 * sizeof(float);
-      ctx->velems[i].instance_divisor = 0;
-      ctx->velems[i].vertex_buffer_index = 0;
-      ctx->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-   }
-
    vg_set_error(ctx, VG_NO_ERROR);
 
    ctx->owned_objects[VG_OBJECT_PAINT] = cso_hash_create();
@@ -170,7 +147,6 @@ struct vg_context * vg_create_context(struct pipe_context *pipe,
 void vg_destroy_context(struct vg_context *ctx)
 {
    struct pipe_resource **cbuf = &ctx->mask.cbuf;
-   struct pipe_resource **vsbuf = &ctx->vs_const_buffer;
 
    util_destroy_blit(ctx->blit);
    renderer_destroy(ctx->renderer);
@@ -181,29 +157,6 @@ void vg_destroy_context(struct vg_context *ctx)
    if (*cbuf)
       pipe_resource_reference(cbuf, NULL);
 
-   if (*vsbuf)
-      pipe_resource_reference(vsbuf, NULL);
-
-   if (ctx->clear.fs) {
-      cso_delete_fragment_shader(ctx->cso_context, ctx->clear.fs);
-      ctx->clear.fs = NULL;
-   }
-
-   if (ctx->plain_vs) {
-      vg_shader_destroy(ctx, ctx->plain_vs);
-      ctx->plain_vs = NULL;
-   }
-   if (ctx->clear_vs) {
-      vg_shader_destroy(ctx, ctx->clear_vs);
-      ctx->clear_vs = NULL;
-   }
-   if (ctx->texture_vs) {
-      vg_shader_destroy(ctx, ctx->texture_vs);
-      ctx->texture_vs = NULL;
-   }
-
-   if (ctx->pass_through_depth_fs)
-      vg_shader_destroy(ctx, ctx->pass_through_depth_fs);
    if (ctx->mask.union_fs)
       vg_shader_destroy(ctx, ctx->mask.union_fs);
    if (ctx->mask.intersect_fs)
@@ -556,40 +509,3 @@ void vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
    if (dest_surface)
       pipe_surface_reference(&dest_surface, NULL);
 }
-
-void * vg_plain_vs(struct vg_context *ctx)
-{
-   if (!ctx->plain_vs) {
-      ctx->plain_vs = shader_create_from_text(ctx->pipe,
-                                              vs_plain_asm,
-                                              200,
-                                              PIPE_SHADER_VERTEX);
-   }
-
-   return ctx->plain_vs->driver;
-}
-
-
-void * vg_clear_vs(struct vg_context *ctx)
-{
-   if (!ctx->clear_vs) {
-      ctx->clear_vs = shader_create_from_text(ctx->pipe,
-                                              vs_clear_asm,
-                                              200,
-                                              PIPE_SHADER_VERTEX);
-   }
-
-   return ctx->clear_vs->driver;
-}
-
-void * vg_texture_vs(struct vg_context *ctx)
-{
-   if (!ctx->texture_vs) {
-      ctx->texture_vs = shader_create_from_text(ctx->pipe,
-                                                vs_texture_asm,
-                                                200,
-                                                PIPE_SHADER_VERTEX);
-   }
-
-   return ctx->texture_vs->driver;
-}
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index b3263cdef5..07f3ca76be 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -108,14 +108,6 @@ struct vg_context
 
    struct cso_hash *owned_objects[VG_OBJECT_LAST];
 
-   struct {
-      struct pipe_shader_state vert_shader;
-      struct pipe_shader_state frag_shader;
-      struct pipe_rasterizer_state raster;
-      void *fs;
-      float vertices[4][2][4];  /**< vertex pos + color */
-   } clear;
-
    struct {
       struct pipe_resource *cbuf;
       struct pipe_sampler_state sampler;
@@ -126,31 +118,16 @@ struct vg_context
       struct vg_shader *set_fs;
    } mask;
 
-   struct vg_shader *pass_through_depth_fs;
-
    struct cso_context *cso_context;
 
-   struct pipe_resource *stencil_quad;
-   VGfloat stencil_vertices[4][2][4];
-
    struct renderer *renderer;
    struct shaders_cache *sc;
    struct shader *shader;
 
    struct pipe_sampler_state blend_sampler;
-   struct {
-      struct pipe_resource *buffer;
-      void *color_matrix_fs;
-   } filter;
    struct vg_paint *default_paint;
 
    struct blit_state *blit;
-
-   struct vg_shader *plain_vs;
-   struct vg_shader *clear_vs;
-   struct vg_shader *texture_vs;
-   struct pipe_resource *vs_const_buffer;
-   struct pipe_vertex_element velems[2];
 };
 
 struct vg_object {
@@ -285,8 +262,4 @@ static INLINE void vg_bound_rect(VGfloat coords[4],
    }
 }
 
-void *vg_plain_vs(struct vg_context *ctx);
-void *vg_clear_vs(struct vg_context *ctx);
-void *vg_texture_vs(struct vg_context *ctx);
-
 #endif
-- 
cgit v1.2.3


From b06de80843e7d096bed4ae03ddc5e2842f1876af Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Wed, 1 Dec 2010 02:30:59 +0800
Subject: st/vega: Fix paint coordinates transformations.

Depending on whether vgDrawPath(mode), vgDrawImage, or vgDrawGlyph[s] is
called, different paint-to-user and user-to-surface matrices should be
used to derive the sample points for the paint.

This fixes "paint" demo.
---
 src/gallium/state_trackers/vega/image.c      |  8 +++++
 src/gallium/state_trackers/vega/matrix.h     |  2 +-
 src/gallium/state_trackers/vega/paint.c      | 53 ++++++++++------------------
 src/gallium/state_trackers/vega/paint.h      |  2 ++
 src/gallium/state_trackers/vega/path.c       | 15 ++++++--
 src/gallium/state_trackers/vega/shader.c     | 21 ++++++++++-
 src/gallium/state_trackers/vega/shader.h     |  3 ++
 src/gallium/state_trackers/vega/vg_context.c | 25 +++++++++++++
 src/gallium/state_trackers/vega/vg_context.h |  4 +++
 9 files changed, 94 insertions(+), 39 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/image.c b/src/gallium/state_trackers/vega/image.c
index b1bda3ff54..fc87536883 100644
--- a/src/gallium/state_trackers/vega/image.c
+++ b/src/gallium/state_trackers/vega/image.c
@@ -523,11 +523,18 @@ void image_copy(struct vg_image *dst, VGint dx, VGint dy,
 void image_draw(struct vg_image *img, struct matrix *matrix)
 {
    struct vg_context *ctx = vg_current_context();
+   struct matrix paint_matrix;
    VGfloat x1, y1;
    VGfloat x2, y2;
    VGfloat x3, y3;
    VGfloat x4, y4;
 
+   if (vg_get_paint_matrix(ctx,
+                           &ctx->state.vg.fill_paint_to_user_matrix,
+                           matrix,
+                           &paint_matrix))
+      return;
+
    x1 = 0;
    y1 = 0;
    x2 = img->width;
@@ -544,6 +551,7 @@ void image_draw(struct vg_image *img, struct matrix *matrix)
 
    shader_set_drawing_image(ctx->shader, VG_TRUE);
    shader_set_paint(ctx->shader, ctx->state.vg.fill_paint);
+   shader_set_paint_matrix(ctx->shader, &paint_matrix);
    shader_set_image(ctx->shader, img);
    shader_bind(ctx->shader);
 
diff --git a/src/gallium/state_trackers/vega/matrix.h b/src/gallium/state_trackers/vega/matrix.h
index 4c207f912a..bed2b3193d 100644
--- a/src/gallium/state_trackers/vega/matrix.h
+++ b/src/gallium/state_trackers/vega/matrix.h
@@ -129,7 +129,7 @@ static INLINE void matrix_make_affine(struct matrix *matrix)
 }
 
 static INLINE void matrix_mult(struct matrix *dst,
-                               struct matrix *src)
+                               const struct matrix *src)
 {
    VGfloat m11 = dst->m[0]*src->m[0] + dst->m[3]*src->m[1] + dst->m[6]*src->m[2];
    VGfloat m12 = dst->m[0]*src->m[3] + dst->m[3]*src->m[4] + dst->m[6]*src->m[5];
diff --git a/src/gallium/state_trackers/vega/paint.c b/src/gallium/state_trackers/vega/paint.c
index c0c8cddabe..467d392975 100644
--- a/src/gallium/state_trackers/vega/paint.c
+++ b/src/gallium/state_trackers/vega/paint.c
@@ -261,9 +261,10 @@ static INLINE void paint_color_buffer(struct vg_paint *paint, void *buffer)
    map[7] = 4.f;
 }
 
-static INLINE void paint_linear_gradient_buffer(struct vg_paint *paint, void *buffer)
+static INLINE void paint_linear_gradient_buffer(struct vg_paint *paint,
+                                                const struct matrix *inv,
+                                                void *buffer)
 {
-   struct vg_context *ctx = paint->base.ctx;
    VGfloat *map = (VGfloat*)buffer;
 
    map[0] = paint->gradient.linear.coords[2] - paint->gradient.linear.coords[0];
@@ -277,15 +278,10 @@ static INLINE void paint_linear_gradient_buffer(struct vg_paint *paint, void *bu
    map[7] = 4.f;
    {
       struct matrix mat;
-      struct matrix inv;
       matrix_load_identity(&mat);
+      /* VEGA_LINEAR_GRADIENT_SHADER expects the first point to be at (0, 0) */
       matrix_translate(&mat, -paint->gradient.linear.coords[0], -paint->gradient.linear.coords[1]);
-      memcpy(&inv, &ctx->state.vg.fill_paint_to_user_matrix,
-             sizeof(struct matrix));
-      matrix_invert(&inv);
-      matrix_mult(&inv, &mat);
-      memcpy(&mat, &inv,
-             sizeof(struct matrix));
+      matrix_mult(&mat, inv);
 
       map[8]  = mat.m[0]; map[9]  = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
       map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
@@ -298,10 +294,11 @@ static INLINE void paint_linear_gradient_buffer(struct vg_paint *paint, void *bu
 }
 
 
-static INLINE void paint_radial_gradient_buffer(struct vg_paint *paint, void *buffer)
+static INLINE void paint_radial_gradient_buffer(struct vg_paint *paint,
+                                                const struct matrix *inv,
+                                                void *buffer)
 {
    VGfloat *radialCoords = paint->gradient.radial.vals;
-   struct vg_context *ctx = paint->base.ctx;
 
    VGfloat *map = (VGfloat*)buffer;
 
@@ -318,15 +315,9 @@ static INLINE void paint_radial_gradient_buffer(struct vg_paint *paint, void *bu
 
    {
       struct matrix mat;
-      struct matrix inv;
       matrix_load_identity(&mat);
       matrix_translate(&mat, -radialCoords[2], -radialCoords[3]);
-      memcpy(&inv, &ctx->state.vg.fill_paint_to_user_matrix,
-             sizeof(struct matrix));
-      matrix_invert(&inv);
-      matrix_mult(&inv, &mat);
-      memcpy(&mat, &inv,
-             sizeof(struct matrix));
+      matrix_mult(&mat, inv);
 
       map[8]  = mat.m[0]; map[9]  = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
       map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
@@ -340,10 +331,10 @@ static INLINE void paint_radial_gradient_buffer(struct vg_paint *paint, void *bu
 }
 
 
-static INLINE void  paint_pattern_buffer(struct vg_paint *paint, void *buffer)
+static INLINE void  paint_pattern_buffer(struct vg_paint *paint,
+                                         const struct matrix *inv,
+                                         void *buffer)
 {
-   struct vg_context *ctx = paint->base.ctx;
-
    VGfloat *map = (VGfloat *)buffer;
    memcpy(map, paint->solid.color, 4 * sizeof(VGfloat));
 
@@ -353,17 +344,8 @@ static INLINE void  paint_pattern_buffer(struct vg_paint *paint, void *buffer)
    map[7] = paint->pattern.sampler_view->texture->height0;
    {
       struct matrix mat;
-      memcpy(&mat, &ctx->state.vg.fill_paint_to_user_matrix,
-             sizeof(struct matrix));
-      matrix_invert(&mat);
-      {
-         struct matrix pm;
-         memcpy(&pm, &ctx->state.vg.path_user_to_surface_matrix,
-                sizeof(struct matrix));
-         matrix_invert(&pm);
-         matrix_mult(&pm, &mat);
-         memcpy(&mat, &pm, sizeof(struct matrix));
-      }
+
+      memcpy(&mat, inv, sizeof(*inv));
 
       map[8]  = mat.m[0]; map[9]  = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
       map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
@@ -695,6 +677,7 @@ VGint paint_constant_buffer_size(struct vg_paint *paint)
 }
 
 void paint_fill_constant_buffer(struct vg_paint *paint,
+                                const struct matrix *mat,
                                 void *buffer)
 {
    switch(paint->type) {
@@ -702,13 +685,13 @@ void paint_fill_constant_buffer(struct vg_paint *paint,
       paint_color_buffer(paint, buffer);
       break;
    case VG_PAINT_TYPE_LINEAR_GRADIENT:
-      paint_linear_gradient_buffer(paint, buffer);
+      paint_linear_gradient_buffer(paint, mat, buffer);
       break;
    case VG_PAINT_TYPE_RADIAL_GRADIENT:
-      paint_radial_gradient_buffer(paint, buffer);
+      paint_radial_gradient_buffer(paint, mat, buffer);
       break;
    case VG_PAINT_TYPE_PATTERN:
-      paint_pattern_buffer(paint, buffer);
+      paint_pattern_buffer(paint, mat, buffer);
       break;
 
    default:
diff --git a/src/gallium/state_trackers/vega/paint.h b/src/gallium/state_trackers/vega/paint.h
index 012cd3e561..2e09b839a4 100644
--- a/src/gallium/state_trackers/vega/paint.h
+++ b/src/gallium/state_trackers/vega/paint.h
@@ -111,7 +111,9 @@ VGint paint_bind_samplers(struct vg_paint *paint, struct pipe_sampler_state **sa
                           struct pipe_sampler_view **sampler_views);
 
 VGint paint_constant_buffer_size(struct vg_paint *paint);
+
 void paint_fill_constant_buffer(struct vg_paint *paint,
+                                const struct matrix *mat,
                                 void *buffer);
 
 
diff --git a/src/gallium/state_trackers/vega/path.c b/src/gallium/state_trackers/vega/path.c
index 62eb62418d..06c96a3550 100644
--- a/src/gallium/state_trackers/vega/path.c
+++ b/src/gallium/state_trackers/vega/path.c
@@ -1532,6 +1532,7 @@ void path_render(struct path *p, VGbitfield paintModes,
                  struct matrix *mat)
 {
    struct vg_context *ctx = vg_current_context();
+   struct matrix paint_matrix;
 
    vg_validate_state(ctx);
 
@@ -1543,19 +1544,29 @@ void path_render(struct path *p, VGbitfield paintModes,
            mat->m[3], mat->m[4], mat->m[5],
            mat->m[6], mat->m[7], mat->m[8]);
 #endif
-   if (paintModes & VG_FILL_PATH) {
+   if ((paintModes & VG_FILL_PATH) &&
+       vg_get_paint_matrix(ctx,
+                           &ctx->state.vg.fill_paint_to_user_matrix,
+                           mat,
+                           &paint_matrix)) {
       /* First the fill */
       shader_set_paint(ctx->shader, ctx->state.vg.fill_paint);
+      shader_set_paint_matrix(ctx->shader, &paint_matrix);
       shader_bind(ctx->shader);
       path_fill(p, mat);
    }
 
-   if (paintModes & VG_STROKE_PATH){
+   if ((paintModes & VG_STROKE_PATH) &&
+       vg_get_paint_matrix(ctx,
+                           &ctx->state.vg.stroke_paint_to_user_matrix,
+                           mat,
+                           &paint_matrix)) {
       /* 8.7.5: "line width less than or equal to 0 prevents stroking from
        *  taking place."*/
       if (ctx->state.vg.stroke.line_width.f <= 0)
          return;
       shader_set_paint(ctx->shader, ctx->state.vg.stroke_paint);
+      shader_set_paint_matrix(ctx->shader, &paint_matrix);
       shader_bind(ctx->shader);
       path_stroke(p, mat);
    }
diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c
index 39c4bb0dfd..a77587c6bf 100644
--- a/src/gallium/state_trackers/vega/shader.c
+++ b/src/gallium/state_trackers/vega/shader.c
@@ -50,6 +50,8 @@ struct shader {
    struct vg_paint *paint;
    struct vg_image *image;
 
+   struct matrix paint_matrix;
+
    VGboolean drawing_image;
    VGImageMode image_mode;
 
@@ -119,7 +121,8 @@ static VGint setup_constant_buffer(struct shader *shader)
       memset(shader->constants, 0, sizeof(VGfloat) * 8);
    }
 
-   paint_fill_constant_buffer(shader->paint, shader->constants + 8);
+   paint_fill_constant_buffer(shader->paint,
+         &shader->paint_matrix, shader->constants + 8);
 
    return param_bytes;
 }
@@ -324,3 +327,19 @@ void shader_set_image(struct shader *shader, struct vg_image *img)
 {
    shader->image = img;
 }
+
+/**
+ * Set the transformation to map a pixel to the paint coordinates.
+ */
+void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat)
+{
+   const struct st_framebuffer *stfb = shader->context->draw_buffer;
+   const VGfloat px_center_offset = 0.5f;
+
+   memcpy(&shader->paint_matrix, mat, sizeof(*mat));
+
+   /* make it window-to-paint for the shaders */
+   matrix_translate(&shader->paint_matrix, px_center_offset,
+         stfb->height - 1.0f + px_center_offset);
+   matrix_scale(&shader->paint_matrix, 1.0f, -1.0f);
+}
diff --git a/src/gallium/state_trackers/vega/shader.h b/src/gallium/state_trackers/vega/shader.h
index f906631b50..ff4466cd87 100644
--- a/src/gallium/state_trackers/vega/shader.h
+++ b/src/gallium/state_trackers/vega/shader.h
@@ -33,6 +33,7 @@ struct shader;
 struct vg_paint;
 struct vg_context;
 struct vg_image;
+struct matrix;
 
 struct shader *shader_create(struct vg_context *context);
 void shader_destroy(struct shader *shader);
@@ -53,6 +54,8 @@ VGboolean shader_drawing_image(struct shader *shader);
 
 void shader_set_image(struct shader *shader, struct vg_image *img);
 
+void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat);
+
 void shader_bind(struct shader *shader);
 
 #endif
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index 4d088b965d..65adadd1fe 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -509,3 +509,28 @@ void vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
    if (dest_surface)
       pipe_surface_reference(&dest_surface, NULL);
 }
+
+/**
+ * A transformation from window coordinates to paint coordinates.
+ */
+VGboolean vg_get_paint_matrix(struct vg_context *ctx,
+                              const struct matrix *paint_to_user,
+                              const struct matrix *user_to_surface,
+                              struct matrix *mat)
+{
+   struct matrix tmp;
+
+   /* get user-to-paint matrix */
+   memcpy(mat, paint_to_user, sizeof(*paint_to_user));
+   if (!matrix_invert(mat))
+      return VG_FALSE;
+
+   /* get surface-to-user matrix */
+   memcpy(&tmp, user_to_surface, sizeof(*user_to_surface));
+   if (!matrix_invert(&tmp))
+      return VG_FALSE;
+
+   matrix_mult(mat, &tmp);
+
+   return VG_TRUE;
+}
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index 07f3ca76be..5d0bca33c5 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -162,6 +162,10 @@ void vg_set_error(struct vg_context *ctx,
 void vg_prepare_blend_surface(struct vg_context *ctx);
 void vg_prepare_blend_surface_from_mask(struct vg_context *ctx);
 
+VGboolean vg_get_paint_matrix(struct vg_context *ctx,
+                              const struct matrix *paint_to_user,
+                              const struct matrix *user_to_surface,
+                              struct matrix *mat);
 
 static INLINE VGboolean is_aligned_to(const void *ptr, VGbyte alignment)
 {
-- 
cgit v1.2.3


From 04f342b4170366e417aa0c414cc536337270d3ab Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Wed, 1 Dec 2010 17:38:57 +0800
Subject: st/vega: Delay blend texture creation until needed.

It is used for more advanced blending or mask update.  It might not be
ever needed for some applications.
---
 src/gallium/state_trackers/vega/mask.c       |  3 +-
 src/gallium/state_trackers/vega/shader.c     |  6 +--
 src/gallium/state_trackers/vega/vg_context.c | 76 ++++++++++------------------
 src/gallium/state_trackers/vega/vg_context.h |  4 +-
 4 files changed, 32 insertions(+), 57 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/mask.c b/src/gallium/state_trackers/vega/mask.c
index e3aec980b5..0a800b2c10 100644
--- a/src/gallium/state_trackers/vega/mask.c
+++ b/src/gallium/state_trackers/vega/mask.c
@@ -316,9 +316,8 @@ static void mask_using_texture(struct pipe_sampler_view *sampler_view,
    views[0] = sampler_view;
 
    /* prepare our blend surface */
-   vg_prepare_blend_surface_from_mask(ctx);
    samplers[1] = &ctx->mask.sampler;
-   views[1] = ctx->draw_buffer->blend_texture_view;
+   views[1] = vg_prepare_blend_surface_from_mask(ctx);
 
    fs = setup_mask_operation(operation);
 
diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c
index 483ff15098..3d397f9ed4 100644
--- a/src/gallium/state_trackers/vega/shader.c
+++ b/src/gallium/state_trackers/vega/shader.c
@@ -137,12 +137,8 @@ static VGint blend_bind_samplers(struct vg_context *ctx,
        bmode == VG_BLEND_SCREEN ||
        bmode == VG_BLEND_DARKEN ||
        bmode == VG_BLEND_LIGHTEN) {
-      struct st_framebuffer *stfb = ctx->draw_buffer;
-
-      vg_prepare_blend_surface(ctx);
-
       samplers[2] = &ctx->blend_sampler;
-      sampler_views[2] = stfb->blend_texture_view;
+      sampler_views[2] = vg_prepare_blend_surface(ctx);
 
       if (!samplers[0] || !sampler_views[0]) {
          samplers[0] = samplers[2];
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index 6ca80e7065..b7d59a559a 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -406,7 +406,6 @@ void vg_validate_state(struct vg_context *ctx)
 
    /* TODO create as needed */
    vg_context_update_alpha_mask_view(ctx, stfb->width, stfb->height);
-   vg_context_update_blend_texture_view(ctx, stfb->width, stfb->height);
 
    renderer_validate(ctx->renderer, ctx->state.dirty,
          ctx->draw_buffer, &ctx->state.vg);
@@ -438,75 +437,56 @@ void vg_set_error(struct vg_context *ctx,
       ctx->_error = code;
 }
 
-void vg_prepare_blend_surface(struct vg_context *ctx)
+static void vg_prepare_blend_texture(struct vg_context *ctx,
+                                     struct pipe_sampler_view *src)
+{
+   struct st_framebuffer *stfb = ctx->draw_buffer;
+   struct pipe_surface *surf;
+
+   vg_context_update_blend_texture_view(ctx, stfb->width, stfb->height);
+
+   surf = ctx->pipe->screen->get_tex_surface(ctx->pipe->screen,
+         stfb->blend_texture_view->texture, 0, 0, 0, PIPE_BIND_RENDER_TARGET);
+   if (surf) {
+      util_blit_pixels_tex(ctx->blit,
+                           src, 0, 0, stfb->width, stfb->height,
+                           surf, 0, 0, stfb->width, stfb->height,
+                           0.0, PIPE_TEX_MIPFILTER_NEAREST);
+
+      pipe_surface_reference(&surf, NULL);
+   }
+}
+
+struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx)
 {
-   struct pipe_surface *dest_surface = NULL;
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_sampler_view *view;
    struct pipe_sampler_view view_templ;
    struct st_framebuffer *stfb = ctx->draw_buffer;
    struct st_renderbuffer *strb = stfb->strb;
 
-   /* first finish all pending rendering */
-   vgFinish();
+   vg_validate_state(ctx);
 
    u_sampler_view_default_template(&view_templ, strb->texture, strb->texture->format);
    view = pipe->create_sampler_view(pipe, strb->texture, &view_templ);
 
-   dest_surface = pipe->screen->get_tex_surface(pipe->screen,
-                                                stfb->blend_texture_view->texture,
-                                                0, 0, 0,
-                                                PIPE_BIND_RENDER_TARGET);
-   util_blit_pixels_tex(ctx->blit,
-                        view,
-                        0, 0,
-                        strb->width, strb->height,
-                        dest_surface,
-                        0, 0,
-                        strb->width, strb->height,
-                        0.0, PIPE_TEX_MIPFILTER_NEAREST);
-
-   if (dest_surface)
-      pipe_surface_reference(&dest_surface, NULL);
-
-   /* make sure it's complete */
-   vgFinish();
+   vg_prepare_blend_texture(ctx, view);
 
    pipe_sampler_view_reference(&view, NULL);
+
+   return stfb->blend_texture_view;
 }
 
 
-void vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
+struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
 {
-   struct pipe_surface *dest_surface = NULL;
-   struct pipe_context *pipe = ctx->pipe;
    struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct st_renderbuffer *strb = stfb->strb;
 
    vg_validate_state(ctx);
 
-   /* first finish all pending rendering */
-   vgFinish();
-
-   dest_surface = pipe->screen->get_tex_surface(pipe->screen,
-                                                stfb->blend_texture_view->texture,
-                                                0, 0, 0,
-                                                PIPE_BIND_RENDER_TARGET);
-
-   util_blit_pixels_tex(ctx->blit,
-                        stfb->alpha_mask_view,
-                        0, 0,
-                        strb->width, strb->height,
-                        dest_surface,
-                        0, 0,
-                        strb->width, strb->height,
-                        0.0, PIPE_TEX_MIPFILTER_NEAREST);
-
-   /* make sure it's complete */
-   vgFinish();
+   vg_prepare_blend_texture(ctx, stfb->alpha_mask_view);
 
-   if (dest_surface)
-      pipe_surface_reference(&dest_surface, NULL);
+   return stfb->blend_texture_view;
 }
 
 /**
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index 5d0bca33c5..32996f4678 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -159,8 +159,8 @@ void vg_validate_state(struct vg_context *ctx);
 void vg_set_error(struct vg_context *ctx,
                   VGErrorCode code);
 
-void vg_prepare_blend_surface(struct vg_context *ctx);
-void vg_prepare_blend_surface_from_mask(struct vg_context *ctx);
+struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx);
+struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx);
 
 VGboolean vg_get_paint_matrix(struct vg_context *ctx,
                               const struct matrix *paint_to_user,
-- 
cgit v1.2.3


From c91c38601234dc67fa356160cbe3bd389cac083a Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Wed, 1 Dec 2010 17:51:41 +0800
Subject: st/vega: Create drawing surface mask as needed.

As the blend texture, a drawing surface mask is used when masking is
enabled.  It should be created as needed.

s/alpha_mask/surface_mask/ to follow OpenVG 1.1 naming.
---
 src/gallium/state_trackers/vega/mask.c       | 38 ++++++++++++----------------
 src/gallium/state_trackers/vega/vg_context.c | 31 ++++++++++++++---------
 src/gallium/state_trackers/vega/vg_context.h |  4 ++-
 3 files changed, 38 insertions(+), 35 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/mask.c b/src/gallium/state_trackers/vega/mask.c
index 0a800b2c10..8431e1b84b 100644
--- a/src/gallium/state_trackers/vega/mask.c
+++ b/src/gallium/state_trackers/vega/mask.c
@@ -48,17 +48,6 @@ struct vg_mask_layer {
    struct pipe_sampler_view *sampler_view;
 };
 
-static INLINE struct pipe_surface *
-alpha_mask_surface(struct vg_context *ctx, int usage)
-{
-   struct pipe_screen *screen = ctx->pipe->screen;
-   struct st_framebuffer *stfb = ctx->draw_buffer;
-   return screen->get_tex_surface(screen,
-                                  stfb->alpha_mask_view->texture,
-                                  0, 0, 0,
-                                  usage);
-}
-
 static INLINE VGboolean
 intersect_rectangles(VGint dwidth, VGint dheight,
                      VGint swidth, VGint sheight,
@@ -289,7 +278,8 @@ static void mask_using_texture(struct pipe_sampler_view *sampler_view,
                                VGint width, VGint height)
 {
    struct vg_context *ctx = vg_current_context();
-   struct pipe_resource *dst = ctx->draw_buffer->alpha_mask_view->texture;
+   struct pipe_sampler_view *dst_view = vg_get_surface_mask(ctx);
+   struct pipe_resource *dst = dst_view->texture;
    struct pipe_resource *texture = sampler_view->texture;
    const struct pipe_sampler_state *samplers[2];
    struct pipe_sampler_view *views[2];
@@ -310,6 +300,7 @@ static void mask_using_texture(struct pipe_sampler_view *sampler_view,
                 loc[1], loc[2], loc[3]);
 #endif
 
+
    sampler = ctx->mask.sampler;
    sampler.normalized_coords = 1;
    samplers[0] = &sampler;
@@ -408,7 +399,7 @@ void mask_copy(struct vg_mask_layer *layer,
                VGint width, VGint height)
 {
    struct vg_context *ctx = vg_current_context();
-   struct pipe_sampler_view *src = ctx->draw_buffer->alpha_mask_view;
+   struct pipe_sampler_view *src = vg_get_surface_mask(ctx);
    struct pipe_surface *surf;
 
    /* get the destination surface */
@@ -433,10 +424,13 @@ static void mask_layer_render_to(struct vg_mask_layer *layer,
                                  VGbitfield paint_modes)
 {
    struct vg_context *ctx = vg_current_context();
+   struct pipe_screen *screen = ctx->pipe->screen;
+   struct pipe_sampler_view *view = vg_get_surface_mask(ctx);
    struct matrix *mat = &ctx->state.vg.path_user_to_surface_matrix;
    struct pipe_surface *surf;
 
-   surf = alpha_mask_surface(ctx, PIPE_BIND_RENDER_TARGET);
+   surf = screen->get_tex_surface(screen, view->texture,
+                                  0, 0, 0, PIPE_BIND_RENDER_TARGET);
 
    renderer_validate_for_mask_rendering(ctx->renderer, surf);
 
@@ -447,6 +441,8 @@ static void mask_layer_render_to(struct vg_mask_layer *layer,
    if (paint_modes & VG_STROKE_PATH){
       path_stroke(path, mat);
    }
+
+   pipe_surface_reference(&surf, NULL);
 }
 
 void mask_render_to(struct path *path,
@@ -454,12 +450,12 @@ void mask_render_to(struct path *path,
                     VGMaskOperation operation)
 {
    struct vg_context *ctx = vg_current_context();
-   struct st_framebuffer *fb_buffers = ctx->draw_buffer;
+   struct st_framebuffer *stfb = ctx->draw_buffer;
    struct vg_mask_layer *temp_layer;
    VGint width, height;
 
-   width = fb_buffers->alpha_mask_view->texture->width0;
-   height = fb_buffers->alpha_mask_view->texture->height0;
+   width = stfb->width;
+   height = stfb->height;
 
    temp_layer = mask_layer_create(width, height);
    mask_layer_fill(temp_layer, 0, 0, width, height, 0.0f);
@@ -506,6 +502,7 @@ void mask_fill(VGint x, VGint y, VGint width, VGint height,
                VGfloat value)
 {
    struct vg_context *ctx = vg_current_context();
+   struct pipe_sampler_view *view = vg_get_surface_mask(ctx);
 
 #if DEBUG_MASKS
    debug_printf("mask_fill(%d, %d, %d, %d) with  rgba(%f, %f, %f, %f)\n",
@@ -513,8 +510,7 @@ void mask_fill(VGint x, VGint y, VGint width, VGint height,
                 0.0f, 0.0f, 0.0f, value);
 #endif
 
-   mask_resource_fill(ctx->draw_buffer->alpha_mask_view->texture,
-                      x, y, width, height, value);
+   mask_resource_fill(view->texture, x, y, width, height, value);
 }
 
 VGint mask_bind_samplers(struct pipe_sampler_state **samplers,
@@ -523,10 +519,8 @@ VGint mask_bind_samplers(struct pipe_sampler_state **samplers,
    struct vg_context *ctx = vg_current_context();
 
    if (ctx->state.vg.masking) {
-      struct st_framebuffer *fb_buffers = ctx->draw_buffer;
-
       samplers[1] = &ctx->mask.sampler;
-      sampler_views[1] = fb_buffers->alpha_mask_view;
+      sampler_views[1] = vg_get_surface_mask(ctx);
       return 1;
    } else
       return 0;
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index b7d59a559a..beb5f06da0 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -276,11 +276,11 @@ create_tex_and_view(struct pipe_context *pipe, enum pipe_format format,
 }
 
 static void
-vg_context_update_alpha_mask_view(struct vg_context *ctx,
-                                  uint width, uint height)
+vg_context_update_surface_mask_view(struct vg_context *ctx,
+                                    uint width, uint height)
 {
    struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct pipe_sampler_view *old_sampler_view = stfb->alpha_mask_view;
+   struct pipe_sampler_view *old_sampler_view = stfb->surface_mask_view;
    struct pipe_context *pipe = ctx->pipe;
 
    if (old_sampler_view &&
@@ -293,10 +293,10 @@ vg_context_update_alpha_mask_view(struct vg_context *ctx,
      this texture and use it as a sampler, so while this wastes some
      space it makes both of those a lot simpler
    */
-   stfb->alpha_mask_view = create_tex_and_view(pipe,
+   stfb->surface_mask_view = create_tex_and_view(pipe,
          PIPE_FORMAT_B8G8R8A8_UNORM, width, height);
 
-   if (!stfb->alpha_mask_view) {
+   if (!stfb->surface_mask_view) {
       if (old_sampler_view)
          pipe_sampler_view_reference(&old_sampler_view, NULL);
       return;
@@ -316,16 +316,16 @@ vg_context_update_alpha_mask_view(struct vg_context *ctx,
       subold_surf.face = 0;
       subold_surf.level = 0;
       pipe->resource_copy_region(pipe,
-                                 stfb->alpha_mask_view->texture,
+                                 stfb->surface_mask_view->texture,
                                  subsurf,
                                  0, 0, 0,
                                  old_sampler_view->texture,
                                  subold_surf,
                                  0, 0, 0,
                                  MIN2(old_sampler_view->texture->width0,
-                                      stfb->alpha_mask_view->texture->width0),
+                                      stfb->surface_mask_view->texture->width0),
                                  MIN2(old_sampler_view->texture->height0,
-                                      stfb->alpha_mask_view->texture->height0));
+                                      stfb->surface_mask_view->texture->height0));
    }
 
    /* Free the old texture
@@ -404,9 +404,6 @@ void vg_validate_state(struct vg_context *ctx)
    if (vg_context_update_depth_stencil_rb(ctx, stfb->width, stfb->height))
       ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
 
-   /* TODO create as needed */
-   vg_context_update_alpha_mask_view(ctx, stfb->width, stfb->height);
-
    renderer_validate(ctx->renderer, ctx->state.dirty,
          ctx->draw_buffer, &ctx->state.vg);
 
@@ -484,11 +481,21 @@ struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *
 
    vg_validate_state(ctx);
 
-   vg_prepare_blend_texture(ctx, stfb->alpha_mask_view);
+   vg_context_update_surface_mask_view(ctx, stfb->width, stfb->height);
+   vg_prepare_blend_texture(ctx, stfb->surface_mask_view);
 
    return stfb->blend_texture_view;
 }
 
+struct pipe_sampler_view *vg_get_surface_mask(struct vg_context *ctx)
+{
+   struct st_framebuffer *stfb = ctx->draw_buffer;
+
+   vg_context_update_surface_mask_view(ctx, stfb->width, stfb->height);
+
+   return stfb->surface_mask_view;
+}
+
 /**
  * A transformation from window coordinates to paint coordinates.
  */
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index 32996f4678..7e921151e7 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -56,7 +56,7 @@ struct st_framebuffer {
    struct st_renderbuffer *strb;
    struct st_renderbuffer *dsrb;
 
-   struct pipe_sampler_view *alpha_mask_view;
+   struct pipe_sampler_view *surface_mask_view;
 
    struct pipe_sampler_view *blend_texture_view;
 
@@ -162,6 +162,8 @@ void vg_set_error(struct vg_context *ctx,
 struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx);
 struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx);
 
+struct pipe_sampler_view *vg_get_surface_mask(struct vg_context *ctx);
+
 VGboolean vg_get_paint_matrix(struct vg_context *ctx,
                               const struct matrix *paint_to_user,
                               const struct matrix *user_to_surface,
-- 
cgit v1.2.3


From d7a6901cac48cc3c4eea24113e108ef9dce843c4 Mon Sep 17 00:00:00 2001
From: Chia-I Wu <olv@lunarg.com>
Date: Wed, 1 Dec 2010 17:13:09 +0800
Subject: st/vega: Initialize pipe states with renderer.

Initialize vertex elements, rasterizer, stencil ref, and vertex shader
with renderer_create.  Remove RASTERIZER_DIRTY and VS_DIRTY flags.
---
 src/gallium/state_trackers/vega/renderer.c   | 37 +++++++++++++++-------------
 src/gallium/state_trackers/vega/vg_context.c |  2 +-
 src/gallium/state_trackers/vega/vg_context.h | 15 ++++++-----
 3 files changed, 28 insertions(+), 26 deletions(-)

(limited to 'src/gallium/state_trackers/vega/vg_context.h')

diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
index 8a195f316b..7d0ff32e95 100644
--- a/src/gallium/state_trackers/vega/renderer.c
+++ b/src/gallium/state_trackers/vega/renderer.c
@@ -508,7 +508,6 @@ static void renderer_quad_draw(struct renderer *r)
                                  sizeof(r->vertices),
                                  PIPE_BIND_VERTEX_BUFFER);
    if (buf) {
-      cso_set_vertex_elements(r->cso, 2, r->velems);
       util_draw_vertex_buffer(r->pipe, buf, 0,
                               PIPE_PRIM_TRIANGLE_FAN,
                               Elements(r->vertices),     /* verts */
@@ -912,6 +911,7 @@ VGboolean renderer_polygon_stencil_begin(struct renderer *renderer,
 
    assert(renderer->state == RENDERER_STATE_INIT);
 
+   cso_save_vertex_elements(renderer->cso);
    cso_save_blend(renderer->cso);
    cso_save_depth_stencil_alpha(renderer->cso);
 
@@ -1015,6 +1015,8 @@ void renderer_polygon_stencil_end(struct renderer *renderer)
    if (renderer->u.polygon_stencil.manual_two_sides)
       cso_restore_rasterizer(renderer->cso);
 
+   cso_restore_vertex_elements(renderer->cso);
+
    /* restore color writes */
    cso_restore_blend(renderer->cso);
 
@@ -1031,17 +1033,12 @@ VGboolean renderer_polygon_fill_begin(struct renderer *renderer,
                                       VGboolean save_dsa)
 {
    struct pipe_depth_stencil_alpha_state dsa;
-   struct pipe_stencil_ref sr;
 
    assert(renderer->state == RENDERER_STATE_INIT);
 
    if (save_dsa)
       cso_save_depth_stencil_alpha(renderer->cso);
 
-   /* only need a fixed 0. Rely on default or move it out at least? */
-   memset(&sr, 0, sizeof(sr));
-   cso_set_stencil_ref(renderer->cso, &sr);
-
    /* setup stencil ops */
    memset(&dsa, 0, sizeof(dsa));
    dsa.stencil[0].enabled = 1;
@@ -1086,9 +1083,12 @@ void renderer_polygon_fill_end(struct renderer *renderer)
 
 struct renderer * renderer_create(struct vg_context *owner)
 {
+   struct renderer *renderer;
+   struct pipe_rasterizer_state *raster;
+   struct pipe_stencil_ref sr;
    VGint i;
-   struct renderer *renderer = CALLOC_STRUCT(renderer);
 
+   renderer = CALLOC_STRUCT(renderer);
    if (!renderer)
       return NULL;
 
@@ -1105,6 +1105,19 @@ struct renderer * renderer_create(struct vg_context *owner)
       renderer->velems[i].vertex_buffer_index = 0;
       renderer->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
    }
+   cso_set_vertex_elements(renderer->cso, 2, renderer->velems);
+
+   /* GL rasterization rules */
+   raster = &renderer->g3d.rasterizer;
+   memset(raster, 0, sizeof(*raster));
+   raster->gl_rasterization_rules = 1;
+   cso_set_rasterizer(renderer->cso, raster);
+
+   /* fixed at 0 */
+   memset(&sr, 0, sizeof(sr));
+   cso_set_stencil_ref(renderer->cso, &sr);
+
+   renderer_set_vs(renderer, RENDERER_VS_PLAIN);
 
    renderer->state = RENDERER_STATE_INIT;
 
@@ -1258,13 +1271,6 @@ void renderer_validate(struct renderer *renderer,
       cso_set_blend(renderer->cso, &blend);
    }
 
-   if (dirty & RASTERIZER_DIRTY) {
-      struct pipe_rasterizer_state *raster = &renderer->g3d.rasterizer;
-      memset(raster, 0, sizeof(struct pipe_rasterizer_state));
-      raster->gl_rasterization_rules = 1;
-      cso_set_rasterizer(renderer->cso, raster);
-   }
-
    if (dirty & FRAMEBUFFER_DIRTY) {
       struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
       struct pipe_resource **cbuf = &renderer->vs_const_buffer;
@@ -1309,9 +1315,6 @@ void renderer_validate(struct renderer *renderer,
       }
    }
 
-   if (dirty & VS_DIRTY)
-      renderer_set_vs(renderer, RENDERER_VS_PLAIN);
-
    /* must be last because it renders to the depth buffer*/
    if (dirty & DEPTH_STENCIL_DIRTY) {
       update_clip_state(renderer, state);
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index beb5f06da0..5b072655c7 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -407,7 +407,7 @@ void vg_validate_state(struct vg_context *ctx)
    renderer_validate(ctx->renderer, ctx->state.dirty,
          ctx->draw_buffer, &ctx->state.vg);
 
-   ctx->state.dirty = NONE_DIRTY;
+   ctx->state.dirty = 0;
 
    shader_set_masking(ctx->shader, ctx->state.vg.masking);
    shader_set_image_mode(ctx->shader, ctx->state.vg.image_mode);
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index 7e921151e7..d616a20a3d 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -78,14 +78,13 @@ enum vg_object_type {
    VG_OBJECT_LAST
 };
 enum dirty_state {
-   NONE_DIRTY          = 0<<0,
-   BLEND_DIRTY         = 1<<1,
-   RASTERIZER_DIRTY    = 1<<2,
-   FRAMEBUFFER_DIRTY   = 1<<3,
-   VS_DIRTY            = 1<<4,
-   DEPTH_STENCIL_DIRTY = 1<<5,
-   ALL_DIRTY           = BLEND_DIRTY | RASTERIZER_DIRTY |
-   FRAMEBUFFER_DIRTY | VS_DIRTY | DEPTH_STENCIL_DIRTY
+   BLEND_DIRTY         = 1 << 0,
+   FRAMEBUFFER_DIRTY   = 1 << 1,
+   DEPTH_STENCIL_DIRTY = 1 << 2,
+
+   ALL_DIRTY           = BLEND_DIRTY |
+                         FRAMEBUFFER_DIRTY |
+                         DEPTH_STENCIL_DIRTY
 };
 
 struct vg_context
-- 
cgit v1.2.3