| static constexpr char SKSL_MINIFIED_sksl_graphite_frag[] = |
| "const int $kTileModeRepeat=1;const int $kTileModeDecal=3;const int $kReadSwizzleNormalRGBA" |
| "=0;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;$pure half4 sk_error(){return half4" |
| "(1.,0.,1.,1.);}$pure half4 sk_passthrough(half4 color){return color;}$pure half4" |
| " sk_solid_shader(float4 colorParam){return half4(colorParam);}$pure half4 $apply_swizzle" |
| "(int swizzleType,half4 color){switch(swizzleType){case 1:return half4(color" |
| ".xyz,1.);case 2:return color.xxxx;case 3:return half4(color.xxx,1.);case 4:" |
| "return color.zyxw;default:return color;}}$pure float $apply_xfer_fn(int kind" |
| ",float x,half[7]cs){float G=float(cs[0]);float A=float(cs[1]);float B=float" |
| "(cs[2]);float C=float(cs[3]);float D=float(cs[4]);float E=float(cs[5]);float" |
| " F=float(cs[6]);float s=sign(x);x=abs(x);switch(kind){case 1:x=x<D?C*x+F:pow" |
| "(A*x+B,G)+E;break;case 2:x=pow(max(A+B*pow(x,C),0.)/(D+E*pow(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,half[7]srcCoeffs,half3x3 gamutTransform" |
| ",int dstKind,half[7]dstCoeffs){float4 color=float4(halfColor);if(bool(flags" |
| "&$kColorSpaceXformFlagUnpremul)){color=unpremul(color);}if(bool(flags&$kColorSpaceXformFlagLinearize" |
| ")){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)){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 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 imgSize,float4 subset,int tileModeX,int tileModeY,int filterMode" |
| ",int readSwizzle,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)+.5,ceil(subset.zw)-.5);}else{insetClamp" |
| "=float4(subset.xy+.5,subset.zw-.5);}float2 clampedPos=clamp(pos,insetClamp." |
| "xy,insetClamp.zw);half4 color=sample(s,clampedPos/imgSize);color=$apply_swizzle" |
| "(readSwizzle,color);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(s,float2(extraCoordX,clampedPos.y)/imgSize);extraColorX=$apply_swizzle" |
| "(readSwizzle,extraColorX);}if(sampleExtraY){extraCoordY=error.y>0.?insetClamp" |
| ".y:insetClamp.w;extraColorY=sample(s,float2(clampedPos.x,extraCoordY)/imgSize" |
| ");extraColorY=$apply_swizzle(readSwizzle,extraColorY);}if(sampleExtraX&&sampleExtraY" |
| "){half4 extraColorXY=sample(s,float2(extraCoordX,extraCoordY)/imgSize);extraColorXY" |
| "=$apply_swizzle(readSwizzle,extraColorXY);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 imgSize" |
| ",float4 subset,int tileModeX,int tileModeY,half4x4 coeffs,int readSwizzle,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" |
| "(pos+float2(float(x),float(y)),imgSize,subset,tileModeX,tileModeY,$kFilterModeNearest" |
| ",readSwizzle,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 imgSize,float4 subset,int tileModeX,int tileModeY,int" |
| " filterMode,int readSwizzle,int csXformFlags,int csXformSrcKind,half[7]csXformSrcCoeffs" |
| ",half3x3 csXformGamutTransform,int csXformDstKind,half[7]csXformDstCoeffs,sampler2D" |
| " s){half4 sampleColor=$sample_image(coords,imgSize,subset,tileModeX,tileModeY" |
| ",filterMode,readSwizzle,s);return sk_color_space_transform(sampleColor,csXformFlags" |
| ",csXformSrcKind,csXformSrcCoeffs,csXformGamutTransform,csXformDstKind,csXformDstCoeffs" |
| ");}$pure half4 sk_cubic_image_shader(float2 coords,float2 imgSize,float4 subset" |
| ",int tileModeX,int tileModeY,half4x4 cubicCoeffs,int readSwizzle,int csXformFlags" |
| ",int csXformSrcKind,half[7]csXformSrcCoeffs,half3x3 csXformGamutTransform,int" |
| " csXformDstKind,half[7]csXformDstCoeffs,sampler2D s){half4 sampleColor=$cubic_filter_image" |
| "(coords,imgSize,subset,tileModeX,tileModeY,cubicCoeffs,readSwizzle,s);return" |
| " sk_color_space_transform(sampleColor,csXformFlags,csXformSrcKind,csXformSrcCoeffs" |
| ",csXformGamutTransform,csXformDstKind,csXformDstCoeffs);}$pure half4 sk_yuv_image_shader" |
| "(float2 coords,float2 imgSize,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,half[7]csXformSrcCoeffs,half3x3 csXformGamutTransform" |
| ",int csXformDstKind,half[7]csXformDstCoeffs,sampler2D sY,sampler2D sU,sampler2D" |
| " sV,sampler2D sA){half4 sampleColorY=useCubic!=0?$cubic_filter_image(coords" |
| ",imgSize,subset,tileModeX,tileModeY,cubicCoeffs,$kReadSwizzleNormalRGBA,sY)" |
| ":$sample_image(coords,imgSize,subset,tileModeX,tileModeY,filterMode,$kReadSwizzleNormalRGBA" |
| ",sY);half4 sampleColorU=useCubic!=0?$cubic_filter_image(coords,imgSize,subset" |
| ",tileModeX,tileModeY,cubicCoeffs,$kReadSwizzleNormalRGBA,sU):$sample_image(" |
| "coords,imgSize,subset,tileModeX,tileModeY,filterMode,$kReadSwizzleNormalRGBA" |
| ",sU);half4 sampleColorV=useCubic!=0?$cubic_filter_image(coords,imgSize,subset" |
| ",tileModeX,tileModeY,cubicCoeffs,$kReadSwizzleNormalRGBA,sY):$sample_image(" |
| "coords,imgSize,subset,tileModeX,tileModeY,filterMode,$kReadSwizzleNormalRGBA" |
| ",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(" |
| "preColor*yuvToRGBMatrix+half3(yuvToRGBTranslate));if(channelSelectA==half4(" |
| "0.)){sampleColor.w=1.;}else{half4 sampleColorA=useCubic!=0?$cubic_filter_image" |
| "(coords,imgSize,subset,tileModeX,tileModeY,cubicCoeffs,$kReadSwizzleNormalRGBA" |
| ",sA):$sample_image(coords,imgSize,subset,tileModeX,tileModeY,filterMode,$kReadSwizzleNormalRGBA" |
| ",sA);sampleColor.w=dot(channelSelectA,sampleColorA);sampleColor.xyz*=sampleColor" |
| ".w;}return sk_color_space_transform(sampleColor,csXformFlags,csXformSrcKind" |
| ",csXformSrcCoeffs,csXformGamutTransform,csXformDstKind,csXformDstCoeffs);}$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){switch(maskFormat){case 0:return texColor.xxxx;case 1:return" |
| " half4(texColor.xyz,max(max(texColor.x,texColor.y),texColor.z));default:return" |
| " 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(uv.x>0.&&uv." |
| "y>0.){if(radii.x>0.&&radii.y>0.||strokeParams.x>0.&&strokeParams.y<0.){float2" |
| " d=$elliptical_distance(uv*xyFlip,radii,strokeParams.x,jacobian);if(radii.x" |
| "-strokeParams.x<=0.){d.y=1.;}else{d.y*=-1.;}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)));}}"; |
