kmcom-nuxt-layers 2.2.6 → 2.2.9

package/layers/shader/app/components/Preset/ThemeWave.client.vue

@@ -1,8 +1,7 @@
 <script setup lang="ts">
-  import {
-    createAmbientUniforms,
-    createThemeWaveColorNode,
-  } from '#layers/shader/app/composables/useAmbientMaterials'
+  import { createThemeWaveColorNode } from '#layers/shader/app/composables/useAmbientMaterials'
+  import { type ThemePresetProps } from '#layers/shader/app/composables/useThemePreset'
+  import type { TSLNode } from '#layers/shader/app/types/tsl'
 
   const {
     speed = 1.0,
@@ -13,98 +12,39 @@
     color2 = '#6366f1',
     color3 = '#a78bfa',
     color4 = '#38bdf8',
-  } = defineProps<{
-    speed?: number
-    intensity?: number
-    mouseInteraction?: boolean
-    mouseStrength?: number
-    color1?: string
-    color2?: string
-    color3?: string
-    color4?: string
-  }>()
+  } = defineProps<ThemePresetProps>()
 
   const emit = defineEmits<{
-    node: [colorNode: any]
+    node: [colorNode: TSLNode]
   }>()
 
-  const uniforms = createAmbientUniforms({
-    speed: speed,
-    intensity: intensity,
-    mouseInteraction: mouseInteraction,
-  })
-  if (mouseInteraction) {
-    uniforms.mouseStrength.value = mouseStrength
-  }
-
-  const c1 = useShaderColor(color1)
-  const c2 = useShaderColor(color2)
-  const c3 = useShaderColor(color3)
-  const c4 = useShaderColor(color4)
-
-  const colorNode = createThemeWaveColorNode(uniforms, {
-    color1: c1.node,
-    color2: c2.node,
-    color3: c3.node,
-    color4: c4.node,
+  const { uniforms, colorNode } = useThemePreset(createThemeWaveColorNode, {
+    get speed() {
+      return speed
+    },
+    get intensity() {
+      return intensity
+    },
+    get mouseInteraction() {
+      return mouseInteraction
+    },
+    get mouseStrength() {
+      return mouseStrength
+    },
+    get color1() {
+      return color1
+    },
+    get color2() {
+      return color2
+    },
+    get color3() {
+      return color3
+    },
+    get color4() {
+      return color4
+    },
   })
 
-  watch(
-    () => color1,
-    (hex) => c1.tweenTo(hex, 0.8)
-  )
-  watch(
-    () => color2,
-    (hex) => c2.tweenTo(hex, 0.8)
-  )
-  watch(
-    () => color3,
-    (hex) => c3.tweenTo(hex, 0.8)
-  )
-  watch(
-    () => color4,
-    (hex) => c4.tweenTo(hex, 0.8)
-  )
-
-  try {
-    const runtime = useShaderRuntimeContext()
-    watch(
-      () => [runtime.mouse.mouseX.value, runtime.mouse.mouseY.value],
-      ([mx, my]) => {
-        uniforms.mouseX.value = mx
-        uniforms.mouseY.value = my
-      },
-      { immediate: true }
-    )
-  } catch {
-    // No runtime context
-  }
-
-  watch(
-    () => speed,
-    (v) => {
-      uniforms.speed.value = v
-    }
-  )
-  watch(
-    () => intensity,
-    (v) => {
-      uniforms.intensity.value = v
-    }
-  )
-  watch(
-    () => mouseInteraction,
-    (v) => {
-      uniforms.mouseStrength.value = v ? mouseStrength : 0
-    }
-  )
-  watch(
-    () => mouseStrength,
-    (v) => {
-      if (mouseInteraction) uniforms.mouseStrength.value = v
-    }
-  )
-
   emit('node', colorNode)
   defineExpose({ uniforms, colorNode })
 </script>

package/layers/shader/app/components/Shader/Background.client.vue

@@ -13,7 +13,7 @@
     Scene,
     SRGBColorSpace,
   } from 'three'
-  import { WebGPURenderer } from 'three/webgpu'
+  import { MeshBasicNodeMaterial, WebGPURenderer } from 'three/webgpu'
 
   const {
     material = null,
@@ -25,7 +25,7 @@
     pointerEvents = 'none',
   } = defineProps<{
     /** The TSL node material to render */
-    material?: any
+    material?: MeshBasicNodeMaterial | null
     /** Background clear color */
     clearColor?: string
     /** Tone mapping algorithm */
@@ -41,13 +41,13 @@
   }>()
 
   const emit = defineEmits<{
-    ready: [renderer: any]
+    ready: [renderer: WebGPURenderer]
   }>()
 
   const canvasRef = useTemplateRef<HTMLCanvasElement>('canvasRef')
   const { width, height } = useWindowSize()
 
-  let renderer: any
+  let renderer: WebGPURenderer | undefined
   let scene: Scene
   let camera: PerspectiveCamera
   let planeMesh: Mesh

package/layers/shader/app/components/Shader/Host.client.vue

@@ -1,36 +1,34 @@
 <script setup lang="ts">
   import type { Component } from 'vue'
+  import type { TSLNode } from '#layers/shader/app/types/tsl'
   import { tweenUniform } from '#layers/shader/app/utils/tsl/tween'
   import { DoubleSide } from 'three'
   import { mix as tslMix, uniform } from 'three/tsl'
   import { MeshBasicNodeMaterial } from 'three/webgpu'
 
-  const props = withDefaults(
-    defineProps<{
-      /** The active preset component */
-      preset?: Component | null
-      /** Crossfade duration in seconds */
-      transitionDuration?: number
-      /** Props forwarded to the active preset component */
-      presetProps?: Record<string, any>
-      /** ShaderBackground props */
-      clearColor?: string
-      toneMapping?: 'aces' | 'reinhard' | 'cineon' | 'linear'
-      fixed?: boolean
-      zIndex?: number
-      pointerEvents?: 'none' | 'auto'
-    }>(),
-    {
-      preset: null,
-      transitionDuration: 1.0,
-      presetProps: () => ({}),
-      clearColor: '#000000',
-      toneMapping: 'aces',
-      fixed: true,
-      zIndex: -1,
-      pointerEvents: 'none',
-    }
-  )
+  const {
+    preset = null,
+    transitionDuration = 1.0,
+    presetProps = {} as Record<string, unknown>,
+    clearColor = '#000000',
+    toneMapping = 'aces',
+    fixed = true,
+    zIndex = -1,
+    pointerEvents = 'none',
+  } = defineProps<{
+    /** The active preset component */
+    preset?: Component | null
+    /** Crossfade duration in seconds */
+    transitionDuration?: number
+    /** Props forwarded to the active preset component */
+    presetProps?: Record<string, unknown>
+    /** ShaderBackground props */
+    clearColor?: string
+    toneMapping?: 'aces' | 'reinhard' | 'cineon' | 'linear'
+    fixed?: boolean
+    zIndex?: number
+    pointerEvents?: 'none' | 'auto'
+  }>()
 
   const emit = defineEmits<{
     transitionStart: []
@@ -42,7 +40,7 @@
   const isTransitioning = ref(false)
 
   // Current and next preset tracking
-  const currentPreset = shallowRef<Component | null>(props.preset)
+  const currentPreset = shallowRef<Component | null>(preset)
   const nextPreset = shallowRef<Component | null>(null)
 
   function setCurrentPreset(preset: Component | null) {
@@ -54,15 +52,15 @@
   material.side = DoubleSide
 
   // Current and next graph nodes (set by preset via @node event)
-  let currentNode: any = null
-  let nextNode: any = null
+  let currentNode: TSLNode | null = null
+  let nextNode: TSLNode | null = null
 
-  function setCurrentNode(node: any) {
+  function setCurrentNode(node: TSLNode) {
     currentNode = node
     updateMaterialNode()
   }
 
-  function setNextNode(node: any) {
+  function setNextNode(node: TSLNode) {
     nextNode = node
     updateMaterialNode()
   }
@@ -79,7 +77,7 @@
 
   // Watch preset changes for crossfade
   watch(
-    () => props.preset,
+    () => preset,
     async (newPreset, oldPreset) => {
       if (!newPreset || newPreset === oldPreset) return
 
@@ -100,7 +98,7 @@
         transitionProgress,
         0,
         1,
-        props.transitionDuration,
+        transitionDuration,
         (t) => t * t * (3 - 2 * t) // smoothstep
       )
 

package/layers/shader/app/components/Shader/Runtime.client.vue

@@ -1,41 +1,33 @@
 <script setup lang="ts">
-  const props = withDefaults(
-    defineProps<{
-      speed?: number
-      accentColor?: string
-      darkMode?: boolean
-      mouseSmoothing?: number
-    }>(),
-    {
-      speed: 1.0,
-      accentColor: '#8b5cf6',
-      darkMode: true,
-      mouseSmoothing: 0.1,
-    }
-  )
+  const {
+    speed = 1.0,
+    accentColor = '#8b5cf6',
+    darkMode = true,
+    mouseSmoothing = 0.1,
+  } = defineProps<{
+    speed?: number
+    accentColor?: string
+    darkMode?: boolean
+    mouseSmoothing?: number
+  }>()
 
-  const runtime = useShaderRuntime({
-    speed: props.speed,
-    accentColor: props.accentColor,
-    darkMode: props.darkMode,
-    mouseSmoothing: props.mouseSmoothing,
-  })
+  const runtime = useShaderRuntime({ speed, accentColor, darkMode, mouseSmoothing })
 
   // Watch props and update runtime uniforms
   watch(
-    () => props.speed,
+    () => speed,
     (val) => runtime.time.setSpeed(val)
   )
 
   watch(
-    () => props.accentColor,
+    () => accentColor,
     (val) => {
       runtime.accentColor.value = val
     }
   )
 
   watch(
-    () => props.darkMode,
+    () => darkMode,
     (val) => {
       runtime.darkMode.value = val
     }

package/layers/shader/app/composables/useAmbientMaterials.ts

@@ -28,7 +28,35 @@ import {
   voronoi2D,
 } from '../shaders/common/noise'
 import { cosinePalette } from '../shaders/common/palette'
-import type { TSLNode } from '../shaders/types'
+import type { FloatUniform, TSLNode, Vec3Uniform } from '../shaders/types'
+
+// ============================================
+// Private helpers
+// ============================================
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function buildFlowWarpedUV(uvCoord: any, t: any, mouseOffset: any): {
+  warpedUV: TSLNode
+  n1: TSLNode
+  n2: TSLNode
+} {
+  const warpCoarse1 = simplexNoise2D(add(mul(uvCoord, 1.5), t))
+  const warpCoarse2 = simplexNoise2D(add(mul(uvCoord, 1.5), mul(t, -0.5), 7.0))
+  const warpedUV1 = add(uvCoord, mul(vec2(warpCoarse1, warpCoarse2), 0.25), mouseOffset)
+
+  const warpMed1 = simplexNoise2D(add(mul(warpedUV1, 3.0), mul(t, 0.7)))
+  const warpMed2 = simplexNoise2D(add(mul(warpedUV1, 3.0), mul(t, -0.3), 15.0))
+  const warpedUV2 = add(warpedUV1, mul(vec2(warpMed1, warpMed2), 0.12))
+
+  const warpFine1 = simplexNoise2D(add(mul(warpedUV2, 5.0), mul(t, 1.2)))
+  const warpFine2 = simplexNoise2D(add(mul(warpedUV2, 5.0), mul(t, -0.8), 25.0))
+  const warpedUV = add(warpedUV2, mul(vec2(warpFine1, warpFine2), 0.05))
+
+  const n1 = fbm2D(warpedUV, { octaves: 5, frequency: 2.0 }).mul(0.5).add(0.5)
+  const n2 = ridgedFbm2d(warpedUV, { octaves: 4, frequency: 1.5 })
+
+  return { warpedUV, n1, n2 }
+}
 
 // ============================================
 // Types
@@ -42,11 +70,11 @@ export type AmbientMaterialOptions = {
 }
 
 export type AmbientUniforms = {
-  speed: any
-  intensity: any
-  mouseX: any
-  mouseY: any
-  mouseStrength: any
+  speed: FloatUniform
+  intensity: FloatUniform
+  mouseX: FloatUniform
+  mouseY: FloatUniform
+  mouseStrength: FloatUniform
 }
 
 export type AmbientMaterialResult = {
@@ -55,7 +83,7 @@ export type AmbientMaterialResult = {
 }
 
 export type AmbientNodeResult = {
-  colorNode: any
+  colorNode: TSLNode
   uniforms: AmbientUniforms
 }
 
@@ -78,7 +106,7 @@ export function createAmbientUniforms(options: AmbientMaterialOptions = {}): Amb
 // Color Node Creators (TSL node, no material)
 // ============================================
 
-export function createAuroraColorNode(uniforms: AmbientUniforms): any {
+export function createAuroraColorNode(uniforms: AmbientUniforms): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -137,7 +165,7 @@ export function createAuroraColorNode(uniforms: AmbientUniforms): any {
   })()
 }
 
-export function createNebulaColorNode(uniforms: AmbientUniforms): any {
+export function createNebulaColorNode(uniforms: AmbientUniforms): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -205,7 +233,7 @@ export function createNebulaColorNode(uniforms: AmbientUniforms): any {
   })()
 }
 
-export function createFlowColorNode(uniforms: AmbientUniforms): any {
+export function createFlowColorNode(uniforms: AmbientUniforms): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -223,20 +251,7 @@ export function createFlowColorNode(uniforms: AmbientUniforms): any {
       mul(sub(uMouseY, 0.5), uMouseStrength, 0.3)
     )
 
-    const warpCoarse1 = simplexNoise2D(add(mul(uvCoord, 1.5), t))
-    const warpCoarse2 = simplexNoise2D(add(mul(uvCoord, 1.5), mul(t, -0.5), 7.0))
-    const warpedUV1 = add(uvCoord, mul(vec2(warpCoarse1, warpCoarse2), 0.25), mouseOffset)
-
-    const warpMed1 = simplexNoise2D(add(mul(warpedUV1, 3.0), mul(t, 0.7)))
-    const warpMed2 = simplexNoise2D(add(mul(warpedUV1, 3.0), mul(t, -0.3), 15.0))
-    const warpedUV2 = add(warpedUV1, mul(vec2(warpMed1, warpMed2), 0.12))
-
-    const warpFine1 = simplexNoise2D(add(mul(warpedUV2, 5.0), mul(t, 1.2)))
-    const warpFine2 = simplexNoise2D(add(mul(warpedUV2, 5.0), mul(t, -0.8), 25.0))
-    const warpedUV = add(warpedUV2, mul(vec2(warpFine1, warpFine2), 0.05))
-
-    const n1 = fbm2D(warpedUV, { octaves: 5, frequency: 2.0 }).mul(0.5).add(0.5)
-    const n2 = ridgedFbm2d(warpedUV, { octaves: 4, frequency: 1.5 })
+    const { n1, n2 } = buildFlowWarpedUV(uvCoord, t, mouseOffset)
 
     const color1 = vec3(0.075, 0.306, 0.369)
     const color2 = vec3(0.443, 0.698, 0.502)
@@ -266,7 +281,7 @@ export function createFlowColorNode(uniforms: AmbientUniforms): any {
   })()
 }
 
-export function createGradientMeshColorNode(uniforms: AmbientUniforms): any {
+export function createGradientMeshColorNode(uniforms: AmbientUniforms): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -353,16 +368,16 @@ export function createGradientMeshColorNode(uniforms: AmbientUniforms): any {
 }
 
 export type ThemeColorUniforms = {
-  color1: any // TSL uniform node wrapping a THREE.Color
-  color2: any
-  color3: any
-  color4: any
+  color1: Vec3Uniform
+  color2: Vec3Uniform
+  color3: Vec3Uniform
+  color4: Vec3Uniform
 }
 
 export function createThemeGradientColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -453,7 +468,7 @@ export function createThemeGradientColorNode(
 export function createThemeFlowColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -471,20 +486,7 @@ export function createThemeFlowColorNode(
       mul(sub(uMouseY, 0.5), uMouseStrength, 0.3)
     )
 
-    const warpCoarse1 = simplexNoise2D(add(mul(uvCoord, 1.5), t))
-    const warpCoarse2 = simplexNoise2D(add(mul(uvCoord, 1.5), mul(t, -0.5), 7.0))
-    const warpedUV1 = add(uvCoord, mul(vec2(warpCoarse1, warpCoarse2), 0.25), mouseOffset)
-
-    const warpMed1 = simplexNoise2D(add(mul(warpedUV1, 3.0), mul(t, 0.7)))
-    const warpMed2 = simplexNoise2D(add(mul(warpedUV1, 3.0), mul(t, -0.3), 15.0))
-    const warpedUV2 = add(warpedUV1, mul(vec2(warpMed1, warpMed2), 0.12))
-
-    const warpFine1 = simplexNoise2D(add(mul(warpedUV2, 5.0), mul(t, 1.2)))
-    const warpFine2 = simplexNoise2D(add(mul(warpedUV2, 5.0), mul(t, -0.8), 25.0))
-    const warpedUV = add(warpedUV2, mul(vec2(warpFine1, warpFine2), 0.05))
-
-    const n1 = fbm2D(warpedUV, { octaves: 5, frequency: 2.0 }).mul(0.5).add(0.5)
-    const n2 = ridgedFbm2d(warpedUV, { octaves: 4, frequency: 1.5 })
+    const { n1, n2 } = buildFlowWarpedUV(uvCoord, t, mouseOffset)
 
     let colorNode = mix(colors.color1, colors.color2, n1)
     colorNode = mix(colorNode, colors.color3, mul(n2, 0.5))
@@ -506,7 +508,7 @@ export function createThemeFlowColorNode(
 export function createThemeAuroraColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -563,7 +565,7 @@ export function createThemeAuroraColorNode(
 export function createThemeWaveColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -613,7 +615,7 @@ export function createThemeWaveColorNode(
 export function createThemeLavaLampColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -681,7 +683,7 @@ export function createThemeLavaLampColorNode(
 export function createThemeBubbleColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -716,7 +718,7 @@ export function createThemeBubbleColorNode(
 export function createThemePlasmaColorNode(
   uniforms: AmbientUniforms,
   colors: ThemeColorUniforms
-): any {
+): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,
@@ -770,7 +772,7 @@ export function createThemePlasmaColorNode(
   })()
 }
 
-export function createOceanColorNode(uniforms: AmbientUniforms): any {
+export function createOceanColorNode(uniforms: AmbientUniforms): TSLNode {
   const {
     speed: uSpeed,
     intensity: uIntensity,

package/layers/shader/app/composables/useShaderMixBlend.ts

@@ -0,0 +1,26 @@
+import { Color } from 'three'
+import { mix, uniform, vec4 } from 'three/tsl'
+
+import type { TSLNode } from '../types/tsl'
+
+export function useShaderMixBlend(
+  blendFn: (base: TSLNode, blend: TSLNode) => TSLNode,
+  colorGetter: () => string,
+  opacityGetter: () => number,
+  order: number = 0
+) {
+  const colorNode = uniform(new Color(colorGetter()))
+  const opacityNode = uniform(opacityGetter())
+
+  watch(colorGetter, (v) => {
+    colorNode.value.set(v)
+  })
+  watch(opacityGetter, (v) => {
+    opacityNode.value = v
+  })
+
+  useShaderStage(
+    (prev) => vec4(mix(prev.xyz, blendFn(prev.xyz, colorNode as unknown as TSLNode), opacityNode), prev.w),
+    order
+  )
+}

package/layers/shader/app/composables/useThemePreset.ts

@@ -0,0 +1,75 @@
+import {
+  createAmbientUniforms,
+  type AmbientUniforms,
+  type ThemeColorUniforms,
+} from '#layers/shader/app/composables/useAmbientMaterials'
+import type { TSLNode } from '#layers/shader/app/types/tsl'
+
+export type ThemePresetProps = {
+  speed?: number
+  intensity?: number
+  mouseInteraction?: boolean
+  mouseStrength?: number
+  color1?: string
+  color2?: string
+  color3?: string
+  color4?: string
+}
+
+export function useThemePreset(
+  colorNodeFactory: (uniforms: AmbientUniforms, colors: ThemeColorUniforms) => TSLNode,
+  props: Readonly<Required<ThemePresetProps>>
+) {
+  const uniforms = createAmbientUniforms({
+    speed: props.speed,
+    intensity: props.intensity,
+    mouseInteraction: props.mouseInteraction,
+  })
+  if (props.mouseInteraction) {
+    uniforms.mouseStrength.value = props.mouseStrength
+  }
+
+  const c1 = useShaderColor(props.color1)
+  const c2 = useShaderColor(props.color2)
+  const c3 = useShaderColor(props.color3)
+  const c4 = useShaderColor(props.color4)
+
+  const colorNode = colorNodeFactory(uniforms, {
+    color1: c1.node,
+    color2: c2.node,
+    color3: c3.node,
+    color4: c4.node,
+  })
+
+  watch(() => props.color1, (hex) => c1.tweenTo(hex, 0.8))
+  watch(() => props.color2, (hex) => c2.tweenTo(hex, 0.8))
+  watch(() => props.color3, (hex) => c3.tweenTo(hex, 0.8))
+  watch(() => props.color4, (hex) => c4.tweenTo(hex, 0.8))
+
+  try {
+    const runtime = useShaderRuntimeContext()
+    watch(
+      () => [runtime.mouse.mouseX.value, runtime.mouse.mouseY.value],
+      ([mx, my]) => {
+        uniforms.mouseX.value = mx
+        uniforms.mouseY.value = my
+      },
+      { immediate: true }
+    )
+  } catch {
+    // No runtime context
+  }
+
+  watch(() => props.speed, (v) => { uniforms.speed.value = v })
+  watch(() => props.intensity, (v) => { uniforms.intensity.value = v })
+  watch(
+    () => props.mouseInteraction,
+    (v) => { uniforms.mouseStrength.value = v ? props.mouseStrength : 0 }
+  )
+  watch(
+    () => props.mouseStrength,
+    (v) => { if (props.mouseInteraction) uniforms.mouseStrength.value = v }
+  )
+
+  return { uniforms, colorNode }
+}

package/layers/shader/app/shaders/common/noise.ts

@@ -26,6 +26,7 @@ import {
   vec4,
 } from 'three/tsl'
 
+import type { FBMOptions } from '../../types/tsl'
 import type { TSLNode } from '../types'
 import {
   fade,
@@ -204,13 +205,7 @@ export function gradientNoise3D(p: TSLNode): TSLNode {
 // FBM (Fractal Brownian Motion)
 // ============================================
 
-export type FBMOptions = {
-  octaves?: number
-  lacunarity?: number
-  gain?: number
-  amplitude?: number
-  frequency?: number
-}
+export type { FBMOptions }
 
 /**
  * 2D Fractal Brownian Motion