| static constexpr char SKSL_MINIFIED_sksl_graphite_frag[] = |
| "const int $kTileModeClamp=0;const int $kTileModeRepeat=1;const int $kTileModeDecal" |
| "=3;const int $kFilterModeNearest=0;const int $kFilterModeLinear=1;const int" |
| " $kColorSpaceXformFlagUnpremul=1;const int $kColorSpaceXformFlagLinearize=2" |
| ";const int $kColorSpaceXformFlagGamutTransform=4;const int $kColorSpaceXformFlagEncode" |
| "=8;const int $kColorSpaceXformFlagPremul=16;const int $kColorSpaceXformFlagAlphaSwizzle" |
| "=32;const int $kMaskFormatA8=0;const float $kLinearInset=.50001;$pure half4" |
| " sk_error(){return half4(1.,0.,0.,1.);}$pure half4 sk_passthrough(half4 color" |
| "){return color;}$pure half4 sk_solid_shader(float4 colorParam){return half4" |
| "(colorParam);}$pure half4 sk_rgb_opaque(float4 colorParam){return half4(half3" |
| "(colorParam.xyz),1.);}$pure half4 sk_alpha_only(float4 colorParam){return half4" |
| "(0.,0.,0.,half(colorParam.w));}$pure float $apply_xfer_fn(int kind,float x," |
| "half4[2]cs){float G=float(cs[0].x);float A=float(cs[0].y);float B=float(cs[" |
| "0].z);float C=float(cs[0].w);float D=float(cs[1].x);float E=float(cs[1].y);" |
| "float F=float(cs[1].z);float s=sign(x);x=abs(x);{float x_C;switch(kind){case" |
| " 1:x=x<D?C*x+F:pow(A*x+B,G)+E;break;case 2:x_C=pow(x,C);x=pow(max(A+B*x_C,0." |
| ")/(D+E*x_C),F);break;case 3:x=x*A<=1.?pow(x*A,B):exp((x-E)*C)+D;x*=F+1.;break" |
| ";case 4:x/=F+1.;x=x<=1.?A*pow(x,B):C*log(x-D)+E;break;}}return s*x;}$pure half4" |
| " sk_color_space_transform(half4 halfColor,int flags,int srcKind,half3x3 gamutTransform" |
| ",int dstKind,half4x4 coeffs){float4 color=float4(halfColor);if(bool(flags&$kColorSpaceXformFlagUnpremul" |
| "))color=unpremul(color);if(bool(flags&$kColorSpaceXformFlagLinearize)){half4" |
| " srcCoeffs[2];srcCoeffs[0]=coeffs[0];srcCoeffs[1]=coeffs[1];color.x=$apply_xfer_fn" |
| "(srcKind,color.x,srcCoeffs);color.y=$apply_xfer_fn(srcKind,color.y,srcCoeffs" |
| ");color.z=$apply_xfer_fn(srcKind,color.z,srcCoeffs);}if(bool(flags&$kColorSpaceXformFlagGamutTransform" |
| "))color.xyz=float3x3(gamutTransform)*color.xyz;if(bool(flags&$kColorSpaceXformFlagEncode" |
| ")){half4 dstCoeffs[2];dstCoeffs[0]=coeffs[2];dstCoeffs[1]=coeffs[3];color.x" |
| "=$apply_xfer_fn(dstKind,color.x,dstCoeffs);color.y=$apply_xfer_fn(dstKind,color" |
| ".y,dstCoeffs);color.z=$apply_xfer_fn(dstKind,color.z,dstCoeffs);}if(bool(flags" |
| "&$kColorSpaceXformFlagPremul))color.xyz*=color.w;return half4(color);}$pure" |
| " half4 $color_space_transform_swizzle(half4 halfColor,int flags,int srcKind" |
| ",half3x3 gamutTransform,int dstKind,half4x4 coeffs){if(flags==0)return halfColor" |
| ";else{if(bool(flags&$kColorSpaceXformFlagAlphaSwizzle))halfColor.w=dot(half2" |
| "(halfColor.x,1.),half2(coeffs[1].w,coeffs[3].w));return sk_color_space_transform" |
| "(halfColor,flags,srcKind,gamutTransform,dstKind,coeffs);}}$pure float $tile" |
| "(int tileMode,float f,float low,float high){switch(tileMode){case 0:return clamp" |
| "(f,low,high);case 1:{float length=high-low;return mod(f-low,length)+low;}case" |
| " 2:{float length=high-low;float length2=2.*length;float tmp=mod(f-low,length2" |
| ");return mix(tmp,length2-tmp,step(length,tmp))+low;}default:return f;}}$pure" |
| " half4 $sample_image(float2 pos,float2 invImgSize,sampler2D s){return sample" |
| "(s,pos*invImgSize);}$pure half4 $sample_image_subset(float2 pos,float2 invImgSize" |
| ",float4 subset,int tileModeX,int tileModeY,int filterMode,float2 linearFilterInset" |
| ",sampler2D s){if(tileModeX==$kTileModeDecal&&filterMode==$kFilterModeNearest" |
| "){float snappedX=floor(pos.x)+.5;if(snappedX<subset.x||snappedX>subset.z)return" |
| " half4(0.);}if(tileModeY==$kTileModeDecal&&filterMode==$kFilterModeNearest)" |
| "{float snappedY=floor(pos.y)+.5;if(snappedY<subset.y||snappedY>subset.w)return" |
| " half4(0.);}pos.x=$tile(tileModeX,pos.x,subset.x,subset.z);pos.y=$tile(tileModeY" |
| ",pos.y,subset.y,subset.w);float4 insetClamp;if(filterMode==$kFilterModeNearest" |
| ")insetClamp=float4(floor(subset.xy)+$kLinearInset,ceil(subset.zw)-$kLinearInset" |
| ");else insetClamp=float4(subset.xy+linearFilterInset.x,subset.zw-linearFilterInset" |
| ".y);float2 clampedPos=clamp(pos,insetClamp.xy,insetClamp.zw);half4 color=$sample_image" |
| "(clampedPos,invImgSize,s);if(filterMode==$kFilterModeLinear){half2 error=half2" |
| "(pos-clampedPos);half2 absError=abs(error);bool sampleExtraX=tileModeX==$kTileModeRepeat" |
| ";bool sampleExtraY=tileModeY==$kTileModeRepeat;if(sampleExtraX||sampleExtraY" |
| "){float extraCoordX;float extraCoordY;half4 extraColorX;half4 extraColorY;if" |
| "(sampleExtraX){extraCoordX=error.x>0.?insetClamp.x:insetClamp.z;extraColorX" |
| "=$sample_image(float2(extraCoordX,clampedPos.y),invImgSize,s);}if(sampleExtraY" |
| "){extraCoordY=error.y>0.?insetClamp.y:insetClamp.w;extraColorY=$sample_image" |
| "(float2(clampedPos.x,extraCoordY),invImgSize,s);}if(sampleExtraX&&sampleExtraY" |
| "){half4 extraColorXY=$sample_image(float2(extraCoordX,extraCoordY),invImgSize" |
| ",s);color=mix(mix(color,extraColorX,absError.x),mix(extraColorY,extraColorXY" |
| ",absError.x),absError.y);}else if(sampleExtraX)color=mix(color,extraColorX," |
| "absError.x);else if(sampleExtraY)color=mix(color,extraColorY,absError.y);}if" |
| "(tileModeX==$kTileModeDecal)color*=max(1.-absError.x,0.);if(tileModeY==$kTileModeDecal" |
| ")color*=max(1.-absError.y,0.);}return color;}$pure half4 $cubic_filter_image" |
| "(float2 pos,float2 invImgSize,float4 subset,int tileModeX,int tileModeY,half4x4" |
| " coeffs,sampler2D s){float2 f=fract(pos-.5);pos-=1.5;pos=floor(pos)+.5;half4" |
| " wx=coeffs*half4(1.,half(f.x),half(f.x*f.x),half((f.x*f.x)*f.x));half4 wy=coeffs" |
| "*half4(1.,half(f.y),half(f.y*f.y),half((f.y*f.y)*f.y));half4 color=half4(0." |
| ");for(int y=0;y<4;++y){half4 rowColor=half4(0.);for(int x=0;x<4;++x)rowColor" |
| "+=wx[x]*$sample_image_subset(pos+float2(float(x),float(y)),invImgSize,subset" |
| ",tileModeX,tileModeY,$kFilterModeNearest,float2(.50001),s);color+=wy[y]*rowColor" |
| ";}color.w=saturate(color.w);color.xyz=clamp(color.xyz,half3(0.),color.www);" |
| "return color;}$pure half4 sk_image_shader(float2 coords,float2 invImgSize,float4" |
| " subset,int tileModeX,int tileModeY,int filterMode,int csXformFlags,int csXformSrcKind" |
| ",half3x3 csXformGamutTransform,int csXformDstKind,half4x4 csXformCoeffs,sampler2D" |
| " s){half4 sampleColor=$sample_image_subset(coords,invImgSize,subset,tileModeX" |
| ",tileModeY,filterMode,float2(.50001),s);return $color_space_transform_swizzle" |
| "(sampleColor,csXformFlags,csXformSrcKind,csXformGamutTransform,csXformDstKind" |
| ",csXformCoeffs);}$pure half4 sk_cubic_image_shader(float2 coords,float2 invImgSize" |
| ",float4 subset,int tileModeX,int tileModeY,half4x4 cubicCoeffs,int csXformFlags" |
| ",int csXformSrcKind,half3x3 csXformGamutTransform,int csXformDstKind,half4x4" |
| " csXformCoeffs,sampler2D s){half4 sampleColor=$cubic_filter_image(coords,invImgSize" |
| ",subset,tileModeX,tileModeY,cubicCoeffs,s);return $color_space_transform_swizzle" |
| "(sampleColor,csXformFlags,csXformSrcKind,csXformGamutTransform,csXformDstKind" |
| ",csXformCoeffs);}$pure half4 sk_hw_image_shader(float2 coords,float2 invImgSize" |
| ",int csXformFlags,int csXformSrcKind,half3x3 csXformGamutTransform,int csXformDstKind" |
| ",half4x4 csXformCoeffs,sampler2D s){half4 sampleColor=$sample_image(coords," |
| "invImgSize,s);return $color_space_transform_swizzle(sampleColor,csXformFlags" |
| ",csXformSrcKind,csXformGamutTransform,csXformDstKind,csXformCoeffs);}$pure half4" |
| " $yuv_to_rgb(half4 sampleColorY,half4 sampleColorU,half4 sampleColorV,half4" |
| " sampleColorA,half4 channelSelectY,half4 channelSelectU,half4 channelSelectV" |
| ",half4 channelSelectA,half3x3 yuvToRGBMatrix,float3 yuvToRGBTranslate){float" |
| " Y=float(dot(channelSelectY,sampleColorY));float U=float(dot(channelSelectU" |
| ",sampleColorU));float V=float(dot(channelSelectV,sampleColorV));half3 preColor" |
| "=half3(half(Y),half(U),half(V));half4 sampleColor;sampleColor.xyz=saturate(" |
| "yuvToRGBMatrix*preColor+half3(yuvToRGBTranslate));sampleColor.w=dot(channelSelectA" |
| ",sampleColorA);sampleColor.xyz*=sampleColor.w;return sampleColor;}$pure half4" |
| " sk_yuv_image_shader(float2 coords,float2 invImgSizeY,float2 invImgSizeUV,float4" |
| " subset,float2 linearFilterUVInset,int tileModeX,int tileModeY,int filterModeY" |
| ",int filterModeUV,half4 channelSelectY,half4 channelSelectU,half4 channelSelectV" |
| ",half4 channelSelectA,half3x3 yuvToRGBMatrix,float3 yuvToRGBTranslate,sampler2D" |
| " sY,sampler2D sU,sampler2D sV,sampler2D sA){if(filterModeY!=filterModeUV)coords" |
| "=floor(coords)+.5;int tileModeX_UV=tileModeX==$kTileModeDecal?$kTileModeClamp" |
| ":tileModeX;int tileModeY_UV=tileModeY==$kTileModeDecal?$kTileModeClamp:tileModeY" |
| ";half4 sampleColorY;half4 sampleColorU;half4 sampleColorV;half4 sampleColorA" |
| ";sampleColorY=$sample_image_subset(coords,invImgSizeY,subset,tileModeX,tileModeY" |
| ",filterModeY,float2(.50001),sY);sampleColorU=$sample_image_subset(coords,invImgSizeUV" |
| ",subset,tileModeX_UV,tileModeY_UV,filterModeUV,linearFilterUVInset,sU);sampleColorV" |
| "=$sample_image_subset(coords,invImgSizeUV,subset,tileModeX_UV,tileModeY_UV," |
| "filterModeUV,linearFilterUVInset,sV);if(channelSelectA==half4(1.))sampleColorA" |
| "=half4(0.,0.,0.,1.);else sampleColorA=$sample_image_subset(coords,invImgSizeY" |
| ",subset,tileModeX,tileModeY,filterModeY,float2(.50001),sA);return $yuv_to_rgb" |
| "(sampleColorY,sampleColorU,sampleColorV,sampleColorA,channelSelectY,channelSelectU" |
| ",channelSelectV,channelSelectA,yuvToRGBMatrix,yuvToRGBTranslate);}$pure half4" |
| " sk_cubic_yuv_image_shader(float2 coords,float2 invImgSizeY,float2 invImgSizeUV" |
| ",float4 subset,int tileModeX,int tileModeY,half4x4 cubicCoeffs,half4 channelSelectY" |
| ",half4 channelSelectU,half4 channelSelectV,half4 channelSelectA,half3x3 yuvToRGBMatrix" |
| ",float3 yuvToRGBTranslate,sampler2D sY,sampler2D sU,sampler2D sV,sampler2D sA" |
| "){int tileModeX_UV=tileModeX==$kTileModeDecal?$kTileModeClamp:tileModeX;int" |
| " tileModeY_UV=tileModeY==$kTileModeDecal?$kTileModeClamp:tileModeY;half4 sampleColorY" |
| ";half4 sampleColorU;half4 sampleColorV;half4 sampleColorA;sampleColorY=$cubic_filter_image" |
| "(coords,invImgSizeY,subset,tileModeX,tileModeY,cubicCoeffs,sY);sampleColorU" |
| "=$cubic_filter_image(coords,invImgSizeUV,subset,tileModeX_UV,tileModeY_UV,cubicCoeffs" |
| ",sU);sampleColorV=$cubic_filter_image(coords,invImgSizeUV,subset,tileModeX_UV" |
| ",tileModeY_UV,cubicCoeffs,sV);if(channelSelectA==half4(1.))sampleColorA=half4" |
| "(0.,0.,0.,1.);else sampleColorA=$cubic_filter_image(coords,invImgSizeY,subset" |
| ",tileModeX,tileModeY,cubicCoeffs,sA);return $yuv_to_rgb(sampleColorY,sampleColorU" |
| ",sampleColorV,sampleColorA,channelSelectY,channelSelectU,channelSelectV,channelSelectA" |
| ",yuvToRGBMatrix,yuvToRGBTranslate);}$pure half4 sk_dither_shader(half4 colorIn" |
| ",float2 coords,half range,sampler2D lut){half value=sample(lut,coords*.125)" |
| ".x-.5;return half4(clamp(colorIn.xyz+value*range,0.,colorIn.w),colorIn.w);}" |
| "$pure float2 $tile_grad(int tileMode,float2 t){switch(tileMode){case 0:t.x=" |
| "saturate(t.x);break;case 1:t.x=fract(t.x);break;case 2:{float t_1=t.x-1.;t." |
| "x=(t_1-2.*floor(t_1*.5))-1.;if(sk_Caps.mustDoOpBetweenFloorAndAbs)t.x=clamp" |
| "(t.x,-1.,1.);t.x=abs(t.x);break;}case 3:if(t.x<0.||t.x>1.)return float2(0.," |
| "-1.);break;}return t;}$pure half4 $colorize_grad_4(float4[4]colorsParam,float4" |
| " offsetsParam,float2 t){if(t.y<0.)return half4(0.);else if(t.x<=offsetsParam" |
| ".x)return half4(colorsParam[0]);else if(t.x<offsetsParam.y)return half4(mix" |
| "(colorsParam[0],colorsParam[1],(t.x-offsetsParam.x)/(offsetsParam.y-offsetsParam" |
| ".x)));else if(t.x<offsetsParam.z)return half4(mix(colorsParam[1],colorsParam" |
| "[2],(t.x-offsetsParam.y)/(offsetsParam.z-offsetsParam.y)));else if(t.x<offsetsParam" |
| ".w)return half4(mix(colorsParam[2],colorsParam[3],(t.x-offsetsParam.z)/(offsetsParam" |
| ".w-offsetsParam.z)));else return half4(colorsParam[3]);}$pure half4 $colorize_grad_8" |
| "(float4[8]colorsParam,float4[2]offsetsParam,float2 t){if(t.y<0.)return half4" |
| "(0.);else if(t.x<offsetsParam[1].x)if(t.x<offsetsParam[0].z)if(t.x<=offsetsParam" |
| "[0].x)return half4(colorsParam[0]);else if(t.x<offsetsParam[0].y)return half4" |
| "(mix(colorsParam[0],colorsParam[1],(t.x-offsetsParam[0].x)/(offsetsParam[0]" |
| ".y-offsetsParam[0].x)));else return half4(mix(colorsParam[1],colorsParam[2]" |
| ",(t.x-offsetsParam[0].y)/(offsetsParam[0].z-offsetsParam[0].y)));else if(t." |
| "x<offsetsParam[0].w)return half4(mix(colorsParam[2],colorsParam[3],(t.x-offsetsParam" |
| "[0].z)/(offsetsParam[0].w-offsetsParam[0].z)));else return half4(mix(colorsParam" |
| "[3],colorsParam[4],(t.x-offsetsParam[0].w)/(offsetsParam[1].x-offsetsParam[" |
| "0].w)));else if(t.x<offsetsParam[1].z)if(t.x<offsetsParam[1].y)return half4" |
| "(mix(colorsParam[4],colorsParam[5],(t.x-offsetsParam[1].x)/(offsetsParam[1]" |
| ".y-offsetsParam[1].x)));else return half4(mix(colorsParam[5],colorsParam[6]" |
| ",(t.x-offsetsParam[1].y)/(offsetsParam[1].z-offsetsParam[1].y)));else if(t." |
| "x<offsetsParam[1].w)return half4(mix(colorsParam[6],colorsParam[7],(t.x-offsetsParam" |
| "[1].z)/(offsetsParam[1].w-offsetsParam[1].z)));else return half4(colorsParam" |
| "[7]);}half4 $colorize_grad_tex(sampler2D colorsAndOffsetsSampler,int numStops" |
| ",float2 t){if(t.y<0.)return half4(0.);else if(t.x==0.)return sampleLod(colorsAndOffsetsSampler" |
| ",float2(0.,.25),0.);else if(t.x==1.)return sampleLod(colorsAndOffsetsSampler" |
| ",float2(1.,.25),0.);else{float low=0.;float high=float(numStops);float invNumStops" |
| "=1./high;for(int loop=1;loop<numStops;loop+=loop){float mid=floor((low+high" |
| ")*.5);float samplePos=(mid+.5)*invNumStops;float2 tmp=float2(sampleLod(colorsAndOffsetsSampler" |
| ",float2(samplePos,.75),0.).xy);float offset=ldexp(tmp.x,int(tmp.y));if(t.x<" |
| "offset)high=mid;else low=mid;}high=(low+1.5)*invNumStops;low=(low+.5)*invNumStops" |
| ";half4 color0=sampleLod(colorsAndOffsetsSampler,float2(low,.25),0.);half4 color1" |
| "=sampleLod(colorsAndOffsetsSampler,float2(high,.25),0.);float2 tmp=float2(sampleLod" |
| "(colorsAndOffsetsSampler,float2(low,.75),0.).xy);float offset0=ldexp(tmp.x," |
| "int(tmp.y));tmp=float2(sampleLod(colorsAndOffsetsSampler,float2(high,.75),0." |
| ").xy);float offset1=ldexp(tmp.x,int(tmp.y));return half4(mix(float4(color0)" |
| ",float4(color1),(t.x-offset0)/(offset1-offset0)));}}$pure float2 $linear_grad_layout" |
| "(float2 pos){return float2(pos.x+1e-05,1.);}$pure float2 $radial_grad_layout" |
| "(float2 pos){float t=length(pos);return float2(t,1.);}$pure float2 $sweep_grad_layout" |
| "(float biasParam,float scaleParam,float2 pos){float angle;if(sk_Caps.atan2ImplementedAsAtanYOverX" |
| ")angle=2.*atan(-pos.y,length(pos)-pos.x);else angle=pos.x!=0.?atan(-pos.y,-" |
| "pos.x):sign(pos.y)*-1.57079637;float t=((angle*.159154937+.5)+biasParam)*scaleParam" |
| ";return float2(t,1.);}$pure float2 $conical_grad_layout(float radius0,float" |
| " dRadius,float a,float invA,float2 pos){if(a==0.&&invA==1.){float t=length(" |
| "pos)*dRadius-radius0;return float2(t,1.);}else{float c=dot(pos,pos)-radius0" |
| "*radius0;float negB=2.*(dRadius*radius0+pos.x);float t;if(a==0.)t=c/negB;else" |
| "{float d=negB*negB-(4.*a)*c;if(d<0.)return float2(0.,-1.);float quadSign=sign" |
| "(1.-dRadius);t=invA*(negB+quadSign*sqrt(d));}float isValid=sign(t*dRadius+radius0" |
| ");return float2(t,isValid);}}$pure half4 sk_linear_grad_4_shader(float2 coords" |
| ",float4[4]colorsParam,float4 offsetsParam,int tileMode,int colorSpace,int doUnpremul" |
| "){float2 t=$linear_grad_layout(coords);t=$tile_grad(tileMode,t);half4 color" |
| "=$colorize_grad_4(colorsParam,offsetsParam,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_linear_grad_8_shader(float2 coords" |
| ",float4[8]colorsParam,float4[2]offsetsParam,int tileMode,int colorSpace,int" |
| " doUnpremul){float2 t=$linear_grad_layout(coords);t=$tile_grad(tileMode,t);" |
| "half4 color=$colorize_grad_8(colorsParam,offsetsParam,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_linear_grad_tex_shader(float2" |
| " coords,int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D colorAndOffsetSampler" |
| "){float2 t=$linear_grad_layout(coords);t=$tile_grad(tileMode,t);half4 color" |
| "=$colorize_grad_tex(colorAndOffsetSampler,numStops,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_radial_grad_4_shader(float2 coords" |
| ",float4[4]colorsParam,float4 offsetsParam,int tileMode,int colorSpace,int doUnpremul" |
| "){float2 t=$radial_grad_layout(coords);t=$tile_grad(tileMode,t);half4 color" |
| "=$colorize_grad_4(colorsParam,offsetsParam,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_radial_grad_8_shader(float2 coords" |
| ",float4[8]colorsParam,float4[2]offsetsParam,int tileMode,int colorSpace,int" |
| " doUnpremul){float2 t=$radial_grad_layout(coords);t=$tile_grad(tileMode,t);" |
| "half4 color=$colorize_grad_8(colorsParam,offsetsParam,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_radial_grad_tex_shader(float2" |
| " coords,int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D colorAndOffsetSampler" |
| "){float2 t=$radial_grad_layout(coords);t=$tile_grad(tileMode,t);half4 color" |
| "=$colorize_grad_tex(colorAndOffsetSampler,numStops,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_sweep_grad_4_shader(float2 coords" |
| ",float4[4]colorsParam,float4 offsetsParam,float biasParam,float scaleParam," |
| "int tileMode,int colorSpace,int doUnpremul){float2 t=$sweep_grad_layout(biasParam" |
| ",scaleParam,coords);t=$tile_grad(tileMode,t);half4 color=$colorize_grad_4(colorsParam" |
| ",offsetsParam,t);return $interpolated_to_rgb_unpremul(color,colorSpace,doUnpremul" |
| ");}$pure half4 sk_sweep_grad_8_shader(float2 coords,float4[8]colorsParam,float4" |
| "[2]offsetsParam,float biasParam,float scaleParam,int tileMode,int colorSpace" |
| ",int doUnpremul){float2 t=$sweep_grad_layout(biasParam,scaleParam,coords);t" |
| "=$tile_grad(tileMode,t);half4 color=$colorize_grad_8(colorsParam,offsetsParam" |
| ",t);return $interpolated_to_rgb_unpremul(color,colorSpace,doUnpremul);}$pure" |
| " half4 sk_sweep_grad_tex_shader(float2 coords,float biasParam,float scaleParam" |
| ",int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D colorAndOffsetSampler" |
| "){float2 t=$sweep_grad_layout(biasParam,scaleParam,coords);t=$tile_grad(tileMode" |
| ",t);half4 color=$colorize_grad_tex(colorAndOffsetSampler,numStops,t);return" |
| " $interpolated_to_rgb_unpremul(color,colorSpace,doUnpremul);}$pure half4 sk_conical_grad_4_shader" |
| "(float2 coords,float4[4]colorsParam,float4 offsetsParam,float radius0Param," |
| "float dRadiusParam,float aParam,float invAParam,int tileMode,int colorSpace" |
| ",int doUnpremul){float2 t=$conical_grad_layout(radius0Param,dRadiusParam,aParam" |
| ",invAParam,coords);t=$tile_grad(tileMode,t);half4 color=$colorize_grad_4(colorsParam" |
| ",offsetsParam,t);return $interpolated_to_rgb_unpremul(color,colorSpace,doUnpremul" |
| ");}$pure half4 sk_conical_grad_8_shader(float2 coords,float4[8]colorsParam," |
| "float4[2]offsetsParam,float radius0Param,float dRadiusParam,float aParam,float" |
| " invAParam,int tileMode,int colorSpace,int doUnpremul){float2 t=$conical_grad_layout" |
| "(radius0Param,dRadiusParam,aParam,invAParam,coords);t=$tile_grad(tileMode,t" |
| ");half4 color=$colorize_grad_8(colorsParam,offsetsParam,t);return $interpolated_to_rgb_unpremul" |
| "(color,colorSpace,doUnpremul);}$pure half4 sk_conical_grad_tex_shader(float2" |
| " coords,float radius0Param,float dRadiusParam,float aParam,float invAParam," |
| "int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D colorAndOffsetSampler" |
| "){float2 t=$conical_grad_layout(radius0Param,dRadiusParam,aParam,invAParam," |
| "coords);t=$tile_grad(tileMode,t);half4 color=$colorize_grad_tex(colorAndOffsetSampler" |
| ",numStops,t);return $interpolated_to_rgb_unpremul(color,colorSpace,doUnpremul" |
| ");}$pure half4 sk_matrix_colorfilter(half4 colorIn,float4x4 m,float4 v,int inHSLA" |
| "){if(bool(inHSLA))colorIn=$rgb_to_hsl(colorIn.xyz,colorIn.w);else colorIn=unpremul" |
| "(colorIn);half4 colorOut=half4(m*float4(colorIn)+v);if(bool(inHSLA))colorOut" |
| "=$hsl_to_rgb(colorOut.xyz,colorOut.w);else{colorOut=saturate(colorOut);colorOut" |
| ".xyz*=colorOut.w;}return colorOut;}$pure half4 $noise_helper(half2 noiseVec" |
| ",half2 stitchData,int stitching,sampler2D permutationSampler){const half kBlockSize" |
| "=256.;half4 floorVal;floorVal.xy=floor(noiseVec);floorVal.zw=floorVal.xy+half2" |
| "(1.);if(bool(stitching))floorVal-=step(stitchData.xyxy,floorVal)*stitchData" |
| ".xyxy;half sampleX=sample(permutationSampler,float2(half2((floorVal.x+.5)*.00390625" |
| ",.5))).x;half sampleY=sample(permutationSampler,float2(half2((floorVal.z+.5" |
| ")*.00390625,.5))).x;half2 latticeIdx=half2(sampleX,sampleY);if(sk_Caps.PerlinNoiseRoundingFix" |
| ")latticeIdx=floor(latticeIdx*half2(255.)+half2(.5))*half2(.003921569);half4" |
| " noiseXCoords=kBlockSize*latticeIdx.xyxy+floorVal.yyww;noiseXCoords*=half4(" |
| ".00390625);return noiseXCoords;}$pure half4 $noise_function(half2 noiseVec," |
| "half4 noiseXCoords,sampler2D noiseSampler){half2 fractVal=fract(noiseVec);half2" |
| " noiseSmooth=smoothstep(0.,1.,fractVal);const half kInv256=.00390625;half4 result" |
| ";for(int channel=0;channel<4;channel++){half chanCoord=(half(channel)+.5)*.25" |
| ";half4 sampleA=sample(noiseSampler,float2(float(noiseXCoords.x),float(chanCoord" |
| ")));half4 sampleB=sample(noiseSampler,float2(float(noiseXCoords.y),float(chanCoord" |
| ")));half4 sampleC=sample(noiseSampler,float2(float(noiseXCoords.w),float(chanCoord" |
| ")));half4 sampleD=sample(noiseSampler,float2(float(noiseXCoords.z),float(chanCoord" |
| ")));half2 tmpFractVal=fractVal;half u=dot((sampleA.yw+sampleA.xz*kInv256)*2." |
| "-1.,tmpFractVal);tmpFractVal.x-=1.;half v=dot((sampleB.yw+sampleB.xz*kInv256" |
| ")*2.-1.,tmpFractVal);half a=mix(u,v,noiseSmooth.x);tmpFractVal.y-=1.;v=dot(" |
| "(sampleC.yw+sampleC.xz*kInv256)*2.-1.,tmpFractVal);tmpFractVal.x+=1.;u=dot(" |
| "(sampleD.yw+sampleD.xz*kInv256)*2.-1.,tmpFractVal);half b=mix(u,v,noiseSmooth" |
| ".x);result[channel]=mix(a,b,noiseSmooth.y);}return result;}$pure half4 perlin_noise_shader" |
| "(float2 coords,float2 baseFrequency,float2 stitchDataIn,int noiseType,int numOctaves" |
| ",int stitching,sampler2D permutationSampler,sampler2D noiseSampler){const int" |
| " kFractalNoise=0;half2 noiseVec=half2((coords+.5)*baseFrequency);half4 color" |
| "=half4(0.);half2 stitchData=half2(stitchDataIn);half ratio=1.;for(int octave" |
| "=0;octave<numOctaves;++octave){half4 noiseXCoords=$noise_helper(noiseVec,stitchData" |
| ",stitching,permutationSampler);half4 tmp=$noise_function(noiseVec,noiseXCoords" |
| ",noiseSampler);if(noiseType!=kFractalNoise)tmp=abs(tmp);color+=tmp*ratio;noiseVec" |
| "*=half2(2.);ratio*=.5;stitchData*=half2(2.);}if(noiseType==kFractalNoise)color" |
| "=color*half4(.5)+half4(.5);color=saturate(color);return half4(color.xyz*color" |
| ".www,color.w);}$pure half4 sk_blend(half4 src,half4 dst,int blendMode){switch" |
| "(blendMode){case 0:return blend_clear(src,dst);case 1:return blend_src(src," |
| "dst);case 2:return blend_dst(src,dst);case 3:return blend_porter_duff(half4" |
| "(1.,0.,0.,-1.),src,dst);case 4:return blend_porter_duff(half4(0.,1.,-1.,0.)" |
| ",src,dst);case 5:return blend_porter_duff(half4(0.,0.,1.,0.),src,dst);case 6" |
| ":return blend_porter_duff(half4(0.,0.,0.,1.),src,dst);case 7:return blend_porter_duff" |
| "(half4(0.,0.,-1.,0.),src,dst);case 8:return blend_porter_duff(half4(0.,0.,0." |
| ",-1.),src,dst);case 9:return blend_porter_duff(half4(0.,0.,1.,-1.),src,dst)" |
| ";case 10:return blend_porter_duff(half4(0.,0.,-1.,1.),src,dst);case 11:return" |
| " blend_porter_duff(half4(0.,0.,-1.,-1.),src,dst);case 12:return blend_porter_duff" |
| "(half4(1.,1.,0.,0.),src,dst);case 13:return blend_modulate(src,dst);case 14" |
| ":return blend_screen(src,dst);case 15:return blend_overlay(0.,src,dst);case" |
| " 16:return blend_darken(1.,src,dst);case 17:return blend_darken(-1.,src,dst" |
| ");case 18:return blend_color_dodge(src,dst);case 19:return blend_color_burn" |
| "(src,dst);case 20:return blend_overlay(1.,src,dst);case 21:return blend_soft_light" |
| "(src,dst);case 22:return blend_difference(src,dst);case 23:return blend_exclusion" |
| "(src,dst);case 24:return blend_multiply(src,dst);case 25:return blend_hslc(" |
| "half2(0.,1.),src,dst);case 26:return blend_hslc(half2(1.),src,dst);case 27:" |
| "return blend_hslc(half2(0.),src,dst);case 28:return blend_hslc(half2(1.,0.)" |
| ",src,dst);default:return half4(0.);}}$pure half4 sk_coeff_blend(half4 src,half4" |
| " dst,half4 coeffs){return blend_porter_duff(coeffs,src,dst);}$pure half4 sk_table_colorfilter" |
| "(half4 inColor,sampler2D s){half4 coords=unpremul(inColor)*.99609375+.001953125" |
| ";half4 color=half4(sample(s,float2(half2(coords.x,.375))).x,sample(s,float2" |
| "(half2(coords.y,.625))).x,sample(s,float2(half2(coords.z,.875))).x,1.);return" |
| " color*sample(s,float2(half2(coords.w,.125))).x;}$pure half4 sk_gaussian_colorfilter" |
| "(half4 inColor){half factor=1.-inColor.w;factor=exp((-factor*factor)*4.)-.018" |
| ";return half4(factor);}$pure half4 sample_indexed_atlas(float2 textureCoords" |
| ",int atlasIndex,sampler2D atlas0,sampler2D atlas1,sampler2D atlas2,sampler2D" |
| " atlas3){switch(atlasIndex){case 1:return sample(atlas1,textureCoords);case" |
| " 2:return sample(atlas2,textureCoords);case 3:return sample(atlas3,textureCoords" |
| ");default:return sample(atlas0,textureCoords);}}$pure half3 $sample_indexed_atlas_lcd" |
| "(float2 textureCoords,int atlasIndex,half2 offset,sampler2D atlas0,sampler2D" |
| " atlas1,sampler2D atlas2,sampler2D atlas3){half3 distance=half3(1.);switch(" |
| "atlasIndex){case 1:distance.x=sample(atlas1,float2(half2(textureCoords)-offset" |
| ")).x;distance.y=sample(atlas1,textureCoords).x;distance.z=sample(atlas1,float2" |
| "(half2(textureCoords)+offset)).x;case 2:distance.x=sample(atlas2,float2(half2" |
| "(textureCoords)-offset)).x;distance.y=sample(atlas2,textureCoords).x;distance" |
| ".z=sample(atlas2,float2(half2(textureCoords)+offset)).x;case 3:distance.x=sample" |
| "(atlas3,float2(half2(textureCoords)-offset)).x;distance.y=sample(atlas3,textureCoords" |
| ").x;distance.z=sample(atlas3,float2(half2(textureCoords)+offset)).x;default" |
| ":distance.x=sample(atlas0,float2(half2(textureCoords)-offset)).x;distance.y" |
| "=sample(atlas0,textureCoords).x;distance.z=sample(atlas0,float2(half2(textureCoords" |
| ")+offset)).x;}return distance;}$pure half4 bitmap_text_coverage_fn(half4 texColor" |
| ",int maskFormat){return maskFormat==$kMaskFormatA8?texColor.xxxx:texColor;}" |
| "$pure half4 sdf_text_coverage_fn(half texColor,half2 gammaParams,float2 unormTexCoords" |
| "){half dist=7.96875*(texColor-.5019608);dist-=gammaParams.x;half2 dist_grad" |
| "=half2(dFdx(dist),dFdy(dist));half dg_len2=dot(dist_grad,dist_grad);dist_grad" |
| "=dg_len2>=.0001?dist_grad*inversesqrt(dg_len2):half2(.7071);float2x2 jacobian" |
| "=float2x2(dFdx(unormTexCoords),dFdy(unormTexCoords));half2 grad=half2(jacobian" |
| "*float2(dist_grad));half approxFragWidth=.65*length(grad);if(gammaParams.y>" |
| "0.)return half4(saturate((dist+approxFragWidth)/(2.*approxFragWidth)));else" |
| " return half4(smoothstep(-approxFragWidth,approxFragWidth,dist));}$pure half4" |
| " sdf_text_lcd_coverage_fn(float2 textureCoords,half2 pixelGeometryDelta,half4" |
| " gammaParams,float2 unormTexCoords,float texIndex,sampler2D atlas0,sampler2D" |
| " atlas1,sampler2D atlas2,sampler2D atlas3){float2x2 jacobian=float2x2(dFdx(" |
| "unormTexCoords),dFdy(unormTexCoords));half2 offset=half2(jacobian*float2(pixelGeometryDelta" |
| "));half3 distance=$sample_indexed_atlas_lcd(textureCoords,int(texIndex),offset" |
| ",atlas0,atlas1,atlas2,atlas3);half3 dist=half3(7.96875)*(distance-half3(.5019608" |
| "));dist-=gammaParams.xyz;half2 dist_grad=half2(dFdx(dist.y),dFdy(dist.y));half" |
| " dg_len2=dot(dist_grad,dist_grad);dist_grad=dg_len2>=.0001?dist_grad*inversesqrt" |
| "(dg_len2):half2(.7071);half2 grad=half2(jacobian*float2(dist_grad));half3 approxFragWidth" |
| "=half3(.65*length(grad));if(gammaParams.w>0.)return half4(saturate(dist+approxFragWidth" |
| "/(2.*approxFragWidth)),1.);else return half4(smoothstep(-approxFragWidth,approxFragWidth" |
| ",dist),1.);}$pure float $inverse_grad_len(float2 localGrad,float2x2 jacobian" |
| "){float2 devGrad=localGrad*jacobian;return inversesqrt(dot(devGrad,devGrad)" |
| ");}$pure float2 $elliptical_distance(float2 uv,float2 radii,float strokeRadius" |
| ",float2x2 jacobian){float2 invR2=1./(radii*radii+strokeRadius*strokeRadius)" |
| ";float2 normUV=invR2*uv;float invGradLength=$inverse_grad_len(normUV,jacobian" |
| ");float f=(.5*invGradLength)*(dot(uv,normUV)-1.);float width=((radii.x*strokeRadius" |
| ")*invR2.x)*invGradLength;return float2(width-f,width+f);}void $corner_distance" |
| "(inout float2 dist,float2x2 jacobian,float2 strokeParams,float2 cornerEdgeDist" |
| ",float2 xyFlip,float2 radii){float2 uv=radii-cornerEdgeDist;if(all(greaterThan" |
| "(uv,float2(0.))))if(all(greaterThan(radii,float2(0.)))||strokeParams.x>0.&&" |
| "strokeParams.y<0.){float2 d=$elliptical_distance(uv*xyFlip,radii,strokeParams" |
| ".x,jacobian);d.y=radii.x-strokeParams.x<=0.?1.:-d.y;dist=min(dist,d);}else if" |
| "(strokeParams.y==0.){float bevelDist=((strokeParams.x-uv.x)-uv.y)*$inverse_grad_len" |
| "(xyFlip,jacobian);dist.x=min(dist.x,bevelDist);}}void $corner_distances(inout" |
| " float2 d,float2x2 J,float2 stroke,float4 edgeDists,float4 xRadii,float4 yRadii" |
| "){$corner_distance(d,J,stroke,edgeDists.xy,float2(-1.),float2(xRadii.x,yRadii" |
| ".x));$corner_distance(d,J,stroke,edgeDists.zy,float2(1.,-1.),float2(xRadii." |
| "y,yRadii.y));$corner_distance(d,J,stroke,edgeDists.zw,float2(1.),float2(xRadii" |
| ".z,yRadii.z));$corner_distance(d,J,stroke,edgeDists.xw,float2(-1.,1.),float2" |
| "(xRadii.w,yRadii.w));}$pure half4 analytic_rrect_coverage_fn(float4 coords," |
| "float4 jacobian,float4 edgeDistances,float4 xRadii,float4 yRadii,float2 strokeParams" |
| ",float2 perPixelControl){if(perPixelControl.x>0.)return half4(1.);else if(perPixelControl" |
| ".y>1.){float2 outerDist=min(edgeDistances.xy,edgeDistances.zw);float c=min(" |
| "outerDist.x,outerDist.y)*coords.w;float scale=(perPixelControl.y-1.)*coords" |
| ".w;float bias=coverage_bias(scale);return half4(half(saturate(scale*(c+bias" |
| "))));}else{float2x2 J=float2x2(jacobian)*(1./coords.w);float2 invGradLen=float2" |
| "($inverse_grad_len(float2(1.,0.),J),$inverse_grad_len(float2(0.,1.),J));float2" |
| " outerDist=invGradLen*(strokeParams.x+min(edgeDistances.xy,edgeDistances.zw" |
| "));float2 d=float2(min(outerDist.x,outerDist.y),-1.);float scale;float bias" |
| ";if(perPixelControl.x>-.95){float2 dim=invGradLen*((edgeDistances.xy+edgeDistances" |
| ".zw)+2.*strokeParams.xx);scale=min(min(dim.x,dim.y),1.);bias=coverage_bias(" |
| "scale);}else{float2 strokeWidth=(2.*strokeParams.x)*invGradLen;float2 innerDist" |
| "=strokeWidth-outerDist;d.y=-max(innerDist.x,innerDist.y);if(strokeParams.x>" |
| "0.){float narrowStroke=min(strokeWidth.x,strokeWidth.y);float2 strokeDim=mix" |
| "(float2(narrowStroke),strokeWidth,greaterThanEqual(innerDist,float2(-.5)));" |
| "scale=saturate(max(strokeDim.x,strokeDim.y));bias=coverage_bias(scale);}else" |
| " scale=(bias=1.);}$corner_distances(d,J,strokeParams,edgeDistances,xRadii,yRadii" |
| ");float outsetDist=min(perPixelControl.y,0.)*coords.w;float finalCoverage=scale" |
| "*(min(d.x+outsetDist,-d.y)+bias);return half4(half(saturate(finalCoverage))" |
| ");}}$pure half4 per_edge_aa_quad_coverage_fn(float4 coords,float4 edgeDistances" |
| "){float2 outerDist=min(edgeDistances.xy,edgeDistances.zw);float c=min(outerDist" |
| ".x,outerDist.y)*coords.w;return half4(half(saturate(c)));}$pure half4 $rect_blur_coverage_fn" |
| "(float2 coords,float4 rect,half isFast,half invSixSigma,sampler2D integral)" |
| "{half xCoverage;half yCoverage;if(isFast!=0.){half2 pos=max(half2(rect.xy-coords" |
| "),half2(coords-rect.zw));xCoverage=sample(integral,float2(float(invSixSigma" |
| "*pos.x),.5)).x;yCoverage=sample(integral,float2(float(invSixSigma*pos.y),.5" |
| ")).x;}else{half4 rect=half4(half2(rect.xy-coords),half2(coords-rect.zw));xCoverage" |
| "=(1.-sample(integral,float2(float(invSixSigma*rect.x),.5)).x)-sample(integral" |
| ",float2(float(invSixSigma*rect.z),.5)).x;yCoverage=(1.-sample(integral,float2" |
| "(float(invSixSigma*rect.y),.5)).x)-sample(integral,float2(float(invSixSigma" |
| "*rect.w),.5)).x;}return half4(xCoverage*yCoverage);}$pure half4 $circle_blur_coverage_fn" |
| "(float2 coords,float4 circle,sampler2D blurProfile){float invTextureRadius=" |
| "circle.z;float normSolidRadius=circle.w;half2 vec=half2((coords-circle.xy)*" |
| "invTextureRadius);float dist=float(length(vec))-normSolidRadius;return sample" |
| "(blurProfile,float2(dist,.5)).xxxx;}$pure half4 $rrect_blur_coverage_fn(float2" |
| " coords,float4 proxyRect,half edgeSize,sampler2D ninePatch){float2 translatedFragPosFloat" |
| "=coords-proxyRect.xy;float2 proxyCenter=(proxyRect.zw-proxyRect.xy)*.5;translatedFragPosFloat" |
| "-=proxyCenter;half2 fragDirection=half2(sign(translatedFragPosFloat));translatedFragPosFloat" |
| "=abs(translatedFragPosFloat);half2 translatedFragPosHalf=half2(translatedFragPosFloat" |
| "-(proxyCenter-float(edgeSize)));translatedFragPosHalf=max(translatedFragPosHalf" |
| ",0.);translatedFragPosHalf*=fragDirection;translatedFragPosHalf+=half2(edgeSize" |
| ");half2 proxyDims=half2(2.*edgeSize);half2 texCoord=translatedFragPosHalf/proxyDims" |
| ";return sample(ninePatch,float2(texCoord)).xxxx;}$pure half4 blur_coverage_fn" |
| "(float2 coords,float4 shapeData,half2 blurData,int shapeType,sampler2D s){switch" |
| "(shapeType){case 0:{return $rect_blur_coverage_fn(coords,shapeData,blurData" |
| ".x,blurData.y,s);}case 2:{return $circle_blur_coverage_fn(coords,shapeData," |
| "s);}case 1:{return $rrect_blur_coverage_fn(coords,shapeData,blurData.x,s);}" |
| "}return half4(0.);}"; |
