blob: 82e8497a5a3dddeec594bdb409cbaabc28f9a139 [file] [log] [blame]
 // Intrinsics that are available to public SkSL (SkRuntimeEffect) // See "The OpenGL ES Shading Language, Section 8" // 8.1 : Angle and Trigonometry Functions \$pure \$genType radians(\$genType degrees); \$pure \$genHType radians(\$genHType degrees); \$pure \$genType degrees(\$genType radians); \$pure \$genHType degrees(\$genHType radians); \$pure \$genType sin(\$genType angle); \$pure \$genHType sin(\$genHType angle); \$pure \$genType cos(\$genType angle); \$pure \$genHType cos(\$genHType angle); \$pure \$genType tan(\$genType angle); \$pure \$genHType tan(\$genHType angle); \$pure \$genType asin(\$genType x); \$pure \$genHType asin(\$genHType x); \$pure \$genType acos(\$genType x); \$pure \$genHType acos(\$genHType x); \$pure \$genType atan(\$genType y, \$genType x); \$pure \$genHType atan(\$genHType y, \$genHType x); \$pure \$genType atan(\$genType y_over_x); \$pure \$genHType atan(\$genHType y_over_x); // 8.1 : Angle and Trigonometry Functions (GLSL ES 3.0) \$pure \$es3 \$genType sinh(\$genType x); \$pure \$es3 \$genHType sinh(\$genHType x); \$pure \$es3 \$genType cosh(\$genType x); \$pure \$es3 \$genHType cosh(\$genHType x); \$pure \$es3 \$genType tanh(\$genType x); \$pure \$es3 \$genHType tanh(\$genHType x); \$pure \$es3 \$genType asinh(\$genType x); \$pure \$es3 \$genHType asinh(\$genHType x); \$pure \$es3 \$genType acosh(\$genType x); \$pure \$es3 \$genHType acosh(\$genHType x); \$pure \$es3 \$genType atanh(\$genType x); \$pure \$es3 \$genHType atanh(\$genHType x); // 8.2 : Exponential Functions \$pure \$genType pow(\$genType x, \$genType y); \$pure \$genHType pow(\$genHType x, \$genHType y); \$pure \$genType exp(\$genType x); \$pure \$genHType exp(\$genHType x); \$pure \$genType log(\$genType x); \$pure \$genHType log(\$genHType x); \$pure \$genType exp2(\$genType x); \$pure \$genHType exp2(\$genHType x); \$pure \$genType log2(\$genType x); \$pure \$genHType log2(\$genHType x); \$pure \$genType sqrt(\$genType x); \$pure \$genHType sqrt(\$genHType x); \$pure \$genType inversesqrt(\$genType x); \$pure \$genHType inversesqrt(\$genHType x); // 8.3 : Common Functions \$pure \$genType abs(\$genType x); \$pure \$genHType abs(\$genHType x); \$pure \$genType sign(\$genType x); \$pure \$genHType sign(\$genHType x); \$pure \$genType floor(\$genType x); \$pure \$genHType floor(\$genHType x); \$pure \$genType ceil(\$genType x); \$pure \$genHType ceil(\$genHType x); \$pure \$genType fract(\$genType x); \$pure \$genHType fract(\$genHType x); \$pure \$genType mod(\$genType x, float y); \$pure \$genType mod(\$genType x, \$genType y); \$pure \$genHType mod(\$genHType x, half y); \$pure \$genHType mod(\$genHType x, \$genHType y); \$pure \$genType min(\$genType x, \$genType y); \$pure \$genType min(\$genType x, float y); \$pure \$genHType min(\$genHType x, \$genHType y); \$pure \$genHType min(\$genHType x, half y); \$pure \$genType max(\$genType x, \$genType y); \$pure \$genType max(\$genType x, float y); \$pure \$genHType max(\$genHType x, \$genHType y); \$pure \$genHType max(\$genHType x, half y); \$pure \$genType clamp(\$genType x, \$genType minVal, \$genType maxVal); \$pure \$genType clamp(\$genType x, float minVal, float maxVal); \$pure \$genHType clamp(\$genHType x, \$genHType minVal, \$genHType maxVal); \$pure \$genHType clamp(\$genHType x, half minVal, half maxVal); \$pure \$genType saturate(\$genType x); // SkSL extension \$pure \$genHType saturate(\$genHType x); // SkSL extension \$pure \$genType mix(\$genType x, \$genType y, \$genType a); \$pure \$genType mix(\$genType x, \$genType y, float a); \$pure \$genHType mix(\$genHType x, \$genHType y, \$genHType a); \$pure \$genHType mix(\$genHType x, \$genHType y, half a); \$pure \$genType step(\$genType edge, \$genType x); \$pure \$genType step(float edge, \$genType x); \$pure \$genHType step(\$genHType edge, \$genHType x); \$pure \$genHType step(half edge, \$genHType x); \$pure \$genType smoothstep(\$genType edge0, \$genType edge1, \$genType x); \$pure \$genType smoothstep(float edge0, float edge1, \$genType x); \$pure \$genHType smoothstep(\$genHType edge0, \$genHType edge1, \$genHType x); \$pure \$genHType smoothstep(half edge0, half edge1, \$genHType x); // 8.3 : Common Functions (GLSL ES 3.0) \$pure \$es3 \$genIType abs(\$genIType x); \$pure \$es3 \$genIType sign(\$genIType x); \$pure \$es3 \$genIType floatBitsToInt (\$genType value); \$pure \$es3 \$genUType floatBitsToUint(\$genType value); \$pure \$es3 \$genType intBitsToFloat (\$genIType value); \$pure \$es3 \$genType uintBitsToFloat(\$genUType value); \$pure \$es3 \$genType trunc(\$genType x); \$pure \$es3 \$genHType trunc(\$genHType x); \$pure \$es3 \$genType round(\$genType x); \$pure \$es3 \$genHType round(\$genHType x); \$pure \$es3 \$genType roundEven(\$genType x); \$pure \$es3 \$genHType roundEven(\$genHType x); \$pure \$es3 \$genIType min(\$genIType x, \$genIType y); \$pure \$es3 \$genIType min(\$genIType x, int y); \$pure \$es3 \$genUType min(\$genUType x, \$genUType y); \$pure \$es3 \$genUType min(\$genUType x, uint y); \$pure \$es3 \$genIType max(\$genIType x, \$genIType y); \$pure \$es3 \$genIType max(\$genIType x, int y); \$pure \$es3 \$genUType max(\$genUType x, \$genUType y); \$pure \$es3 \$genUType max(\$genUType x, uint y); \$pure \$es3 \$genIType clamp(\$genIType x, \$genIType minVal, \$genIType maxVal); \$pure \$es3 \$genIType clamp(\$genIType x, int minVal, int maxVal); \$pure \$es3 \$genUType clamp(\$genUType x, \$genUType minVal, \$genUType maxVal); \$pure \$es3 \$genUType clamp(\$genUType x, uint minVal, uint maxVal); \$pure \$es3 \$genType mix(\$genType x, \$genType y, \$genBType a); \$pure \$es3 \$genHType mix(\$genHType x, \$genHType y, \$genBType a); // 8.3 : Common Functions (GLSL ES 3.0) -- cannot be used in constant-expressions \$pure \$es3 \$genBType isnan(\$genType x); \$pure \$es3 \$genBType isnan(\$genHType x); \$pure \$es3 \$genBType isinf(\$genType x); \$pure \$es3 \$genBType isinf(\$genHType x); \$es3 \$genType modf(\$genType x, out \$genType i); \$es3 \$genHType modf(\$genHType x, out \$genHType i); // 8.4 : Floating-Point Pack and Unpack Functions (GLSL ES 3.0) \$pure \$es3 uint packUnorm2x16(float2 v); \$pure \$es3 float2 unpackUnorm2x16(uint p); // 8.5 : Geometric Functions \$pure float length(\$genType x); \$pure half length(\$genHType x); \$pure float distance(\$genType p0, \$genType p1); \$pure half distance(\$genHType p0, \$genHType p1); \$pure float dot(\$genType x, \$genType y); \$pure half dot(\$genHType x, \$genHType y); \$pure float3 cross(float3 x, float3 y); \$pure half3 cross(half3 x, half3 y); \$pure \$genType normalize(\$genType x); \$pure \$genHType normalize(\$genHType x); \$pure \$genType faceforward(\$genType N, \$genType I, \$genType Nref); \$pure \$genHType faceforward(\$genHType N, \$genHType I, \$genHType Nref); \$pure \$genType reflect(\$genType I, \$genType N); \$pure \$genHType reflect(\$genHType I, \$genHType N); \$pure \$genType refract(\$genType I, \$genType N, float eta); \$pure \$genHType refract(\$genHType I, \$genHType N, half eta); // 8.6 : Matrix Functions \$pure \$squareMat matrixCompMult(\$squareMat x, \$squareMat y); \$pure \$squareHMat matrixCompMult(\$squareHMat x, \$squareHMat y); \$pure \$es3 \$mat matrixCompMult(\$mat x, \$mat y); \$pure \$es3 \$hmat matrixCompMult(\$hmat x, \$hmat y); // 8.6 : Matrix Functions (GLSL 1.4, poly-filled by SkSL as needed) \$pure \$squareMat inverse(\$squareMat m); \$pure \$squareHMat inverse(\$squareHMat m); // 8.6 : Matrix Functions (GLSL ES 3.0) \$pure \$es3 float determinant(\$squareMat m); \$pure \$es3 half determinant(\$squareHMat m); \$pure \$es3 \$squareMat transpose(\$squareMat m); \$pure \$es3 \$squareHMat transpose(\$squareHMat m); \$pure \$es3 float2x3 transpose(float3x2 m); \$pure \$es3 half2x3 transpose(half3x2 m); \$pure \$es3 float2x4 transpose(float4x2 m); \$pure \$es3 half2x4 transpose(half4x2 m); \$pure \$es3 float3x2 transpose(float2x3 m); \$pure \$es3 half3x2 transpose(half2x3 m); \$pure \$es3 float3x4 transpose(float4x3 m); \$pure \$es3 half3x4 transpose(half4x3 m); \$pure \$es3 float4x2 transpose(float2x4 m); \$pure \$es3 half4x2 transpose(half2x4 m); \$pure \$es3 float4x3 transpose(float3x4 m); \$pure \$es3 half4x3 transpose(half3x4 m); \$pure \$es3 \$squareMat outerProduct(\$vec c, \$vec r); \$pure \$es3 \$squareHMat outerProduct(\$hvec c, \$hvec r); \$pure \$es3 float2x3 outerProduct(float3 c, float2 r); \$pure \$es3 half2x3 outerProduct(half3 c, half2 r); \$pure \$es3 float3x2 outerProduct(float2 c, float3 r); \$pure \$es3 half3x2 outerProduct(half2 c, half3 r); \$pure \$es3 float2x4 outerProduct(float4 c, float2 r); \$pure \$es3 half2x4 outerProduct(half4 c, half2 r); \$pure \$es3 float4x2 outerProduct(float2 c, float4 r); \$pure \$es3 half4x2 outerProduct(half2 c, half4 r); \$pure \$es3 float3x4 outerProduct(float4 c, float3 r); \$pure \$es3 half3x4 outerProduct(half4 c, half3 r); \$pure \$es3 float4x3 outerProduct(float3 c, float4 r); \$pure \$es3 half4x3 outerProduct(half3 c, half4 r); // 8.7 : Vector Relational Functions \$pure \$bvec lessThan(\$vec x, \$vec y); \$pure \$bvec lessThan(\$hvec x, \$hvec y); \$pure \$bvec lessThan(\$ivec x, \$ivec y); \$pure \$bvec lessThan(\$svec x, \$svec y); \$pure \$bvec lessThanEqual(\$vec x, \$vec y); \$pure \$bvec lessThanEqual(\$hvec x, \$hvec y); \$pure \$bvec lessThanEqual(\$ivec x, \$ivec y); \$pure \$bvec lessThanEqual(\$svec x, \$svec y); \$pure \$bvec greaterThan(\$vec x, \$vec y); \$pure \$bvec greaterThan(\$hvec x, \$hvec y); \$pure \$bvec greaterThan(\$ivec x, \$ivec y); \$pure \$bvec greaterThan(\$svec x, \$svec y); \$pure \$bvec greaterThanEqual(\$vec x, \$vec y); \$pure \$bvec greaterThanEqual(\$hvec x, \$hvec y); \$pure \$bvec greaterThanEqual(\$ivec x, \$ivec y); \$pure \$bvec greaterThanEqual(\$svec x, \$svec y); \$pure \$bvec equal(\$vec x, \$vec y); \$pure \$bvec equal(\$hvec x, \$hvec y); \$pure \$bvec equal(\$ivec x, \$ivec y); \$pure \$bvec equal(\$svec x, \$svec y); \$pure \$bvec equal(\$bvec x, \$bvec y); \$pure \$bvec notEqual(\$vec x, \$vec y); \$pure \$bvec notEqual(\$hvec x, \$hvec y); \$pure \$bvec notEqual(\$ivec x, \$ivec y); \$pure \$bvec notEqual(\$svec x, \$svec y); \$pure \$bvec notEqual(\$bvec x, \$bvec y); \$pure \$es3 \$bvec lessThan(\$usvec x, \$usvec y); \$pure \$es3 \$bvec lessThan(\$uvec x, \$uvec y); \$pure \$es3 \$bvec lessThanEqual(\$uvec x, \$uvec y); \$pure \$es3 \$bvec lessThanEqual(\$usvec x, \$usvec y); \$pure \$es3 \$bvec greaterThan(\$uvec x, \$uvec y); \$pure \$es3 \$bvec greaterThan(\$usvec x, \$usvec y); \$pure \$es3 \$bvec greaterThanEqual(\$uvec x, \$uvec y); \$pure \$es3 \$bvec greaterThanEqual(\$usvec x, \$usvec y); \$pure \$es3 \$bvec equal(\$uvec x, \$uvec y); \$pure \$es3 \$bvec equal(\$usvec x, \$usvec y); \$pure \$es3 \$bvec notEqual(\$uvec x, \$uvec y); \$pure \$es3 \$bvec notEqual(\$usvec x, \$usvec y); \$pure bool any(\$bvec x); \$pure bool all(\$bvec x); \$pure \$bvec not(\$bvec x); // 8.9 : Fragment Processing Functions (GLSL ES 3.0) \$pure \$es3 \$genType dFdx(\$genType p); \$pure \$es3 \$genType dFdy(\$genType p); \$pure \$es3 \$genHType dFdx(\$genHType p); \$pure \$es3 \$genHType dFdy(\$genHType p); \$pure \$es3 \$genType fwidth(\$genType p); \$pure \$es3 \$genHType fwidth(\$genHType p); // SkSL utility functions // The max() guards against division by zero when the incoming color is transparent black \$pure half4 unpremul(half4 color) { return half4 (color.rgb / max(color.a, 0.0001), color.a); } \$pure float4 unpremul(float4 color) { return float4(color.rgb / max(color.a, 0.0001), color.a); } // Similar, but used for polar-space CSS colors \$export \$pure half4 \$unpremul_polar(half4 color) { return half4(color.r, color.gb / max(color.a, 0.0001), color.a); } // Convert RGBA -> HSLA (including unpremul). // // Based on work by Sam Hocevar, Emil Persson, and Ian Taylor [1][2][3]. High-level ideas: // // - minimize the number of branches by sorting and computing the hue phase in parallel (vec4s) // // - trade the third sorting branch for a potentially faster std::min and leaving 2nd/3rd // channels unsorted (based on the observation that swapping both the channels and the bias sign // has no effect under abs) // // - use epsilon offsets for denominators, to avoid explicit zero-checks // // An additional trick we employ is deferring premul->unpremul conversion until the very end: the // alpha factor gets naturally simplified for H and S, and only L requires a dedicated unpremul // division (so we trade three divs for one). // // [1] http://lolengine.net/blog/2013/01/13/fast-rgb-to-hsv // [2] http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl // [3] http://www.chilliant.com/rgb2hsv.html \$export \$pure half4 \$rgb_to_hsl(half3 c, half a) { half4 p = (c.g < c.b) ? half4(c.bg, -1, 2/3.0) : half4(c.gb, 0, -1/3.0); half4 q = (c.r < p.x) ? half4(p.x, c.r, p.yw) : half4(c.r, p.x, p.yz); // q.x -> max channel value // q.yz -> 2nd/3rd channel values (unsorted) // q.w -> bias value dependent on max channel selection const half kEps = 0.0001; half pmV = q.x; half pmC = pmV - min(q.y, q.z); half pmL = pmV - pmC * 0.5; half H = abs(q.w + (q.y - q.z) / (pmC * 6 + kEps)); half S = pmC / (a + kEps - abs(pmL * 2 - a)); half L = pmL / (a + kEps); return half4(H, S, L, a); } // Convert HSLA -> RGBA (including clamp and premul). // // Based on work by Sam Hocevar, Emil Persson, and Ian Taylor [1][2][3]. // // [1] http://lolengine.net/blog/2013/01/13/fast-rgb-to-hsv // [2] http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl // [3] http://www.chilliant.com/rgb2hsv.html \$export \$pure half3 \$hsl_to_rgb(half3 hsl) { half C = (1 - abs(2 * hsl.z - 1)) * hsl.y; half3 p = hsl.xxx + half3(0, 2/3.0, 1/3.0); half3 q = saturate(abs(fract(p) * 6 - 3) - 1); return (q - 0.5) * C + hsl.z; } \$export \$pure half4 \$hsl_to_rgb(half3 hsl, half a) { return saturate(half4(\$hsl_to_rgb(hsl) * a, a)); } // Color conversion functions used in gradient interpolation, based on // https://www.w3.org/TR/css-color-4/#color-conversion-code // TODO(skia:13108): For all of these, we can eliminate any linear math at the beginning // (by removing the corresponding linear math at the end of the CPU code). \$export \$pure half3 \$css_lab_to_xyz(half3 lab) { const half k = 24389 / 27.0; const half e = 216 / 24389.0; half3 f; f[1] = (lab[0] + 16) / 116; f[0] = (lab[1] / 500) + f[1]; f[2] = f[1] - (lab[2] / 200); half3 f_cubed = pow(f, half3(3)); half3 xyz = half3( f_cubed[0] > e ? f_cubed[0] : (116 * f[0] - 16) / k, lab[0] > k * e ? f_cubed[1] : lab[0] / k, f_cubed[2] > e ? f_cubed[2] : (116 * f[2] - 16) / k ); const half3 D50 = half3(0.3457 / 0.3585, 1.0, (1.0 - 0.3457 - 0.3585) / 0.3585); return xyz * D50; } // Skia stores all polar colors with hue in the first component, so this "LCH -> Lab" transform // actually takes "HCL". This is also used to do the same polar transform for OkHCL to OkLAB. // See similar comments & logic in SkGradientShaderBase.cpp. \$pure half3 \$css_hcl_to_lab(half3 hcl) { return half3( hcl[2], hcl[1] * cos(radians(hcl[0])), hcl[1] * sin(radians(hcl[0])) ); } \$export \$pure half3 \$css_hcl_to_xyz(half3 hcl) { return \$css_lab_to_xyz(\$css_hcl_to_lab(hcl)); } \$export \$pure half3 \$css_oklab_to_linear_srgb(half3 oklab) { half l_ = oklab.x + 0.3963377774 * oklab.y + 0.2158037573 * oklab.z, m_ = oklab.x - 0.1055613458 * oklab.y - 0.0638541728 * oklab.z, s_ = oklab.x - 0.0894841775 * oklab.y - 1.2914855480 * oklab.z; half l = l_*l_*l_, m = m_*m_*m_, s = s_*s_*s_; return half3( +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s, -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s, -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s ); } \$export \$pure half3 \$css_okhcl_to_linear_srgb(half3 okhcl) { return \$css_oklab_to_linear_srgb(\$css_hcl_to_lab(okhcl)); } \$export \$pure half3 \$css_oklab_gamut_map_to_linear_srgb(half3 oklab) { // Constants for the normal vector of the plane formed by white, black, and // the specified vertex of the gamut. const half2 normal_R = half2(0.409702, -0.912219); const half2 normal_M = half2(-0.397919, -0.917421); const half2 normal_B = half2(-0.906800, 0.421562); const half2 normal_C = half2(-0.171122, 0.985250); const half2 normal_G = half2(0.460276, 0.887776); const half2 normal_Y = half2(0.947925, 0.318495); // For the triangles formed by white (W) or black (K) with the vertices // of Yellow and Red (YR), Red and Magenta (RM), etc, the constants to be // used to compute the intersection of a line of constant hue and luminance // with that plane. const half c0_YR = 0.091132; const half2 cW_YR = half2(0.070370, 0.034139); const half2 cK_YR = half2(0.018170, 0.378550); const half c0_RM = 0.113902; const half2 cW_RM = half2(0.090836, 0.036251); const half2 cK_RM = half2(0.226781, 0.018764); const half c0_MB = 0.161739; const half2 cW_MB = half2(-0.008202, -0.264819); const half2 cK_MB = half2( 0.187156, -0.284304); const half c0_BC = 0.102047; const half2 cW_BC = half2(-0.014804, -0.162608); const half2 cK_BC = half2(-0.276786, 0.004193); const half c0_CG = 0.092029; const half2 cW_CG = half2(-0.038533, -0.001650); const half2 cK_CG = half2(-0.232572, -0.094331); const half c0_GY = 0.081709; const half2 cW_GY = half2(-0.034601, -0.002215); const half2 cK_GY = half2( 0.012185, 0.338031); half2 ab = oklab.yz; // Find the planes to intersect with and set the constants based on those // planes. half c0; half2 cW; half2 cK; if (dot(ab, normal_R) < 0.0) { if (dot(ab, normal_G) < 0.0) { if (dot(ab, normal_C) < 0.0) { c0 = c0_BC; cW = cW_BC; cK = cK_BC; } else { c0 = c0_CG; cW = cW_CG; cK = cK_CG; } } else { if (dot(ab, normal_Y) < 0.0) { c0 = c0_GY; cW = cW_GY; cK = cK_GY; } else { c0 = c0_YR; cW = cW_YR; cK = cK_YR; } } } else { if (dot(ab, normal_B) < 0.0) { if (dot(ab, normal_M) < 0.0) { c0 = c0_RM; cW = cW_RM; cK = cK_RM; } else { c0 = c0_MB; cW = cW_MB; cK = cK_MB; } } else { c0 = c0_BC; cW = cW_BC; cK = cK_BC; } } // Perform the intersection. half alpha = 1.0; // Intersect with the plane with white. half w_denom = dot(cW, ab); if (w_denom > 0.0) { half one_minus_L = 1.0 - oklab.r; half w_num = c0*one_minus_L; if (w_num < w_denom) { alpha = min(alpha, w_num / w_denom); } } // Intersect with the plane with black. half k_denom = dot(cK, ab); if (k_denom > 0.0) { half L = oklab.r; half k_num = c0*L; if (k_num < k_denom) { alpha = min(alpha, k_num / k_denom); } } // Attenuate the ab coordinate by alpha. oklab.yz *= alpha; return \$css_oklab_to_linear_srgb(oklab); } \$export \$pure half3 \$css_okhcl_gamut_map_to_linear_srgb(half3 okhcl) { return \$css_oklab_gamut_map_to_linear_srgb(\$css_hcl_to_lab(okhcl)); } // TODO(skia:13108): Use our optimized version (though it has different range) // Doing so might require fixing (re-deriving?) the math for the HWB version below \$export \$pure half3 \$css_hsl_to_srgb(half3 hsl) { hsl.x = mod(hsl.x, 360); if (hsl.x < 0) { hsl.x += 360; } hsl.yz /= 100; half3 k = mod(half3(0, 8, 4) + hsl.x/30, 12); half a = hsl.y * min(hsl.z, 1 - hsl.z); return hsl.z - a * clamp(min(k - 3, 9 - k), -1, 1); } \$export \$pure half3 \$css_hwb_to_srgb(half3 hwb) { hwb.yz /= 100; if (hwb.y + hwb.z >= 1) { half gray = hwb.y / (hwb.y + hwb.z); return half3(gray); } half3 rgb = \$css_hsl_to_srgb(half3(hwb.x, 100, 50)); rgb *= (1 - hwb.y - hwb.z); rgb += hwb.y; return rgb; } /* * The actual output color space of this function depends on the input color space * (it might be sRGB, linear sRGB, or linear XYZ). The actual space is what's stored * in the gradient/SkColor4fXformer's fIntermediateColorSpace. */ \$export \$pure half4 \$interpolated_to_rgb_unpremul(half4 color, int colorSpace, int doUnpremul) { const int kDestination = 0; const int kSRGBLinear = 1; const int kLab = 2; const int kOKLab = 3; const int kOKLabGamutMap = 4; const int kLCH = 5; const int kOKLCH = 6; const int kOKLCHGamutMap = 7; const int kSRGB = 8; const int kHSL = 9; const int kHWB = 10; if (bool(doUnpremul)) { switch (colorSpace) { case kLab: case kOKLab: case kOKLabGamutMap: color = unpremul(color); break; case kLCH: case kOKLCH: case kOKLCHGamutMap: case kHSL: case kHWB: color = \$unpremul_polar(color); break; } } switch (colorSpace) { case kLab: color.rgb = \$css_lab_to_xyz(color.rgb); break; case kOKLab: color.rgb = \$css_oklab_to_linear_srgb(color.rgb); break; case kOKLabGamutMap: color.rgb = \$css_oklab_gamut_map_to_linear_srgb(color.rgb); break; case kLCH: color.rgb = \$css_hcl_to_xyz(color.rgb); break; case kOKLCH: color.rgb = \$css_okhcl_to_linear_srgb(color.rgb); break; case kOKLCHGamutMap: color.rgb = \$css_okhcl_gamut_map_to_linear_srgb(color.rgb); break; case kHSL: color.rgb = \$css_hsl_to_srgb(color.rgb); break; case kHWB: color.rgb = \$css_hwb_to_srgb(color.rgb); break; } return color; }