glre 0.38.0 → 0.40.0

package/src/addons/space/lookAt.ts

@@ -0,0 +1,49 @@
+import { Fn, Vec3, Float, vec3, mat3 } from '../../node'
+
+export const lookAtForward = Fn(([forward, up]: [Vec3, Vec3]) => {
+        const zaxis = forward.normalize().toVar()
+        const xaxis = up.cross(zaxis).normalize().toVar()
+        const yaxis = zaxis.cross(xaxis).toVar()
+        return mat3(xaxis, yaxis, zaxis)
+}).setLayout({
+        name: 'lookAtForward',
+        type: 'mat3',
+        inputs: [
+                { name: 'forward', type: 'vec3' },
+                { name: 'up', type: 'vec3' },
+        ],
+})
+
+export const lookAt = Fn(([eye, target, up]: [Vec3, Vec3, Vec3]) => {
+        const forward = target.sub(eye).normalize().toVar()
+        return lookAtForward(forward, up)
+}).setLayout({
+        name: 'lookAt',
+        type: 'mat3',
+        inputs: [
+                { name: 'eye', type: 'vec3' },
+                { name: 'target', type: 'vec3' },
+                { name: 'up', type: 'vec3' },
+        ],
+})
+
+export const lookAtRoll = Fn(([eye, target, roll]: [Vec3, Vec3, Float]) => {
+        const up = vec3(roll.sin(), roll.cos(), 0).toVar()
+        return lookAt(eye, target, up)
+}).setLayout({
+        name: 'lookAtRoll',
+        type: 'mat3',
+        inputs: [
+                { name: 'eye', type: 'vec3' },
+                { name: 'target', type: 'vec3' },
+                { name: 'roll', type: 'float' },
+        ],
+})
+
+export const lookAtBasic = Fn(([forward]: [Vec3]) => {
+        return lookAtForward(forward, vec3(0, 1, 0))
+}).setLayout({
+        name: 'lookAtBasic',
+        type: 'mat3',
+        inputs: [{ name: 'forward', type: 'vec3' }],
+})

package/src/addons/space/lookAtView.ts

@@ -0,0 +1,40 @@
+import { Fn, Vec3, Float, vec3 } from '../../node'
+import { lookAt, lookAtRoll } from './lookAt'
+import { translateMat3 } from './translate'
+
+export const lookAtView = Fn(([position, target, up]: [Vec3, Vec3, Vec3]) => {
+        const m = lookAt(position, target, up).toVar()
+        return translateMat3(m, position)
+}).setLayout({
+        name: 'lookAtView',
+        type: 'mat4',
+        inputs: [
+                { name: 'position', type: 'vec3' },
+                { name: 'target', type: 'vec3' },
+                { name: 'up', type: 'vec3' },
+        ],
+})
+
+export const lookAtViewRoll = Fn(([position, target, roll]: [Vec3, Vec3, Float]) => {
+        const m = lookAtRoll(position, target, roll).toVar()
+        return translateMat3(m, position)
+}).setLayout({
+        name: 'lookAtViewRoll',
+        type: 'mat4',
+        inputs: [
+                { name: 'position', type: 'vec3' },
+                { name: 'target', type: 'vec3' },
+                { name: 'roll', type: 'float' },
+        ],
+})
+
+export const lookAtViewBasic = Fn(([position, target]: [Vec3, Vec3]) => {
+        return lookAtView(position, target, vec3(0, 1, 0))
+}).setLayout({
+        name: 'lookAtViewBasic',
+        type: 'mat4',
+        inputs: [
+                { name: 'position', type: 'vec3' },
+                { name: 'target', type: 'vec3' },
+        ],
+})

package/src/addons/space/mirrorTile.ts

