glre 0.41.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
         "name": "glre",
-        "version": "0.41.0",
+        "version": "0.42.0",
         "author": "tseijp",
         "license": "MIT",
         "private": false,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+import { Fn, Float, Vec3 } from '../../../node'
+import { blendReflect, blendReflectVec3 } from './reflect'
+
+export const blendGlow = Fn(([base, blend]: [Float, Float]): Float => {
+        return blendReflect(blend, base)
+}).setLayout({
+        name: 'blendGlow',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendGlowVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return blendReflectVec3(blend, base)
+}).setLayout({
+        name: 'blendGlowVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendGlowVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendGlowVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendGlowVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

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

@@ -0,0 +1,36 @@
+import { Fn, Float, Vec3 } from '../../../node'
+import { blendOverlay, blendOverlayVec3 } from './overlay'
+
+export const blendHardLight = Fn(([base, blend]: [Float, Float]): Float => {
+        return blendOverlay(blend, base)
+}).setLayout({
+        name: 'blendHardLight',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendHardLightVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return blendOverlayVec3(blend, base)
+}).setLayout({
+        name: 'blendHardLightVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendHardLightVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendHardLightVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendHardLightVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

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

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

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

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

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

@@ -0,0 +1,28 @@
+export * from './add'
+export * from './average'
+export * from './color'
+export * from './colorBurn'
+export * from './colorDodge'
+export * from './darken'
+export * from './difference'
+export * from './exclusion'
+export * from './glow'
+export * from './hardLight'
+export * from './hardMix'
+export * from './hue'
+export * from './lighten'
+export * from './linearBurn'
+export * from './luminosity'
+export * from './multiply'
+export * from './linearDodge'
+export * from './linearLight'
+export * from './negation'
+export * from './phoenix'
+export * from './pinLight'
+export * from './vividLight'
+export * from './overlay'
+export * from './reflect'
+export * from './saturation'
+export * from './screen'
+export * from './softLight'
+export * from './subtract'

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

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

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

@@ -0,0 +1,39 @@
+import { Fn, Float, Vec3, vec3, max } from '../../../node'
+
+export const blendLinearBurn = Fn(([base, blend]: [Float, Float]): Float => {
+        return max(base.add(blend).sub(1), 0)
+}).setLayout({
+        name: 'blendLinearBurn',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendLinearBurnVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(
+                blendLinearBurn(base.r, blend.r),
+                blendLinearBurn(base.g, blend.g),
+                blendLinearBurn(base.b, blend.b)
+        )
+}).setLayout({
+        name: 'blendLinearBurnVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendLinearBurnVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendLinearBurnVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendLinearBurnVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

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

@@ -0,0 +1,39 @@
+import { Fn, Float, Vec3, vec3, min } from '../../../node'
+
+export const blendLinearDodge = Fn(([base, blend]: [Float, Float]): Float => {
+        return min(base.add(blend), 1)
+}).setLayout({
+        name: 'blendLinearDodge',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendLinearDodgeVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(
+                blendLinearDodge(base.r, blend.r),
+                blendLinearDodge(base.g, blend.g),
+                blendLinearDodge(base.b, blend.b)
+        )
+}).setLayout({
+        name: 'blendLinearDodgeVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendLinearDodgeVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendLinearDodgeVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendLinearDodgeVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

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

@@ -0,0 +1,44 @@
+import { Fn, Float, Vec3, vec3, If } from '../../../node'
+import { blendLinearBurn } from './linearBurn'
+import { blendLinearDodge } from './linearDodge'
+
+export const blendLinearLight = Fn(([base, blend]: [Float, Float]): Float => {
+        If(blend.lessThan(0.5), () => {
+                return blendLinearBurn(base, blend.mul(2))
+        })
+        return blendLinearDodge(base, blend.sub(0.5).mul(2))
+}).setLayout({
+        name: 'blendLinearLight',
+        type: 'float',
+        inputs: [
+                { name: 'base', type: 'float' },
+                { name: 'blend', type: 'float' },
+        ],
+})
+
+export const blendLinearLightVec3 = Fn(([base, blend]: [Vec3, Vec3]): Vec3 => {
+        return vec3(
+                blendLinearLight(base.r, blend.r),
+                blendLinearLight(base.g, blend.g),
+                blendLinearLight(base.b, blend.b)
+        )
+}).setLayout({
+        name: 'blendLinearLightVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+        ],
+})
+
+export const blendLinearLightVec3Opacity = Fn(([base, blend, opacity]: [Vec3, Vec3, Float]): Vec3 => {
+        return blendLinearLightVec3(base, blend).mul(opacity).add(base.mul(opacity.oneMinus()))
+}).setLayout({
+        name: 'blendLinearLightVec3Opacity',
+        type: 'vec3',
+        inputs: [
+                { name: 'base', type: 'vec3' },
+                { name: 'blend', type: 'vec3' },
+                { name: 'opacity', type: 'float' },
+        ],
+})

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' },
+        ],
+})