glre 0.41.0 → 0.43.0

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

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

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

@@ -0,0 +1,9 @@
+export * from './compositeXor'
+export * from './destinationAtop'
+export * from './destinationIn'
+export * from './destinationOut'
+export * from './destinationOver'
+export * from './sourceAtop'
+export * from './sourceIn'
+export * from './sourceOut'
+export * from './sourceOver'

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

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

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

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

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

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

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

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

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

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

package/src/addons/draw/arrows.ts

@@ -1,59 +1,46 @@
-import { Fn, Vec2, Float, float, vec2, floor, length, clamp, min, dot, cos, normalize, If } from '../../node'
+import { Fn, Float, Vec2, float, vec2, length, clamp, min, step, If } from '../../node'
+import { lineSDF } from '../sdf/lineSDF'
 
-// Constants
-const ARROWS_TILE_SIZE = float(32)
-const ARROWS_HEAD_ANGLE = float(0.5)
+const ARROWS_TILE_SIZE = float(32.0)
 
-// Arrow tile center coordinate calculation
 export const arrowsTileCenterCoord = Fn(([pos]: [Vec2]): Vec2 => {
-        return floor(pos.div(ARROWS_TILE_SIZE)).add(0.5).mul(ARROWS_TILE_SIZE)
+        const floored = pos.div(ARROWS_TILE_SIZE).floor()
+        return floored.add(0.5).mul(ARROWS_TILE_SIZE)
 }).setLayout({
         name: 'arrowsTileCenterCoord',
         type: 'vec2',
         inputs: [{ name: 'pos', type: 'vec2' }],
 })
 
