0,0 → 1,693 |
/************************************************************************** |
* |
* 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 |