glre 0.41.0 → 0.43.0

package/src/addons/color/blend/luminosity.ts

@@ -0,0 +1,28 @@
+import { Fn, Vec3, Float, vec3 } from '../../../node'
+import { rgb2hsv } from '../space/rgb2hsv'
+import { hsv2rgb } from '../space/hsv2rgb'
+
+export const blendLuminosity = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        const baseHSV = rgb2hsv(base)
+        const blendHSV = rgb2hsv(blend)
+        return hsv2rgb(vec3(baseHSV.x, baseHSV.y, blendHSV.z))
+}).setLayout({
+        name: 'blendLuminosity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendLuminosityOpacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendLuminosity(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendLuminosityOpacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/multiply.ts

@@ -0,0 +1,35 @@
+import { Fn, Float, Vec3 } from '../../../node'
+
+export const blendMultiply = Fn(([base, blend]: [Float, Float]): Float => {
+        return base.mul(blend)
+}).setLayout({
+        name: 'blendMultiply',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendMultiplyVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return base.mul(blend)
+}).setLayout({
+        name: 'blendMultiplyVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendMultiplyVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendMultiplyVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendMultiplyVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/negation.ts

@@ -0,0 +1,35 @@
+import { Fn, Float, Vec3, vec3, abs, float } from '../../../node'
+
+export const blendNegation = Fn(([base, blend]: [Float, Float]): Float => {
+        return float(1).sub(abs(float(1).sub(base).sub(blend)))
+}).setLayout({
+        name: 'blendNegation',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendNegationVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(1).sub(abs(vec3(1).sub(base).sub(blend)))
+}).setLayout({
+        name: 'blendNegationVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendNegationVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendNegationVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendNegationVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/overlay.ts

@@ -0,0 +1,38 @@
+import { Fn, Float, Vec3, vec3, If } from '../../../node'
+
+export const blendOverlay = Fn(([base, blend]: [Float, Float]): Float => {
+        If(base.lessThan(0.5), () => {
+                return base.mul(blend).mul(2)
+        })
+        return base.oneMinus().mul(blend.oneMinus()).mul(2).oneMinus()
+}).setLayout({
+        name: 'blendOverlay',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendOverlayVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(blendOverlay(base.r, blend.r), blendOverlay(base.g, blend.g), blendOverlay(base.b, blend.b))
+}).setLayout({
+        name: 'blendOverlayVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendOverlayVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendOverlayVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendOverlayVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/phoenix.ts

@@ -0,0 +1,35 @@
+import { Fn, Float, Vec3, vec3, min, max, float } from '../../../node'
+
+export const blendPhoenix = Fn(([base, blend]: [Float, Float]): Float => {
+        return min(base, blend).sub(max(base, blend)).add(float(1))
+}).setLayout({
+        name: 'blendPhoenix',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendPhoenixVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return min(base, blend).sub(max(base, blend)).add(vec3(1))
+}).setLayout({
+        name: 'blendPhoenixVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendPhoenixVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendPhoenixVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendPhoenixVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/pinLight.ts

@@ -0,0 +1,40 @@
+import { Fn, Float, Vec3, vec3, If } from '../../../node'
+import { blendDarken } from './darken'
+import { blendLighten } from './lighten'
+
+export const blendPinLight = Fn(([base, blend]: [Float, Float]): Float => {
+        If(blend.lessThan(0.5), () => {
+                return blendDarken(base, blend.mul(2))
+        })
+        return blendLighten(base, blend.sub(0.5).mul(2))
+}).setLayout({
+        name: 'blendPinLight',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendPinLightVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(blendPinLight(base.x, blend.x), blendPinLight(base.y, blend.y), blendPinLight(base.z, blend.z))
+}).setLayout({
+        name: 'blendPinLightVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendPinLightVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendPinLightVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendPinLightVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/reflect.ts

@@ -0,0 +1,35 @@
+import { Fn, Float, Vec3, vec3, min, select } from '../../../node'
+
+export const blendReflect = Fn(([base, blend]: [Float, Float]): Float => {
+        return select(blend, min(base.mul(base).div(blend.oneMinus()), 1), blend.equal(1))
+}).setLayout({
+        name: 'blendReflect',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendReflectVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(blendReflect(base.r, blend.r), blendReflect(base.g, blend.g), blendReflect(base.b, blend.b))
+}).setLayout({
+        name: 'blendReflectVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendReflectVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendReflectVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendReflectVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/saturation.ts

@@ -0,0 +1,28 @@
+import { Fn, Vec3, Float, vec3 } from '../../../node'
+import { rgb2hsv } from '../space/rgb2hsv'
+import { hsv2rgb } from '../space/hsv2rgb'
+
+export const blendSaturation = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        const baseHSV = rgb2hsv(base)
+        const blendHSV = rgb2hsv(blend)
+        return hsv2rgb(vec3(baseHSV.x, blendHSV.y, baseHSV.z))
+}).setLayout({
+        name: 'blendSaturation',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendSaturationOpacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendSaturation(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendSaturationOpacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/screen.ts

@@ -0,0 +1,39 @@
+import { Fn, Float, Vec3, vec3, float } from '../../../node'
+
+export const blendScreenFloat = Fn(([base, blend]: [Float, Float]): Float => {
+        return float(1).sub(float(1).sub(base).mul(float(1).sub(blend)))
+}).setLayout({
+        name: 'blendScreenFloat',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendScreen = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(
+                blendScreenFloat(base.x, blend.x),
+                blendScreenFloat(base.y, blend.y),
+                blendScreenFloat(base.z, blend.z)
+        )
+}).setLayout({
+        name: 'blendScreen',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendScreenOpacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendScreen(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendScreenOpacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/softLight.ts

@@ -0,0 +1,63 @@
+import { Fn, Float, Vec3, Vec4, If, sqrt, vec3, vec4 } from '../../../node'
+
+const blendSoftLightFloat = Fn(([base, blend]: [Float, Float]): Float => {
+        If(blend.lessThan(0.5), () => {
+                return base
+                        .mul(2)
+                        .mul(blend)
+                        .add(base.mul(base).mul(blend.mul(2).oneMinus()))
+        })
+        return sqrt(base).mul(blend.mul(2).sub(1)).add(base.mul(2).mul(blend.oneMinus()))
+}).setLayout({
+        name: 'blendSoftLight',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendSoftLight = blendSoftLightFloat
+
+export const blendSoftLightVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(
+                blendSoftLightFloat(base.r, blend.r),
+                blendSoftLightFloat(base.g, blend.g),
+                blendSoftLightFloat(base.b, blend.b)
+        )
+}).setLayout({
+        name: 'blendSoftLightVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendSoftLightVec4 = Fn(([base, blend]: [Vec4, Vec4]): Vec4 => {
+        return vec4(
+                blendSoftLightFloat(base.r, blend.r),
+                blendSoftLightFloat(base.g, blend.g),
+                blendSoftLightFloat(base.b, blend.b),
+                blendSoftLightFloat(base.a, blend.a)
+        )
+}).setLayout({
+        name: 'blendSoftLightVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'base', type: 'vec4' },
+                { name: 'blend', type: 'vec4' },
+        ],
+})
+
+export const blendSoftLightVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendSoftLightVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendSoftLightVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/blend/subtract.ts

@@ -0,0 +1,37 @@
+import { Fn, Float, Vec3, max, vec3 } from '../../../node'
+
+const blendSubtractFloat = Fn(([base, blend]: [Float, Float]): Float => {
+        return max(base.add(blend).sub(1), 0)
+}).setLayout({
+        name: 'blendSubtract',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' }
+        ]
+})
+
+export const blendSubtract = blendSubtractFloat
+
+export const blendSubtractVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return max(base.add(blend).sub(vec3(1)), vec3(0))
+}).setLayout({
+        name: 'blendSubtractVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' }
+        ]
+})
+
+export const blendSubtractVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendSubtractVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendSubtractVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' }
+        ]
+})

package/src/addons/color/blend/vividLight.ts

@@ -0,0 +1,44 @@
+import { Fn, Float, Vec3, vec3, If } from '../../../node'
+import { blendColorBurn } from './colorBurn'
+import { blendColorDodge } from './colorDodge'
+
+export const blendVividLight = Fn(([base, blend]: [Float, Float]): Float => {
+        If(blend.lessThan(0.5), () => {
+                return blendColorBurn(base, blend.mul(2))
+        })
+        return blendColorDodge(base, blend.sub(0.5).mul(2))
+}).setLayout({
+        name: 'blendVividLight',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendVividLightVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(
+                blendVividLight(base.r, blend.r),
+                blendVividLight(base.g, blend.g),
+                blendVividLight(base.b, blend.b)
+        )
+}).setLayout({
+        name: 'blendVividLightVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendVividLightVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendVividLightVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendVividLightVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

package/src/addons/color/composite/compositeXor.ts

@@ -0,0 +1,40 @@
+import { Fn, Float, Vec3, Vec4, vec4 } from '../../../node'
+
+const compositeXorFloat = Fn(([src, dst]: [Float, Float]): Float => {
+        return src.mul(dst.oneMinus()).add(dst.mul(src.oneMinus()))
+}).setLayout({
+        name: 'compositeXor',
+        type: 'float',
+        inputs: [
+                { name: 'src', type: 'float' },
+                { name: 'dst', type: 'float' },
+        ],
+})
+
+export const compositeXor = compositeXorFloat
+
+export const compositeXorVec3 = Fn(([srcColor, dstColor, srcAlpha, dstAlpha]: [Vec3, Vec3, Float, Float]): Vec3 => {
+        return srcColor.mul(dstAlpha.oneMinus()).add(dstColor.mul(srcAlpha.oneMinus()))
+}).setLayout({
+        name: 'compositeXorVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'srcColor', type: 'vec3' },
+                { name: 'dstColor', type: 'vec3' },
+                { name: 'srcAlpha', type: 'float' },
+                { name: 'dstAlpha', type: 'float' },
+        ],
+})
+
+export const compositeXorVec4 = Fn(([srcColor, dstColor]: [Vec4, Vec4]): Vec4 => {
+        const resultRgb = compositeXorVec3(srcColor.rgb, dstColor.rgb, srcColor.a, dstColor.a)
+        const resultA = compositeXorFloat(srcColor.a, dstColor.a)
+        return vec4(resultRgb, resultA)
+}).setLayout({
+        name: 'compositeXorVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'srcColor', type: 'vec4' },
+                { name: 'dstColor', type: 'vec4' },
+        ],
+})

package/src/addons/color/composite/destinationAtop.ts

@@ -0,0 +1,42 @@
+import { Fn, Float, Vec3, Vec4, vec4 } from '../../../node'
+
+const compositeDestinationAtopFloat = Fn(([src, dst]: [Float, Float]): Float => {
+        return dst.mul(src).add(src.mul(dst.oneMinus()))
+}).setLayout({
+        name: 'compositeDestinationAtop',
+        type: 'float',
+        inputs: [
+                { name: 'src', type: 'float' },
+                { name: 'dst', type: 'float' },
+        ],
+})
+
+export const compositeDestinationAtop = compositeDestinationAtopFloat
+
+export const compositeDestinationAtopVec3 = Fn(
+        ([srcColor, dstColor, srcAlpha, dstAlpha]: [Vec3, Vec3, Float, Float]): Vec3 => {
+                return dstColor.mul(srcAlpha).add(srcColor.mul(dstAlpha.oneMinus()))
+        }
+).setLayout({
+        name: 'compositeDestinationAtopVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'srcColor', type: 'vec3' },
+                { name: 'dstColor', type: 'vec3' },
+                { name: 'srcAlpha', type: 'float' },
+                { name: 'dstAlpha', type: 'float' },
+        ],
+})
+
+export const compositeDestinationAtopVec4 = Fn(([srcColor, dstColor]: [Vec4, Vec4]): Vec4 => {
+        const resultRgb = compositeDestinationAtopVec3(srcColor.rgb, dstColor.rgb, srcColor.a, dstColor.a)
+        const resultA = compositeDestinationAtopFloat(srcColor.a, dstColor.a)
+        return vec4(resultRgb, resultA)
+}).setLayout({
+        name: 'compositeDestinationAtopVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'srcColor', type: 'vec4' },
+                { name: 'dstColor', type: 'vec4' },
+        ],
+})

package/src/addons/color/composite/destinationIn.ts

@@ -0,0 +1,42 @@
+import { Fn, Float, Vec3, Vec4, vec4 } from '../../../node'
+
+const compositeDestinationInFloat = Fn(([src, dst]: [Float, Float]): Float => {
+        return dst.mul(src)
+}).setLayout({
+        name: 'compositeDestinationIn',
+        type: 'float',
+        inputs: [
+                { name: 'src', type: 'float' },
+                { name: 'dst', type: 'float' },
+        ],
+})
+
+export const compositeDestinationIn = compositeDestinationInFloat
+
+export const compositeDestinationInVec3 = Fn(
+        ([srcColor, dstColor, srcAlpha, dstAlpha]: [Vec3, Vec3, Float, Float]): Vec3 => {
+                return dstColor.mul(srcAlpha)
+        }
+).setLayout({
+        name: 'compositeDestinationInVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'srcColor', type: 'vec3' },
+                { name: 'dstColor', type: 'vec3' },
+                { name: 'srcAlpha', type: 'float' },
+                { name: 'dstAlpha', type: 'float' },
+        ],
+})
+
+export const compositeDestinationInVec4 = Fn(([srcColor, dstColor]: [Vec4, Vec4]): Vec4 => {
+        const resultRgb = compositeDestinationInVec3(srcColor.rgb, dstColor.rgb, srcColor.a, dstColor.a)
+        const resultA = compositeDestinationInFloat(srcColor.a, dstColor.a)
+        return vec4(resultRgb, resultA)
+}).setLayout({
+        name: 'compositeDestinationInVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'srcColor', type: 'vec4' },
+                { name: 'dstColor', type: 'vec4' },
+        ],
+})

package/src/addons/color/composite/destinationOut.ts

@@ -0,0 +1,42 @@
+import { Fn, Float, Vec3, Vec4, vec4 } from '../../../node'
+
+const compositeDestinationOutFloat = Fn(([src, dst]: [Float, Float]): Float => {
+        return dst.mul(src.oneMinus())
+}).setLayout({
+        name: 'compositeDestinationOut',
+        type: 'float',
+        inputs: [
+                { name: 'src', type: 'float' },
+                { name: 'dst', type: 'float' },
+        ],
+})
+
+export const compositeDestinationOut = compositeDestinationOutFloat
+
+export const compositeDestinationOutVec3 = Fn(
+        ([_srcColor, dstColor, srcAlpha, _dstAlpha]: [Vec3, Vec3, Float, Float]): Vec3 => {
+                return dstColor.mul(srcAlpha.oneMinus())
+        }
+).setLayout({
+        name: 'compositeDestinationOutVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'srcColor', type: 'vec3' },
+                { name: 'dstColor', type: 'vec3' },
+                { name: 'srcAlpha', type: 'float' },
+                { name: 'dstAlpha', type: 'float' },
+        ],
+})
+
+export const compositeDestinationOutVec4 = Fn(([srcColor, dstColor]: [Vec4, Vec4]): Vec4 => {
+        const resultRgb = compositeDestinationOutVec3(srcColor.rgb, dstColor.rgb, srcColor.a, dstColor.a)
+        const resultA = compositeDestinationOutFloat(srcColor.a, dstColor.a)
+        return vec4(resultRgb, resultA)
+}).setLayout({
+        name: 'compositeDestinationOutVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'srcColor', type: 'vec4' },
+                { name: 'dstColor', type: 'vec4' },
+        ],
+})