pixospritz-core 0.10.1 → 1.0.1

package/src/engine/shaders/skybox/cosmic/fs.js

@@ -0,0 +1,147 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function fs() {
+  return `
+  precision mediump float;
+  uniform samplerCube uSkybox;
+  uniform mat4 uViewDirectionProjectionInverse;
+  uniform float uTime;
+  varying vec4 vPosition;
+
+  // Hash functions
+  float hash(vec3 p) {
+    return fract(sin(dot(p, vec3(12.9898, 78.233, 45.164))) * 43758.5453);
+  }
+  
+  float hash2(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+  }
+
+  // Value noise
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    
+    float a = hash2(i);
+    float b = hash2(i + vec2(1.0, 0.0));
+    float c = hash2(i + vec2(0.0, 1.0));
+    float d = hash2(i + vec2(1.0, 1.0));
+    
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+  }
+
+  // Fractal brownian motion for nebulae
+  float fbm(vec2 p) {
+    float value = 0.0;
+    float amplitude = 0.5;
+    for (int i = 0; i < 6; i++) {
+      value += amplitude * noise(p);
+      amplitude *= 0.5;
+      p *= 2.0;
+    }
+    return value;
+  }
+
+  void main() {
+    vec4 t = uViewDirectionProjectionInverse * vPosition;
+    vec3 dir = normalize(t.xyz / t.w);
+    float time = uTime * 0.05;
+
+    // Deep space black base
+    vec3 color = vec3(0.01, 0.01, 0.02);
+    
+    // Multiple star layers with different densities
+    // Close bright stars
+    float starDensity1 = 0.0015;
+    vec3 starPos1 = dir * 80.0;
+    float star1 = step(1.0 - starDensity1, hash(floor(starPos1)));
+    if (star1 > 0.0) {
+      float twinkle = sin(time * 20.0 + hash(floor(starPos1)) * 6.28) * 0.2 + 0.8;
+      float brightness = (0.7 + 0.3 * hash(floor(starPos1) + 1.0)) * twinkle;
+      vec3 starColor = mix(vec3(1.0, 0.9, 0.8), vec3(0.8, 0.9, 1.0), hash(floor(starPos1) + 2.0));
+      color += starColor * brightness;
+    }
+    
+    // Medium distant stars
+    float starDensity2 = 0.003;
+    vec3 starPos2 = dir * 150.0;
+    float star2 = step(1.0 - starDensity2, hash(floor(starPos2)));
+    if (star2 > 0.0) {
+      float brightness = 0.4 + 0.3 * hash(floor(starPos2) + 1.0);
+      color += vec3(brightness);
+    }
+    
+    // Far dim stars (star dust)
+    float starDensity3 = 0.008;
+    vec3 starPos3 = dir * 300.0;
+    float star3 = step(1.0 - starDensity3, hash(floor(starPos3)));
+    if (star3 > 0.0) {
+      color += vec3(0.15 + 0.1 * hash(floor(starPos3)));
+    }
+
+    // Nebula layer 1 - Blue/purple
+    vec2 nebulaUV1 = dir.xy + dir.z * 0.5;
+    float nebula1 = fbm(nebulaUV1 * 2.0 + time * 0.1);
+    nebula1 = smoothstep(0.3, 0.8, nebula1);
+    vec3 nebulaColor1 = mix(vec3(0.1, 0.05, 0.2), vec3(0.2, 0.1, 0.4), nebula1);
+    color += nebulaColor1 * nebula1 * 0.4;
+    
+    // Nebula layer 2 - Pink/red (different orientation)
+    vec2 nebulaUV2 = dir.xz + dir.y * 0.5 + vec2(100.0);
+    float nebula2 = fbm(nebulaUV2 * 1.5 + time * 0.08);
+    nebula2 = smoothstep(0.4, 0.85, nebula2);
+    vec3 nebulaColor2 = mix(vec3(0.15, 0.02, 0.05), vec3(0.3, 0.05, 0.15), nebula2);
+    color += nebulaColor2 * nebula2 * 0.3;
+    
+    // Nebula layer 3 - Teal emission nebula
+    vec2 nebulaUV3 = dir.yz + dir.x * 0.5 + vec2(50.0, 200.0);
+    float nebula3 = fbm(nebulaUV3 * 2.5 + time * 0.12);
+    nebula3 = smoothstep(0.5, 0.9, nebula3);
+    vec3 nebulaColor3 = vec3(0.05, 0.15, 0.2) * nebula3;
+    color += nebulaColor3 * 0.25;
+
+    // Milky Way band (follows a curved path)
+    float milkyWay = abs(dir.y - sin(dir.x * 0.5) * 0.3);
+    milkyWay = 1.0 - smoothstep(0.0, 0.4, milkyWay);
+    float milkyNoise = fbm(dir.xz * 8.0 + time * 0.05);
+    color += vec3(0.1, 0.1, 0.12) * milkyWay * milkyNoise;
+    
+    // Add some extra star density in milky way
+    float milkyStars = step(0.97, noise(dir.xz * 500.0)) * milkyWay;
+    color += vec3(0.5, 0.5, 0.6) * milkyStars;
+
+    // Distant galaxies (rare, bright spots)
+    float galaxyDensity = 0.0002;
+    vec3 galaxyPos = dir * 20.0;
+    float galaxy = step(1.0 - galaxyDensity, hash(floor(galaxyPos)));
+    if (galaxy > 0.0) {
+      vec2 galaxyUV = fract(galaxyPos.xy) - 0.5;
+      float galaxyDist = length(galaxyUV);
+      float galaxyBright = exp(-galaxyDist * 15.0);
+      // Spiral arm effect
+      float angle = atan(galaxyUV.y, galaxyUV.x);
+      float spiral = sin(angle * 2.0 + galaxyDist * 10.0 + time) * 0.3 + 0.7;
+      vec3 galaxyColor = mix(vec3(1.0, 0.9, 0.7), vec3(0.7, 0.8, 1.0), hash(floor(galaxyPos) + 3.0));
+      color += galaxyColor * galaxyBright * spiral * 0.5;
+    }
+
+    // Subtle animated shimmer
+    float shimmer = noise(dir.xy * 100.0 + time * 2.0) * 0.02;
+    color += vec3(shimmer);
+
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+}

package/src/engine/shaders/skybox/cosmic/vs.js

@@ -0,0 +1,23 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function vs() {
+  return `
+  attribute vec4 aPosition;
+  varying vec4 vPosition;
+  void main() {
+    vPosition = aPosition;
+    gl_Position = aPosition;
+  }
+`;
+}

package/src/engine/shaders/skybox/matrix/fs.js

@@ -0,0 +1,127 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function fs() {
+    return `
+    precision highp float;
+    uniform mat4 uViewDirectionProjectionInverse;
+    varying vec4 vPosition;
+    uniform float uTime;
+    uniform vec2 uResolution;
+
+    const float PI = 3.141592653589793;
+
+    // simple float hash from vec2
+    float hash12(vec2 p) {
+        return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+    }
+
+    // value noise (cheap)
+    float noise2(vec2 p) {
+        vec2 i = floor(p);
+        vec2 f = fract(p);
+        float a = hash12(i + vec2(0.0, 0.0));
+        float b = hash12(i + vec2(1.0, 0.0));
+        float c = hash12(i + vec2(0.0, 1.0));
+        float d = hash12(i + vec2(1.0, 1.0));
+        vec2 u = f * f * (3.0 - 2.0 * f);
+        return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+    }
+
+    // smooth pulse shape
+    float pulse(float x, float wid) {
+        return smoothstep(0.0, wid, x) * (1.0 - smoothstep(1.0 - wid, 1.0, x));
+    }
+
+    void main() {
+        // Reconstruct view direction from interpolated clip-space position
+        vec4 t = uViewDirectionProjectionInverse * vPosition;
+        vec3 dir = normalize(t.xyz / t.w);
+
+        // convert direction -> equirectangular-like UV so "columns" wrap horizontally
+        float u = atan(dir.z, dir.x) / (2.0 * PI) + 0.5;
+        float v = asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5;
+        vec2 uv = vec2(u, v);
+
+        // Column layout
+        float colsBase = mix(120.0, 240.0, clamp(uResolution.x / 1600.0, 0.0, 1.0));
+        float horizonBias = 1.0 - abs(v - 0.5) * 2.0;
+        float cols = max(32.0, colsBase * (0.6 + 0.8 * horizonBias));
+
+        float colIndexF = floor(uv.x * cols);
+        float colX = (colIndexF + 0.5) / cols;
+
+        // per-column seed & speed variety
+        float seed = hash12(vec2(colIndexF, floor(uTime * 10.0)));
+        float speed = 0.8 + hash12(vec2(colIndexF, 9.0)) * 2.2;
+
+        // vertical tiling for character cells
+        float charSize = mix(0.018, 0.035, clamp(uResolution.y/900.0, 0.0, 1.0));
+        float rows = 1.0 / charSize;
+
+        float yScaled = uv.y * rows;
+        float yCell = floor(yScaled);
+        float yFrac = fract(yScaled);
+
+        // falling offset based on time and column seed
+        float fall = fract((uTime * speed * 0.25) + seed * 10.0);
+
+        float dropPos = fract(seed * 7.3 + uTime * 0.25 * speed);
+        float drop2 = fract(seed * 3.1 + uTime * 0.57 * speed * 0.7);
+
+        float d1 = abs(yCell / rows - dropPos);
+        float d2 = abs(yCell / rows - drop2);
+
+        float head = exp(-pow((yFrac + fract(yCell*0.9183) * 0.35), 2.0) * 40.0);
+        float tail = exp(-d1 * 8.0) + 0.5 * exp(-d2 * 12.0);
+
+        float glyphSeed = hash12(vec2(colIndexF, yCell));
+        float glyphPulse = pulse(fract(yScaled - (seed*3.0 + uTime*0.9*speed)), 0.12);
+        float glyph = smoothstep(0.35, 0.55, glyphSeed + 0.2 * noise2(vec2(colIndexF * 0.13, yCell * 0.07 + uTime * 0.1)));
+
+        float brightness = clamp( 1.6 * head + 0.9 * tail * glyph + 0.35 * glyph * glyphPulse, 0.0, 1.6);
+
+        float colWidth = 1.0 / cols * 0.9;
+        float colMask = smoothstep(0.0, 1.0, 1.0 - abs(uv.x - colX) / (colWidth * 0.6));
+
+        float jitter = noise2(vec2(colIndexF * 0.7, yCell * 0.9 + uTime * 0.2)) * 0.5;
+        float charV = smoothstep(0.0, 1.0, 1.0 - abs(yFrac - (0.5 + jitter*0.2)) * 2.0);
+
+        float intensity = brightness * colMask * charV;
+
+        vec3 baseGreen = vec3(0.1, 0.95, 0.15);
+        vec3 headColor = mix(baseGreen * 0.6, vec3(1.0, 1.0, 0.9), clamp(head * 2.0, 0.0, 1.0));
+        vec3 tailColor = baseGreen * (0.6 + 0.8 * glyph);
+
+        float headFactor = clamp(head * 2.0, 0.0, 1.0);
+        vec3 col = mix(tailColor, headColor, headFactor) * intensity;
+
+        float bgNoise = 0.04 * (noise2(uv * 400.0 + uTime * 0.03));
+        float verticalVignette = pow(1.0 - abs(v - 0.5) * 1.6, 1.8);
+        vec3 bg = vec3(0.01, 0.03, 0.01) * verticalVignette + bgNoise;
+
+        float stars = smoothstep(0.9996, 1.0, noise2(uv * 2000.0 + uTime * 0.1));
+        vec3 starCol = vec3(0.6, 1.0, 0.6) * stars * 1.2;
+
+        vec3 final = col + bg + starCol;
+
+        float glow = pow(intensity, 1.6) * 0.9;
+        final += vec3(glow * 0.14, glow * 0.22, glow * 0.06);
+
+        final = 1.0 - exp(-final * 1.6);
+        final = pow(final, vec3(0.9));
+
+        gl_FragColor = vec4(final, 1.0);
+    }
+`;
+}

package/src/engine/shaders/skybox/matrix/vs.js

@@ -0,0 +1,23 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function vs() {
+  return `
+  attribute vec4 aPosition;
+  varying vec4 vPosition;
+  void main() {
+    vPosition = aPosition;
+    gl_Position = aPosition;
+  }
+`;
+}

package/src/engine/shaders/skybox/morning/fs.js

@@ -0,0 +1,109 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function fs() {
+  return `
+  precision mediump float;
+ 
+  uniform samplerCube uSkybox;
+  uniform mat4 uViewDirectionProjectionInverse;
+  uniform float uTime;
+  
+  varying vec4 vPosition;
+  
+  // Hash function for clouds
+  float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+  }
+  
+  // Value noise
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    
+    float a = hash(i);
+    float b = hash(i + vec2(1.0, 0.0));
+    float c = hash(i + vec2(0.0, 1.0));
+    float d = hash(i + vec2(1.0, 1.0));
+    
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+  }
+  
+  // Fractal brownian motion for fluffy clouds
+  float fbm(vec2 p) {
+    float value = 0.0;
+    float amplitude = 0.5;
+    for (int i = 0; i < 5; i++) {
+      value += amplitude * noise(p);
+      amplitude *= 0.5;
+      p *= 2.0;
+    }
+    return value;
+  }
+  
+  void main() {
+    vec4 t = uViewDirectionProjectionInverse * vPosition;
+    vec3 dir = normalize(t.xyz / t.w);
+    
+    // Height-based gradient
+    float y = dir.y * 0.5 + 0.5;
+    
+    // Sun position (rising from the east)
+    vec3 sunDir = normalize(vec3(1.0, 0.3, 0.0));
+    float sunDot = dot(dir, sunDir);
+    
+    // Morning color palette - soft and fresh
+    vec3 horizonColor = vec3(1.0, 0.85, 0.7);    // Warm peachy horizon
+    vec3 skyColor = vec3(0.5, 0.7, 0.95);        // Soft blue sky
+    vec3 sunColor = vec3(1.0, 1.0, 0.9);         // Bright morning sun
+    vec3 glowColor = vec3(1.0, 0.9, 0.7);        // Warm glow
+    
+    // Base sky gradient - softer transition
+    vec3 color = mix(horizonColor, skyColor, pow(y, 0.6));
+    
+    // Morning sun glow
+    float glow = pow(max(0.0, sunDot), 8.0);
+    color = mix(color, glowColor, glow * 0.6);
+    
+    // Bright sun disc
+    float sun = pow(max(0.0, sunDot), 512.0) * 2.0;
+    color = mix(color, sunColor, min(1.0, sun));
+    
+    // Fluffy morning clouds
+    float time = uTime * 0.015;
+    vec2 cloudUV = dir.xz / (abs(dir.y) + 0.3) * 1.5 + vec2(time, 0.0);
+    float clouds = fbm(cloudUV * 2.0);
+    
+    // Shape clouds nicely
+    clouds = smoothstep(0.35, 0.65, clouds);
+    
+    // Clouds are bright white in morning light
+    vec3 cloudColor = mix(vec3(0.95, 0.95, 1.0), vec3(1.0, 0.98, 0.9), glow);
+    
+    // Apply clouds more in the upper sky
+    float cloudMask = smoothstep(0.1, 0.6, y) * (1.0 - smoothstep(0.7, 1.0, y));
+    color = mix(color, cloudColor, clouds * cloudMask * 0.7);
+    
+    // Soft atmospheric haze near horizon
+    float haze = exp(-y * 4.0);
+    color = mix(color, horizonColor * 1.1, haze * 0.25);
+    
+    // Add subtle light rays
+    float rays = pow(max(0.0, sunDot), 2.0) * noise(dir.xz * 10.0 + time * 0.5) * 0.15;
+    color += vec3(rays) * (1.0 - y);
+    
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+}

