Remove SkBlendMode from SkSL
We've lived without this for a long time. It bloats sksl_gpu (inhibits some inlining!), and if things go according to plan, we'll be removing enum support from SkSL entirely soon. Change-Id: If844bbe5fdae41df7930d5c8ea9b832f9dd1b922 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/419099 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
This commit is contained in:
Brian Osman
Skia Commit-Bot
parent
c804b740b8
commit
3e4ef49890
@ -531,7 +531,6 @@ sksl_blend_tests = [
|
||||
"/sksl/blend/BlendDstIn.sksl",
|
||||
"/sksl/blend/BlendDstOut.sksl",
|
||||
"/sksl/blend/BlendDstOver.sksl",
|
||||
"/sksl/blend/BlendEnum.sksl",
|
||||
"/sksl/blend/BlendExclusion.sksl",
|
||||
"/sksl/blend/BlendHardLight.sksl",
|
||||
"/sksl/blend/BlendHue.sksl",
|
||||
|
||||
@ -1,7 +0,0 @@
|
||||
/*#pragma settings Default*/
|
||||
|
||||
uniform half4 src, dst;
|
||||
|
||||
void main() {
|
||||
sk_FragColor = blend(SkBlendMode::kModulate, src, dst);
|
||||
}
|
||||
@ -1 +1,5 @@
|
||||
SkBlendMode w=0;
|
||||
enum class E {
|
||||
kZero = 0
|
||||
};
|
||||
|
||||
E e=0;
|
||||
|
||||
@ -30,22 +30,6 @@ void main() {
|
||||
case E::kOne: sk_FragColor = half4(14); break;
|
||||
}
|
||||
|
||||
// Test that built-in enums work equally well.
|
||||
const SkBlendMode m = SkBlendMode::kClear;
|
||||
if (m == SkBlendMode::kClear) { sk_FragColor = half4(15); }
|
||||
@if (m == SkBlendMode::kClear) { sk_FragColor = half4(16); }
|
||||
if (m == SkBlendMode::kSrc) { sk_FragColor = half4(17); }
|
||||
@if (m != SkBlendMode::kDst) { sk_FragColor = half4(18); }
|
||||
|
||||
sk_FragColor = (m == SkBlendMode::kClear) ? half4(19) : half4(-19);
|
||||
sk_FragColor = (m != SkBlendMode::kSrc) ? half4(20) : half4(-20);
|
||||
|
||||
@switch (SkBlendMode::kClear) {
|
||||
case SkBlendMode::kClear: sk_FragColor = half4(21); break;
|
||||
case SkBlendMode::kSrc: sk_FragColor = half4(22); break;
|
||||
case SkBlendMode::kDst: sk_FragColor = half4(23); break;
|
||||
}
|
||||
|
||||
// Test with a non-const enum.
|
||||
E f = E::kOne;
|
||||
if (f == E::kOne) { sk_FragColor = half4(1); }
|
||||
|
||||
@ -15,9 +15,6 @@ class GrGLSLShaderBuilder;
|
||||
namespace GrGLSLBlend {
|
||||
/*
|
||||
* Returns the name of the built in blend function for a SkBlendMode.
|
||||
* When and if the SkSL compiler supports inlining it'd be simpler to just call
|
||||
* blend(mode, src, dst) where mode is a literal when the desired blend mode is
|
||||
* not variable.
|
||||
*/
|
||||
const char* BlendFuncName(SkBlendMode mode);
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -507,73 +507,6 @@ half4 blend_luminosity(half4 src, half4 dst) {
|
||||
src.a + dst.a - alpha);
|
||||
}
|
||||
|
||||
enum class SkBlendMode {
|
||||
kClear = 0,
|
||||
kSrc = 1,
|
||||
kDst = 2,
|
||||
kSrcOver = 3,
|
||||
kDstOver = 4,
|
||||
kSrcIn = 5,
|
||||
kDstIn = 6,
|
||||
kSrcOut = 7,
|
||||
kDstOut = 8,
|
||||
kSrcATop = 9,
|
||||
kDstATop = 10,
|
||||
kXor = 11,
|
||||
kPlus = 12,
|
||||
kModulate = 13,
|
||||
kScreen = 14,
|
||||
kOverlay = 15,
|
||||
kDarken = 16,
|
||||
kLighten = 17,
|
||||
kColorDodge = 18,
|
||||
kColorBurn = 19,
|
||||
kHardLight = 20,
|
||||
kSoftLight = 21,
|
||||
kDifference = 22,
|
||||
kExclusion = 23,
|
||||
kMultiply = 24,
|
||||
kHue = 25,
|
||||
kSaturation = 26,
|
||||
kColor = 27,
|
||||
kLuminosity = 28
|
||||
};
|
||||
|
||||
half4 blend(SkBlendMode mode, half4 src, half4 dst) {
|
||||
switch (mode) {
|
||||
case SkBlendMode::kClear: return blend_clear(src, dst);
|
||||
case SkBlendMode::kSrc: return blend_src(src, dst);
|
||||
case SkBlendMode::kDst: return blend_dst(src, dst);
|
||||
case SkBlendMode::kSrcOver: return blend_src_over(src, dst);
|
||||
case SkBlendMode::kDstOver: return blend_dst_over(src, dst);
|
||||
case SkBlendMode::kSrcIn: return blend_src_in(src, dst);
|
||||
case SkBlendMode::kDstIn: return blend_dst_in(src, dst);
|
||||
case SkBlendMode::kSrcOut: return blend_src_out(src, dst);
|
||||
case SkBlendMode::kDstOut: return blend_dst_out(src, dst);
|
||||
case SkBlendMode::kSrcATop: return blend_src_atop(src, dst);
|
||||
case SkBlendMode::kDstATop: return blend_dst_atop(src, dst);
|
||||
case SkBlendMode::kXor: return blend_xor(src, dst);
|
||||
case SkBlendMode::kPlus: return blend_plus(src, dst);
|
||||
case SkBlendMode::kModulate: return blend_modulate(src, dst);
|
||||
case SkBlendMode::kScreen: return blend_screen(src, dst);
|
||||
case SkBlendMode::kOverlay: return blend_overlay(src, dst);
|
||||
case SkBlendMode::kDarken: return blend_darken(src, dst);
|
||||
case SkBlendMode::kLighten: return blend_lighten(src, dst);
|
||||
case SkBlendMode::kColorDodge: return blend_color_dodge(src, dst);
|
||||
case SkBlendMode::kColorBurn: return blend_color_burn(src, dst);
|
||||
case SkBlendMode::kHardLight: return blend_hard_light(src, dst);
|
||||
case SkBlendMode::kSoftLight: return blend_soft_light(src, dst);
|
||||
case SkBlendMode::kDifference: return blend_difference(src, dst);
|
||||
case SkBlendMode::kExclusion: return blend_exclusion(src, dst);
|
||||
case SkBlendMode::kMultiply: return blend_multiply(src, dst);
|
||||
case SkBlendMode::kHue: return blend_hue(src, dst);
|
||||
case SkBlendMode::kSaturation: return blend_saturation(src, dst);
|
||||
case SkBlendMode::kColor: return blend_color(src, dst);
|
||||
case SkBlendMode::kLuminosity: return blend_luminosity(src, dst);
|
||||
default: return half4(0); // Avoids "'blend' can exit without returning a value."
|
||||
}
|
||||
}
|
||||
|
||||
// The max() guards against division by zero when the incoming color is transparent black
|
||||
half4 unpremul(half4 color) { return half4(color.rgb / max(color.a, 0.0001), color.a); }
|
||||
float4 unpremul(float4 color) { return float4(color.rgb / max(color.a, 0.0001), color.a); }
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,170 +0,0 @@
|
||||
#version 400
|
||||
out vec4 sk_FragColor;
|
||||
uniform vec4 src;
|
||||
uniform vec4 dst;
|
||||
float _blend_overlay_component_hh2h2(vec2 s, vec2 d) {
|
||||
return 2.0 * d.x <= d.y ? (2.0 * s.x) * d.x : s.y * d.y - (2.0 * (d.y - d.x)) * (s.y - s.x);
|
||||
}
|
||||
vec4 blend_overlay_h4h4h4(vec4 src, vec4 dst) {
|
||||
vec4 result = vec4(_blend_overlay_component_hh2h2(src.xw, dst.xw), _blend_overlay_component_hh2h2(src.yw, dst.yw), _blend_overlay_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
result.xyz += dst.xyz * (1.0 - src.w) + src.xyz * (1.0 - dst.w);
|
||||
return result;
|
||||
}
|
||||
float _color_dodge_component_hh2h2(vec2 s, vec2 d) {
|
||||
if (d.x == 0.0) {
|
||||
return s.x * (1.0 - d.y);
|
||||
} else {
|
||||
float delta = s.y - s.x;
|
||||
if (delta == 0.0) {
|
||||
return (s.y * d.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
} else {
|
||||
delta = min(d.y, (d.x * s.y) / delta);
|
||||
return (delta * s.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
float _color_burn_component_hh2h2(vec2 s, vec2 d) {
|
||||
if (d.y == d.x) {
|
||||
return (s.y * d.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
} else if (s.x == 0.0) {
|
||||
return d.x * (1.0 - s.y);
|
||||
} else {
|
||||
float delta = max(0.0, d.y - ((d.y - d.x) * s.y) / s.x);
|
||||
return (delta * s.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
}
|
||||
}
|
||||
float _soft_light_component_hh2h2(vec2 s, vec2 d) {
|
||||
if (2.0 * s.x <= s.y) {
|
||||
return (((d.x * d.x) * (s.y - 2.0 * s.x)) / d.y + (1.0 - d.y) * s.x) + d.x * ((-s.y + 2.0 * s.x) + 1.0);
|
||||
} else if (4.0 * d.x <= d.y) {
|
||||
float DSqd = d.x * d.x;
|
||||
float DCub = DSqd * d.x;
|
||||
float DaSqd = d.y * d.y;
|
||||
float DaCub = DaSqd * d.y;
|
||||
return (((DaSqd * (s.x - d.x * ((3.0 * s.y - 6.0 * s.x) - 1.0)) + ((12.0 * d.y) * DSqd) * (s.y - 2.0 * s.x)) - (16.0 * DCub) * (s.y - 2.0 * s.x)) - DaCub * s.x) / DaSqd;
|
||||
} else {
|
||||
return ((d.x * ((s.y - 2.0 * s.x) + 1.0) + s.x) - sqrt(d.y * d.x) * (s.y - 2.0 * s.x)) - d.y * s.x;
|
||||
}
|
||||
}
|
||||
vec3 _blend_set_color_luminance_h3h3hh3(vec3 hueSatColor, float alpha, vec3 lumColor) {
|
||||
float lum = dot(vec3(0.30000001192092896, 0.5899999737739563, 0.10999999940395355), lumColor);
|
||||
vec3 result = (lum - dot(vec3(0.30000001192092896, 0.5899999737739563, 0.10999999940395355), hueSatColor)) + hueSatColor;
|
||||
float minComp = min(min(result.x, result.y), result.z);
|
||||
float maxComp = max(max(result.x, result.y), result.z);
|
||||
if (minComp < 0.0 && lum != minComp) {
|
||||
result = lum + (result - lum) * (lum / (lum - minComp));
|
||||
}
|
||||
if (maxComp > alpha && maxComp != lum) {
|
||||
return lum + ((result - lum) * (alpha - lum)) / (maxComp - lum);
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
vec3 _blend_set_color_saturation_helper_h3h3h(vec3 minMidMax, float sat) {
|
||||
if (minMidMax.x < minMidMax.z) {
|
||||
return vec3(0.0, (sat * (minMidMax.y - minMidMax.x)) / (minMidMax.z - minMidMax.x), sat);
|
||||
} else {
|
||||
return vec3(0.0);
|
||||
}
|
||||
}
|
||||
vec3 _blend_set_color_saturation_h3h3h3(vec3 hueLumColor, vec3 satColor) {
|
||||
float sat = max(max(satColor.x, satColor.y), satColor.z) - min(min(satColor.x, satColor.y), satColor.z);
|
||||
if (hueLumColor.x <= hueLumColor.y) {
|
||||
if (hueLumColor.y <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor, sat);
|
||||
} else if (hueLumColor.x <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.xzy, sat).xzy;
|
||||
} else {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.zxy, sat).yzx;
|
||||
}
|
||||
} else if (hueLumColor.x <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.yxz, sat).yxz;
|
||||
} else if (hueLumColor.y <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.yzx, sat).zxy;
|
||||
} else {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.zyx, sat).zyx;
|
||||
}
|
||||
}
|
||||
vec4 blend_h4eh4h4(int mode, vec4 src, vec4 dst) {
|
||||
switch (mode) {
|
||||
case 0:
|
||||
return vec4(0.0);
|
||||
case 1:
|
||||
return src;
|
||||
case 2:
|
||||
return dst;
|
||||
case 3:
|
||||
return src + (1.0 - src.w) * dst;
|
||||
case 4:
|
||||
return (1.0 - dst.w) * src + dst;
|
||||
case 5:
|
||||
return src * dst.w;
|
||||
case 6:
|
||||
return dst * src.w;
|
||||
case 7:
|
||||
return (1.0 - dst.w) * src;
|
||||
case 8:
|
||||
return (1.0 - src.w) * dst;
|
||||
case 9:
|
||||
return dst.w * src + (1.0 - src.w) * dst;
|
||||
case 10:
|
||||
return (1.0 - dst.w) * src + src.w * dst;
|
||||
case 11:
|
||||
return (1.0 - dst.w) * src + (1.0 - src.w) * dst;
|
||||
case 12:
|
||||
return min(src + dst, 1.0);
|
||||
case 13:
|
||||
return src * dst;
|
||||
case 14:
|
||||
return src + (1.0 - src) * dst;
|
||||
case 15:
|
||||
return blend_overlay_h4h4h4(src, dst);
|
||||
case 16:
|
||||
vec4 _0_result = src + (1.0 - src.w) * dst;
|
||||
_0_result.xyz = min(_0_result.xyz, (1.0 - dst.w) * src.xyz + dst.xyz);
|
||||
return _0_result;
|
||||
case 17:
|
||||
vec4 _1_result = src + (1.0 - src.w) * dst;
|
||||
_1_result.xyz = max(_1_result.xyz, (1.0 - dst.w) * src.xyz + dst.xyz);
|
||||
return _1_result;
|
||||
case 18:
|
||||
return vec4(_color_dodge_component_hh2h2(src.xw, dst.xw), _color_dodge_component_hh2h2(src.yw, dst.yw), _color_dodge_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 19:
|
||||
return vec4(_color_burn_component_hh2h2(src.xw, dst.xw), _color_burn_component_hh2h2(src.yw, dst.yw), _color_burn_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 20:
|
||||
return blend_overlay_h4h4h4(dst, src);
|
||||
case 21:
|
||||
return dst.w == 0.0 ? src : vec4(_soft_light_component_hh2h2(src.xw, dst.xw), _soft_light_component_hh2h2(src.yw, dst.yw), _soft_light_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 22:
|
||||
return vec4((src.xyz + dst.xyz) - 2.0 * min(src.xyz * dst.w, dst.xyz * src.w), src.w + (1.0 - src.w) * dst.w);
|
||||
case 23:
|
||||
return vec4((dst.xyz + src.xyz) - (2.0 * dst.xyz) * src.xyz, src.w + (1.0 - src.w) * dst.w);
|
||||
case 24:
|
||||
return vec4(((1.0 - src.w) * dst.xyz + (1.0 - dst.w) * src.xyz) + src.xyz * dst.xyz, src.w + (1.0 - src.w) * dst.w);
|
||||
case 25:
|
||||
float _2_alpha = dst.w * src.w;
|
||||
vec3 _3_sda = src.xyz * dst.w;
|
||||
vec3 _4_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_blend_set_color_saturation_h3h3h3(_3_sda, _4_dsa), _2_alpha, _4_dsa) + dst.xyz) - _4_dsa) + src.xyz) - _3_sda, (src.w + dst.w) - _2_alpha);
|
||||
case 26:
|
||||
float _5_alpha = dst.w * src.w;
|
||||
vec3 _6_sda = src.xyz * dst.w;
|
||||
vec3 _7_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_blend_set_color_saturation_h3h3h3(_7_dsa, _6_sda), _5_alpha, _7_dsa) + dst.xyz) - _7_dsa) + src.xyz) - _6_sda, (src.w + dst.w) - _5_alpha);
|
||||
case 27:
|
||||
float _8_alpha = dst.w * src.w;
|
||||
vec3 _9_sda = src.xyz * dst.w;
|
||||
vec3 _10_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_9_sda, _8_alpha, _10_dsa) + dst.xyz) - _10_dsa) + src.xyz) - _9_sda, (src.w + dst.w) - _8_alpha);
|
||||
case 28:
|
||||
float _11_alpha = dst.w * src.w;
|
||||
vec3 _12_sda = src.xyz * dst.w;
|
||||
vec3 _13_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_13_dsa, _11_alpha, _12_sda) + dst.xyz) - _13_dsa) + src.xyz) - _12_sda, (src.w + dst.w) - _11_alpha);
|
||||
default:
|
||||
return vec4(0.0);
|
||||
}
|
||||
}
|
||||
void main() {
|
||||
sk_FragColor = blend_h4eh4h4(13, src, dst);
|
||||
}
|
||||
@ -1,181 +0,0 @@
|
||||
#include <metal_stdlib>
|
||||
#include <simd/simd.h>
|
||||
using namespace metal;
|
||||
struct Uniforms {
|
||||
float4 src;
|
||||
float4 dst;
|
||||
};
|
||||
struct Inputs {
|
||||
};
|
||||
struct Outputs {
|
||||
float4 sk_FragColor [[color(0)]];
|
||||
};
|
||||
float _blend_overlay_component_hh2h2(float2 s, float2 d) {
|
||||
return 2.0 * d.x <= d.y ? (2.0 * s.x) * d.x : s.y * d.y - (2.0 * (d.y - d.x)) * (s.y - s.x);
|
||||
}
|
||||
float4 blend_overlay_h4h4h4(float4 src, float4 dst) {
|
||||
float4 result = float4(_blend_overlay_component_hh2h2(src.xw, dst.xw), _blend_overlay_component_hh2h2(src.yw, dst.yw), _blend_overlay_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
result.xyz = result.xyz + dst.xyz * (1.0 - src.w) + src.xyz * (1.0 - dst.w);
|
||||
return result;
|
||||
}
|
||||
float _color_dodge_component_hh2h2(float2 s, float2 d) {
|
||||
if (d.x == 0.0) {
|
||||
return s.x * (1.0 - d.y);
|
||||
} else {
|
||||
float delta = s.y - s.x;
|
||||
if (delta == 0.0) {
|
||||
return (s.y * d.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
} else {
|
||||
delta = min(d.y, (d.x * s.y) / delta);
|
||||
return (delta * s.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
float _color_burn_component_hh2h2(float2 s, float2 d) {
|
||||
if (d.y == d.x) {
|
||||
return (s.y * d.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
} else if (s.x == 0.0) {
|
||||
return d.x * (1.0 - s.y);
|
||||
} else {
|
||||
float delta = max(0.0, d.y - ((d.y - d.x) * s.y) / s.x);
|
||||
return (delta * s.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
}
|
||||
}
|
||||
float _soft_light_component_hh2h2(float2 s, float2 d) {
|
||||
if (2.0 * s.x <= s.y) {
|
||||
return (((d.x * d.x) * (s.y - 2.0 * s.x)) / d.y + (1.0 - d.y) * s.x) + d.x * ((-s.y + 2.0 * s.x) + 1.0);
|
||||
} else if (4.0 * d.x <= d.y) {
|
||||
float DSqd = d.x * d.x;
|
||||
float DCub = DSqd * d.x;
|
||||
float DaSqd = d.y * d.y;
|
||||
float DaCub = DaSqd * d.y;
|
||||
return (((DaSqd * (s.x - d.x * ((3.0 * s.y - 6.0 * s.x) - 1.0)) + ((12.0 * d.y) * DSqd) * (s.y - 2.0 * s.x)) - (16.0 * DCub) * (s.y - 2.0 * s.x)) - DaCub * s.x) / DaSqd;
|
||||
} else {
|
||||
return ((d.x * ((s.y - 2.0 * s.x) + 1.0) + s.x) - sqrt(d.y * d.x) * (s.y - 2.0 * s.x)) - d.y * s.x;
|
||||
}
|
||||
}
|
||||
float3 _blend_set_color_luminance_h3h3hh3(float3 hueSatColor, float alpha, float3 lumColor) {
|
||||
float lum = dot(float3(0.30000001192092896, 0.5899999737739563, 0.10999999940395355), lumColor);
|
||||
float3 result = (lum - dot(float3(0.30000001192092896, 0.5899999737739563, 0.10999999940395355), hueSatColor)) + hueSatColor;
|
||||
float minComp = min(min(result.x, result.y), result.z);
|
||||
float maxComp = max(max(result.x, result.y), result.z);
|
||||
if (minComp < 0.0 && lum != minComp) {
|
||||
result = lum + (result - lum) * (lum / (lum - minComp));
|
||||
}
|
||||
if (maxComp > alpha && maxComp != lum) {
|
||||
return lum + ((result - lum) * (alpha - lum)) / (maxComp - lum);
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
float3 _blend_set_color_saturation_helper_h3h3h(float3 minMidMax, float sat) {
|
||||
if (minMidMax.x < minMidMax.z) {
|
||||
return float3(0.0, (sat * (minMidMax.y - minMidMax.x)) / (minMidMax.z - minMidMax.x), sat);
|
||||
} else {
|
||||
return float3(0.0);
|
||||
}
|
||||
}
|
||||
float3 _blend_set_color_saturation_h3h3h3(float3 hueLumColor, float3 satColor) {
|
||||
float sat = max(max(satColor.x, satColor.y), satColor.z) - min(min(satColor.x, satColor.y), satColor.z);
|
||||
if (hueLumColor.x <= hueLumColor.y) {
|
||||
if (hueLumColor.y <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor, sat);
|
||||
} else if (hueLumColor.x <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.xzy, sat).xzy;
|
||||
} else {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.zxy, sat).yzx;
|
||||
}
|
||||
} else if (hueLumColor.x <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.yxz, sat).yxz;
|
||||
} else if (hueLumColor.y <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.yzx, sat).zxy;
|
||||
} else {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.zyx, sat).zyx;
|
||||
}
|
||||
}
|
||||
float4 blend_h4eh4h4(int mode, float4 src, float4 dst) {
|
||||
switch (mode) {
|
||||
case 0:
|
||||
return float4(0.0);
|
||||
case 1:
|
||||
return src;
|
||||
case 2:
|
||||
return dst;
|
||||
case 3:
|
||||
return src + (1.0 - src.w) * dst;
|
||||
case 4:
|
||||
return (1.0 - dst.w) * src + dst;
|
||||
case 5:
|
||||
return src * dst.w;
|
||||
case 6:
|
||||
return dst * src.w;
|
||||
case 7:
|
||||
return (1.0 - dst.w) * src;
|
||||
case 8:
|
||||
return (1.0 - src.w) * dst;
|
||||
case 9:
|
||||
return dst.w * src + (1.0 - src.w) * dst;
|
||||
case 10:
|
||||
return (1.0 - dst.w) * src + src.w * dst;
|
||||
case 11:
|
||||
return (1.0 - dst.w) * src + (1.0 - src.w) * dst;
|
||||
case 12:
|
||||
return min(src + dst, 1.0);
|
||||
case 13:
|
||||
return src * dst;
|
||||
case 14:
|
||||
return src + (1.0 - src) * dst;
|
||||
case 15:
|
||||
return blend_overlay_h4h4h4(src, dst);
|
||||
case 16:
|
||||
float4 _0_result = src + (1.0 - src.w) * dst;
|
||||
_0_result.xyz = min(_0_result.xyz, (1.0 - dst.w) * src.xyz + dst.xyz);
|
||||
return _0_result;
|
||||
case 17:
|
||||
float4 _1_result = src + (1.0 - src.w) * dst;
|
||||
_1_result.xyz = max(_1_result.xyz, (1.0 - dst.w) * src.xyz + dst.xyz);
|
||||
return _1_result;
|
||||
case 18:
|
||||
return float4(_color_dodge_component_hh2h2(src.xw, dst.xw), _color_dodge_component_hh2h2(src.yw, dst.yw), _color_dodge_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 19:
|
||||
return float4(_color_burn_component_hh2h2(src.xw, dst.xw), _color_burn_component_hh2h2(src.yw, dst.yw), _color_burn_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 20:
|
||||
return blend_overlay_h4h4h4(dst, src);
|
||||
case 21:
|
||||
return dst.w == 0.0 ? src : float4(_soft_light_component_hh2h2(src.xw, dst.xw), _soft_light_component_hh2h2(src.yw, dst.yw), _soft_light_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 22:
|
||||
return float4((src.xyz + dst.xyz) - 2.0 * min(src.xyz * dst.w, dst.xyz * src.w), src.w + (1.0 - src.w) * dst.w);
|
||||
case 23:
|
||||
return float4((dst.xyz + src.xyz) - (2.0 * dst.xyz) * src.xyz, src.w + (1.0 - src.w) * dst.w);
|
||||
case 24:
|
||||
return float4(((1.0 - src.w) * dst.xyz + (1.0 - dst.w) * src.xyz) + src.xyz * dst.xyz, src.w + (1.0 - src.w) * dst.w);
|
||||
case 25:
|
||||
float _2_alpha = dst.w * src.w;
|
||||
float3 _3_sda = src.xyz * dst.w;
|
||||
float3 _4_dsa = dst.xyz * src.w;
|
||||
return float4((((_blend_set_color_luminance_h3h3hh3(_blend_set_color_saturation_h3h3h3(_3_sda, _4_dsa), _2_alpha, _4_dsa) + dst.xyz) - _4_dsa) + src.xyz) - _3_sda, (src.w + dst.w) - _2_alpha);
|
||||
case 26:
|
||||
float _5_alpha = dst.w * src.w;
|
||||
float3 _6_sda = src.xyz * dst.w;
|
||||
float3 _7_dsa = dst.xyz * src.w;
|
||||
return float4((((_blend_set_color_luminance_h3h3hh3(_blend_set_color_saturation_h3h3h3(_7_dsa, _6_sda), _5_alpha, _7_dsa) + dst.xyz) - _7_dsa) + src.xyz) - _6_sda, (src.w + dst.w) - _5_alpha);
|
||||
case 27:
|
||||
float _8_alpha = dst.w * src.w;
|
||||
float3 _9_sda = src.xyz * dst.w;
|
||||
float3 _10_dsa = dst.xyz * src.w;
|
||||
return float4((((_blend_set_color_luminance_h3h3hh3(_9_sda, _8_alpha, _10_dsa) + dst.xyz) - _10_dsa) + src.xyz) - _9_sda, (src.w + dst.w) - _8_alpha);
|
||||
case 28:
|
||||
float _11_alpha = dst.w * src.w;
|
||||
float3 _12_sda = src.xyz * dst.w;
|
||||
float3 _13_dsa = dst.xyz * src.w;
|
||||
return float4((((_blend_set_color_luminance_h3h3hh3(_13_dsa, _11_alpha, _12_sda) + dst.xyz) - _13_dsa) + src.xyz) - _12_sda, (src.w + dst.w) - _11_alpha);
|
||||
default:
|
||||
return float4(0.0);
|
||||
}
|
||||
}
|
||||
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
|
||||
Outputs _out;
|
||||
(void)_out;
|
||||
_out.sk_FragColor = blend_h4eh4h4(13, _uniforms.src, _uniforms.dst);
|
||||
return _out;
|
||||
}
|
||||
@ -1,170 +0,0 @@
|
||||
|
||||
out vec4 sk_FragColor;
|
||||
uniform vec4 src;
|
||||
uniform vec4 dst;
|
||||
float _blend_overlay_component_hh2h2(vec2 s, vec2 d) {
|
||||
return 2.0 * d.x <= d.y ? (2.0 * s.x) * d.x : s.y * d.y - (2.0 * (d.y - d.x)) * (s.y - s.x);
|
||||
}
|
||||
vec4 blend_overlay_h4h4h4(vec4 src, vec4 dst) {
|
||||
vec4 result = vec4(_blend_overlay_component_hh2h2(src.xw, dst.xw), _blend_overlay_component_hh2h2(src.yw, dst.yw), _blend_overlay_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
result.xyz += dst.xyz * (1.0 - src.w) + src.xyz * (1.0 - dst.w);
|
||||
return result;
|
||||
}
|
||||
float _color_dodge_component_hh2h2(vec2 s, vec2 d) {
|
||||
if (d.x == 0.0) {
|
||||
return s.x * (1.0 - d.y);
|
||||
} else {
|
||||
float delta = s.y - s.x;
|
||||
if (delta == 0.0) {
|
||||
return (s.y * d.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
} else {
|
||||
delta = min(d.y, (d.x * s.y) / delta);
|
||||
return (delta * s.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
float _color_burn_component_hh2h2(vec2 s, vec2 d) {
|
||||
if (d.y == d.x) {
|
||||
return (s.y * d.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
} else if (s.x == 0.0) {
|
||||
return d.x * (1.0 - s.y);
|
||||
} else {
|
||||
float delta = max(0.0, d.y - ((d.y - d.x) * s.y) / s.x);
|
||||
return (delta * s.y + s.x * (1.0 - d.y)) + d.x * (1.0 - s.y);
|
||||
}
|
||||
}
|
||||
float _soft_light_component_hh2h2(vec2 s, vec2 d) {
|
||||
if (2.0 * s.x <= s.y) {
|
||||
return (((d.x * d.x) * (s.y - 2.0 * s.x)) / d.y + (1.0 - d.y) * s.x) + d.x * ((-s.y + 2.0 * s.x) + 1.0);
|
||||
} else if (4.0 * d.x <= d.y) {
|
||||
float DSqd = d.x * d.x;
|
||||
float DCub = DSqd * d.x;
|
||||
float DaSqd = d.y * d.y;
|
||||
float DaCub = DaSqd * d.y;
|
||||
return (((DaSqd * (s.x - d.x * ((3.0 * s.y - 6.0 * s.x) - 1.0)) + ((12.0 * d.y) * DSqd) * (s.y - 2.0 * s.x)) - (16.0 * DCub) * (s.y - 2.0 * s.x)) - DaCub * s.x) / DaSqd;
|
||||
} else {
|
||||
return ((d.x * ((s.y - 2.0 * s.x) + 1.0) + s.x) - sqrt(d.y * d.x) * (s.y - 2.0 * s.x)) - d.y * s.x;
|
||||
}
|
||||
}
|
||||
vec3 _blend_set_color_luminance_h3h3hh3(vec3 hueSatColor, float alpha, vec3 lumColor) {
|
||||
float lum = dot(vec3(0.30000001192092896, 0.5899999737739563, 0.10999999940395355), lumColor);
|
||||
vec3 result = (lum - dot(vec3(0.30000001192092896, 0.5899999737739563, 0.10999999940395355), hueSatColor)) + hueSatColor;
|
||||
float minComp = min(min(result.x, result.y), result.z);
|
||||
float maxComp = max(max(result.x, result.y), result.z);
|
||||
if (minComp < 0.0 && lum != minComp) {
|
||||
result = lum + (result - lum) * (lum / (lum - minComp));
|
||||
}
|
||||
if (maxComp > alpha && maxComp != lum) {
|
||||
return lum + ((result - lum) * (alpha - lum)) / (maxComp - lum);
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
vec3 _blend_set_color_saturation_helper_h3h3h(vec3 minMidMax, float sat) {
|
||||
if (minMidMax.x < minMidMax.z) {
|
||||
return vec3(0.0, (sat * (minMidMax.y - minMidMax.x)) / (minMidMax.z - minMidMax.x), sat);
|
||||
} else {
|
||||
return vec3(0.0);
|
||||
}
|
||||
}
|
||||
vec3 _blend_set_color_saturation_h3h3h3(vec3 hueLumColor, vec3 satColor) {
|
||||
float sat = max(max(satColor.x, satColor.y), satColor.z) - min(min(satColor.x, satColor.y), satColor.z);
|
||||
if (hueLumColor.x <= hueLumColor.y) {
|
||||
if (hueLumColor.y <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor, sat);
|
||||
} else if (hueLumColor.x <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.xzy, sat).xzy;
|
||||
} else {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.zxy, sat).yzx;
|
||||
}
|
||||
} else if (hueLumColor.x <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.yxz, sat).yxz;
|
||||
} else if (hueLumColor.y <= hueLumColor.z) {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.yzx, sat).zxy;
|
||||
} else {
|
||||
return _blend_set_color_saturation_helper_h3h3h(hueLumColor.zyx, sat).zyx;
|
||||
}
|
||||
}
|
||||
vec4 blend_h4eh4h4(int mode, vec4 src, vec4 dst) {
|
||||
switch (mode) {
|
||||
case 0:
|
||||
return vec4(0.0);
|
||||
case 1:
|
||||
return src;
|
||||
case 2:
|
||||
return dst;
|
||||
case 3:
|
||||
return src + (1.0 - src.w) * dst;
|
||||
case 4:
|
||||
return (1.0 - dst.w) * src + dst;
|
||||
case 5:
|
||||
return src * dst.w;
|
||||
case 6:
|
||||
return dst * src.w;
|
||||
case 7:
|
||||
return (1.0 - dst.w) * src;
|
||||
case 8:
|
||||
return (1.0 - src.w) * dst;
|
||||
case 9:
|
||||
return dst.w * src + (1.0 - src.w) * dst;
|
||||
case 10:
|
||||
return (1.0 - dst.w) * src + src.w * dst;
|
||||
case 11:
|
||||
return (1.0 - dst.w) * src + (1.0 - src.w) * dst;
|
||||
case 12:
|
||||
return min(src + dst, 1.0);
|
||||
case 13:
|
||||
return src * dst;
|
||||
case 14:
|
||||
return src + (1.0 - src) * dst;
|
||||
case 15:
|
||||
return blend_overlay_h4h4h4(src, dst);
|
||||
case 16:
|
||||
vec4 _0_result = src + (1.0 - src.w) * dst;
|
||||
_0_result.xyz = min(_0_result.xyz, (1.0 - dst.w) * src.xyz + dst.xyz);
|
||||
return _0_result;
|
||||
case 17:
|
||||
vec4 _1_result = src + (1.0 - src.w) * dst;
|
||||
_1_result.xyz = max(_1_result.xyz, (1.0 - dst.w) * src.xyz + dst.xyz);
|
||||
return _1_result;
|
||||
case 18:
|
||||
return vec4(_color_dodge_component_hh2h2(src.xw, dst.xw), _color_dodge_component_hh2h2(src.yw, dst.yw), _color_dodge_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 19:
|
||||
return vec4(_color_burn_component_hh2h2(src.xw, dst.xw), _color_burn_component_hh2h2(src.yw, dst.yw), _color_burn_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 20:
|
||||
return blend_overlay_h4h4h4(dst, src);
|
||||
case 21:
|
||||
return dst.w == 0.0 ? src : vec4(_soft_light_component_hh2h2(src.xw, dst.xw), _soft_light_component_hh2h2(src.yw, dst.yw), _soft_light_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
case 22:
|
||||
return vec4((src.xyz + dst.xyz) - 2.0 * min(src.xyz * dst.w, dst.xyz * src.w), src.w + (1.0 - src.w) * dst.w);
|
||||
case 23:
|
||||
return vec4((dst.xyz + src.xyz) - (2.0 * dst.xyz) * src.xyz, src.w + (1.0 - src.w) * dst.w);
|
||||
case 24:
|
||||
return vec4(((1.0 - src.w) * dst.xyz + (1.0 - dst.w) * src.xyz) + src.xyz * dst.xyz, src.w + (1.0 - src.w) * dst.w);
|
||||
case 25:
|
||||
float _2_alpha = dst.w * src.w;
|
||||
vec3 _3_sda = src.xyz * dst.w;
|
||||
vec3 _4_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_blend_set_color_saturation_h3h3h3(_3_sda, _4_dsa), _2_alpha, _4_dsa) + dst.xyz) - _4_dsa) + src.xyz) - _3_sda, (src.w + dst.w) - _2_alpha);
|
||||
case 26:
|
||||
float _5_alpha = dst.w * src.w;
|
||||
vec3 _6_sda = src.xyz * dst.w;
|
||||
vec3 _7_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_blend_set_color_saturation_h3h3h3(_7_dsa, _6_sda), _5_alpha, _7_dsa) + dst.xyz) - _7_dsa) + src.xyz) - _6_sda, (src.w + dst.w) - _5_alpha);
|
||||
case 27:
|
||||
float _8_alpha = dst.w * src.w;
|
||||
vec3 _9_sda = src.xyz * dst.w;
|
||||
vec3 _10_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_9_sda, _8_alpha, _10_dsa) + dst.xyz) - _10_dsa) + src.xyz) - _9_sda, (src.w + dst.w) - _8_alpha);
|
||||
case 28:
|
||||
float _11_alpha = dst.w * src.w;
|
||||
vec3 _12_sda = src.xyz * dst.w;
|
||||
vec3 _13_dsa = dst.xyz * src.w;
|
||||
return vec4((((_blend_set_color_luminance_h3h3hh3(_13_dsa, _11_alpha, _12_sda) + dst.xyz) - _13_dsa) + src.xyz) - _12_sda, (src.w + dst.w) - _11_alpha);
|
||||
default:
|
||||
return vec4(0.0);
|
||||
}
|
||||
}
|
||||
void main() {
|
||||
sk_FragColor = blend_h4eh4h4(13, src, dst);
|
||||
}
|
||||
@ -9,9 +9,8 @@ OpName %_UniformBuffer "_UniformBuffer"
|
||||
OpMemberName %_UniformBuffer 0 "src"
|
||||
OpMemberName %_UniformBuffer 1 "dst"
|
||||
OpName %_blend_overlay_component_hh2h2 "_blend_overlay_component_hh2h2"
|
||||
OpName %blend_overlay_h4h4h4 "blend_overlay_h4h4h4"
|
||||
OpName %result "result"
|
||||
OpName %main "main"
|
||||
OpName %_0_result "_0_result"
|
||||
OpDecorate %sk_FragColor RelaxedPrecision
|
||||
OpDecorate %sk_FragColor Location 0
|
||||
OpDecorate %sk_FragColor Index 0
|
||||
@ -21,13 +20,14 @@ OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
|
||||
OpMemberDecorate %_UniformBuffer 1 Offset 16
|
||||
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
|
||||
OpDecorate %_UniformBuffer Block
|
||||
OpDecorate %12 Binding 0
|
||||
OpDecorate %12 DescriptorSet 0
|
||||
OpDecorate %11 Binding 0
|
||||
OpDecorate %11 DescriptorSet 0
|
||||
OpDecorate %21 RelaxedPrecision
|
||||
OpDecorate %22 RelaxedPrecision
|
||||
OpDecorate %23 RelaxedPrecision
|
||||
OpDecorate %24 RelaxedPrecision
|
||||
OpDecorate %25 RelaxedPrecision
|
||||
OpDecorate %26 RelaxedPrecision
|
||||
OpDecorate %32 RelaxedPrecision
|
||||
OpDecorate %33 RelaxedPrecision
|
||||
OpDecorate %34 RelaxedPrecision
|
||||
OpDecorate %35 RelaxedPrecision
|
||||
@ -52,35 +52,24 @@ OpDecorate %53 RelaxedPrecision
|
||||
OpDecorate %54 RelaxedPrecision
|
||||
OpDecorate %55 RelaxedPrecision
|
||||
OpDecorate %56 RelaxedPrecision
|
||||
OpDecorate %57 RelaxedPrecision
|
||||
OpDecorate %result RelaxedPrecision
|
||||
OpDecorate %64 RelaxedPrecision
|
||||
OpDecorate %65 RelaxedPrecision
|
||||
OpDecorate %_0_result RelaxedPrecision
|
||||
OpDecorate %66 RelaxedPrecision
|
||||
OpDecorate %67 RelaxedPrecision
|
||||
OpDecorate %68 RelaxedPrecision
|
||||
OpDecorate %71 RelaxedPrecision
|
||||
OpDecorate %72 RelaxedPrecision
|
||||
OpDecorate %74 RelaxedPrecision
|
||||
OpDecorate %75 RelaxedPrecision
|
||||
OpDecorate %78 RelaxedPrecision
|
||||
OpDecorate %79 RelaxedPrecision
|
||||
OpDecorate %76 RelaxedPrecision
|
||||
OpDecorate %77 RelaxedPrecision
|
||||
OpDecorate %80 RelaxedPrecision
|
||||
OpDecorate %81 RelaxedPrecision
|
||||
OpDecorate %82 RelaxedPrecision
|
||||
OpDecorate %85 RelaxedPrecision
|
||||
OpDecorate %86 RelaxedPrecision
|
||||
OpDecorate %88 RelaxedPrecision
|
||||
OpDecorate %89 RelaxedPrecision
|
||||
OpDecorate %90 RelaxedPrecision
|
||||
OpDecorate %91 RelaxedPrecision
|
||||
OpDecorate %92 RelaxedPrecision
|
||||
OpDecorate %93 RelaxedPrecision
|
||||
OpDecorate %94 RelaxedPrecision
|
||||
OpDecorate %95 RelaxedPrecision
|
||||
OpDecorate %96 RelaxedPrecision
|
||||
OpDecorate %97 RelaxedPrecision
|
||||
OpDecorate %98 RelaxedPrecision
|
||||
OpDecorate %99 RelaxedPrecision
|
||||
OpDecorate %100 RelaxedPrecision
|
||||
OpDecorate %101 RelaxedPrecision
|
||||
OpDecorate %102 RelaxedPrecision
|
||||
OpDecorate %103 RelaxedPrecision
|
||||
OpDecorate %104 RelaxedPrecision
|
||||
@ -88,15 +77,23 @@ OpDecorate %105 RelaxedPrecision
|
||||
OpDecorate %106 RelaxedPrecision
|
||||
OpDecorate %107 RelaxedPrecision
|
||||
OpDecorate %108 RelaxedPrecision
|
||||
OpDecorate %109 RelaxedPrecision
|
||||
OpDecorate %110 RelaxedPrecision
|
||||
OpDecorate %111 RelaxedPrecision
|
||||
OpDecorate %112 RelaxedPrecision
|
||||
OpDecorate %113 RelaxedPrecision
|
||||
OpDecorate %114 RelaxedPrecision
|
||||
OpDecorate %115 RelaxedPrecision
|
||||
OpDecorate %116 RelaxedPrecision
|
||||
OpDecorate %117 RelaxedPrecision
|
||||
OpDecorate %119 RelaxedPrecision
|
||||
OpDecorate %120 RelaxedPrecision
|
||||
OpDecorate %122 RelaxedPrecision
|
||||
OpDecorate %123 RelaxedPrecision
|
||||
OpDecorate %124 RelaxedPrecision
|
||||
OpDecorate %125 RelaxedPrecision
|
||||
OpDecorate %126 RelaxedPrecision
|
||||
OpDecorate %127 RelaxedPrecision
|
||||
OpDecorate %128 RelaxedPrecision
|
||||
OpDecorate %129 RelaxedPrecision
|
||||
OpDecorate %130 RelaxedPrecision
|
||||
%float = OpTypeFloat 32
|
||||
%v4float = OpTypeVector %float 4
|
||||
%_ptr_Output_v4float = OpTypePointer Output %v4float
|
||||
@ -106,145 +103,142 @@ OpDecorate %127 RelaxedPrecision
|
||||
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
|
||||
%_UniformBuffer = OpTypeStruct %v4float %v4float
|
||||
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
|
||||
%12 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
|
||||
%11 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
|
||||
%v2float = OpTypeVector %float 2
|
||||
%_ptr_Function_v2float = OpTypePointer Function %v2float
|
||||
%16 = OpTypeFunction %float %_ptr_Function_v2float %_ptr_Function_v2float
|
||||
%15 = OpTypeFunction %float %_ptr_Function_v2float %_ptr_Function_v2float
|
||||
%float_2 = OpConstant %float 2
|
||||
%_ptr_Function_float = OpTypePointer Function %float
|
||||
%_ptr_Function_v4float = OpTypePointer Function %v4float
|
||||
%58 = OpTypeFunction %v4float %_ptr_Function_v4float %_ptr_Function_v4float
|
||||
%float_1 = OpConstant %float 1
|
||||
%v3float = OpTypeVector %float 3
|
||||
%void = OpTypeVoid
|
||||
%117 = OpTypeFunction %void
|
||||
%58 = OpTypeFunction %void
|
||||
%_ptr_Function_v4float = OpTypePointer Function %v4float
|
||||
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
|
||||
%int = OpTypeInt 32 1
|
||||
%int_1 = OpConstant %int 1
|
||||
%int_0 = OpConstant %int 0
|
||||
%_blend_overlay_component_hh2h2 = OpFunction %float None %16
|
||||
%float_1 = OpConstant %float 1
|
||||
%v3float = OpTypeVector %float 3
|
||||
%_blend_overlay_component_hh2h2 = OpFunction %float None %15
|
||||
%17 = OpFunctionParameter %_ptr_Function_v2float
|
||||
%18 = OpFunctionParameter %_ptr_Function_v2float
|
||||
%19 = OpFunctionParameter %_ptr_Function_v2float
|
||||
%20 = OpLabel
|
||||
%28 = OpVariable %_ptr_Function_float Function
|
||||
%22 = OpLoad %v2float %19
|
||||
%23 = OpCompositeExtract %float %22 0
|
||||
%24 = OpFMul %float %float_2 %23
|
||||
%25 = OpLoad %v2float %19
|
||||
%26 = OpCompositeExtract %float %25 1
|
||||
%27 = OpFOrdLessThanEqual %bool %24 %26
|
||||
OpSelectionMerge %32 None
|
||||
OpBranchConditional %27 %30 %31
|
||||
%19 = OpLabel
|
||||
%27 = OpVariable %_ptr_Function_float Function
|
||||
%21 = OpLoad %v2float %18
|
||||
%22 = OpCompositeExtract %float %21 0
|
||||
%23 = OpFMul %float %float_2 %22
|
||||
%24 = OpLoad %v2float %18
|
||||
%25 = OpCompositeExtract %float %24 1
|
||||
%26 = OpFOrdLessThanEqual %bool %23 %25
|
||||
OpSelectionMerge %31 None
|
||||
OpBranchConditional %26 %29 %30
|
||||
%29 = OpLabel
|
||||
%32 = OpLoad %v2float %17
|
||||
%33 = OpCompositeExtract %float %32 0
|
||||
%34 = OpFMul %float %float_2 %33
|
||||
%35 = OpLoad %v2float %18
|
||||
%36 = OpCompositeExtract %float %35 0
|
||||
%37 = OpFMul %float %34 %36
|
||||
OpStore %27 %37
|
||||
OpBranch %31
|
||||
%30 = OpLabel
|
||||
%33 = OpLoad %v2float %18
|
||||
%34 = OpCompositeExtract %float %33 0
|
||||
%35 = OpFMul %float %float_2 %34
|
||||
%36 = OpLoad %v2float %19
|
||||
%37 = OpCompositeExtract %float %36 0
|
||||
%38 = OpFMul %float %35 %37
|
||||
OpStore %28 %38
|
||||
OpBranch %32
|
||||
%38 = OpLoad %v2float %17
|
||||
%39 = OpCompositeExtract %float %38 1
|
||||
%40 = OpLoad %v2float %18
|
||||
%41 = OpCompositeExtract %float %40 1
|
||||
%42 = OpFMul %float %39 %41
|
||||
%43 = OpLoad %v2float %18
|
||||
%44 = OpCompositeExtract %float %43 1
|
||||
%45 = OpLoad %v2float %18
|
||||
%46 = OpCompositeExtract %float %45 0
|
||||
%47 = OpFSub %float %44 %46
|
||||
%48 = OpFMul %float %float_2 %47
|
||||
%49 = OpLoad %v2float %17
|
||||
%50 = OpCompositeExtract %float %49 1
|
||||
%51 = OpLoad %v2float %17
|
||||
%52 = OpCompositeExtract %float %51 0
|
||||
%53 = OpFSub %float %50 %52
|
||||
%54 = OpFMul %float %48 %53
|
||||
%55 = OpFSub %float %42 %54
|
||||
OpStore %27 %55
|
||||
OpBranch %31
|
||||
%31 = OpLabel
|
||||
%39 = OpLoad %v2float %18
|
||||
%40 = OpCompositeExtract %float %39 1
|
||||
%41 = OpLoad %v2float %19
|
||||
%42 = OpCompositeExtract %float %41 1
|
||||
%43 = OpFMul %float %40 %42
|
||||
%44 = OpLoad %v2float %19
|
||||
%45 = OpCompositeExtract %float %44 1
|
||||
%46 = OpLoad %v2float %19
|
||||
%47 = OpCompositeExtract %float %46 0
|
||||
%48 = OpFSub %float %45 %47
|
||||
%49 = OpFMul %float %float_2 %48
|
||||
%50 = OpLoad %v2float %18
|
||||
%51 = OpCompositeExtract %float %50 1
|
||||
%52 = OpLoad %v2float %18
|
||||
%53 = OpCompositeExtract %float %52 0
|
||||
%54 = OpFSub %float %51 %53
|
||||
%55 = OpFMul %float %49 %54
|
||||
%56 = OpFSub %float %43 %55
|
||||
OpStore %28 %56
|
||||
OpBranch %32
|
||||
%32 = OpLabel
|
||||
%57 = OpLoad %float %28
|
||||
OpReturnValue %57
|
||||
%56 = OpLoad %float %27
|
||||
OpReturnValue %56
|
||||
OpFunctionEnd
|
||||
%blend_overlay_h4h4h4 = OpFunction %v4float None %58
|
||||
%60 = OpFunctionParameter %_ptr_Function_v4float
|
||||
%61 = OpFunctionParameter %_ptr_Function_v4float
|
||||
%62 = OpLabel
|
||||
%result = OpVariable %_ptr_Function_v4float Function
|
||||
%66 = OpVariable %_ptr_Function_v2float Function
|
||||
%69 = OpVariable %_ptr_Function_v2float Function
|
||||
%main = OpFunction %void None %58
|
||||
%59 = OpLabel
|
||||
%_0_result = OpVariable %_ptr_Function_v4float Function
|
||||
%68 = OpVariable %_ptr_Function_v2float Function
|
||||
%73 = OpVariable %_ptr_Function_v2float Function
|
||||
%76 = OpVariable %_ptr_Function_v2float Function
|
||||
%80 = OpVariable %_ptr_Function_v2float Function
|
||||
%83 = OpVariable %_ptr_Function_v2float Function
|
||||
%64 = OpLoad %v4float %60
|
||||
%65 = OpVectorShuffle %v2float %64 %64 0 3
|
||||
OpStore %66 %65
|
||||
%67 = OpLoad %v4float %61
|
||||
%68 = OpVectorShuffle %v2float %67 %67 0 3
|
||||
OpStore %69 %68
|
||||
%70 = OpFunctionCall %float %_blend_overlay_component_hh2h2 %66 %69
|
||||
%71 = OpLoad %v4float %60
|
||||
%72 = OpVectorShuffle %v2float %71 %71 1 3
|
||||
%78 = OpVariable %_ptr_Function_v2float Function
|
||||
%82 = OpVariable %_ptr_Function_v2float Function
|
||||
%87 = OpVariable %_ptr_Function_v2float Function
|
||||
%91 = OpVariable %_ptr_Function_v2float Function
|
||||
%62 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%66 = OpLoad %v4float %62
|
||||
%67 = OpVectorShuffle %v2float %66 %66 0 3
|
||||
OpStore %68 %67
|
||||
%69 = OpAccessChain %_ptr_Uniform_v4float %11 %int_0
|
||||
%71 = OpLoad %v4float %69
|
||||
%72 = OpVectorShuffle %v2float %71 %71 0 3
|
||||
OpStore %73 %72
|
||||
%74 = OpLoad %v4float %61
|
||||
%75 = OpVectorShuffle %v2float %74 %74 1 3
|
||||
OpStore %76 %75
|
||||
%77 = OpFunctionCall %float %_blend_overlay_component_hh2h2 %73 %76
|
||||
%78 = OpLoad %v4float %60
|
||||
%79 = OpVectorShuffle %v2float %78 %78 2 3
|
||||
OpStore %80 %79
|
||||
%81 = OpLoad %v4float %61
|
||||
%82 = OpVectorShuffle %v2float %81 %81 2 3
|
||||
OpStore %83 %82
|
||||
%84 = OpFunctionCall %float %_blend_overlay_component_hh2h2 %80 %83
|
||||
%85 = OpLoad %v4float %60
|
||||
%86 = OpCompositeExtract %float %85 3
|
||||
%88 = OpLoad %v4float %60
|
||||
%89 = OpCompositeExtract %float %88 3
|
||||
%90 = OpFSub %float %float_1 %89
|
||||
%91 = OpLoad %v4float %61
|
||||
%92 = OpCompositeExtract %float %91 3
|
||||
%93 = OpFMul %float %90 %92
|
||||
%94 = OpFAdd %float %86 %93
|
||||
%95 = OpCompositeConstruct %v4float %70 %77 %84 %94
|
||||
OpStore %result %95
|
||||
%96 = OpLoad %v4float %result
|
||||
%97 = OpVectorShuffle %v3float %96 %96 0 1 2
|
||||
%99 = OpLoad %v4float %61
|
||||
%100 = OpVectorShuffle %v3float %99 %99 0 1 2
|
||||
%101 = OpLoad %v4float %60
|
||||
%102 = OpCompositeExtract %float %101 3
|
||||
%103 = OpFSub %float %float_1 %102
|
||||
%104 = OpVectorTimesScalar %v3float %100 %103
|
||||
%105 = OpLoad %v4float %60
|
||||
%106 = OpVectorShuffle %v3float %105 %105 0 1 2
|
||||
%107 = OpLoad %v4float %61
|
||||
%108 = OpCompositeExtract %float %107 3
|
||||
%109 = OpFSub %float %float_1 %108
|
||||
%110 = OpVectorTimesScalar %v3float %106 %109
|
||||
%111 = OpFAdd %v3float %104 %110
|
||||
%112 = OpFAdd %v3float %97 %111
|
||||
%113 = OpLoad %v4float %result
|
||||
%114 = OpVectorShuffle %v4float %113 %112 4 5 6 3
|
||||
OpStore %result %114
|
||||
%115 = OpLoad %v4float %result
|
||||
OpReturnValue %115
|
||||
OpFunctionEnd
|
||||
%main = OpFunction %void None %117
|
||||
%118 = OpLabel
|
||||
%124 = OpVariable %_ptr_Function_v4float Function
|
||||
%128 = OpVariable %_ptr_Function_v4float Function
|
||||
%119 = OpAccessChain %_ptr_Uniform_v4float %12 %int_1
|
||||
%123 = OpLoad %v4float %119
|
||||
OpStore %124 %123
|
||||
%125 = OpAccessChain %_ptr_Uniform_v4float %12 %int_0
|
||||
%127 = OpLoad %v4float %125
|
||||
OpStore %128 %127
|
||||
%129 = OpFunctionCall %v4float %blend_overlay_h4h4h4 %124 %128
|
||||
OpStore %sk_FragColor %129
|
||||
%74 = OpFunctionCall %float %_blend_overlay_component_hh2h2 %68 %73
|
||||
%75 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%76 = OpLoad %v4float %75
|
||||
%77 = OpVectorShuffle %v2float %76 %76 1 3
|
||||
OpStore %78 %77
|
||||
%79 = OpAccessChain %_ptr_Uniform_v4float %11 %int_0
|
||||
%80 = OpLoad %v4float %79
|
||||
%81 = OpVectorShuffle %v2float %80 %80 1 3
|
||||
OpStore %82 %81
|
||||
%83 = OpFunctionCall %float %_blend_overlay_component_hh2h2 %78 %82
|
||||
%84 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%85 = OpLoad %v4float %84
|
||||
%86 = OpVectorShuffle %v2float %85 %85 2 3
|
||||
OpStore %87 %86
|
||||
%88 = OpAccessChain %_ptr_Uniform_v4float %11 %int_0
|
||||
%89 = OpLoad %v4float %88
|
||||
%90 = OpVectorShuffle %v2float %89 %89 2 3
|
||||
OpStore %91 %90
|
||||
%92 = OpFunctionCall %float %_blend_overlay_component_hh2h2 %87 %91
|
||||
%93 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%94 = OpLoad %v4float %93
|
||||
%95 = OpCompositeExtract %float %94 3
|
||||
%97 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%98 = OpLoad %v4float %97
|
||||
%99 = OpCompositeExtract %float %98 3
|
||||
%100 = OpFSub %float %float_1 %99
|
||||
%101 = OpAccessChain %_ptr_Uniform_v4float %11 %int_0
|
||||
%102 = OpLoad %v4float %101
|
||||
%103 = OpCompositeExtract %float %102 3
|
||||
%104 = OpFMul %float %100 %103
|
||||
%105 = OpFAdd %float %95 %104
|
||||
%106 = OpCompositeConstruct %v4float %74 %83 %92 %105
|
||||
OpStore %_0_result %106
|
||||
%107 = OpLoad %v4float %_0_result
|
||||
%108 = OpVectorShuffle %v3float %107 %107 0 1 2
|
||||
%110 = OpAccessChain %_ptr_Uniform_v4float %11 %int_0
|
||||
%111 = OpLoad %v4float %110
|
||||
%112 = OpVectorShuffle %v3float %111 %111 0 1 2
|
||||
%113 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%114 = OpLoad %v4float %113
|
||||
%115 = OpCompositeExtract %float %114 3
|
||||
%116 = OpFSub %float %float_1 %115
|
||||
%117 = OpVectorTimesScalar %v3float %112 %116
|
||||
%118 = OpAccessChain %_ptr_Uniform_v4float %11 %int_1
|
||||
%119 = OpLoad %v4float %118
|
||||
%120 = OpVectorShuffle %v3float %119 %119 0 1 2
|
||||
%121 = OpAccessChain %_ptr_Uniform_v4float %11 %int_0
|
||||
%122 = OpLoad %v4float %121
|
||||
%123 = OpCompositeExtract %float %122 3
|
||||
%124 = OpFSub %float %float_1 %123
|
||||
%125 = OpVectorTimesScalar %v3float %120 %124
|
||||
%126 = OpFAdd %v3float %117 %125
|
||||
%127 = OpFAdd %v3float %108 %126
|
||||
%128 = OpLoad %v4float %_0_result
|
||||
%129 = OpVectorShuffle %v4float %128 %127 4 5 6 3
|
||||
OpStore %_0_result %129
|
||||
%130 = OpLoad %v4float %_0_result
|
||||
OpStore %sk_FragColor %130
|
||||
OpReturn
|
||||
OpFunctionEnd
|
||||
|
||||
@ -5,11 +5,8 @@ uniform vec4 dst;
|
||||
float _blend_overlay_component_hh2h2(vec2 s, vec2 d) {
|
||||
return 2.0 * d.x <= d.y ? (2.0 * s.x) * d.x : s.y * d.y - (2.0 * (d.y - d.x)) * (s.y - s.x);
|
||||
}
|
||||
vec4 blend_overlay_h4h4h4(vec4 src, vec4 dst) {
|
||||
vec4 result = vec4(_blend_overlay_component_hh2h2(src.xw, dst.xw), _blend_overlay_component_hh2h2(src.yw, dst.yw), _blend_overlay_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
result.xyz += dst.xyz * (1.0 - src.w) + src.xyz * (1.0 - dst.w);
|
||||
return result;
|
||||
}
|
||||
void main() {
|
||||
sk_FragColor = blend_overlay_h4h4h4(dst, src);
|
||||
vec4 _0_result = vec4(_blend_overlay_component_hh2h2(dst.xw, src.xw), _blend_overlay_component_hh2h2(dst.yw, src.yw), _blend_overlay_component_hh2h2(dst.zw, src.zw), dst.w + (1.0 - dst.w) * src.w);
|
||||
_0_result.xyz += src.xyz * (1.0 - dst.w) + dst.xyz * (1.0 - src.w);
|
||||
sk_FragColor = _0_result;
|
||||
}
|
||||
|
||||
@ -13,14 +13,11 @@ struct Outputs {
|
||||
float _blend_overlay_component_hh2h2(float2 s, float2 d) {
|
||||
return 2.0 * d.x <= d.y ? (2.0 * s.x) * d.x : s.y * d.y - (2.0 * (d.y - d.x)) * (s.y - s.x);
|
||||
}
|
||||
float4 blend_overlay_h4h4h4(float4 src, float4 dst) {
|
||||
float4 result = float4(_blend_overlay_component_hh2h2(src.xw, dst.xw), _blend_overlay_component_hh2h2(src.yw, dst.yw), _blend_overlay_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
result.xyz = result.xyz + dst.xyz * (1.0 - src.w) + src.xyz * (1.0 - dst.w);
|
||||
return result;
|
||||
}
|
||||
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
|
||||
Outputs _out;
|
||||
(void)_out;
|
||||
_out.sk_FragColor = blend_overlay_h4h4h4(_uniforms.dst, _uniforms.src);
|
||||
float4 _0_result = float4(_blend_overlay_component_hh2h2(_uniforms.dst.xw, _uniforms.src.xw), _blend_overlay_component_hh2h2(_uniforms.dst.yw, _uniforms.src.yw), _blend_overlay_component_hh2h2(_uniforms.dst.zw, _uniforms.src.zw), _uniforms.dst.w + (1.0 - _uniforms.dst.w) * _uniforms.src.w);
|
||||
_0_result.xyz = _0_result.xyz + _uniforms.src.xyz * (1.0 - _uniforms.dst.w) + _uniforms.dst.xyz * (1.0 - _uniforms.src.w);
|
||||
_out.sk_FragColor = _0_result;
|
||||
return _out;
|
||||
}
|
||||
|
||||
@ -5,11 +5,8 @@ uniform vec4 dst;
|
||||
float _blend_overlay_component_hh2h2(vec2 s, vec2 d) {
|
||||
return 2.0 * d.x <= d.y ? (2.0 * s.x) * d.x : s.y * d.y - (2.0 * (d.y - d.x)) * (s.y - s.x);
|
||||
}
|
||||
vec4 blend_overlay_h4h4h4(vec4 src, vec4 dst) {
|
||||
vec4 result = vec4(_blend_overlay_component_hh2h2(src.xw, dst.xw), _blend_overlay_component_hh2h2(src.yw, dst.yw), _blend_overlay_component_hh2h2(src.zw, dst.zw), src.w + (1.0 - src.w) * dst.w);
|
||||
result.xyz += dst.xyz * (1.0 - src.w) + src.xyz * (1.0 - dst.w);
|
||||
return result;
|
||||
}
|
||||
void main() {
|
||||
sk_FragColor = blend_overlay_h4h4h4(dst, src);
|
||||
vec4 _0_result = vec4(_blend_overlay_component_hh2h2(dst.xw, src.xw), _blend_overlay_component_hh2h2(dst.yw, src.yw), _blend_overlay_component_hh2h2(dst.zw, src.zw), dst.w + (1.0 - dst.w) * src.w);
|
||||
_0_result.xyz += src.xyz * (1.0 - dst.w) + dst.xyz * (1.0 - src.w);
|
||||
sk_FragColor = _0_result;
|
||||
}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
### Compilation failed:
|
||||
|
||||
error: 1: cannot construct 'SkBlendMode'
|
||||
error: 5: cannot construct 'E'
|
||||
1 error
|
||||
|
||||
@ -20,29 +20,23 @@ OpDecorate %24 RelaxedPrecision
|
||||
OpDecorate %26 RelaxedPrecision
|
||||
OpDecorate %28 RelaxedPrecision
|
||||
OpDecorate %30 RelaxedPrecision
|
||||
OpDecorate %32 RelaxedPrecision
|
||||
OpDecorate %34 RelaxedPrecision
|
||||
OpDecorate %36 RelaxedPrecision
|
||||
OpDecorate %38 RelaxedPrecision
|
||||
OpDecorate %40 RelaxedPrecision
|
||||
OpDecorate %42 RelaxedPrecision
|
||||
OpDecorate %47 RelaxedPrecision
|
||||
OpDecorate %51 RelaxedPrecision
|
||||
OpDecorate %35 RelaxedPrecision
|
||||
OpDecorate %39 RelaxedPrecision
|
||||
OpDecorate %44 RelaxedPrecision
|
||||
OpDecorate %45 RelaxedPrecision
|
||||
OpDecorate %54 RelaxedPrecision
|
||||
OpDecorate %55 RelaxedPrecision
|
||||
OpDecorate %56 RelaxedPrecision
|
||||
OpDecorate %57 RelaxedPrecision
|
||||
OpDecorate %66 RelaxedPrecision
|
||||
OpDecorate %67 RelaxedPrecision
|
||||
OpDecorate %68 RelaxedPrecision
|
||||
OpDecorate %75 RelaxedPrecision
|
||||
OpDecorate %76 RelaxedPrecision
|
||||
OpDecorate %77 RelaxedPrecision
|
||||
OpDecorate %84 RelaxedPrecision
|
||||
OpDecorate %85 RelaxedPrecision
|
||||
OpDecorate %86 RelaxedPrecision
|
||||
OpDecorate %93 RelaxedPrecision
|
||||
OpDecorate %94 RelaxedPrecision
|
||||
OpDecorate %95 RelaxedPrecision
|
||||
OpDecorate %100 RelaxedPrecision
|
||||
OpDecorate %63 RelaxedPrecision
|
||||
OpDecorate %64 RelaxedPrecision
|
||||
OpDecorate %65 RelaxedPrecision
|
||||
OpDecorate %72 RelaxedPrecision
|
||||
OpDecorate %73 RelaxedPrecision
|
||||
OpDecorate %74 RelaxedPrecision
|
||||
OpDecorate %81 RelaxedPrecision
|
||||
OpDecorate %82 RelaxedPrecision
|
||||
OpDecorate %83 RelaxedPrecision
|
||||
OpDecorate %88 RelaxedPrecision
|
||||
%float = OpTypeFloat 32
|
||||
%v4float = OpTypeVector %float 4
|
||||
%_ptr_Output_v4float = OpTypePointer Output %v4float
|
||||
@ -70,42 +64,30 @@ OpDecorate %100 RelaxedPrecision
|
||||
%28 = OpConstantComposite %v4float %float_11 %float_11 %float_11 %float_11
|
||||
%float_13 = OpConstant %float 13
|
||||
%30 = OpConstantComposite %v4float %float_13 %float_13 %float_13 %float_13
|
||||
%float_15 = OpConstant %float 15
|
||||
%32 = OpConstantComposite %v4float %float_15 %float_15 %float_15 %float_15
|
||||
%float_16 = OpConstant %float 16
|
||||
%34 = OpConstantComposite %v4float %float_16 %float_16 %float_16 %float_16
|
||||
%float_18 = OpConstant %float 18
|
||||
%36 = OpConstantComposite %v4float %float_18 %float_18 %float_18 %float_18
|
||||
%float_19 = OpConstant %float 19
|
||||
%38 = OpConstantComposite %v4float %float_19 %float_19 %float_19 %float_19
|
||||
%float_20 = OpConstant %float 20
|
||||
%40 = OpConstantComposite %v4float %float_20 %float_20 %float_20 %float_20
|
||||
%float_21 = OpConstant %float 21
|
||||
%42 = OpConstantComposite %v4float %float_21 %float_21 %float_21 %float_21
|
||||
%int = OpTypeInt 32 1
|
||||
%_ptr_Function_int = OpTypePointer Function %int
|
||||
%int_1 = OpConstant %int 1
|
||||
%float_4 = OpConstant %float 4
|
||||
%56 = OpConstantComposite %v4float %float_4 %float_4 %float_4 %float_4
|
||||
%44 = OpConstantComposite %v4float %float_4 %float_4 %float_4 %float_4
|
||||
%int_0 = OpConstant %int 0
|
||||
%_ptr_Function_v4float = OpTypePointer Function %v4float
|
||||
%float_n7 = OpConstant %float -7
|
||||
%66 = OpConstantComposite %v4float %float_n7 %float_n7 %float_n7 %float_n7
|
||||
%54 = OpConstantComposite %v4float %float_n7 %float_n7 %float_n7 %float_n7
|
||||
%float_8 = OpConstant %float 8
|
||||
%75 = OpConstantComposite %v4float %float_8 %float_8 %float_8 %float_8
|
||||
%63 = OpConstantComposite %v4float %float_8 %float_8 %float_8 %float_8
|
||||
%float_9 = OpConstant %float 9
|
||||
%84 = OpConstantComposite %v4float %float_9 %float_9 %float_9 %float_9
|
||||
%72 = OpConstantComposite %v4float %float_9 %float_9 %float_9 %float_9
|
||||
%float_n10 = OpConstant %float -10
|
||||
%93 = OpConstantComposite %v4float %float_n10 %float_n10 %float_n10 %float_n10
|
||||
%81 = OpConstantComposite %v4float %float_n10 %float_n10 %float_n10 %float_n10
|
||||
%float_12 = OpConstant %float 12
|
||||
%100 = OpConstantComposite %v4float %float_12 %float_12 %float_12 %float_12
|
||||
%88 = OpConstantComposite %v4float %float_12 %float_12 %float_12 %float_12
|
||||
%main = OpFunction %void None %11
|
||||
%12 = OpLabel
|
||||
%f = OpVariable %_ptr_Function_int Function
|
||||
%60 = OpVariable %_ptr_Function_v4float Function
|
||||
%70 = OpVariable %_ptr_Function_v4float Function
|
||||
%79 = OpVariable %_ptr_Function_v4float Function
|
||||
%88 = OpVariable %_ptr_Function_v4float Function
|
||||
%48 = OpVariable %_ptr_Function_v4float Function
|
||||
%58 = OpVariable %_ptr_Function_v4float Function
|
||||
%67 = OpVariable %_ptr_Function_v4float Function
|
||||
%76 = OpVariable %_ptr_Function_v4float Function
|
||||
OpStore %sk_FragColor %14
|
||||
OpStore %sk_FragColor %16
|
||||
OpStore %sk_FragColor %18
|
||||
@ -115,90 +97,84 @@ OpStore %sk_FragColor %24
|
||||
OpStore %sk_FragColor %26
|
||||
OpStore %sk_FragColor %28
|
||||
OpStore %sk_FragColor %30
|
||||
OpStore %sk_FragColor %32
|
||||
OpStore %sk_FragColor %34
|
||||
OpStore %sk_FragColor %36
|
||||
OpStore %sk_FragColor %38
|
||||
OpStore %sk_FragColor %40
|
||||
OpStore %sk_FragColor %42
|
||||
OpStore %f %int_1
|
||||
%47 = OpLoad %int %f
|
||||
%48 = OpIEqual %bool %47 %int_1
|
||||
OpSelectionMerge %50 None
|
||||
OpBranchConditional %48 %49 %50
|
||||
%49 = OpLabel
|
||||
%35 = OpLoad %int %f
|
||||
%36 = OpIEqual %bool %35 %int_1
|
||||
OpSelectionMerge %38 None
|
||||
OpBranchConditional %36 %37 %38
|
||||
%37 = OpLabel
|
||||
OpStore %sk_FragColor %14
|
||||
OpBranch %50
|
||||
OpBranch %38
|
||||
%38 = OpLabel
|
||||
%39 = OpLoad %int %f
|
||||
%40 = OpINotEqual %bool %39 %int_1
|
||||
OpSelectionMerge %42 None
|
||||
OpBranchConditional %40 %41 %42
|
||||
%41 = OpLabel
|
||||
OpStore %sk_FragColor %44
|
||||
OpBranch %42
|
||||
%42 = OpLabel
|
||||
%45 = OpLoad %int %f
|
||||
%47 = OpIEqual %bool %45 %int_0
|
||||
OpSelectionMerge %52 None
|
||||
OpBranchConditional %47 %50 %51
|
||||
%50 = OpLabel
|
||||
%51 = OpLoad %int %f
|
||||
%52 = OpINotEqual %bool %51 %int_1
|
||||
OpSelectionMerge %54 None
|
||||
OpBranchConditional %52 %53 %54
|
||||
%53 = OpLabel
|
||||
OpStore %sk_FragColor %56
|
||||
OpBranch %54
|
||||
%54 = OpLabel
|
||||
%57 = OpLoad %int %f
|
||||
%59 = OpIEqual %bool %57 %int_0
|
||||
OpSelectionMerge %64 None
|
||||
OpBranchConditional %59 %62 %63
|
||||
%62 = OpLabel
|
||||
OpStore %60 %20
|
||||
OpBranch %64
|
||||
%63 = OpLabel
|
||||
OpStore %60 %66
|
||||
OpBranch %64
|
||||
%64 = OpLabel
|
||||
%67 = OpLoad %v4float %60
|
||||
OpStore %sk_FragColor %67
|
||||
%68 = OpLoad %int %f
|
||||
%69 = OpINotEqual %bool %68 %int_0
|
||||
OpSelectionMerge %73 None
|
||||
OpBranchConditional %69 %71 %72
|
||||
%71 = OpLabel
|
||||
OpStore %70 %75
|
||||
OpBranch %73
|
||||
%72 = OpLabel
|
||||
OpStore %70 %22
|
||||
OpBranch %73
|
||||
%73 = OpLabel
|
||||
%76 = OpLoad %v4float %70
|
||||
OpStore %sk_FragColor %76
|
||||
%77 = OpLoad %int %f
|
||||
%78 = OpIEqual %bool %77 %int_1
|
||||
OpSelectionMerge %82 None
|
||||
OpBranchConditional %78 %80 %81
|
||||
%80 = OpLabel
|
||||
OpStore %79 %84
|
||||
OpBranch %82
|
||||
%81 = OpLabel
|
||||
OpStore %79 %24
|
||||
OpBranch %82
|
||||
%82 = OpLabel
|
||||
%85 = OpLoad %v4float %79
|
||||
OpStore %sk_FragColor %85
|
||||
%86 = OpLoad %int %f
|
||||
%87 = OpINotEqual %bool %86 %int_1
|
||||
OpSelectionMerge %91 None
|
||||
OpBranchConditional %87 %89 %90
|
||||
%89 = OpLabel
|
||||
OpStore %88 %26
|
||||
OpBranch %91
|
||||
%90 = OpLabel
|
||||
OpStore %88 %93
|
||||
OpBranch %91
|
||||
%91 = OpLabel
|
||||
%94 = OpLoad %v4float %88
|
||||
OpStore %sk_FragColor %94
|
||||
%95 = OpLoad %int %f
|
||||
OpSelectionMerge %96 None
|
||||
OpSwitch %95 %96 0 %97 1 %98
|
||||
%97 = OpLabel
|
||||
OpStore %48 %20
|
||||
OpBranch %52
|
||||
%51 = OpLabel
|
||||
OpStore %48 %54
|
||||
OpBranch %52
|
||||
%52 = OpLabel
|
||||
%55 = OpLoad %v4float %48
|
||||
OpStore %sk_FragColor %55
|
||||
%56 = OpLoad %int %f
|
||||
%57 = OpINotEqual %bool %56 %int_0
|
||||
OpSelectionMerge %61 None
|
||||
OpBranchConditional %57 %59 %60
|
||||
%59 = OpLabel
|
||||
OpStore %58 %63
|
||||
OpBranch %61
|
||||
%60 = OpLabel
|
||||
OpStore %58 %22
|
||||
OpBranch %61
|
||||
%61 = OpLabel
|
||||
%64 = OpLoad %v4float %58
|
||||
OpStore %sk_FragColor %64
|
||||
%65 = OpLoad %int %f
|
||||
%66 = OpIEqual %bool %65 %int_1
|
||||
OpSelectionMerge %70 None
|
||||
OpBranchConditional %66 %68 %69
|
||||
%68 = OpLabel
|
||||
OpStore %67 %72
|
||||
OpBranch %70
|
||||
%69 = OpLabel
|
||||
OpStore %67 %24
|
||||
OpBranch %70
|
||||
%70 = OpLabel
|
||||
%73 = OpLoad %v4float %67
|
||||
OpStore %sk_FragColor %73
|
||||
%74 = OpLoad %int %f
|
||||
%75 = OpINotEqual %bool %74 %int_1
|
||||
OpSelectionMerge %79 None
|
||||
OpBranchConditional %75 %77 %78
|
||||
%77 = OpLabel
|
||||
OpStore %76 %26
|
||||
OpBranch %79
|
||||
%78 = OpLabel
|
||||
OpStore %76 %81
|
||||
OpBranch %79
|
||||
%79 = OpLabel
|
||||
%82 = OpLoad %v4float %76
|
||||
OpStore %sk_FragColor %82
|
||||
%83 = OpLoad %int %f
|
||||
OpSelectionMerge %84 None
|
||||
OpSwitch %83 %84 0 %85 1 %86
|
||||
%85 = OpLabel
|
||||
OpStore %sk_FragColor %28
|
||||
OpBranch %96
|
||||
%98 = OpLabel
|
||||
OpStore %sk_FragColor %100
|
||||
OpBranch %96
|
||||
%96 = OpLabel
|
||||
OpBranch %84
|
||||
%86 = OpLabel
|
||||
OpStore %sk_FragColor %88
|
||||
OpBranch %84
|
||||
%84 = OpLabel
|
||||
OpReturn
|
||||
OpFunctionEnd
|
||||
|
||||
@ -20,20 +20,6 @@ void main() {
|
||||
{
|
||||
sk_FragColor = vec4(13.0);
|
||||
}
|
||||
{
|
||||
sk_FragColor = vec4(15.0);
|
||||
}
|
||||
{
|
||||
sk_FragColor = vec4(16.0);
|
||||
}
|
||||
{
|
||||
sk_FragColor = vec4(18.0);
|
||||
}
|
||||
sk_FragColor = vec4(19.0);
|
||||
sk_FragColor = vec4(20.0);
|
||||
{
|
||||
sk_FragColor = vec4(21.0);
|
||||
}
|
||||
int f = 1;
|
||||
if (f == 1) {
|
||||
sk_FragColor = vec4(1.0);
|
||||
|
||||
@ -28,20 +28,6 @@ fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front
|
||||
{
|
||||
_out.sk_FragColor = float4(13.0);
|
||||
}
|
||||
{
|
||||
_out.sk_FragColor = float4(15.0);
|
||||
}
|
||||
{
|
||||
_out.sk_FragColor = float4(16.0);
|
||||
}
|
||||
{
|
||||
_out.sk_FragColor = float4(18.0);
|
||||
}
|
||||
_out.sk_FragColor = float4(19.0);
|
||||
_out.sk_FragColor = float4(20.0);
|
||||
{
|
||||
_out.sk_FragColor = float4(21.0);
|
||||
}
|
||||
int f = 1;
|
||||
if (f == 1) {
|
||||
_out.sk_FragColor = float4(1.0);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user