| /************************************************************************** |
| * |
| * Copyright 2009 VMware, Inc. All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
| * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| **************************************************************************/ |
| |
| #ifndef ASM_FILL_H |
| #define ASM_FILL_H |
| |
| #include "tgsi/tgsi_ureg.h" |
| |
| typedef void (* ureg_func)( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant); |
| |
| static INLINE void |
| solid_fill( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| ureg_MOV(ureg, *out, constant[2]); |
| } |
| |
| /** |
| * Perform frag-coord-to-paint-coord transform. The transformation is in |
| * CONST[4..6]. |
| */ |
| #define PAINT_TRANSFORM \ |
| ureg_MOV(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_XY), in[0]); \ |
| ureg_MOV(ureg, \ |
| ureg_writemask(temp[0], TGSI_WRITEMASK_Z), \ |
| ureg_scalar(constant[3], TGSI_SWIZZLE_Y)); \ |
| ureg_DP3(ureg, temp[1], constant[4], ureg_src(temp[0])); \ |
| ureg_DP3(ureg, temp[2], constant[5], ureg_src(temp[0])); \ |
| ureg_DP3(ureg, temp[3], constant[6], ureg_src(temp[0])); \ |
| ureg_RCP(ureg, temp[3], ureg_src(temp[3])); \ |
| ureg_MUL(ureg, temp[1], ureg_src(temp[1]), ureg_src(temp[3])); \ |
| ureg_MUL(ureg, temp[2], ureg_src(temp[2]), ureg_src(temp[3])); \ |
| ureg_MOV(ureg, \ |
| ureg_writemask(temp[4], TGSI_WRITEMASK_X), \ |
| ureg_src(temp[1])); \ |
| ureg_MOV(ureg, \ |
| ureg_writemask(temp[4], TGSI_WRITEMASK_Y), \ |
| ureg_src(temp[2])); |
| |
| static INLINE void |
| linear_grad( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| PAINT_TRANSFORM |
| |
| /* grad = DP2((x, y), CONST[2].xy) * CONST[2].z */ |
| ureg_MUL(ureg, temp[0], |
| ureg_scalar(constant[2], TGSI_SWIZZLE_Y), |
| ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_Y)); |
| ureg_MAD(ureg, temp[1], |
| ureg_scalar(constant[2], TGSI_SWIZZLE_X), |
| ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_X), |
| ureg_src(temp[0])); |
| ureg_MUL(ureg, temp[2], ureg_src(temp[1]), |
| ureg_scalar(constant[2], TGSI_SWIZZLE_Z)); |
| |
| ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[2]), sampler[0]); |
| } |
| |
| static INLINE void |
| radial_grad( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| PAINT_TRANSFORM |
| |
| /* |
| * Calculate (sqrt(B^2 + AC) - B) / A, where |
| * |
| * A is CONST[2].z, |
| * B is DP2((x, y), CONST[2].xy), and |
| * C is DP2((x, y), (x, y)). |
| */ |
| |
| /* B and C */ |
| ureg_DP2(ureg, temp[0], ureg_src(temp[4]), constant[2]); |
| ureg_DP2(ureg, temp[1], ureg_src(temp[4]), ureg_src(temp[4])); |
| |
| /* the square root */ |
| ureg_MUL(ureg, temp[2], ureg_src(temp[0]), ureg_src(temp[0])); |
| ureg_MAD(ureg, temp[3], ureg_src(temp[1]), |
| ureg_scalar(constant[2], TGSI_SWIZZLE_Z), ureg_src(temp[2])); |
| ureg_RSQ(ureg, temp[3], ureg_src(temp[3])); |
| ureg_RCP(ureg, temp[3], ureg_src(temp[3])); |
| |
| ureg_SUB(ureg, temp[3], ureg_src(temp[3]), ureg_src(temp[0])); |
| ureg_RCP(ureg, temp[0], ureg_scalar(constant[2], TGSI_SWIZZLE_Z)); |
| ureg_MUL(ureg, temp[0], ureg_src(temp[0]), ureg_src(temp[3])); |
| |
| ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[0]), sampler[0]); |
| } |
| |
| |
| static INLINE void |
| pattern( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| PAINT_TRANSFORM |
| |
| /* (s, t) = (x / tex_width, y / tex_height) */ |
| ureg_RCP(ureg, temp[0], |
| ureg_swizzle(constant[3], |
| TGSI_SWIZZLE_Z, |
| TGSI_SWIZZLE_W, |
| TGSI_SWIZZLE_Z, |
| TGSI_SWIZZLE_W)); |
| ureg_MOV(ureg, temp[1], ureg_src(temp[4])); |
| ureg_MUL(ureg, |
| ureg_writemask(temp[1], TGSI_WRITEMASK_X), |
| ureg_src(temp[1]), |
| ureg_src(temp[0])); |
| ureg_MUL(ureg, |
| ureg_writemask(temp[1], TGSI_WRITEMASK_Y), |
| ureg_src(temp[1]), |
| ureg_src(temp[0])); |
| |
| ureg_TEX(ureg, *out, TGSI_TEXTURE_2D, ureg_src(temp[1]), sampler[0]); |
| } |
| |
| static INLINE void |
| paint_degenerate( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* CONST[3].y is 1.0f */ |
| ureg_MOV(ureg, temp[1], ureg_scalar(constant[3], TGSI_SWIZZLE_Y)); |
| ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[1]), sampler[0]); |
| } |
| |
| static INLINE void |
| image_normal( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* store and pass image color in TEMP[1] */ |
| ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]); |
| ureg_MOV(ureg, *out, ureg_src(temp[1])); |
| } |
| |
| |
| static INLINE void |
| image_multiply( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* store and pass image color in TEMP[1] */ |
| ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]); |
| ureg_MUL(ureg, *out, ureg_src(temp[0]), ureg_src(temp[1])); |
| } |
| |
| |
| static INLINE void |
| image_stencil( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* store and pass image color in TEMP[1] */ |
| ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]); |
| ureg_MOV(ureg, *out, ureg_src(temp[0])); |
| } |
| |
| static INLINE void |
| color_transform( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* note that TEMP[1] may already be used for image color */ |
| |
| ureg_MAD(ureg, temp[2], ureg_src(temp[0]), constant[0], constant[1]); |
| /* clamp to [0.0f, 1.0f] */ |
| ureg_CLAMP(ureg, temp[2], |
| ureg_src(temp[2]), |
| ureg_scalar(constant[3], TGSI_SWIZZLE_X), |
| ureg_scalar(constant[3], TGSI_SWIZZLE_Y)); |
| ureg_MOV(ureg, *out, ureg_src(temp[2])); |
| } |
| |
| static INLINE void |
| alpha_normal( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* save per-channel alpha in TEMP[1] */ |
| ureg_MOV(ureg, temp[1], ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W)); |
| |
| ureg_MOV(ureg, *out, ureg_src(temp[0])); |
| } |
| |
| static INLINE void |
| alpha_per_channel( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| /* save per-channel alpha in TEMP[1] */ |
| ureg_MUL(ureg, |
| ureg_writemask(temp[1], TGSI_WRITEMASK_W), |
| ureg_src(temp[0]), |
| ureg_src(temp[1])); |
| ureg_MUL(ureg, |
| ureg_writemask(temp[1], TGSI_WRITEMASK_XYZ), |
| ureg_src(temp[1]), |
| ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W)); |
| |
| /* update alpha */ |
| ureg_MOV(ureg, |
| ureg_writemask(temp[0], TGSI_WRITEMASK_W), |
| ureg_src(temp[1])); |
| ureg_MOV(ureg, *out, ureg_src(temp[0])); |
| } |
| |
| /** |
| * Premultiply src and dst. |
| */ |
| static INLINE void |
| blend_premultiply( struct ureg_program *ureg, |
| struct ureg_src src, |
| struct ureg_src src_channel_alpha, |
| struct ureg_src dst) |
| { |
| /* premultiply src */ |
| ureg_MUL(ureg, |
| ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ), |
| src, |
| src_channel_alpha); |
| /* premultiply dst */ |
| ureg_MUL(ureg, |
| ureg_writemask(ureg_dst(dst), TGSI_WRITEMASK_XYZ), |
| dst, |
| ureg_scalar(dst, TGSI_SWIZZLE_W)); |
| } |
| |
| /** |
| * Unpremultiply src. |
| */ |
| static INLINE void |
| blend_unpremultiply( struct ureg_program *ureg, |
| struct ureg_src src, |
| struct ureg_src one, |
| struct ureg_dst temp[1]) |
| { |
| /* replace 0.0f by 1.0f before calculating reciprocal */ |
| ureg_CMP(ureg, |
| temp[0], |
| ureg_negate(ureg_scalar(src, TGSI_SWIZZLE_W)), |
| ureg_scalar(src, TGSI_SWIZZLE_W), |
| one); |
| ureg_RCP(ureg, temp[0], ureg_src(temp[0])); |
| |
| ureg_MUL(ureg, |
| ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ), |
| src, |
| ureg_src(temp[0])); |
| } |
| |
| /** |
| * Emit instructions for the specified blend mode. Colors will be |
| * unpremultiplied. Two temporary registers are required. |
| * |
| * The output is written back to src. |
| */ |
| static INLINE void |
| blend_generic(struct ureg_program *ureg, |
| VGBlendMode mode, |
| struct ureg_src src, |
| struct ureg_src src_channel_alpha, |
| struct ureg_src dst, |
| struct ureg_src one, |
| struct ureg_dst temp[2]) |
| { |
| struct ureg_dst out; |
| |
| blend_premultiply(ureg, src, src_channel_alpha, dst); |
| |
| /* blend in-place */ |
| out = ureg_dst(src); |
| |
| switch (mode) { |
| case VG_BLEND_SRC: |
| ureg_MOV(ureg, out, src); |
| break; |
| case VG_BLEND_SRC_OVER: |
| /* RGBA_out = RGBA_src + (1 - A_src) * RGBA_dst */ |
| ureg_SUB(ureg, temp[0], one, src_channel_alpha); |
| ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src); |
| break; |
| case VG_BLEND_DST_OVER: |
| /* RGBA_out = RGBA_dst + (1 - A_dst) * RGBA_src */ |
| ureg_SUB(ureg, temp[0], one, ureg_scalar(dst, TGSI_SWIZZLE_W)); |
| ureg_MAD(ureg, out, ureg_src(temp[0]), src, dst); |
| break; |
| case VG_BLEND_SRC_IN: |
| ureg_MUL(ureg, out, src, ureg_scalar(dst, TGSI_SWIZZLE_W)); |
| break; |
| case VG_BLEND_DST_IN: |
| ureg_MUL(ureg, out, dst, src_channel_alpha); |
| break; |
| case VG_BLEND_MULTIPLY: |
| /* |
| * RGB_out = (1 - A_dst) * RGB_src + (1 - A_src) * RGB_dst + |
| * RGB_src * RGB_dst |
| */ |
| ureg_MAD(ureg, temp[0], |
| ureg_scalar(dst, TGSI_SWIZZLE_W), ureg_negate(src), src); |
| ureg_MAD(ureg, temp[1], |
| src_channel_alpha, ureg_negate(dst), dst); |
| ureg_MAD(ureg, temp[0], src, dst, ureg_src(temp[0])); |
| ureg_ADD(ureg, out, ureg_src(temp[0]), ureg_src(temp[1])); |
| /* alpha is src over */ |
| ureg_ADD(ureg, ureg_writemask(out, TGSI_WRITEMASK_W), |
| src, ureg_src(temp[1])); |
| break; |
| case VG_BLEND_SCREEN: |
| /* RGBA_out = RGBA_src + (1 - RGBA_src) * RGBA_dst */ |
| ureg_SUB(ureg, temp[0], one, src); |
| ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src); |
| break; |
| case VG_BLEND_DARKEN: |
| case VG_BLEND_LIGHTEN: |
| /* src over */ |
| ureg_SUB(ureg, temp[0], one, src_channel_alpha); |
| ureg_MAD(ureg, temp[0], ureg_src(temp[0]), dst, src); |
| /* dst over */ |
| ureg_SUB(ureg, temp[1], one, ureg_scalar(dst, TGSI_SWIZZLE_W)); |
| ureg_MAD(ureg, temp[1], ureg_src(temp[1]), src, dst); |
| /* take min/max for colors */ |
| if (mode == VG_BLEND_DARKEN) { |
| ureg_MIN(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ), |
| ureg_src(temp[0]), ureg_src(temp[1])); |
| } |
| else { |
| ureg_MAX(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ), |
| ureg_src(temp[0]), ureg_src(temp[1])); |
| } |
| break; |
| case VG_BLEND_ADDITIVE: |
| /* RGBA_out = RGBA_src + RGBA_dst */ |
| ureg_ADD(ureg, temp[0], src, dst); |
| ureg_MIN(ureg, out, ureg_src(temp[0]), one); |
| break; |
| default: |
| assert(0); |
| break; |
| } |
| |
| blend_unpremultiply(ureg, src, one, temp); |
| } |
| |
| #define BLEND_GENERIC(mode) \ |
| do { \ |
| ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]); \ |
| blend_generic(ureg, (mode), ureg_src(temp[0]), ureg_src(temp[1]), \ |
| ureg_src(temp[2]), \ |
| ureg_scalar(constant[3], TGSI_SWIZZLE_Y), temp + 3); \ |
| ureg_MOV(ureg, *out, ureg_src(temp[0])); \ |
| } while (0) |
| |
| static INLINE void |
| blend_src( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_SRC); |
| } |
| |
| static INLINE void |
| blend_src_over( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_SRC_OVER); |
| } |
| |
| static INLINE void |
| blend_dst_over( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_DST_OVER); |
| } |
| |
| static INLINE void |
| blend_src_in( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_SRC_IN); |
| } |
| |
| static INLINE void |
| blend_dst_in( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_DST_IN); |
| } |
| |
| static INLINE void |
| blend_multiply( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_MULTIPLY); |
| } |
| |
| static INLINE void |
| blend_screen( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_SCREEN); |
| } |
| |
| static INLINE void |
| blend_darken( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_DARKEN); |
| } |
| |
| static INLINE void |
| blend_lighten( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_LIGHTEN); |
| } |
| |
| static INLINE void |
| blend_additive( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| BLEND_GENERIC(VG_BLEND_ADDITIVE); |
| } |
| |
| static INLINE void |
| mask( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[0], sampler[1]); |
| ureg_MUL(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_W), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W), |
| ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W)); |
| ureg_MOV(ureg, *out, ureg_src(temp[0])); |
| } |
| |
| static INLINE void |
| premultiply( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| ureg_MUL(ureg, |
| ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ), |
| ureg_src(temp[0]), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W)); |
| } |
| |
| static INLINE void |
| unpremultiply( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| ureg_TEX(ureg, temp[0], TGSI_TEXTURE_2D, in[0], sampler[1]); |
| } |
| |
| |
| static INLINE void |
| color_bw( struct ureg_program *ureg, |
| struct ureg_dst *out, |
| struct ureg_src *in, |
| struct ureg_src *sampler, |
| struct ureg_dst *temp, |
| struct ureg_src *constant) |
| { |
| ureg_ADD(ureg, temp[1], |
| ureg_scalar(constant[3], TGSI_SWIZZLE_Y), |
| ureg_scalar(constant[3], TGSI_SWIZZLE_Y)); |
| ureg_RCP(ureg, temp[2], ureg_src(temp[1])); |
| ureg_ADD(ureg, temp[1], |
| ureg_scalar(constant[3], TGSI_SWIZZLE_Y), |
| ureg_src(temp[2])); |
| ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Y)); |
| ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Z), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X)); |
| ureg_SGE(ureg, |
| ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ), |
| ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_X), |
| ureg_src(temp[1])); |
| ureg_SGE(ureg, |
| ureg_writemask(temp[0], TGSI_WRITEMASK_W), |
| ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W), |
| ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_Y)); |
| ureg_MOV(ureg, *out, ureg_src(temp[0])); |
| } |
| |
| |
| struct shader_asm_info { |
| VGint id; |
| ureg_func func; |
| |
| VGboolean needs_position; |
| |
| VGint start_const; |
| VGint num_consts; |
| |
| VGint start_sampler; |
| VGint num_samplers; |
| |
| VGint start_temp; |
| VGint num_temps; |
| }; |
| |
| |
| /* paint types */ |
| static const struct shader_asm_info shaders_paint_asm[] = { |
| {VEGA_SOLID_FILL_SHADER, solid_fill, |
| VG_FALSE, 2, 1, 0, 0, 0, 0}, |
| {VEGA_LINEAR_GRADIENT_SHADER, linear_grad, |
| VG_TRUE, 2, 5, 0, 1, 0, 5}, |
| {VEGA_RADIAL_GRADIENT_SHADER, radial_grad, |
| VG_TRUE, 2, 5, 0, 1, 0, 5}, |
| {VEGA_PATTERN_SHADER, pattern, |
| VG_TRUE, 3, 4, 0, 1, 0, 5}, |
| {VEGA_PAINT_DEGENERATE_SHADER, paint_degenerate, |
| VG_FALSE, 3, 1, 0, 1, 0, 2} |
| }; |
| |
| /* image draw modes */ |
| static const struct shader_asm_info shaders_image_asm[] = { |
| {VEGA_IMAGE_NORMAL_SHADER, image_normal, |
| VG_TRUE, 0, 0, 3, 1, 0, 2}, |
| {VEGA_IMAGE_MULTIPLY_SHADER, image_multiply, |
| VG_TRUE, 0, 0, 3, 1, 0, 2}, |
| {VEGA_IMAGE_STENCIL_SHADER, image_stencil, |
| VG_TRUE, 0, 0, 3, 1, 0, 2} |
| }; |
| |
| static const struct shader_asm_info shaders_color_transform_asm[] = { |
| {VEGA_COLOR_TRANSFORM_SHADER, color_transform, |
| VG_FALSE, 0, 4, 0, 0, 0, 3} |
| }; |
| |
| static const struct shader_asm_info shaders_alpha_asm[] = { |
| {VEGA_ALPHA_NORMAL_SHADER, alpha_normal, |
| VG_FALSE, 0, 0, 0, 0, 0, 2}, |
| {VEGA_ALPHA_PER_CHANNEL_SHADER, alpha_per_channel, |
| VG_FALSE, 0, 0, 0, 0, 0, 2} |
| }; |
| |
| /* extra blend modes */ |
| static const struct shader_asm_info shaders_blend_asm[] = { |
| #define BLEND_ASM_INFO(id, func) { (id), (func), VG_TRUE, 3, 1, 2, 1, 0, 5 } |
| BLEND_ASM_INFO(VEGA_BLEND_SRC_SHADER, blend_src), |
| BLEND_ASM_INFO(VEGA_BLEND_SRC_OVER_SHADER, blend_src_over), |
| BLEND_ASM_INFO(VEGA_BLEND_DST_OVER_SHADER, blend_dst_over), |
| BLEND_ASM_INFO(VEGA_BLEND_SRC_IN_SHADER, blend_src_in), |
| BLEND_ASM_INFO(VEGA_BLEND_DST_IN_SHADER, blend_dst_in), |
| BLEND_ASM_INFO(VEGA_BLEND_MULTIPLY_SHADER, blend_multiply), |
| BLEND_ASM_INFO(VEGA_BLEND_SCREEN_SHADER, blend_screen), |
| BLEND_ASM_INFO(VEGA_BLEND_DARKEN_SHADER, blend_darken), |
| BLEND_ASM_INFO(VEGA_BLEND_LIGHTEN_SHADER, blend_lighten), |
| BLEND_ASM_INFO(VEGA_BLEND_ADDITIVE_SHADER, blend_additive) |
| #undef BLEND_ASM_INFO |
| }; |
| |
| static const struct shader_asm_info shaders_mask_asm[] = { |
| {VEGA_MASK_SHADER, mask, |
| VG_TRUE, 0, 0, 1, 1, 0, 2} |
| }; |
| |
| /* premultiply */ |
| static const struct shader_asm_info shaders_premultiply_asm[] = { |
| {VEGA_PREMULTIPLY_SHADER, premultiply, |
| VG_FALSE, 0, 0, 0, 0, 0, 1}, |
| {VEGA_UNPREMULTIPLY_SHADER, unpremultiply, |
| VG_FALSE, 0, 0, 0, 0, 0, 1}, |
| }; |
| |
| /* color transform to black and white */ |
| static const struct shader_asm_info shaders_bw_asm[] = { |
| {VEGA_BW_SHADER, color_bw, |
| VG_FALSE, 3, 1, 0, 0, 0, 3}, |
| }; |
| |
| #endif |
