cso: put cso_release_all into cso_destroy_context

[mesa.git] / src / gallium / state_trackers / vega / renderer.c

diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
index 952b12356a4c610548ea11481a57e2e85ba4607b..d369c323bcc48003b45467e980660297f6842778 100644 (file)
--- a/src/gallium/state_trackers/vega/renderer.c
+++ b/src/gallium/state_trackers/vega/renderer.c
@@ -28,7 +28,6 @@
 #include "renderer.h"
 
 #include "vg_context.h"
-#include "paint.h" /* for paint_is_opaque */
 
 #include "pipe/p_context.h"
 #include "pipe/p_state.h"
@@ -140,7 +139,7 @@ static VGboolean renderer_can_support(struct renderer *renderer,
    struct pipe_screen *screen = renderer->pipe->screen;
 
    return screen->is_format_supported(screen,
-         res->format, res->target, 0, bindings, 0);
+         res->format, res->target, 0, bindings);
 }
 
 /**
@@ -174,12 +173,13 @@ static void renderer_set_mvp(struct renderer *renderer,
    pipe_resource_reference(&cbuf, NULL);
    cbuf = pipe_buffer_create(renderer->pipe->screen,
                              PIPE_BIND_CONSTANT_BUFFER,
+                             PIPE_USAGE_DEFAULT,
                              sizeof(consts));
    if (cbuf) {
       pipe_buffer_write(renderer->pipe, cbuf,
             0, sizeof(consts), consts);
    }
-   renderer->pipe->set_constant_buffer(renderer->pipe,
+   pipe_set_constant_buffer(renderer->pipe,
          PIPE_SHADER_VERTEX, 0, cbuf);
 
    memcpy(cur, mvp, sizeof(*mvp));
@@ -308,7 +308,9 @@ static void renderer_set_fs(struct renderer *r, RendererFs id)
 
       switch (id) {
       case RENDERER_FS_COLOR:
-         fs = util_make_fragment_passthrough_shader(r->pipe);
+         fs = util_make_fragment_passthrough_shader(r->pipe,
+                          TGSI_SEMANTIC_COLOR, TGSI_INTERPOLATE_PERSPECTIVE,
+                          TRUE);
          break;
       case RENDERER_FS_TEXTURE:
          fs = util_make_fragment_tex_shader(r->pipe,
@@ -346,11 +348,9 @@ static void vg_set_viewport(struct renderer *r,
    viewport.scale[0] =  fb->width / 2.f;
    viewport.scale[1] =  fb->height / y_scale;
    viewport.scale[2] =  1.0;
-   viewport.scale[3] =  1.0;
    viewport.translate[0] = fb->width / 2.f;
    viewport.translate[1] = fb->height / 2.f;
    viewport.translate[2] = 0.0;
-   viewport.translate[3] = 0.0;
 
    cso_set_viewport(r->cso, &viewport);
 }
@@ -435,11 +435,11 @@ static void renderer_set_samplers(struct renderer *r,
 
    /* set samplers */
    for (i = 0; i < num_views; i++)
-      cso_single_sampler(r->cso, i, &sampler);
-   cso_single_sampler_done(r->cso);
+      cso_single_sampler(r->cso, PIPE_SHADER_FRAGMENT, i, &sampler);
+   cso_single_sampler_done(r->cso, PIPE_SHADER_FRAGMENT);
 
    /* set views */
-   cso_set_fragment_sampler_views(r->cso, num_views, views);
+   cso_set_sampler_views(r->cso, PIPE_SHADER_FRAGMENT, num_views, views);
 }
 
 /**
@@ -461,8 +461,8 @@ static void renderer_set_custom_fs(struct renderer *renderer,
 
    /* set samplers and views */
    if (num_samplers) {
-      cso_set_samplers(renderer->cso, num_samplers, samplers);
-      cso_set_fragment_sampler_views(renderer->cso, num_samplers, views);
+      cso_set_samplers(renderer->cso, PIPE_SHADER_FRAGMENT, num_samplers, samplers);
+      cso_set_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT, num_samplers, views);
    }
 
    /* upload fs constant buffer */
