glre 0.38.0 → 0.40.0

package/src/addons/animation/easing/cubicInOut.ts

@@ -0,0 +1,11 @@
+import { Fn, X } from '../../../node'
+
+export const cubicInOut = Fn(([t]: [X]): X => {
+        const early = t.mul(t).mul(t).mul(4)
+        const late = t.mul(2).sub(2).pow(3).div(2).add(1)
+        return (early as any).select(late, t.lessThan(0.5))
+}).setLayout({
+        name: 'cubicInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/cubicOut.ts

@@ -0,0 +1,10 @@
+import { Fn, X } from '../../../node'
+
+export const cubicOut = Fn(([t]: [X]): X => {
+        const f = t.sub(1)
+        return f.mul(f).mul(f).add(1)
+}).setLayout({
+        name: 'cubicOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/elasticIn.ts

@@ -0,0 +1,10 @@
+import { Fn, Float, sin, pow, float } from '../../../node'
+import { HALF_PI } from '../../math/const'
+
+export const elasticIn = Fn(([t]: [Float]): Float => {
+        return sin(t.mul(13).mul(HALF_PI)).mul(pow(float(2), t.sub(1).mul(10)))
+}).setLayout({
+        name: 'elasticIn',
+        type: 'float',
+        inputs: [{ name: 't', type: 'float' }],
+})

package/src/addons/animation/easing/elasticInOut.ts

@@ -0,0 +1,21 @@
+import { Fn, Float, sin, pow, float } from '../../../node'
+import { HALF_PI } from '../../math/const'
+
+export const elasticInOut = Fn(([t]: [Float]): Float => {
+        const t2 = t.mul(2)
+        const t2minus1 = t2.sub(1)
+        return sin(HALF_PI.mul(13).mul(t2))
+                .mul(pow(float(2), t2minus1.mul(10)))
+                .div(2)
+                .select(
+                        sin(HALF_PI.mul(-13).mul(t2minus1.add(1)))
+                                .mul(pow(float(2), t2minus1.mul(-10)))
+                                .div(2)
+                                .add(1),
+                        t.lessThan(0.5)
+                )
+}).setLayout({
+        name: 'elasticInOut',
+        type: 'float',
+        inputs: [{ name: 't', type: 'float' }],
+})

package/src/addons/animation/easing/elasticOut.ts

@@ -0,0 +1,12 @@
+import { Fn, Float, sin, pow, float } from '../../../node'
+import { HALF_PI } from '../../math/const'
+
+export const elasticOut = Fn(([t]: [Float]): Float => {
+        return sin(float(-13).mul(t.add(1)).mul(HALF_PI))
+                .mul(pow(float(2), float(-10).mul(t)))
+                .add(1)
+}).setLayout({
+        name: 'elasticOut',
+        type: 'float',
+        inputs: [{ name: 't', type: 'float' }],
+})

package/src/addons/animation/easing/exponentialIn.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const exponentialIn = Fn(([t]: [X]): X => {
+        return (t as any).select(t.sub(1).mul(10).exp2(), t.equal(0))
+}).setLayout({
+        name: 'exponentialIn',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/exponentialInOut.ts

@@ -0,0 +1,13 @@
+import { Fn, X } from '../../../node'
+
+export const exponentialInOut = Fn(([t]: [X]): X => {
+        const isZeroOrOne = t.equal(0).or(t.equal(1))
+        const early = t.mul(20).sub(10).exp2().div(2)
+        const late = t.mul(-20).add(10).exp2().div(-2).add(1)
+        const result = (early as any).select(late, t.lessThan(0.5))
+        return (t as any).select(result, isZeroOrOne)
+}).setLayout({
+        name: 'exponentialInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/exponentialOut.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const exponentialOut = Fn(([t]: [X]): X => {
+        return (t as any).select(t.mul(-10).exp2().negate().add(1), t.equal(1))
+}).setLayout({
+        name: 'exponentialOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/index.ts

@@ -0,0 +1,33 @@
+export * from './backIn'
+export * from './backInOut'
+export * from './backOut'
+export * from './bounceIn'
+export * from './bounceInOut'
+export * from './bounceOut'
+export * from './circularIn'
+export * from './circularInOut'
+export * from './circularOut'
+export * from './cubicIn'
+export * from './cubicInOut'
+export * from './cubicOut'
+export * from './elasticIn'
+export * from './elasticInOut'
+export * from './elasticOut'
+export * from './exponentialIn'
+export * from './exponentialInOut'
+export * from './exponentialOut'
+export * from './linearIn'
+export * from './linearInOut'
+export * from './linearOut'
+export * from './quadraticIn'
+export * from './quadraticInOut'
+export * from './quadraticOut'
+export * from './quarticIn'
+export * from './quarticInOut'
+export * from './quarticOut'
+export * from './quinticIn'
+export * from './quinticInOut'
+export * from './quinticOut'
+export * from './sineIn'
+export * from './sineInOut'
+export * from './sineOut'

package/src/addons/animation/easing/linearIn.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const linearIn = Fn(([t]: [X]): X => {
+        return t
+}).setLayout({
+        name: 'linearIn',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/linearInOut.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const linearInOut = Fn(([t]: [X]): X => {
+        return t
+}).setLayout({
+        name: 'linearInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/linearOut.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const linearOut = Fn(([t]: [X]): X => {
+        return t
+}).setLayout({
+        name: 'linearOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quadraticIn.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const quadraticIn = Fn(([t]: [X]): X => {
+        return t.mul(t)
+}).setLayout({
+        name: 'quadraticIn',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quadraticInOut.ts

@@ -0,0 +1,10 @@
+import { Fn, X, select } from '../../../node'
+
+export const quadraticInOut = Fn(([t]: [X]): X => {
+        const p = t.mul(t).mul(2)
+        return select(p, p.negate().add(t.mul(4)).sub(1), t.lessThan(0.5))
+}).setLayout({
+        name: 'quadraticInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quadraticOut.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const quadraticOut = Fn(([t]: [X]): X => {
+        return t.mul(t.sub(2)).negate()
+}).setLayout({
+        name: 'quadraticOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quarticIn.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const quarticIn = Fn(([t]: [X]): X => {
+        return t.pow(4)
+}).setLayout({
+        name: 'quarticIn',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quarticInOut.ts

@@ -0,0 +1,11 @@
+import { Fn, X, select } from '../../../node'
+
+export const quarticInOut = Fn(([t]: [X]): X => {
+        const early = t.pow(4).mul(8)
+        const late = t.sub(1).pow(4).mul(-8).add(1)
+        return select(early, late, t.lessThan(0.5))
+}).setLayout({
+        name: 'quarticInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quarticOut.ts

@@ -0,0 +1,10 @@
+import { Fn, X } from '../../../node'
+
+export const quarticOut = Fn(([t]: [X]): X => {
+        const it = t.sub(1)
+        return it.mul(it).mul(it).mul(t.oneMinus()).add(1)
+}).setLayout({
+        name: 'quarticOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quinticIn.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const quinticIn = Fn(([t]: [X]): X => {
+        return t.pow(5)
+}).setLayout({
+        name: 'quinticIn',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quinticInOut.ts

@@ -0,0 +1,11 @@
+import { Fn, X, select } from '../../../node'
+
+export const quinticInOut = Fn(([t]: [X]): X => {
+        const early = t.pow(5).mul(16)
+        const late = t.mul(2).sub(2).pow(5).mul(-0.5).add(1)
+        return select(early, late, t.lessThan(0.5))
+}).setLayout({
+        name: 'quinticInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/quinticOut.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../../node'
+
+export const quinticOut = Fn(([t]: [X]): X => {
+        return t.sub(1).pow(5).negate().add(1)
+}).setLayout({
+        name: 'quinticOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/sineIn.ts

@@ -0,0 +1,10 @@
+import { Fn, X, sin } from '../../../node'
+import { HALF_PI } from '../../math/const'
+
+export const sineIn = Fn(([t]: [X]): X => {
+        return sin(t.sub(1).mul(HALF_PI as any)).add(1)
+}).setLayout({
+        name: 'sineIn',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/sineInOut.ts

@@ -0,0 +1,10 @@
+import { Fn, X, cos } from '../../../node'
+import { PI } from '../../math/const'
+
+export const sineInOut = Fn(([t]: [X]): X => {
+        return cos(PI.mul(t)).sub(1).mul(-0.5)
+}).setLayout({
+        name: 'sineInOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/animation/easing/sineOut.ts

@@ -0,0 +1,10 @@
+import { Fn, X, sin } from '../../../node'
+import { HALF_PI } from '../../math/const'
+
+export const sineOut = Fn(([t]: [X]): X => {
+        return sin(t.mul(HALF_PI as any))
+}).setLayout({
+        name: 'sineOut',
+        type: 'auto',
+        inputs: [{ name: 't', type: 'auto' }],
+})

package/src/addons/color/palette/macbeth.ts

@@ -0,0 +1,42 @@
+import { Fn, vec3, Int, Vec3, If, select } from '../../../node'
+
+const colors = [
+        vec3(0.46017, 0.33059, 0.27477), // DARK_SKIN
+        vec3(0.769, 0.576, 0.506), // LIGHT_SKIN
+        vec3(0.356, 0.472, 0.609), // BLUE_SKY
+        vec3(0.357, 0.427, 0.247), // FOLIAGE
+        vec3(0.518, 0.506, 0.694), // BLUE_FLOWER
+        vec3(0.384, 0.749, 0.675), // BLUISH_GREEN
+        vec3(0.867, 0.487, 0.184), // ORANGE
+        vec3(0.290, 0.357, 0.671), // PURPLISH_BLUE
+        vec3(0.769, 0.333, 0.384), // MODERATE_RED
+        vec3(0.365, 0.231, 0.420), // PURPLE
+        vec3(0.624, 0.745, 0.227), // YELLOW_GREEN
+        vec3(0.894, 0.635, 0.160), // ORANGE_YELLOW
+        vec3(0.176, 0.247, 0.584), // BLUE
+        vec3(0.239, 0.588, 0.290), // GREEN
+        vec3(0.690, 0.224, 0.227), // RED
+        vec3(0.925, 0.784, 0.094), // YELLOW
+        vec3(0.749, 0.309, 0.598), // MAGENTA
+        vec3(0.000, 0.537, 0.659), // CYAN
+        vec3(0.956, 0.956, 0.945), // WHITE
+        vec3(0.789, 0.797, 0.797), // NEUTRAL_80
+        vec3(0.635, 0.643, 0.643), // NEUTRAL_65
+        vec3(0.475, 0.478, 0.478), // NEUTRAL_50
+        vec3(0.329, 0.333, 0.337), // NEUTRAL_35
+        vec3(0.200, 0.200, 0.204)  // BLACK
+]
+
+export const macbeth = Fn(([index]: [Int]): Vec3 => {
+        let result = vec3(0)
+        for (let i = 0; i < colors.length; i++) {
+                result = select(result, colors[i], index.equal(i))
+        }
+        return result
+}).setLayout({
+        name: 'macbeth',
+        type: 'vec3',
+        inputs: [
+                { name: 'index', type: 'int' }
+        ]
+})

package/src/addons/color/space/cmyk2rgb.ts

@@ -0,0 +1,12 @@
+import { Fn, Vec4, Vec3, float, vec3 } from '../../../node'
+
+export const cmyk2rgb = Fn(([cmyk]: [Vec4]): Vec3 => {
+        const invK = float(1).sub(cmyk.w).toVar()
+        return float(1)
+                .sub(vec3(1).min(cmyk.xyz.mul(invK).add(cmyk.w)))
+                .saturate()
+}).setLayout({
+        name: 'cmyk2rgb',
+        type: 'vec3',
+        inputs: [{ name: 'cmyk', type: 'vec4' }],
+})

package/src/addons/color/space/gamma2linear.ts

@@ -0,0 +1,19 @@
+import { Fn, Vec4, float, vec4, X } from '../../../node'
+
+const GAMMA = float(2.2)
+
+export const gamma2linear = Fn(([v]: [X]): X => {
+        return v.pow(GAMMA)
+}).setLayout({
+        name: 'gamma2linear',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})
+
+export const gamma2linearVec4 = Fn(([v]: [Vec4]): Vec4 => {
+        return vec4(gamma2linear(v.xyz), v.w)
+}).setLayout({
+        name: 'gamma2linearVec4',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})

package/src/addons/color/space/hsl2rgb.ts

@@ -0,0 +1,20 @@
+import { Fn, Vec3, Vec4, float, vec4 } from '../../../node'
+import { hue2rgb } from './hue2rgb'
+
+export const hsl2rgb = Fn(([hsl]: [Vec3]): Vec3 => {
+        const rgb = hue2rgb(hsl.x).toVar()
+        const C = float(1).sub(hsl.z.mul(2).sub(1).abs()).mul(hsl.y).toVar()
+        return rgb.sub(0.5).mul(C).add(hsl.z)
+}).setLayout({
+        name: 'hsl2rgb',
+        type: 'vec3',
+        inputs: [{ name: 'hsl', type: 'vec3' }],
+})
+
+export const hsl2rgbVec4 = Fn(([hsl]: [Vec4]): Vec4 => {
+        return vec4(hsl2rgb(hsl.xyz), hsl.w)
+}).setLayout({
+        name: 'hsl2rgbVec4',
+        type: 'vec4',
+        inputs: [{ name: 'hsl', type: 'vec4' }],
+})

package/src/addons/color/space/hsv2rgb.ts

@@ -0,0 +1,18 @@
+import { Fn, Vec3, Vec4, vec4 } from '../../../node'
+import { hue2rgb } from './hue2rgb'
+
+export const hsv2rgb = Fn(([hsv]: [Vec3]): Vec3 => {
+        return hue2rgb(hsv.x).sub(1).mul(hsv.y).add(1).mul(hsv.z)
+}).setLayout({
+        name: 'hsv2rgb',
+        type: 'vec3',
+        inputs: [{ name: 'hsv', type: 'vec3' }],
+})
+
+export const hsv2rgbVec4 = Fn(([hsv]: [Vec4]): Vec4 => {
+        return vec4(hsv2rgb(hsv.xyz), hsv.w)
+}).setLayout({
+        name: 'hsv2rgbVec4',
+        type: 'vec4',
+        inputs: [{ name: 'hsv', type: 'vec4' }],
+})

package/src/addons/color/space/hue2rgb.ts

@@ -0,0 +1,12 @@
+import { Fn, Float, Vec3, float, vec3 } from '../../../node'
+
+export const hue2rgb = Fn(([hue]: [Float]): Vec3 => {
+        const R = hue.mul(6).sub(3).abs().sub(1).toVar()
+        const G = float(2).sub(hue.mul(6).sub(2).abs()).toVar()
+        const B = float(2).sub(hue.mul(6).sub(4).abs()).toVar()
+        return vec3(R, G, B).saturate()
+}).setLayout({
+        name: 'hue2rgb',
+        type: 'vec3',
+        inputs: [{ name: 'hue', type: 'float' }],
+})

package/src/addons/color/space/index.ts

@@ -0,0 +1,29 @@
+export * from './cmyk2rgb'
+export * from './gamma2linear'
+export * from './hsl2rgb'
+export * from './hsv2rgb'
+export * from './hue2rgb'
+export * from './lab2lch'
+export * from './lab2rgb'
+export * from './lab2xyz'
+export * from './lch2lab'
+export * from './lch2rgb'
+export * from './linear2gamma'
+export * from './oklab2rgb'
+export * from './rgb2cmyk'
+export * from './rgb2hcv'
+export * from './rgb2hsl'
+export * from './rgb2hsv'
+export * from './rgb2hue'
+export * from './rgb2lab'
+export * from './rgb2lch'
+export * from './rgb2oklab'
+export * from './rgb2srgb'
+export * from './rgb2xyz'
+export * from './rgb2yiq'
+export * from './rgb2yuv'
+export * from './srgb2rgb'
+export * from './xyz2lab'
+export * from './xyz2rgb'
+export * from './yiq2rgb'
+export * from './yuv2rgb'

package/src/addons/color/space/lab2lch.ts

@@ -0,0 +1,22 @@
+import { Fn, atan2, sqrt, vec3, vec4, Vec3, Vec4 } from '../../../node'
+
+export const lab2lch3 = Fn(([lab]: [Vec3]): Vec3 => {
+        const chroma = sqrt(lab.y.mul(lab.y).add(lab.z.mul(lab.z)))
+        const hue = atan2(lab.z, lab.y).mul(57.2957795131)
+        return vec3(lab.x, chroma, hue)
+}).setLayout({
+        name: 'lab2lch3',
+        type: 'vec3',
+        inputs: [{ name: 'lab', type: 'vec3' }],
+})
+
+export const lab2lch4 = Fn(([lab]: [Vec4]): Vec4 => {
+        const lch = lab2lch3(lab.xyz)
+        return vec4(lch, lab.w)
+}).setLayout({
+        name: 'lab2lch4',
+        type: 'vec4',
+        inputs: [{ name: 'lab', type: 'vec4' }],
+})
+
+export const lab2lch = lab2lch3

package/src/addons/color/space/lab2rgb.ts

@@ -0,0 +1,19 @@
+import { Fn, Vec3, Vec4, vec4 } from '../../../node'
+import { lab2xyz } from './lab2xyz'
+import { xyz2rgb } from './xyz2rgb'
+
+export const lab2rgb = Fn(([lab]: [Vec3]): Vec3 => {
+        return xyz2rgb(lab2xyz(lab))
+}).setLayout({
+        name: 'lab2rgb',
+        type: 'vec3',
+        inputs: [{ name: 'lab', type: 'vec3' }],
+})
+
+export const lab2rgbVec4 = Fn(([lab]: [Vec4]): Vec4 => {
+        return vec4(lab2rgb(lab.xyz), lab.w)
+}).setLayout({
+        name: 'lab2rgbVec4',
+        type: 'vec4',
+        inputs: [{ name: 'lab', type: 'vec4' }],
+})

package/src/addons/color/space/lab2xyz.ts

@@ -0,0 +1,32 @@
+import { Fn, Vec3, Vec4, float, select, vec3, vec4 } from '../../../node'
+
+// CIE D65 white point (default)
+const CIE_WHITE = vec3(0.95045592705, 1, 1.08905775076)
+
+export const lab2xyz = Fn(([lab]: [Vec3]): Vec3 => {
+        const fy = lab.x.add(16).div(116).toVar()
+        const fx = lab.y.div(500).add(fy).toVar()
+        const fz = fy.sub(lab.z.div(200)).toVar()
+
+        const threshold = float(0.206897)
+        const delta = float(16).div(116)
+        const factor = float(7.787)
+
+        const convertX = select(fx.pow(3), fx.sub(delta).div(factor), fx.greaterThan(threshold))
+        const convertY = select(fy.pow(3), fy.sub(delta).div(factor), fy.greaterThan(threshold))
+        const convertZ = select(fz.pow(3), fz.sub(delta).div(factor), fz.greaterThan(threshold))
+
+        return CIE_WHITE.mul(100).mul(vec3(convertX, convertY, convertZ))
+}).setLayout({
+        name: 'lab2xyz',
+        type: 'vec3',
+        inputs: [{ name: 'lab', type: 'vec3' }],
+})
+
+export const lab2xyzVec4 = Fn(([lab]: [Vec4]): Vec4 => {
+        return vec4(lab2xyz(lab.xyz), lab.w)
+}).setLayout({
+        name: 'lab2xyzVec4',
+        type: 'vec4',
+        inputs: [{ name: 'lab', type: 'vec4' }],
+})

package/src/addons/color/space/lch2lab.ts

@@ -0,0 +1,21 @@
+import { Fn, vec3, vec4, Vec3, Vec4 } from '../../../node'
+
+export const lch2lab3 = Fn(([lch]: [Vec3]): Vec3 => {
+        const radians = lch.z.mul(0.01745329251)
+        return vec3(lch.x, lch.y.mul(radians.cos()), lch.y.mul(radians.sin()))
+}).setLayout({
+        name: 'lch2lab3',
+        type: 'vec3',
+        inputs: [{ name: 'lch', type: 'vec3' }],
+})
+
+export const lch2lab4 = Fn(([lch]: [Vec4]): Vec4 => {
+        const lab = lch2lab3(lch.xyz)
+        return vec4(lab, lch.w)
+}).setLayout({
+        name: 'lch2lab4',
+        type: 'vec4',
+        inputs: [{ name: 'lch', type: 'vec4' }],
+})
+
+export const lch2lab = lch2lab3

package/src/addons/color/space/lch2rgb.ts

@@ -0,0 +1,22 @@
+import { Fn, Vec3, Vec4, vec4 } from '../../../node'
+import { lch2lab } from './lch2lab'
+import { lab2rgb } from './lab2rgb'
+
+export const lch2rgb3 = Fn(([lch]: [Vec3]): Vec3 => {
+        return lab2rgb(lch2lab(lch))
+}).setLayout({
+        name: 'lch2rgb3',
+        type: 'vec3',
+        inputs: [{ name: 'lch', type: 'vec3' }],
+})
+
+export const lch2rgb4 = Fn(([lch]: [Vec4]): Vec4 => {
+        const rgb = lch2rgb3(lch.xyz)
+        return vec4(rgb, lch.w)
+}).setLayout({
+        name: 'lch2rgb4',
+        type: 'vec4',
+        inputs: [{ name: 'lch', type: 'vec4' }],
+})
+
+export const lch2rgb = lch2rgb3

package/src/addons/color/space/linear2gamma.ts

@@ -0,0 +1,19 @@
+import { Fn, Vec4, float, vec4, X } from '../../../node'
+
+const INV_GAMMA = float(1).div(2.2)
+
+export const linear2gamma = Fn(([v]: [X]): X => {
+        return v.pow(INV_GAMMA)
+}).setLayout({
+        name: 'linear2gamma',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})
+
+export const linear2gammaVec4 = Fn(([v]: [Vec4]): Vec4 => {
+        return vec4(linear2gamma(v.xyz), v.w)
+}).setLayout({
+        name: 'linear2gammaVec4',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})

package/src/addons/color/space/oklab2rgb.ts

@@ -0,0 +1,35 @@
+import { Fn, mat3, vec4, Vec3, Vec4 } from '../../../node'
+
+const OKLAB2RGB_A = mat3(1, 1, 1, 0.3963377774, -0.1055613458, -0.0894841775, 0.2158037573, -0.0638541728, -1.291485548)
+
+const OKLAB2RGB_B = mat3(
+        4.0767416621,
+        -1.2684380046,
+        -0.0041960863,
+        -3.3077115913,
+        2.6097574011,
+        -0.7034186147,
+        0.2309699292,
+        -0.3413193965,
+        1.707614701
+)
+
+export const oklab2rgb3 = Fn(([oklab]: [Vec3]): Vec3 => {
+        const lms = OKLAB2RGB_A.mul(oklab)
+        return OKLAB2RGB_B.mul(lms.mul(lms).mul(lms))
+}).setLayout({
+        name: 'oklab2rgb3',
+        type: 'vec3',
+        inputs: [{ name: 'oklab', type: 'vec3' }],
+})
+
+export const oklab2rgb4 = Fn(([oklab]: [Vec4]): Vec4 => {
+        const rgb = oklab2rgb3(oklab.xyz)
+        return vec4(rgb, oklab.w)
+}).setLayout({
+        name: 'oklab2rgb4',
+        type: 'vec4',
+        inputs: [{ name: 'oklab', type: 'vec4' }],
+})
+
+export const oklab2rgb = oklab2rgb3