| static constexpr char SKSL_MINIFIED_sksl_graphite_frag[] = |
| "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" |
| ";}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,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+$kLinearInset" |
| ",subset.zw-$kLinearInset);}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" |
| ",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,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" |
| " sk_yuv_image_shader(float2 coords,float2 invImgSize,float4 subset,int tileModeX" |
| ",int tileModeY,int filterMode,int useCubic,half4x4 cubicCoeffs,half4 channelSelectY" |
| ",half4 channelSelectU,half4 channelSelectV,half4 channelSelectA,half3x3 yuvToRGBMatrix" |
| ",float3 yuvToRGBTranslate,int csXformFlags,int csXformSrcKind,half3x3 csXformGamutTransform" |
| ",int csXformDstKind,half4x4 csXformCoeffs,sampler2D sY,sampler2D sU,sampler2D" |
| " sV,sampler2D sA){half4 sampleColorY;half4 sampleColorU;half4 sampleColorV;" |
| "if(useCubic!=0){sampleColorY=$cubic_filter_image(coords,invImgSize,subset,tileModeX" |
| ",tileModeY,cubicCoeffs,sY);sampleColorU=$cubic_filter_image(coords,invImgSize" |
| ",subset,tileModeX,tileModeY,cubicCoeffs,sU);sampleColorV=$cubic_filter_image" |
| "(coords,invImgSize,subset,tileModeX,tileModeY,cubicCoeffs,sV);}else{sampleColorY" |
| "=$sample_image_subset(coords,invImgSize,subset,tileModeX,tileModeY,filterMode" |
| ",sY);sampleColorU=$sample_image_subset(coords,invImgSize,subset,tileModeX,tileModeY" |
| ",filterMode,sU);sampleColorV=$sample_image_subset(coords,invImgSize,subset," |
| "tileModeX,tileModeY,filterMode,sV);}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))" |
| ";if(channelSelectA==half4(0.)){sampleColor.w=1.;}else{half4 sampleColorA=useCubic" |
| "!=0?$cubic_filter_image(coords,invImgSize,subset,tileModeX,tileModeY,cubicCoeffs" |
| ",sA):$sample_image_subset(coords,invImgSize,subset,tileModeX,tileModeY,filterMode" |
| ",sA);sampleColor.w=dot(channelSelectA,sampleColorA);sampleColor.xyz*=sampleColor" |
| ".w;}return sk_color_space_transform(sampleColor,csXformFlags,csXformSrcKind" |
| ",csXformGamutTransform,csXformDstKind,csXformCoeffs);}$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{int low=0;int high" |
| "=numStops;for(int loop=1;loop<numStops;loop<<=1){int mid=(low+high)/2;float" |
| " midFlt=(float(mid)+.5)/float(numStops);float2 tmp=float2(sampleLod(colorsAndOffsetsSampler" |
| ",float2(midFlt,.75),0.).xy);float offset=ldexp(tmp.x,int(tmp.y));if(t.x<offset" |
| "){high=mid;}else{low=mid;}}float lowFlt=(float(low)+.5)/float(numStops);float" |
| " highFlt=(float(low+1)+.5)/float(numStops);half4 color0=sampleLod(colorsAndOffsetsSampler" |
| ",float2(lowFlt,.25),0.);half4 color1=sampleLod(colorsAndOffsetsSampler,float2" |
| "(highFlt,.25),0.);float2 tmp=float2(sampleLod(colorsAndOffsetsSampler,float2" |
| "(lowFlt,.75),0.).xy);float offset0=ldexp(tmp.x,int(tmp.y));tmp=float2(sampleLod" |
| "(colorsAndOffsetsSampler,float2(highFlt,.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 point0Param," |
| "float2 point1Param,float2 pos){pos-=point0Param;float2 delta=point1Param-point0Param" |
| ";float t=dot(pos,delta)/dot(delta,delta);return float2(t,1.);}$pure float2 $radial_grad_layout" |
| "(float2 centerParam,float radiusParam,float2 pos){float t=distance(pos,centerParam" |
| ")/radiusParam;return float2(t,1.);}$pure float2 $sweep_grad_layout(float2 centerParam" |
| ",float biasParam,float scaleParam,float2 pos){pos-=centerParam;float angle=" |
| "sk_Caps.atan2ImplementedAsAtanYOverX?2.*atan(-pos.y,length(pos)-pos.x):atan" |
| "(-pos.y,-pos.x);float t=((angle*.159154937+.5)+biasParam)*scaleParam;return" |
| " float2(t,1.);}$pure float3x3 $map_to_unit_x(float2 p0,float2 p1){return float3x3" |
| "(0.,-1.,0.,1.,0.,0.,0.,0.,1.)*inverse(float3x3(p1.y-p0.y,p0.x-p1.x,0.,p1.x-" |
| "p0.x,p1.y-p0.y,0.,p0.x,p0.y,1.));}$pure float2 $conical_grad_layout(float2 point0Param" |
| ",float2 point1Param,float radius0Param,float radius1Param,float2 pos){const" |
| " float SK_ScalarNearlyZero=.000244140625;float dCenter=distance(point0Param" |
| ",point1Param);float dRadius=radius1Param-radius0Param;bool radial=dCenter<SK_ScalarNearlyZero" |
| ";bool strip=abs(dRadius)<SK_ScalarNearlyZero;if(radial){if(strip){return float2" |
| "(0.,-1.);}float scale=1./dRadius;float scaleSign=sign(dRadius);float bias=radius0Param" |
| "/dRadius;float2 pt=(pos-point0Param)*scale;float t=length(pt)*scaleSign-bias" |
| ";return float2(t,1.);}else if(strip){float3x3 transform=$map_to_unit_x(point0Param" |
| ",point1Param);float r=radius0Param/dCenter;float r_2=r*r;float2 pt=(transform" |
| "*float3(pos,1.)).xy;float t=r_2-pt.y*pt.y;if(t<0.){return float2(0.,-1.);}t" |
| "=pt.x+sqrt(t);return float2(t,1.);}else{float f=radius0Param/(radius0Param-" |
| "radius1Param);bool isSwapped=abs(f-1.)<SK_ScalarNearlyZero;if(isSwapped){float2" |
| " tmpPt=point0Param;point0Param=point1Param;point1Param=tmpPt;f=0.;}float2 Cf" |
| "=mix(point0Param,point1Param,f);float3x3 transform=$map_to_unit_x(Cf,point1Param" |
| ");float scaleX=abs(1.-f);float scaleY=scaleX;float r1=abs(radius1Param-radius0Param" |
| ")/dCenter;bool isFocalOnCircle=abs(r1-1.)<SK_ScalarNearlyZero;if(isFocalOnCircle" |
| "){scaleX*=.5;scaleY*=.5;}else{scaleX*=r1/(r1*r1-1.);scaleY/=sqrt(abs(r1*r1-" |
| "1.));}transform=float3x3(scaleX,0.,0.,0.,scaleY,0.,0.,0.,1.)*transform;float2" |
| " pt=(transform*float3(pos,1.)).xy;float invR1=1./r1;float dRadiusSign=sign(" |
| "1.-f);bool isWellBehaved=!isFocalOnCircle&&r1>1.;float x_t=-1.;if(isFocalOnCircle" |
| "){x_t=dot(pt,pt)/pt.x;}else if(isWellBehaved){x_t=length(pt)-pt.x*invR1;}else" |
| "{float temp=pt.x*pt.x-pt.y*pt.y;if(temp>=0.){if(isSwapped||dRadiusSign<0.){" |
| "x_t=-sqrt(temp)-pt.x*invR1;}else{x_t=sqrt(temp)-pt.x*invR1;}}}if(!isWellBehaved" |
| "&&x_t<0.){return float2(0.,-1.);}float t=f+dRadiusSign*x_t;if(isSwapped){t=" |
| "1.-t;}return float2(t,1.);}}$pure half4 sk_linear_grad_4_shader(float2 coords" |
| ",float4[4]colorsParam,float4 offsetsParam,float2 point0Param,float2 point1Param" |
| ",int tileMode,int colorSpace,int doUnpremul){float2 t=$linear_grad_layout(point0Param" |
| ",point1Param,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,float2 point0Param,float2 point1Param,int tileMode,int" |
| " colorSpace,int doUnpremul){float2 t=$linear_grad_layout(point0Param,point1Param" |
| ",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,float2 point0Param,float2" |
| " point1Param,int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D" |
| " colorAndOffsetSampler){float2 t=$linear_grad_layout(point0Param,point1Param" |
| ",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,float2 centerParam,float radiusParam,int tileMode,int colorSpace" |
| ",int doUnpremul){float2 t=$radial_grad_layout(centerParam,radiusParam,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,float2 centerParam,float radiusParam,int tileMode,int colorSpace" |
| ",int doUnpremul){float2 t=$radial_grad_layout(centerParam,radiusParam,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,float2 centerParam,float radiusParam" |
| ",int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D colorAndOffsetSampler" |
| "){float2 t=$radial_grad_layout(centerParam,radiusParam,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" |
| ",float2 centerParam,float biasParam,float scaleParam,int tileMode,int colorSpace" |
| ",int doUnpremul){float2 t=$sweep_grad_layout(centerParam,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,float2 centerParam,float biasParam,float scaleParam,int tileMode" |
| ",int colorSpace,int doUnpremul){float2 t=$sweep_grad_layout(centerParam,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,float2 centerParam,float" |
| " biasParam,float scaleParam,int numStops,int tileMode,int colorSpace,int doUnpremul" |
| ",sampler2D colorAndOffsetSampler){float2 t=$sweep_grad_layout(centerParam,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,float2 point0Param,float2 point1Param" |
| ",float radius0Param,float radius1Param,int tileMode,int colorSpace,int doUnpremul" |
| "){float2 t=$conical_grad_layout(point0Param,point1Param,radius0Param,radius1Param" |
| ",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,float2 point0Param,float2 point1Param,float radius0Param" |
| ",float radius1Param,int tileMode,int colorSpace,int doUnpremul){float2 t=$conical_grad_layout" |
| "(point0Param,point1Param,radius0Param,radius1Param,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,float2 point0Param,float2 point1Param,float radius0Param,float radius1Param" |
| ",int numStops,int tileMode,int colorSpace,int doUnpremul,sampler2D colorAndOffsetSampler" |
| "){float2 t=$conical_grad_layout(point0Param,point1Param,radius0Param,radius1Param" |
| ",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*.00390625,.5))).x;half sampleY=sample(permutationSampler,float2(half2(floorVal" |
| ".z*.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" |
| "=(fractVal*fractVal)*(half2(3.)-2.*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(half2(noiseXCoords.x,chanCoord" |
| ")));half4 sampleB=sample(noiseSampler,float2(half2(noiseXCoords.y,chanCoord" |
| ")));half4 sampleC=sample(noiseSampler,float2(half2(noiseXCoords.w,chanCoord" |
| ")));half4 sampleD=sample(noiseSampler,float2(half2(noiseXCoords.z,chanCoord" |
| ")));half2 uv;half2 tmpFractVal=fractVal;uv.x=dot((sampleA.yw+sampleA.xz*kInv256" |
| ")*2.-half2(1.),tmpFractVal);tmpFractVal.x-=1.;uv.y=dot((sampleB.yw+sampleB." |
| "xz*kInv256)*2.-half2(1.),tmpFractVal);half2 ab;ab.x=mix(uv.x,uv.y,noiseSmooth" |
| ".x);tmpFractVal.y-=1.;uv.y=dot((sampleC.yw+sampleC.xz*kInv256)*2.-half2(1.)" |
| ",tmpFractVal);tmpFractVal.x+=1.;uv.x=dot((sampleD.yw+sampleD.xz*kInv256)*2." |
| "-half2(1.),tmpFractVal);ab.y=mix(uv.x,uv.y,noiseSmooth.x);result[channel]=mix" |
| "(ab.x,ab.y,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_Type=0;half2 noiseVec=half2(floor(coords)*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_Type){tmp=abs(tmp);" |
| "}tmp*=ratio;color+=tmp;noiseVec*=half2(2.);ratio*=.5;stitchData*=half2(2.);" |
| "}if(noiseType==kFractalNoise_Type){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)*255.)*.00390625+.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 half4 bitmap_text_coverage_fn(half4 texColor" |
| ",int maskFormat){return maskFormat==$kMaskFormatA8?texColor.xxxx:texColor;}" |
| "$pure half4 sdf_text_coverage_fn(half texColor,half distAdjust,float2 unormTexCoords" |
| "){half dist=7.96875*(texColor-.5019608);dist-=distAdjust;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);half2 Jdx=half2(dFdx(unormTexCoords" |
| "));half2 Jdy=half2(dFdy(unormTexCoords));half2 grad=half2(dist_grad.x*Jdx.x" |
| "+dist_grad.y*Jdy.x,dist_grad.x*Jdx.y+dist_grad.y*Jdy.y);half afwidth=.65*length" |
| "(grad);return half4(smoothstep(-afwidth,afwidth,dist));}$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 strokeDim=min(strokeWidth.x,strokeWidth.y);if(innerDist" |
| ".y>=-.5&&strokeWidth.y>strokeDim){strokeDim=strokeWidth.y;}if(innerDist.x>=" |
| "-.5&&strokeWidth.x>strokeDim){strokeDim=strokeWidth.x;}scale=min(strokeDim," |
| "1.);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)));}"; |