@@ -474,10 +474,11 @@ static void renderer_set_custom_fs(struct renderer *renderer,
          pipe_resource_reference(&cbuf, NULL);
 
          cbuf = pipe_buffer_create(renderer->pipe->screen,
-               PIPE_BIND_CONSTANT_BUFFER, const_buffer_len);
+               PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_DEFAULT,
+               const_buffer_len);
          pipe_buffer_write(renderer->pipe, cbuf, 0,
                const_buffer_len, const_buffer);
-         renderer->pipe->set_constant_buffer(renderer->pipe,
+         pipe_set_constant_buffer(renderer->pipe,
                PIPE_SHADER_FRAGMENT, 0, cbuf);
 
          renderer->fs_cbuf = cbuf;
@@ -565,20 +566,9 @@ static void renderer_quad_texcoord(struct renderer *r,
  */
 static void renderer_quad_draw(struct renderer *r)
 {
-   struct pipe_resource *buf;
-
-   buf = pipe_user_buffer_create(r->pipe->screen,
-                                 r->vertices,
-                                 sizeof(r->vertices),
-                                 PIPE_BIND_VERTEX_BUFFER);
-   if (buf) {
-      util_draw_vertex_buffer(r->pipe, r->cso, buf, 0,
-                              PIPE_PRIM_TRIANGLE_FAN,
-                              Elements(r->vertices),     /* verts */
-                              Elements(r->vertices[0])); /* attribs/vert */
-
-      pipe_resource_reference(&buf, NULL);
-   }
+   util_draw_user_vertex_buffer(r->cso, r->vertices, PIPE_PRIM_TRIANGLE_FAN,
+                                Elements(r->vertices),     /* verts */
+                                Elements(r->vertices[0])); /* attribs/vert */
 }
 
 /**
@@ -601,8 +591,8 @@ VGboolean renderer_copy_begin(struct renderer *renderer,
    cso_save_framebuffer(renderer->cso);
    cso_save_viewport(renderer->cso);
    cso_save_blend(renderer->cso);
-   cso_save_samplers(renderer->cso);
-   cso_save_fragment_sampler_views(renderer->cso);
+   cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
+   cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
    cso_save_fragment_shader(renderer->cso);
    cso_save_vertex_shader(renderer->cso);
 
@@ -655,8 +645,8 @@ void renderer_copy_end(struct renderer *renderer)
    cso_restore_framebuffer(renderer->cso);
    cso_restore_viewport(renderer->cso);
    cso_restore_blend(renderer->cso);
-   cso_restore_samplers(renderer->cso);
-   cso_restore_fragment_sampler_views(renderer->cso);
+   cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
+   cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
    cso_restore_fragment_shader(renderer->cso);
    cso_restore_vertex_shader(renderer->cso);
 
@@ -675,8 +665,8 @@ VGboolean renderer_drawtex_begin(struct renderer *renderer,
       return VG_FALSE;
 
    cso_save_blend(renderer->cso);
-   cso_save_samplers(renderer->cso);
-   cso_save_fragment_sampler_views(renderer->cso);
+   cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
+   cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
    cso_save_fragment_shader(renderer->cso);
    cso_save_vertex_shader(renderer->cso);
 
@@ -726,8 +716,8 @@ void renderer_drawtex_end(struct renderer *renderer)
    assert(renderer->state == RENDERER_STATE_DRAWTEX);
 
    cso_restore_blend(renderer->cso);
-   cso_restore_samplers(renderer->cso);
-   cso_restore_fragment_sampler_views(renderer->cso);
+   cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
+   cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
    cso_restore_fragment_shader(renderer->cso);
    cso_restore_vertex_shader(renderer->cso);
 
@@ -880,8 +870,7 @@ VGboolean renderer_filter_begin(struct renderer *renderer,
    if (!renderer_can_support(renderer, dst, PIPE_BIND_RENDER_TARGET))
       return VG_FALSE;
 
-   u_surface_default_template(&surf_tmpl, dst,
-                              PIPE_BIND_RENDER_TARGET);
+   u_surface_default_template(&surf_tmpl, dst);
    surf = renderer->pipe->create_surface(renderer->pipe, dst, &surf_tmpl);
    if (!surf)
       return VG_FALSE;
@@ -899,8 +888,8 @@ VGboolean renderer_filter_begin(struct renderer *renderer,
    if (num_samplers) {
       struct pipe_resource *tex;
 
-      cso_save_samplers(renderer->cso);
-      cso_save_fragment_sampler_views(renderer->cso);
+      cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
+      cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
       cso_save_fragment_shader(renderer->cso);
       cso_save_vertex_shader(renderer->cso);
 
@@ -960,8 +949,8 @@ void renderer_filter_end(struct renderer *renderer)
    assert(renderer->state == RENDERER_STATE_FILTER);
 
    if (renderer->u.filter.use_sampler) {
-      cso_restore_samplers(renderer->cso);
-      cso_restore_fragment_sampler_views(renderer->cso);
+      cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
+      cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
       cso_restore_vertex_shader(renderer->cso);
    }
 
@@ -1050,10 +1039,10 @@ void renderer_polygon_stencil(struct renderer *renderer,
 {
    assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
 
-   cso_set_vertex_buffers(renderer->cso, 1, vbuf);
+   cso_set_vertex_buffers(renderer->cso, 0, 1, vbuf);
 
    if (!renderer->u.polygon_stencil.manual_two_sides) {
-      util_draw_arrays(renderer->pipe, mode, start, count);
+      cso_draw_arrays(renderer->cso, mode, start, count);
    }
    else {
       struct pipe_rasterizer_state raster;
@@ -1068,7 +1057,7 @@ void renderer_polygon_stencil(struct renderer *renderer,
 
       cso_set_rasterizer(renderer->cso, &raster);
       cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-      util_draw_arrays(renderer->pipe, mode, start, count);
+      cso_draw_arrays(renderer->cso, mode, start, count);
 
       /* back */
       raster.cull_face = PIPE_FACE_FRONT;
@@ -1076,7 +1065,7 @@ void renderer_polygon_stencil(struct renderer *renderer,
 
       cso_set_rasterizer(renderer->cso, &raster);
       cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-      util_draw_arrays(renderer->pipe, mode, start, count);
+      cso_draw_arrays(renderer->cso, mode, start, count);
    }
 }
 
@@ -1185,7 +1174,9 @@ struct renderer * renderer_create(struct vg_context *owner)
    /* GL rasterization rules */
    raster = &renderer->g3d.rasterizer;
    memset(raster, 0, sizeof(*raster));
-   raster->gl_rasterization_rules = 1;
+   raster->half_pixel_center = 1;
+   raster->bottom_edge_rule = 1;
+   raster->depth_clip = 1;
    cso_set_rasterizer(renderer->cso, raster);
 
    /* fixed at 0 */
@@ -1290,11 +1281,8 @@ static void renderer_validate_blend(struct renderer *renderer,
       blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
       break;
    case VG_BLEND_SRC_OVER:
-      if (paint_is_opaque(state->fill_paint) &&
-          paint_is_opaque(state->stroke_paint)) {
-         /* no blending */
-      }
-      else if (!util_format_has_alpha(fb_format)) {
+      /* use the blend state only when there is no alpha channel */
+      if (!util_format_has_alpha(fb_format)) {
          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;
@@ -1461,11 +1449,11 @@ void renderer_copy_surface(struct renderer *ctx,
    }
 
    assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_SAMPLER_VIEW, 0));
+                                      0, PIPE_BIND_SAMPLER_VIEW));
    assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_SAMPLER_VIEW, 0));
+                                      0, PIPE_BIND_SAMPLER_VIEW));
    assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      0, PIPE_BIND_RENDER_TARGET, 0));
+                                      0, PIPE_BIND_RENDER_TARGET));
 
    /*
     * XXX for now we're always creating a temporary texture.