src/gallium/state_trackers/vega/shader.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.  All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 #include "shader.h"
  28
  29 #include "vg_context.h"
  30 #include "shaders_cache.h"
  31 #include "paint.h"
  32 #include "mask.h"
  33 #include "image.h"
  34 #include "renderer.h"
  35
  36 #include "pipe/p_context.h"
  37 #include "pipe/p_state.h"
  38 #include "util/u_memory.h"
  39 #include "util/u_math.h"
  40 #include "util/u_format.h"
  41
  42 #define MAX_CONSTANTS 28
  43
  44 struct shader {
  45    struct vg_context *context;
  46
  47    VGboolean color_transform;
  48    VGboolean masking;
  49    struct vg_paint *paint;
  50    struct vg_image *image;
  51
  52    struct matrix modelview;
  53    struct matrix paint_matrix;
  54
  55    VGboolean drawing_image;
  56    VGImageMode image_mode;
  57
  58    float constants[MAX_CONSTANTS];
  59    struct pipe_resource *cbuf;
  60    struct pipe_shader_state fs_state;
  61    void *fs;
  62 };
  63
  64 struct shader * shader_create(struct vg_context *ctx)
  65 {
  66    struct shader *shader = 0;
  67
  68    shader = CALLOC_STRUCT(shader);
  69    shader->context = ctx;
  70
  71    return shader;
  72 }
  73
  74 void shader_destroy(struct shader *shader)
  75 {
  76    FREE(shader);
  77 }
  78
  79 void shader_set_color_transform(struct shader *shader, VGboolean set)
  80 {
  81    shader->color_transform = set;
  82 }
  83
  84 void shader_set_masking(struct shader *shader, VGboolean set)
  85 {
  86    shader->masking = set;
  87 }
  88
  89 VGboolean shader_is_masking(struct shader *shader)
  90 {
  91    return shader->masking;
  92 }
  93
  94 void shader_set_paint(struct shader *shader, struct vg_paint *paint)
  95 {
  96    shader->paint = paint;
  97 }
  98
  99 struct vg_paint * shader_paint(struct shader *shader)
 100 {
 101    return shader->paint;
 102 }
 103
 104 static VGint setup_constant_buffer(struct shader *shader)
 105 {
 106    const struct vg_state *state = &shader->context->state.vg;
 107    VGint param_bytes = paint_constant_buffer_size(shader->paint);
 108    VGint i;
 109
 110    param_bytes += sizeof(VGfloat) * 8;
 111    assert(param_bytes <= sizeof(shader->constants));
 112
 113    if (state->color_transform) {
 114       for (i = 0; i < 8; i++) {
 115          VGfloat val = (i < 4) ? 127.0f : 1.0f;
 116          shader->constants[i] =
 117             CLAMP(state->color_transform_values[i], -val, val);
 118       }
 119    }
 120    else {
 121       memset(shader->constants, 0, sizeof(VGfloat) * 8);
 122    }
 123
 124    paint_fill_constant_buffer(shader->paint,
 125          &shader->paint_matrix, shader->constants + 8);
 126
 127    return param_bytes;
 128 }
 129
 130 static VGboolean blend_use_shader(struct shader *shader)
 131 {
 132    struct vg_context *ctx = shader->context;
 133    VGboolean advanced_blending;
 134
 135    switch (ctx->state.vg.blend_mode) {
 136    case VG_BLEND_DST_OVER:
 137    case VG_BLEND_MULTIPLY:
 138    case VG_BLEND_SCREEN:
 139    case VG_BLEND_DARKEN:
 140    case VG_BLEND_LIGHTEN:
 141    case VG_BLEND_ADDITIVE:
 142       advanced_blending = VG_TRUE;
 143       break;
 144    case VG_BLEND_SRC_OVER:
 145       if (util_format_has_alpha(ctx->draw_buffer->strb->format)) {
 146          /* no blending is required if the paints and the image are opaque */
 147          advanced_blending = !paint_is_opaque(ctx->state.vg.fill_paint) ||
 148                              !paint_is_opaque(ctx->state.vg.stroke_paint);
 149          if (!advanced_blending && shader->drawing_image) {
 150             advanced_blending =
 151                util_format_has_alpha(shader->image->sampler_view->format);
 152          }
 153          break;
 154       }
 155       /* fall through */
 156    default:
 157       advanced_blending = VG_FALSE;
 158       break;
 159    }
 160
 161    return advanced_blending;
 162 }
 163
 164 static VGint blend_bind_samplers(struct shader *shader,
 165                                  struct pipe_sampler_state **samplers,
 166                                  struct pipe_sampler_view **sampler_views)
 167 {
 168    if (blend_use_shader(shader)) {
 169       struct vg_context *ctx = shader->context;
 170
 171       samplers[2] = &ctx->blend_sampler;
 172       sampler_views[2] = vg_prepare_blend_surface(ctx);
 173
 174       if (!samplers[0] || !sampler_views[0]) {
 175          samplers[0] = samplers[2];
 176          sampler_views[0] = sampler_views[2];
 177       }
 178       if (!samplers[1] || !sampler_views[1]) {
 179          samplers[1] = samplers[0];
 180          sampler_views[1] = sampler_views[0];
 181       }
 182
 183       return 1;
 184    }
 185    return 0;
 186 }
 187
 188 static VGint setup_samplers(struct shader *shader,
 189                             struct pipe_sampler_state **samplers,
 190                             struct pipe_sampler_view **sampler_views)
 191 {
 192    /* a little wonky: we use the num as a boolean that just says
 193     * whether any sampler/textures have been set. the actual numbering
 194     * for samplers is always the same:
 195     * 0 - paint sampler/texture for gradient/pattern
 196     * 1 - mask sampler/texture
 197     * 2 - blend sampler/texture
 198     * 3 - image sampler/texture
 199     * */
 200    VGint num = 0;
 201
 202    samplers[0] = NULL;
 203    samplers[1] = NULL;
 204    samplers[2] = NULL;
 205    samplers[3] = NULL;
 206    sampler_views[0] = NULL;
 207    sampler_views[1] = NULL;
 208    sampler_views[2] = NULL;
 209    sampler_views[3] = NULL;
 210
 211    num += paint_bind_samplers(shader->paint, samplers, sampler_views);
 212    num += mask_bind_samplers(samplers, sampler_views);
 213    num += blend_bind_samplers(shader, samplers, sampler_views);
 214    if (shader->drawing_image && shader->image)
 215       num += image_bind_samplers(shader->image, samplers, sampler_views);
 216
 217    return (num) ? 4 : 0;
 218 }
 219
 220 static INLINE VGboolean is_format_bw(struct shader *shader)
 221 {
 222 #if 0
 223    struct vg_context *ctx = shader->context;
 224    struct st_framebuffer *stfb = ctx->draw_buffer;
 225 #endif
 226
 227    if (shader->drawing_image && shader->image) {
 228       if (shader->image->format == VG_BW_1)
 229          return VG_TRUE;
 230    }
 231
 232    return VG_FALSE;
 233 }
 234
 235 static void setup_shader_program(struct shader *shader)
 236 {
 237    struct vg_context *ctx = shader->context;
 238    VGint shader_id = 0;
 239    VGBlendMode blend_mode = ctx->state.vg.blend_mode;
 240    VGboolean black_white = is_format_bw(shader);
 241
 242    /* 1st stage: fill */
 243    if (!shader->drawing_image ||
 244        (shader->image_mode == VG_DRAW_IMAGE_MULTIPLY || shader->image_mode == VG_DRAW_IMAGE_STENCIL)) {
 245       switch(paint_type(shader->paint)) {
 246       case VG_PAINT_TYPE_COLOR:
 247          shader_id |= VEGA_SOLID_FILL_SHADER;
 248          break;
 249       case VG_PAINT_TYPE_LINEAR_GRADIENT:
 250          shader_id |= VEGA_LINEAR_GRADIENT_SHADER;
 251          break;
 252       case VG_PAINT_TYPE_RADIAL_GRADIENT:
 253          shader_id |= VEGA_RADIAL_GRADIENT_SHADER;
 254          break;
 255       case VG_PAINT_TYPE_PATTERN:
 256          shader_id |= VEGA_PATTERN_SHADER;
 257          break;
 258
 259       default:
 260          abort();
 261       }
 262
 263       if (paint_is_degenerate(shader->paint))
 264          shader_id = VEGA_PAINT_DEGENERATE_SHADER;
 265    }
 266
 267    /* second stage image */
 268    if (shader->drawing_image) {
 269       switch(shader->image_mode) {
 270       case VG_DRAW_IMAGE_NORMAL:
 271          shader_id |= VEGA_IMAGE_NORMAL_SHADER;
 272          break;
 273       case VG_DRAW_IMAGE_MULTIPLY:
 274          shader_id |= VEGA_IMAGE_MULTIPLY_SHADER;
 275          break;
 276       case VG_DRAW_IMAGE_STENCIL:
 277          shader_id |= VEGA_IMAGE_STENCIL_SHADER;
 278          break;
 279       default:
 280          debug_printf("Unknown image mode!");
 281       }
 282    }
 283
 284    if (shader->color_transform)
 285       shader_id |= VEGA_COLOR_TRANSFORM_SHADER;
 286
 287    if (blend_use_shader(shader)) {
 288       if (shader->drawing_image && shader->image_mode == VG_DRAW_IMAGE_STENCIL)
 289          shader_id |= VEGA_ALPHA_PER_CHANNEL_SHADER;
 290       else
 291          shader_id |= VEGA_ALPHA_NORMAL_SHADER;
 292
 293       switch(blend_mode) {
 294       case VG_BLEND_SRC:
 295          shader_id |= VEGA_BLEND_SRC_SHADER;
 296          break;
 297       case VG_BLEND_SRC_OVER:
 298          shader_id |= VEGA_BLEND_SRC_OVER_SHADER;
 299          break;
 300       case VG_BLEND_DST_OVER:
 301          shader_id |= VEGA_BLEND_DST_OVER_SHADER;
 302          break;
 303       case VG_BLEND_SRC_IN:
 304          shader_id |= VEGA_BLEND_SRC_IN_SHADER;
 305          break;
 306       case VG_BLEND_DST_IN:
 307          shader_id |= VEGA_BLEND_DST_IN_SHADER;
 308          break;
 309       case VG_BLEND_MULTIPLY:
 310          shader_id |= VEGA_BLEND_MULTIPLY_SHADER;
 311          break;
 312       case VG_BLEND_SCREEN:
 313          shader_id |= VEGA_BLEND_SCREEN_SHADER;
 314          break;
 315       case VG_BLEND_DARKEN:
 316          shader_id |= VEGA_BLEND_DARKEN_SHADER;
 317          break;
 318       case VG_BLEND_LIGHTEN:
 319          shader_id |= VEGA_BLEND_LIGHTEN_SHADER;
 320          break;
 321       case VG_BLEND_ADDITIVE:
 322          shader_id |= VEGA_BLEND_ADDITIVE_SHADER;
 323          break;
 324       default:
 325          assert(0);
 326          break;
 327       }
 328    }
 329    else {
 330       /* update alpha of the source */
 331       if (shader->drawing_image && shader->image_mode == VG_DRAW_IMAGE_STENCIL)
 332          shader_id |= VEGA_ALPHA_PER_CHANNEL_SHADER;
 333    }
 334
 335    if (shader->masking)
 336       shader_id |= VEGA_MASK_SHADER;
 337
 338    if (black_white)
 339       shader_id |= VEGA_BW_SHADER;
 340
 341    shader->fs = shaders_cache_fill(ctx->sc, shader_id);
 342 }
 343
 344
 345 void shader_bind(struct shader *shader)
 346 {
 347    struct vg_context *ctx = shader->context;
 348    struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
 349    struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
 350    VGint num_samplers, param_bytes;
 351
 352    /* first resolve the real paint type */
 353    paint_resolve_type(shader->paint);
 354
 355    num_samplers = setup_samplers(shader, samplers, sampler_views);
 356    param_bytes = setup_constant_buffer(shader);
 357    setup_shader_program(shader);
 358
 359    renderer_validate_for_shader(ctx->renderer,
 360          (const struct pipe_sampler_state **) samplers,
 361          sampler_views, num_samplers,
 362          &shader->modelview,
 363          shader->fs, (const void *) shader->constants, param_bytes);
 364 }
 365
 366 void shader_set_image_mode(struct shader *shader, VGImageMode image_mode)
 367 {
 368    shader->image_mode = image_mode;
 369 }
 370
 371 VGImageMode shader_image_mode(struct shader *shader)
 372 {
 373    return shader->image_mode;
 374 }
 375
 376 void shader_set_drawing_image(struct shader *shader, VGboolean drawing_image)
 377 {
 378    shader->drawing_image = drawing_image;
 379 }
 380
 381 VGboolean shader_drawing_image(struct shader *shader)
 382 {
 383    return shader->drawing_image;
 384 }
 385
 386 void shader_set_image(struct shader *shader, struct vg_image *img)
 387 {
 388    shader->image = img;
 389 }
 390
 391 /**
 392  * Set the transformation to map a vertex to the surface coordinates.
 393  */
 394 void shader_set_surface_matrix(struct shader *shader,
 395                                const struct matrix *mat)
 396 {
 397    shader->modelview = *mat;
 398 }
 399
 400 /**
 401  * Set the transformation to map a pixel to the paint coordinates.
 402  */
 403 void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat)
 404 {
 405    const struct st_framebuffer *stfb = shader->context->draw_buffer;
 406    const VGfloat px_center_offset = 0.5f;
 407
 408    memcpy(&shader->paint_matrix, mat, sizeof(*mat));
 409
 410    /* make it window-to-paint for the shaders */
 411    matrix_translate(&shader->paint_matrix, px_center_offset,
 412          stfb->height - 1.0f + px_center_offset);
 413    matrix_scale(&shader->paint_matrix, 1.0f, -1.0f);
 414 }