st/egl: Remove.

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

diff --git a/src/gallium/state_trackers/vega/shaders_cache.c b/src/gallium/state_trackers/vega/shaders_cache.c
index 49b451c1179e6e3d219af51476603fbc6fbc94a8..c1082ca3673c5469020627ea32b3dc748a4c97b3 100644 (file)
--- a/src/gallium/state_trackers/vega/shaders_cache.c
+++ b/src/gallium/state_trackers/vega/shaders_cache.c
@@ -52,12 +52,14 @@
  * of the pipeline. The stages are:
  * 1) Paint generation (color/gradient/pattern)
  * 2) Image composition (normal/multiply/stencil)
- * 3) Mask
- * 4) Extended blend (multiply/screen/darken/lighten)
- * 5) Premultiply/Unpremultiply
- * 6) Color transform (to black and white)
+ * 3) Color transform
+ * 4) Per-channel alpha generation
+ * 5) Extended blend (multiply/screen/darken/lighten)
+ * 6) Mask
+ * 7) Premultiply/Unpremultiply
+ * 8) Color transform (to black and white)
  */
-#define SHADER_STAGES 6
+#define SHADER_STAGES 8
 
 struct cached_shader {
    void *driver_shader;
@@ -180,7 +182,7 @@ combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_sh
    out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
 
    if (num_consts >= 1) {
-      constant = (struct ureg_src *) malloc(sizeof(struct ureg_src) * end_const);
+      constant = malloc(sizeof(struct ureg_src) * end_const);
       for (i = start_const; i < end_const; i++) {
          constant[i] = ureg_DECL_constant(ureg, i);
       }
@@ -188,14 +190,14 @@ combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_sh
    }
 
    if (num_temps >= 1) {
-      temp = (struct ureg_dst *) malloc(sizeof(struct ureg_dst) * end_temp);
+      temp = malloc(sizeof(struct ureg_dst) * end_temp);
       for (i = start_temp; i < end_temp; i++) {
          temp[i] = ureg_DECL_temporary(ureg);
       }
    }
 
    if (num_samplers >= 1) {
-      sampler = (struct ureg_src *) malloc(sizeof(struct ureg_src) * end_sampler);
+      sampler = malloc(sizeof(struct ureg_src) * end_sampler);
       for (i = start_sampler; i < end_sampler; i++) {
          sampler[i] = ureg_DECL_sampler(ureg, i);
       }
@@ -223,11 +225,12 @@ combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_sh
    ureg_END(ureg);
 
    shader->tokens = ureg_finalize(ureg);
-   if(!shader->tokens)
+   if (!shader->tokens) {
+      ureg_destroy(ureg);
       return NULL;
+   }
 
    p = pipe->create_fs_state(pipe, shader);
-   ureg_destroy(ureg);
 
    if (num_temps >= 1) {
       for (i = start_temp; i < end_temp; i++) {
@@ -235,12 +238,11 @@ combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_sh
       }
    }
 
-   if (temp)
-      free(temp);
-   if (constant)
-      free(constant);
-   if (sampler)
-      free(sampler);
+   ureg_destroy(ureg);
+
+   free(temp);
+   free(constant);
+   free(sampler);
 
    return p;
 }
@@ -260,6 +262,7 @@ create_shader(struct pipe_context *pipe,
    case VEGA_LINEAR_GRADIENT_SHADER:
    case VEGA_RADIAL_GRADIENT_SHADER:
    case VEGA_PATTERN_SHADER:
+   case VEGA_PAINT_DEGENERATE_SHADER:
       shaders[idx] = &shaders_paint_asm[(sh >> SHADERS_PAINT_SHIFT) - 1];
       assert(shaders[idx]->id == sh);
       idx++;
@@ -286,10 +289,11 @@ create_shader(struct pipe_context *pipe,
    assert(idx == ((!sh || sh == VEGA_IMAGE_NORMAL_SHADER) ? 1 : 2));
 
    /* third stage */
-   sh = SHADERS_GET_MASK_SHADER(id);
+   sh = SHADERS_GET_COLOR_TRANSFORM_SHADER(id);
    switch (sh) {
-   case VEGA_MASK_SHADER:
-      shaders[idx] = &shaders_mask_asm[(sh >> SHADERS_MASK_SHIFT) - 1];
+   case VEGA_COLOR_TRANSFORM_SHADER:
+      shaders[idx] = &shaders_color_transform_asm[
+         (sh >> SHADERS_COLOR_TRANSFORM_SHIFT) - 1];
       assert(shaders[idx]->id == sh);
       idx++;
       break;
@@ -298,12 +302,32 @@ create_shader(struct pipe_context *pipe,
    }
 
    /* fourth stage */
+   sh = SHADERS_GET_ALPHA_SHADER(id);
+   switch (sh) {
+   case VEGA_ALPHA_NORMAL_SHADER:
+   case VEGA_ALPHA_PER_CHANNEL_SHADER:
+      shaders[idx] = &shaders_alpha_asm[
+         (sh >> SHADERS_ALPHA_SHIFT) - 1];
+      assert(shaders[idx]->id == sh);
+      idx++;
+      break;
+   default:
+      break;
+   }
+
+   /* fifth stage */
    sh = SHADERS_GET_BLEND_SHADER(id);
    switch (sh) {
+   case VEGA_BLEND_SRC_SHADER:
+   case VEGA_BLEND_SRC_OVER_SHADER:
+   case VEGA_BLEND_DST_OVER_SHADER:
+   case VEGA_BLEND_SRC_IN_SHADER:
+   case VEGA_BLEND_DST_IN_SHADER:
    case VEGA_BLEND_MULTIPLY_SHADER:
    case VEGA_BLEND_SCREEN_SHADER:
    case VEGA_BLEND_DARKEN_SHADER:
    case VEGA_BLEND_LIGHTEN_SHADER:
+   case VEGA_BLEND_ADDITIVE_SHADER:
       shaders[idx] = &shaders_blend_asm[(sh >> SHADERS_BLEND_SHIFT) - 1];
       assert(shaders[idx]->id == sh);
       idx++;
@@ -312,7 +336,19 @@ create_shader(struct pipe_context *pipe,
       break;
    }
 
-   /* fifth stage */
+   /* sixth stage */
+   sh = SHADERS_GET_MASK_SHADER(id);
+   switch (sh) {
+   case VEGA_MASK_SHADER:
+      shaders[idx] = &shaders_mask_asm[(sh >> SHADERS_MASK_SHIFT) - 1];
+      assert(shaders[idx]->id == sh);
+      idx++;
+      break;
+   default:
+      break;
+   }
+
+   /* seventh stage */
    sh = SHADERS_GET_PREMULTIPLY_SHADER(id);
    switch (sh) {
    case VEGA_PREMULTIPLY_SHADER:
@@ -326,7 +362,7 @@ create_shader(struct pipe_context *pipe,
       break;
    }
 
-   /* sixth stage */
+   /* eighth stage */
    sh = SHADERS_GET_BW_SHADER(id);
    switch (sh) {
    case VEGA_BW_SHADER:
@@ -404,6 +440,7 @@ struct vg_shader * shader_create_from_text(struct pipe_context *pipe,
                 type == PIPE_SHADER_FRAGMENT);
 
    state.tokens = tokens;
+   memset(&state.stream_output, 0, sizeof(state.stream_output));
    shader->type = type;
    shader->tokens = tokens;