@@ -0,0 +1,73 @@
+import { Fn, Vec2, Vec4, Float, vec4 } from '../../node'
+import { sqTile } from './sqTile'
+import { mirror } from '../math/mirror'
+
+export const mirrorTile = Fn(([t]: [Vec4]): Vec4 => {
+        return vec4(mirror(t.xy.add(t.zw)), t.z, t.w)
+}).setLayout({
+        name: 'mirrorTile',
+        type: 'vec4',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const mirrorTileVec2 = Fn(([v]: [Vec2]): Vec4 => {
+        return mirrorTile(sqTile(v))
+}).setLayout({
+        name: 'mirrorTileVec2',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const mirrorTileFloat = Fn(([v, s]: [Vec2, Float]): Vec4 => {
+        return mirrorTileVec2(v.mul(s))
+}).setLayout({
+        name: 'mirrorTileFloat',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const mirrorTileVec2Scale = Fn(([v, s]: [Vec2, Vec2]): Vec4 => {
+        return mirrorTileVec2(v.mul(s))
+}).setLayout({
+        name: 'mirrorTileVec2Scale',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})
+
+export const mirrorXTile = Fn(([t]: [Vec4]): Vec4 => {
+        return vec4(mirror(t.x.add(t.z)), t.y, t.z, t.w)
+}).setLayout({
+        name: 'mirrorXTile',
+        type: 'vec4',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const mirrorXTileVec2 = Fn(([v]: [Vec2]): Vec4 => {
+        return mirrorXTile(sqTile(v))
+}).setLayout({
+        name: 'mirrorXTileVec2',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const mirrorYTile = Fn(([t]: [Vec4]): Vec4 => {
+        return vec4(t.x, mirror(t.y.add(t.w)), t.z, t.w)
+}).setLayout({
+        name: 'mirrorYTile',
+        type: 'vec4',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const mirrorYTileVec2 = Fn(([v]: [Vec2]): Vec4 => {
+        return mirrorYTile(sqTile(v))
+}).setLayout({
+        name: 'mirrorYTileVec2',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})

package/src/addons/space/nearest.ts

@@ -0,0 +1,13 @@
+import { Fn, Vec2, floor } from '../../node'
+
+export const nearest = Fn(([v, res]: [Vec2, Vec2]): Vec2 => {
+        const offset = res.sub(1).reciprocal().mul(0.5).toVar('offset')
+        return floor(v.mul(res)).div(res).add(offset)
+}).setLayout({
+        name: 'nearest',
+        type: 'vec2',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'res', type: 'vec2' },
+        ],
+})

package/src/addons/space/orthographic.ts

@@ -0,0 +1,25 @@
+import { Fn, Float, Mat4, mat4, vec4 } from '../../node'
+
+export const orthographic = Fn(([l, r, b, t, n, f]: [Float, Float, Float, Float, Float, Float]): Mat4 => {
+        const width = r.sub(l).toVar('width')
+        const height = t.sub(b).toVar('height')
+        const depth = f.sub(n).toVar('depth')
+
+        return mat4(
+                vec4(width.reciprocal().mul(2), 0, 0, 0),
+                vec4(0, height.reciprocal().mul(2), 0, 0),
+                vec4(0, 0, depth.reciprocal().mul(-2), 0),
+                vec4(r.add(l).div(width).negate(), t.add(b).div(height).negate(), f.add(n).div(depth).negate(), 1)
+        )
+}).setLayout({
+        name: 'orthographic',
+        type: 'mat4',
+        inputs: [
+                { name: 'l', type: 'float' },
+                { name: 'r', type: 'float' },
+                { name: 'b', type: 'float' },
+                { name: 't', type: 'float' },
+                { name: 'n', type: 'float' },
+                { name: 'f', type: 'float' },
+        ],
+})

package/src/addons/space/parallaxMapping.ts

@@ -0,0 +1,149 @@
+import { Fn, Vec2, Vec3, Float, X, texture, float, vec2, vec3, int, Loop, If, Break } from '../../node'
+
+const PARALLAXMAPPING_SCALE = float(0.01).constant('PARALLAXMAPPING_SCALE')
+const PARALLAXMAPPING_NUMSEARCHES = float(10).constant('PARALLAXMAPPING_NUMSEARCHES')
+
+export const parallaxMappingSimple = Fn(([tex, V, T]: [X, Vec3, Vec2]): Vec2 => {
+        const initialHeight = texture(tex, T).r.toVar('initialHeight')
+        const texCoordOffset = PARALLAXMAPPING_SCALE.mul(V.xy).mul(initialHeight).toVar('texCoordOffset')
+        return T.sub(texCoordOffset)
+}).setLayout({
+        name: 'parallaxMappingSimple',
+        type: 'vec2',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'V', type: 'vec3' },
+                { name: 'T', type: 'vec2' },
+        ],
+})
+
+export const parallaxMappingSteep = Fn(([tex, V, T]: [X, Vec3, Vec2]): Vec2 => {
+        const minLayers = PARALLAXMAPPING_NUMSEARCHES.mul(0.5).toVar('minLayers')
+        const maxLayers = float(15).toVar('maxLayers')
+        const numLayers = minLayers.mix(maxLayers, V.dot(vec3(0, 0, 1)).abs()).toVar('numLayers')
+        const layerHeight = float(1).div(numLayers).toVar('layerHeight')
+        const currentLayerHeight = float(0).toVar('currentLayerHeight')
+        const dtex = PARALLAXMAPPING_SCALE.mul(V.xy).div(V.z).div(numLayers).toVar('dtex')
+        const currentTextureCoords = T.toVar('currentTextureCoords')
+        const heightFromTexture = texture(tex, currentTextureCoords).r.toVar('heightFromTexture')
+
+        Loop(int(50), ({ i }) => {
+                If(heightFromTexture.lessThanEqual(currentLayerHeight), () => {
+                        Break()
+                })
+                currentLayerHeight.addAssign(layerHeight)
+                currentTextureCoords.subAssign(dtex)
+                heightFromTexture.assign(texture(tex, currentTextureCoords).r)
+        })
+
+        return currentTextureCoords
+}).setLayout({
+        name: 'parallaxMappingSteep',
+        type: 'vec2',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'V', type: 'vec3' },
+                { name: 'T', type: 'vec2' },
+        ],
+})
+
+export const parallaxMappingRelief = Fn(([tex, V, T]: [X, Vec3, Vec2]): Vec2 => {
+        const minLayers = PARALLAXMAPPING_NUMSEARCHES.toVar('minLayers')
+        const maxLayers = float(15).toVar('maxLayers')
+        const numLayers = minLayers.mix(maxLayers, V.dot(vec3(0, 0, 1)).abs()).toVar('numLayers')
+        const layerHeight = float(1).div(numLayers).toVar('layerHeight')
+        const currentLayerHeight = float(0).toVar('currentLayerHeight')
+        const dtex = PARALLAXMAPPING_SCALE.mul(V.xy).div(V.z).div(numLayers).toVar('dtex')
+        const currentTextureCoords = T.toVar('currentTextureCoords')
+        const heightFromTexture = texture(tex, currentTextureCoords).r.toVar('heightFromTexture')
+
+        Loop(int(50), ({ i }) => {
+                If(heightFromTexture.lessThanEqual(currentLayerHeight), () => {
+                        Break()
+                })
+                currentLayerHeight.addAssign(layerHeight)
+                currentTextureCoords.subAssign(dtex)
+                heightFromTexture.assign(texture(tex, currentTextureCoords).r)
+        })
+
+        const deltaTexCoord = dtex.mul(0.5).toVar('deltaTexCoord')
+        const deltaHeight = layerHeight.mul(0.5).toVar('deltaHeight')
+        currentTextureCoords.addAssign(deltaTexCoord)
+        currentLayerHeight.subAssign(deltaHeight)
+
+        Loop(int(5), ({ i }) => {
+                deltaTexCoord.mulAssign(0.5)
+                deltaHeight.mulAssign(0.5)
+                heightFromTexture.assign(texture(tex, currentTextureCoords).r)
+
+                If(heightFromTexture.greaterThan(currentLayerHeight), () => {
+                        currentTextureCoords.subAssign(deltaTexCoord)
+                        currentLayerHeight.addAssign(deltaHeight)
+                }).Else(() => {
+                        currentTextureCoords.addAssign(deltaTexCoord)
+                        currentLayerHeight.subAssign(deltaHeight)
+                })
+        })
+
+        return currentTextureCoords
+}).setLayout({
+        name: 'parallaxMappingRelief',
+        type: 'vec2',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'V', type: 'vec3' },
+                { name: 'T', type: 'vec2' },
+        ],
+})
+
+export const parallaxMappingOcclusion = Fn(([tex, V, T]: [X, Vec3, Vec2]): Vec2 => {
+        const minLayers = PARALLAXMAPPING_NUMSEARCHES.toVar('minLayers')
+        const maxLayers = float(15).toVar('maxLayers')
+        const numLayers = minLayers.mix(maxLayers, V.dot(vec3(0, 0, 1)).abs()).toVar('numLayers')
+        const layerHeight = float(1).div(numLayers).toVar('layerHeight')
+        const curLayerHeight = float(0).toVar('curLayerHeight')
+        const dtex = PARALLAXMAPPING_SCALE.mul(V.xy).div(V.z).div(numLayers).toVar('dtex')
+        const currentTextureCoords = T.toVar('currentTextureCoords')
+        const heightFromTexture = texture(tex, currentTextureCoords).r.toVar('heightFromTexture')
+        const prevTCoords = currentTextureCoords.toVar('prevTCoords')
+
+        Loop(int(50), ({ i }) => {
+                If(heightFromTexture.lessThanEqual(curLayerHeight), () => {
+                        Break()
+                })
+                curLayerHeight.addAssign(layerHeight)
+                prevTCoords.assign(currentTextureCoords)
+                currentTextureCoords.subAssign(dtex)
+                heightFromTexture.assign(texture(tex, currentTextureCoords).r)
+        })
+
+        const nextH = heightFromTexture.sub(curLayerHeight).toVar('nextH')
+        const prevH = texture(tex, prevTCoords).r.sub(curLayerHeight).add(layerHeight).toVar('prevH')
+        const weight = nextH.div(nextH.sub(prevH)).toVar('weight')
+        const finalTexCoords = prevTCoords
+                .mul(weight)
+                .add(currentTextureCoords.mul(float(1).sub(weight)))
+                .toVar('finalTexCoords')
+
+        return finalTexCoords
+}).setLayout({
+        name: 'parallaxMappingOcclusion',
+        type: 'vec2',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'V', type: 'vec3' },
+                { name: 'T', type: 'vec2' },
+        ],
+})
+
+export const parallaxMapping = Fn(([tex, V, T]: [X, Vec3, Vec2]): Vec2 => {
+        return parallaxMappingOcclusion(tex, V, T)
+}).setLayout({
+        name: 'parallaxMapping',
+        type: 'vec2',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'V', type: 'vec3' },
+                { name: 'T', type: 'vec2' },
+        ],
+})