-// Arrows with resolution parameter
-export const arrowsWithResolution = Fn(([p, v, resolution]: [Vec2, Vec2, Vec2]): Float => {
-        const scaledP = p.mul(resolution).toVar()
-        scaledP.subAssign(arrowsTileCenterCoord(scaledP))
-        const mag_v = length(v).toVar()
-
-        const result = float(0).toVar()
-
-        If(mag_v.greaterThan(0), () => {
-                const dir_v = v.div(mag_v).toVar()
-                mag_v.assign(clamp(mag_v, 5, ARROWS_TILE_SIZE.div(2)))
-                const vScaled = dir_v.mul(mag_v).toVar()
-
-                // Simplified arrow implementation based on GLSL default style
-                const arrow = float(1)
-                        .add(
-                                min(
-                                        float(0),
-                                        dot(normalize(vScaled.sub(scaledP)), dir_v).sub(cos(ARROWS_HEAD_ANGLE.div(2)))
-                                )
-                                        .mul(2)
-                                        .mul(length(vScaled.sub(scaledP)))
-                                        .add(min(float(0), dot(scaledP, dir_v).add(1)))
-                                        .add(
-                                                min(
-                                                        float(0),
-                                                        cos(ARROWS_HEAD_ANGLE.div(2)).sub(
-                                                                dot(normalize(vScaled.mul(0.33).sub(scaledP)), dir_v)
-                                                        )
-                                                )
-                                                        .mul(mag_v)
-                                                        .mul(0.8)
-                                        )
-                        )
-                        .saturate()
-                result.assign(arrow)
+export const arrows = Fn(([p, v, resolution]: [Vec2, Vec2, Vec2]): Float => {
+        const pScaled = p.mul(resolution).toVar('pScaled')
+        pScaled.subAssign(arrowsTileCenterCoord(pScaled))
+        const mag_v = length(v).toVar('mag_v')
+
+        If(mag_v.greaterThan(0.0), () => {
+                const dir_v = v.div(mag_v).toVar('dir_v')
+                mag_v.assign(clamp(mag_v, float(5.0), ARROWS_TILE_SIZE.div(2.0)))
+                const vScaled = dir_v.mul(mag_v).toVar('vScaled')
+
+                const shaft = lineSDF(pScaled, vScaled, vScaled.negate()).toVar('shaft')
+                const head1 = lineSDF(
+                        pScaled,
+                        vScaled,
+                        vScaled.mul(0.4).add(vec2(vScaled.y.negate(), vScaled.x).mul(0.2))
+                ).toVar('head1')
+                const head2 = lineSDF(
+                        pScaled,
+                        vScaled,
+                        vScaled.mul(0.4).add(vec2(vScaled.y, vScaled.x.negate()).mul(0.2))
+                ).toVar('head2')
+                const head = min(head1, head2).toVar('head')
+
+                return step(min(shaft, head), float(1.0))
         })
 
-        return result
+        return float(0.0)
 }).setLayout({
-        name: 'arrowsWithResolution',
+        name: 'arrows',
         type: 'float',
         inputs: [
                 { name: 'p', type: 'vec2' },
@@ -62,11 +49,10 @@ export const arrowsWithResolution = Fn(([p, v, resolution]: [Vec2, Vec2, Vec2]):
         ],
 })
 
-// Arrows with default resolution
-export const arrows = Fn(([p, v]: [Vec2, Vec2]): Float => {
-        return arrowsWithResolution(p, v, vec2(1))
+export const arrowsSimple = Fn(([p, v]: [Vec2, Vec2]): Float => {
+        return arrows(p, v, vec2(1.0))
 }).setLayout({
-        name: 'arrows',
+        name: 'arrowsSimple',
         type: 'float',
         inputs: [
                 { name: 'p', type: 'vec2' },

package/src/addons/draw/axis.ts

@@ -1,50 +1,32 @@
-import { Fn, Vec2, Vec3, Vec4, Mat4, Float, vec3, vec4, Loop, int } from '../../node'
+import { Fn, Vec2, Vec3, Vec4, Mat4, Float, vec3, vec4 } from '../../node'
 import { line } from './line'
 
 export const axis = Fn(([st, M, pos, thickness]: [Vec2, Mat4, Vec3, Float]): Vec4 => {
-        let result = vec4(0, 0, 0, 0).toVar()
+        const rta = vec4(0).toVar()
 
-        // Transform center position
         const center = M.mul(vec4(pos, 1)).toVar()
-        center.xy.assign(center.xy.div(center.w))
-        center.xy.assign(center.xy.div(2).add(0.5))
-
-        // Define axis colors (RGB for XYZ)
-        const axisColors = [
-                vec4(1, 0, 0, 1), // Red for X axis
-                vec4(0, 1, 0, 1), // Green for Y axis
-                vec4(0, 0, 1, 1), // Blue for Z axis
-        ]
-
-        const axisDirections = [
-                vec3(1, 0, 0), // X direction
-                vec3(0, 1, 0), // Y direction
-                vec3(0, 0, 1), // Z direction
-        ]
-
-        // Draw each axis
-        Loop(int(3), ({ i }) => {
-                const axisColor = (i.equal(int(0)) as any).select(
-                        axisColors[0],
-                        (i.equal(int(1)) as any).select(axisColors[1], axisColors[2])
-                )
-
-                const axisDir = (i.equal(int(0)) as any).select(
-                        axisDirections[0],
-                        (i.equal(int(1)) as any).select(axisDirections[1], axisDirections[2])
-                )
-
-                // Transform axis endpoint
-                const axisPoint = (M as any).mul(vec4((pos as any).add(axisDir as any), 1)).toVar()
-                axisPoint.xy.assign(axisPoint.xy.div(axisPoint.w))
-                axisPoint.xy.assign(axisPoint.xy.div(2).add(0.5))
-
-                // Draw line from center to axis endpoint
-                const axisLine = line(st, center.xy, axisPoint.xy, thickness)
-                result.addAssign((axisColor as any).mul(axisLine as any))
-        })
-
-        return result
+        center.xy.divAssign(center.w)
+        center.xy.assign(center.xy.mul(0.5).add(0.5))
+
+        const axisX = vec4(1, 0, 0, 1)
+        const aX = M.mul(vec4(pos.add(vec3(1, 0, 0)), 1)).toVar()
+        aX.xy.divAssign(aX.w)
+        aX.xy.assign(aX.xy.mul(0.5).add(0.5))
+        rta.addAssign(axisX.mul(line(st, center.xy, aX.xy, thickness)))
+
+        const axisY = vec4(0, 1, 0, 1)
+        const aY = M.mul(vec4(pos.add(vec3(0, 1, 0)), 1)).toVar()
+        aY.xy.divAssign(aY.w)
+        aY.xy.assign(aY.xy.mul(0.5).add(0.5))
+        rta.addAssign(axisY.mul(line(st, center.xy, aY.xy, thickness)))
+
+        const axisZ = vec4(0, 0, 1, 1)
+        const aZ = M.mul(vec4(pos.add(vec3(0, 0, 1)), 1)).toVar()
+        aZ.xy.divAssign(aZ.w)
+        aZ.xy.assign(aZ.xy.mul(0.5).add(0.5))
+        rta.addAssign(axisZ.mul(line(st, center.xy, aZ.xy, thickness)))
+
+        return rta
 }).setLayout({
         name: 'axis',
         type: 'vec4',

package/src/addons/draw/bridge.ts

@@ -20,7 +20,7 @@ export const bridgeFloat = Fn(([c, d, s, w]: [Float, Float, Float, Float]): Floa
 export const bridgeVec2 = Fn(([c, d, s, w]: [Vec2, Float, Float, Float]): Vec2 => {
         const strokeMask = stroke(d, s, w.mul(2))
         const maskedC = c.mul(float(1).sub(strokeMask))
-        return maskedC.add(strokeMask)
+        return maskedC.add(stroke(d, s, w))
 }).setLayout({
         name: 'bridgeVec2',
         type: 'vec2',
@@ -36,7 +36,7 @@ export const bridgeVec2 = Fn(([c, d, s, w]: [Vec2, Float, Float, Float]): Vec2 =
 export const bridgeVec3 = Fn(([c, d, s, w]: [Vec3, Float, Float, Float]): Vec3 => {
         const strokeMask = stroke(d, s, w.mul(2))
         const maskedC = c.mul(float(1).sub(strokeMask))
-        return maskedC.add(strokeMask)
+        return maskedC.add(stroke(d, s, w))
 }).setLayout({
         name: 'bridgeVec3',
         type: 'vec3',
@@ -52,7 +52,7 @@ export const bridgeVec3 = Fn(([c, d, s, w]: [Vec3, Float, Float, Float]): Vec3 =
 export const bridgeVec4 = Fn(([c, d, s, w]: [Vec4, Float, Float, Float]): Vec4 => {
         const strokeMask = stroke(d, s, w.mul(2))
         const maskedC = c.mul(float(1).sub(strokeMask))
-        return maskedC.add(strokeMask)
+        return maskedC.add(stroke(d, s, w))
 }).setLayout({
         name: 'bridgeVec4',
         type: 'vec4',
@@ -68,7 +68,7 @@ export const bridgeVec4 = Fn(([c, d, s, w]: [Vec4, Float, Float, Float]): Vec4 =
 export const bridge = Fn(([c, d, s, w]: [X, Float, Float, Float]): X => {
         const strokeMask = stroke(d, s, (w as any).mul(2))
         const maskedC = (c as any).mul(float(1).sub(strokeMask))
-        return maskedC.add(strokeMask)
+        return maskedC.add(stroke(d, s, w as any))
 }).setLayout({
         name: 'bridge',
         type: 'auto',