package/src/engine/shaders/skybox/morning/vs.js

@@ -0,0 +1,23 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function vs() {
+  return `
+  attribute vec4 aPosition;
+  varying vec4 vPosition;
+  void main() {
+    vPosition = aPosition;
+    gl_Position = aPosition;
+  }
+`;
+}

package/src/engine/shaders/skybox/neon/fs.js

@@ -0,0 +1,119 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function fs() {
+  return `
+  precision mediump float;
+  uniform samplerCube uSkybox;
+  varying vec4 vPosition;
+  uniform mat4 uViewDirectionProjectionInverse;
+  uniform float uTime;
+
+  // Hash function
+  float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+  }
+  
+  float hash3(vec3 p) {
+    return fract(sin(dot(p, vec3(12.9898, 78.233, 45.164))) * 43758.5453);
+  }
+
+  // Value noise
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    
+    float a = hash(i);
+    float b = hash(i + vec2(1.0, 0.0));
+    float c = hash(i + vec2(0.0, 1.0));
+    float d = hash(i + vec2(1.0, 1.0));
+    
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+  }
+  
+  void main() {
+    vec4 t = uViewDirectionProjectionInverse * vPosition;
+    vec3 dir = normalize(t.xyz / t.w);
+    float time = uTime;
+    
+    // Dark base with subtle color
+    vec3 color = vec3(0.02, 0.01, 0.05);
+    
+    // Animated grid lines (synthwave style)
+    vec2 gridUV = dir.xz / (dir.y + 0.3);
+    
+    // Perspective grid
+    float gridX = abs(sin(gridUV.x * 8.0 + time * 0.5));
+    float gridZ = abs(sin(gridUV.y * 4.0 - time * 2.0));
+    
+    // Grid lines with glow
+    float lineX = pow(gridX, 20.0);
+    float lineZ = pow(gridZ, 20.0);
+    float grid = max(lineX, lineZ);
+    
+    // Only show grid below horizon
+    float belowHorizon = smoothstep(0.1, -0.3, dir.y);
+    grid *= belowHorizon;
+    
+    // Neon pink/cyan colors
+    vec3 neonPink = vec3(1.0, 0.1, 0.5);
+    vec3 neonCyan = vec3(0.1, 1.0, 0.8);
+    vec3 neonPurple = vec3(0.6, 0.1, 1.0);
+    
+    // Alternate line colors
+    vec3 gridColor = mix(neonPink, neonCyan, sin(time * 0.3) * 0.5 + 0.5);
+    color += gridColor * grid * 0.8;
+    
+    // Add horizon glow
+    float horizonGlow = exp(-abs(dir.y) * 5.0);
+    vec3 horizonColor = mix(neonPink, neonPurple, sin(time * 0.2) * 0.5 + 0.5);
+    color += horizonColor * horizonGlow * 0.6;
+    
+    // Animated neon sun
+    vec3 sunDir = normalize(vec3(sin(time * 0.1), 0.1, -1.0));
+    float sunDot = dot(dir, sunDir);
+    
+    // Segmented retro sun
+    float sunMask = step(0.9, sunDot);
+    float sunStripes = step(0.5, sin(dir.y * 40.0 - time * 2.0));
+    vec3 sunColor = mix(neonPink, vec3(1.0, 0.5, 0.0), (1.0 - dir.y) * 2.0);
+    color = mix(color, sunColor * (0.5 + sunStripes * 0.5), sunMask);
+    
+    // Sun glow
+    float sunGlow = pow(max(0.0, sunDot), 4.0) * (1.0 - sunMask);
+    color += sunColor * sunGlow * 0.5;
+    
+    // Scattered stars with chromatic aberration
+    float starDensity = 0.003;
+    vec3 starPos = dir * 50.0;
+    float star = step(1.0 - starDensity, hash3(floor(starPos)));
+    if (star > 0.0 && dir.y > 0.0) {
+      float twinkle = sin(time * 5.0 + hash3(floor(starPos)) * 6.28) * 0.3 + 0.7;
+      vec3 starColor = mix(neonCyan, neonPink, hash3(floor(starPos) + 1.0));
+      color += starColor * twinkle * 0.8;
+    }
+    
+    // Scanlines effect
+    float scanline = sin(gl_FragCoord.y * 2.0) * 0.03;
+    color *= 1.0 - scanline;
+    
+    // Vignette
+    vec2 uv = gl_FragCoord.xy / vec2(800.0, 600.0); // Approximate
+    float vignette = 1.0 - length(uv - 0.5) * 0.5;
+    color *= vignette;
+    
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+}

package/src/engine/shaders/skybox/neon/vs.js

@@ -0,0 +1,23 @@
+/*                                                 *\
+** ----------------------------------------------- **
+**          Calliope - Pixos Game Engine   	       **
+** ----------------------------------------------- **
+**  Copyright (c) 2020-2025 - Kyle Derby MacInnis  **
+**                                                 **
+**    Any unauthorized distribution or transfer    **
+**       of this work is strictly prohibited.      **
+**                                                 **
+**               All Rights Reserved.              **
+** ----------------------------------------------- **
+\*                                                 */
+
+export default function vs() {
+  return `
+  attribute vec4 aPosition;
+  varying vec4 vPosition;
+  void main() {
+    vPosition = aPosition;
+    gl_Position = aPosition;
+  }
+`;
+}