glre 0.40.0 → 0.42.0

package/dist/react.d.ts

@@ -155,7 +155,7 @@ type Color = XImpl<'color'>;
 type Mat2 = XImpl<'mat2'>;
 type Mat3 = XImpl<'mat3'>;
 type Mat4 = XImpl<'mat4'>;
-type Texture = XImpl<'texture'>;
+type Texture$1 = XImpl<'texture'>;
 type Sampler2D = XImpl<'sampler2D'>;
 type StructBase = XImpl<'struct'>;
 interface ConstantsToType {
@@ -180,7 +180,7 @@ interface ConstantsToType {
     mat2: Mat2;
     mat3: Mat3;
     mat4: Mat4;
-    texture: Texture;
+    texture: Texture$1;
     sampler2D: Sampler2D;
     struct: StructBase;
 }
@@ -386,10 +386,10 @@ type GL = EventState<{
     uniform(target: {
         [key: string]: Uniform;
     }): GL;
-    _texture?(key: string, value: string): GL;
-    texture(key: string, value: string): GL;
+    _texture?(key: string, value: Texture): GL;
+    texture(key: string, value: Texture): GL;
     texture(target: {
-        [key: string]: string;
+        [key: string]: Texture;
     }): GL;
     _attribute?(key: string, value: Attribute, iboValue?: Attribute): GL;
     attribute(key: string, value: Attribute, iboValue?: Attribute): GL;
@@ -408,6 +408,7 @@ type GL = EventState<{
     }): GL;
 }>;
 type Uniform = number | number[] | Float32Array;
+type Texture = string | HTMLImageElement | HTMLVideoElement;
 type Attribute = number[] | Float32Array;
 type Storage = number[] | Float32Array;
 /**
@@ -501,10 +502,10 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     uniform(target: {
         [key: string]: number | number[] | Float32Array<ArrayBufferLike>;
     }): GL;
-    _texture?(key: string, value: string): GL;
-    texture(key: string, value: string): GL;
+    _texture?(key: string, value: string | HTMLImageElement | HTMLVideoElement): GL;
+    texture(key: string, value: string | HTMLImageElement | HTMLVideoElement): GL;
     texture(target: {
-        [key: string]: string;
+        [key: string]: string | HTMLImageElement | HTMLVideoElement;
     }): GL;
     _attribute?(key: string, value: number[] | Float32Array<ArrayBufferLike>, iboValue?: number[] | Float32Array<ArrayBufferLike>): GL;
     attribute(key: string, value: number[] | Float32Array<ArrayBufferLike>, iboValue?: number[] | Float32Array<ArrayBufferLike>): GL;

package/dist/solid.d.ts

@@ -155,7 +155,7 @@ type Color = XImpl<'color'>;
 type Mat2 = XImpl<'mat2'>;
 type Mat3 = XImpl<'mat3'>;
 type Mat4 = XImpl<'mat4'>;
-type Texture = XImpl<'texture'>;
+type Texture$1 = XImpl<'texture'>;
 type Sampler2D = XImpl<'sampler2D'>;
 type StructBase = XImpl<'struct'>;
 interface ConstantsToType {
@@ -180,7 +180,7 @@ interface ConstantsToType {
     mat2: Mat2;
     mat3: Mat3;
     mat4: Mat4;
-    texture: Texture;
+    texture: Texture$1;
     sampler2D: Sampler2D;
     struct: StructBase;
 }
@@ -386,10 +386,10 @@ type GL = EventState<{
     uniform(target: {
         [key: string]: Uniform;
     }): GL;
-    _texture?(key: string, value: string): GL;
-    texture(key: string, value: string): GL;
+    _texture?(key: string, value: Texture): GL;
+    texture(key: string, value: Texture): GL;
     texture(target: {
-        [key: string]: string;
+        [key: string]: Texture;
     }): GL;
     _attribute?(key: string, value: Attribute, iboValue?: Attribute): GL;
     attribute(key: string, value: Attribute, iboValue?: Attribute): GL;
@@ -408,6 +408,7 @@ type GL = EventState<{
     }): GL;
 }>;
 type Uniform = number | number[] | Float32Array;
+type Texture = string | HTMLImageElement | HTMLVideoElement;
 type Attribute = number[] | Float32Array;
 type Storage = number[] | Float32Array;
 /**
@@ -501,10 +502,10 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     uniform(target: {
         [key: string]: number | number[] | Float32Array<ArrayBufferLike>;
     }): GL;
-    _texture?(key: string, value: string): GL;
-    texture(key: string, value: string): GL;
+    _texture?(key: string, value: string | HTMLImageElement | HTMLVideoElement): GL;
+    texture(key: string, value: string | HTMLImageElement | HTMLVideoElement): GL;
     texture(target: {
-        [key: string]: string;
+        [key: string]: string | HTMLImageElement | HTMLVideoElement;
     }): GL;
     _attribute?(key: string, value: number[] | Float32Array<ArrayBufferLike>, iboValue?: number[] | Float32Array<ArrayBufferLike>): GL;
     attribute(key: string, value: number[] | Float32Array<ArrayBufferLike>, iboValue?: number[] | Float32Array<ArrayBufferLike>): GL;

package/package.json

@@ -1,6 +1,6 @@
 {
         "name": "glre",
-        "version": "0.40.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' },
+        ],
+})