package/src/addons/space/perspective.ts

@@ -0,0 +1,24 @@
+import { Fn, Float, Mat4, mat4, tan, float } from '../../node'
+
+export const perspective = Fn(([fov, aspect, near, far]: [Float, Float, Float, Float]): Mat4 => {
+        const f = float(1)
+                .div(tan(fov.div(2)))
+                .toVar('f')
+        const nf = float(1).div(near.sub(far)).toVar('nf')
+        // prettier-ignore
+        return mat4(
+                f.div(aspect), 0, 0, 0,
+                0, f, 0, 0,
+                0, 0, far.add(near).mul(nf), -1,
+                0, 0, float(2).mul(far).mul(near).mul(nf), 0
+        )
+}).setLayout({
+        name: 'perspective',
+        type: 'mat4',
+        inputs: [
+                { name: 'fov', type: 'float' },
+                { name: 'aspect', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})

package/src/addons/space/polar2cart.ts

@@ -0,0 +1,24 @@
+import { Fn, Vec2, Vec3, Float, cos, sin, vec2, vec3 } from '../../node'
+
+export const polar2cart = Fn(([polar]: [Vec2]): Vec2 => {
+        return vec2(cos(polar.x), sin(polar.x)).mul(polar.y)
+}).setLayout({
+        name: 'polar2cart',
+        type: 'vec2',
+        inputs: [{ name: 'polar', type: 'vec2' }],
+})
+
+export const polar2cart3D = Fn(([r, phi, theta]: [Float, Float, Float]): Vec3 => {
+        const x = r.mul(cos(theta)).mul(sin(phi)).toVar('x')
+        const y = r.mul(sin(theta)).mul(sin(phi)).toVar('y')
+        const z = r.mul(cos(phi)).toVar('z')
+        return vec3(x, y, z)
+}).setLayout({
+        name: 'polar2cart3D',
+        type: 'vec3',
+        inputs: [
+                { name: 'r', type: 'float' },
+                { name: 'phi', type: 'float' },
+                { name: 'theta', type: 'float' },
+        ],
+})

package/src/addons/space/ratio.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec2, mix, vec2, step } from '../../node'
+
+export const ratio = Fn(([v, s]: [Vec2, Vec2]): Vec2 => {
+        const wideAspect = vec2(v.x.mul(s.x.div(s.y)).sub(s.x.mul(0.5).sub(s.y.mul(0.5)).div(s.y)), v.y)
+        const tallAspect = vec2(v.x, v.y.mul(s.y.div(s.x)).sub(s.y.mul(0.5).sub(s.x.mul(0.5)).div(s.x)))
+        return mix(wideAspect, tallAspect, step(s.x, s.y))
+}).setLayout({
+        name: 'ratio',
+        type: 'vec2',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/rotate.ts

@@ -0,0 +1,37 @@
+import { Fn, Vec2, Float, vec2 } from '../../node'
+import { rotate2d } from '../math/rotate2d'
+
+export const rotate2DCenter = Fn(([v, r, c]: [Vec2, Float, Vec2]) => {
+        return rotate2d(r).mul(v.sub(c)).add(c)
+}).setLayout({
+        name: 'rotate2DCenter',
+        type: 'vec2',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec2' },
+        ],
+})
+
+export const rotate2DBasic = Fn(([v, r]: [Vec2, Float]) => {
+        return rotate2DCenter(v, r, vec2(0.5))
+}).setLayout({
+        name: 'rotate2DBasic',
+        type: 'vec2',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'r', type: 'float' },
+        ],
+})
+
+export const rotate2DAxis = Fn(([v, xAxis]: [Vec2, Vec2]) => {
+        const negYAxis = vec2(xAxis.y.negate(), xAxis.x).toVar()
+        return vec2(v.dot(negYAxis), v.dot(xAxis))
+}).setLayout({
+        name: 'rotate2DAxis',
+        type: 'vec2',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'xAxis', type: 'vec2' },
+        ],
+})

package/src/addons/space/rotateX.ts

@@ -0,0 +1,54 @@
+import { Fn, Vec3, Vec4, Float, vec4 } from '../../node'
+import { rotate4dX } from '../math/rotate4dX'
+
+// vec4 rotateX(in vec4 v, in float r, in vec4 c)
+export const rotateXVec4Center = Fn(([v, r, c]: [Vec4, Float, Vec4]): Vec4 => {
+        return rotate4dX(r).mul(v.sub(c)).add(c)
+}).setLayout({
+        name: 'rotateXVec4Center',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec4' },
+        ],
+})
+
+// vec4 rotateX(in vec4 v, in float r)
+export const rotateXVec4 = Fn(([v, r]: [Vec4, Float]): Vec4 => {
+        return rotate4dX(r).mul(v)
+}).setLayout({
+        name: 'rotateXVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'r', type: 'float' },
+        ],
+})
+
+// vec3 rotateX(in vec3 v, in float r, in vec3 c)
+export const rotateXVec3Center = Fn(([v, r, c]: [Vec3, Float, Vec3]): Vec3 => {
+        return rotate4dX(r)
+                .mul(vec4(v.sub(c), 1))
+                .xyz.add(c)
+}).setLayout({
+        name: 'rotateXVec3Center',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec3' },
+        ],
+})
+
+// vec3 rotateX(in vec3 v, in float r)
+export const rotateXVec3 = Fn(([v, r]: [Vec3, Float]): Vec3 => {
+        return rotate4dX(r).mul(vec4(v, 1)).xyz
+}).setLayout({
+        name: 'rotateXVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/space/rotateY.ts

@@ -0,0 +1,54 @@
+import { Fn, Vec3, Vec4, Float, vec4 } from '../../node'
+import { rotate4dY } from '../math/rotate4dY'
+
+// vec4 rotateY(in vec4 v, in float r, in vec4 c)
+export const rotateYVec4Center = Fn(([v, r, c]: [Vec4, Float, Vec4]): Vec4 => {
+        return rotate4dY(r).mul(v.sub(c)).add(c)
+}).setLayout({
+        name: 'rotateYVec4Center',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec4' },
+        ],
+})
+
+// vec4 rotateY(in vec4 v, in float r)
+export const rotateYVec4 = Fn(([v, r]: [Vec4, Float]): Vec4 => {
+        return rotate4dY(r).mul(v)
+}).setLayout({
+        name: 'rotateYVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'r', type: 'float' },
+        ],
+})
+
+// vec3 rotateY(in vec3 v, in float r, in vec3 c)
+export const rotateYVec3Center = Fn(([v, r, c]: [Vec3, Float, Vec3]): Vec3 => {
+        return rotate4dY(r)
+                .mul(vec4(v.sub(c), 1))
+                .xyz.add(c)
+}).setLayout({
+        name: 'rotateYVec3Center',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec3' },
+        ],
+})
+
+// vec3 rotateY(in vec3 v, in float r)
+export const rotateYVec3 = Fn(([v, r]: [Vec3, Float]): Vec3 => {
+        return rotate4dY(r).mul(vec4(v, 1)).xyz
+}).setLayout({
+        name: 'rotateYVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/space/rotateZ.ts

@@ -0,0 +1,54 @@
+import { Fn, Vec3, Vec4, Float, vec4 } from '../../node'
+import { rotate4dZ } from '../math/rotate4dZ'
+
+// vec4 rotateZ(in vec4 v, in float r, in vec4 c)
+export const rotateZVec4Center = Fn(([v, r, c]: [Vec4, Float, Vec4]): Vec4 => {
+        return rotate4dZ(r).mul(v.sub(c)).add(c)
+}).setLayout({
+        name: 'rotateZVec4Center',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec4' },
+        ],
+})
+
+// vec4 rotateZ(in vec4 v, in float r)
+export const rotateZVec4 = Fn(([v, r]: [Vec4, Float]): Vec4 => {
+        return rotate4dZ(r).mul(v)
+}).setLayout({
+        name: 'rotateZVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'r', type: 'float' },
+        ],
+})
+
+// vec3 rotateZ(in vec3 v, in float r, in vec3 c)
+export const rotateZVec3Center = Fn(([v, r, c]: [Vec3, Float, Vec3]): Vec3 => {
+        return rotate4dZ(r)
+                .mul(vec4(v.sub(c), 0))
+                .xyz.add(c)
+}).setLayout({
+        name: 'rotateZVec3Center',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'r', type: 'float' },
+                { name: 'c', type: 'vec3' },
+        ],
+})
+
+// vec3 rotateZ(in vec3 v, in float r)
+export const rotateZVec3 = Fn(([v, r]: [Vec3, Float]): Vec3 => {
+        return rotate4dZ(r).mul(vec4(v, 0)).xyz
+}).setLayout({
+        name: 'rotateZVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/space/scale.ts

@@ -0,0 +1,13 @@
+import { Fn, vec2, vec3, vec4, Float, Vec2, Vec3, Vec4, X } from '../../node'
+
+export const scale = Fn(([st, s, center]: [X, X, X]): X => {
+        return st.sub(center).mul(s).add(center)
+}).setLayout({
+        name: 'scale',
+        type: 'auto',
+        inputs: [
+                { name: 'st', type: 'auto' },
+                { name: 's', type: 'auto' },
+                { name: 'center', type: 'auto' },
+        ],
+})

package/src/addons/space/sprite.ts

@@ -0,0 +1,16 @@
+import { Fn, Vec2, Float, vec2, floor, fract } from '../../node'
+
+export const sprite = Fn(([st, grid, index]: [Vec2, Vec2, Float]): Vec2 => {
+        const adjustedIndex = index.add(grid.x).toVar('adjustedIndex')
+        const f = vec2(1).div(grid).toVar('f')
+        const cell = vec2(floor(adjustedIndex), grid.y.sub(floor(adjustedIndex.mul(f.x)))).toVar('cell')
+        return fract(st.add(cell).mul(f))
+}).setLayout({
+        name: 'sprite',
+        type: 'vec2',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'grid', type: 'vec2' },
+                { name: 'index', type: 'float' },
+        ],
+})

package/src/addons/space/sqTile.ts

@@ -0,0 +1,20 @@
+import { Fn, Vec2, Vec4, Float, vec4, fract, floor } from '../../node'
+
+export const sqTile = Fn(([st]: [Vec2]): Vec4 => {
+        return vec4(fract(st), floor(st))
+}).setLayout({
+        name: 'sqTile',
+        type: 'vec4',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const sqTileScale = Fn(([st, scale]: [Vec2, Float]): Vec4 => {
+        return sqTile(st.mul(scale))
+}).setLayout({
+        name: 'sqTileScale',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'scale', type: 'float' },
+        ],
+})