test

Author: Parsa Azari

dist/shaders/code_room_floor.glsl

@@ -0,0 +1,98 @@
+// CODE Room Floor Shader (Tim Rodenbroeker style)
+// Generative grid pattern with dynamic highlights based on player position
+
+uniform float time;
+uniform vec3 playerPos;
+varying vec2 vUv;
+
+// Pattern constants
+#define GRID_SIZE 20.0
+#define SMALL_GRID_SIZE 4.0
+#define LINE_WIDTH 0.03
+#define NODE_RADIUS 0.15
+#define MAX_NODES 5
+
+// Helper for anti-aliasing
+float aastep(float threshold, float value) {
+    float afwidth = length(vec2(dFdx(value), dFdy(value))) * 0.70710678118654757;
+    return smoothstep(threshold-afwidth, threshold+afwidth, value);
+}
+
+// Create a grid pattern
+float grid(vec2 uv, float size, float lineWidth) {
+    vec2 grid = fract(uv * size);
+    vec2 smoothWidth = vec2(lineWidth) / size;
+    vec2 gridLines = smoothstep(vec2(0.0), smoothWidth, grid) * 
+                    (1.0 - smoothstep(vec2(1.0) - smoothWidth, vec2(1.0), grid));
+    return max(gridLines.x, gridLines.y);
+}
+
+// Create a circular node
+float node(vec2 uv, vec2 position, float radius) {
+    float dist = distance(uv, position);
+    return 1.0 - smoothstep(radius - 0.01, radius, dist);
+}
+
+// Generate stable random value
+float random(vec2 st) {
+    return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
+}
+
+void main() {
+    // Get normalized UV coordinates
+    vec2 uv = vUv;
+    
+    // Create base grid
+    float mainGrid = grid(uv, GRID_SIZE, LINE_WIDTH);
+    float subGrid = grid(uv, GRID_SIZE * SMALL_GRID_SIZE, LINE_WIDTH * 0.5);
+    
+    // Calculate base color from grid
+    vec3 baseColor = vec3(0.1, 0.1, 0.12);
+    vec3 gridColor = vec3(0.34, 0.85, 0.53); // green similar to 0x34a853
+    vec3 color = mix(baseColor, gridColor, mainGrid * 0.7);
+    color = mix(color, gridColor * 0.7, subGrid * 0.3);
+    
+    // Add nodes at grid intersections
+    for (int i = 0; i < MAX_NODES; i++) {
+        // Stable node positions based on index
+        float ix = float(i) / float(MAX_NODES);
+        vec2 nodePos = vec2(
+            0.1 + 0.8 * fract(sin(ix * 234.5) * 43758.5453123),
+            0.1 + 0.8 * fract(cos(ix * 598.3) * 13758.5123891)
+        );
+        
+        // Make nodes pulse based on time
+        float pulse = 0.5 + 0.5 * sin(time * (0.5 + ix) + ix * 10.0);
+        float nodeSize = NODE_RADIUS * (0.7 + 0.3 * pulse);
+        
+        // Create node and add to color
+        float nodeValue = node(uv, nodePos, nodeSize);
+        vec3 nodeColor = mix(
+            gridColor,
+            vec3(0.7, 0.9, 0.8), 
+            pulse
+        );
+        color = mix(color, nodeColor, nodeValue * pulse);
+        
+        // Add subtle glow around node
+        float glowRadius = nodeSize * 3.0;
+        float glow = (1.0 - smoothstep(nodeSize, glowRadius, distance(uv, nodePos))) * 0.15 * pulse;
+        color += nodeColor * glow;
+    }
+    
+    // Add player highlight effect
+    vec2 playerUV = playerPos.xz / 20.0 + vec2(0.5); // Convert player position to UV space
+    float distToPlayer = distance(uv, playerUV);
+    
+    // Create radial highlight around player position
+    float playerHighlight = 1.0 - smoothstep(0.0, 0.2, distToPlayer);
+    color = mix(color, gridColor * 1.5, playerHighlight * 0.3);
+    
+    // Add subtle ripple effect from player
+    float ripple = sin(distToPlayer * 20.0 - time * 2.0) * 0.5 + 0.5;
+    ripple *= smoothstep(0.5, 0.0, distToPlayer); // Fade out with distance
+    color += gridColor * ripple * 0.15;
+    
+    // Output final color
+    gl_FragColor = vec4(color, 1.0);
+} 

dist/shaders/common/vertex.glsl

@@ -0,0 +1,29 @@
+// Common vertex shader for Severance environments
+// Used by walls, corridors, and other surfaces
+
+// Varying outputs passed to fragment shader
+varying vec3 vNormal;
+varying vec2 vUv;
+varying vec3 vPosition;
+varying vec3 vViewDir;
+varying vec4 vWorldPosition;
+
+void main() {
+  // Pass texture coordinates to fragment shader
+  vUv = uv;
+  
+  // Transform normal into view space
+  vNormal = normalize(normalMatrix * normal);
+  
+  // Calculate view space position
+  vPosition = (modelViewMatrix * vec4(position, 1.0)).xyz;
+  
+  // Calculate view direction (not normalized)
+  vViewDir = normalize(-vPosition);
+  
+  // Calculate world position for effects that need it
+  vWorldPosition = modelMatrix * vec4(position, 1.0);
+  
+  // Output clip space position
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+} 

dist/shaders/corridor.glsl

@@ -0,0 +1,42 @@
+// Corridor shader for Severance environment
+// Provides subtle lighting effects and enhances the clinical atmosphere
+
+uniform vec3 lightColor;
+uniform float lightIntensity;
+uniform vec3 ambientLight;
+uniform float time;
+
+varying vec3 vNormal;
+varying vec3 vPosition;
+varying vec2 vUv;
+
+void main() {
+  // Calculate normal lighting
+  vec3 normal = normalize(vNormal);
+  vec3 viewDir = normalize(-vPosition);
+  
+  // Calculate basic lighting
+  float diffuse = max(dot(normal, vec3(0.0, -1.0, 0.0)), 0.0);
+  
+  // Add flickering effect to simulate fluorescent lighting
+  float flicker = 1.0 + 0.02 * sin(time * 10.0) * sin(time * 5.0);
+  
+  // Subtle edge glow effect for that clinical Severance look
+  float edgeGlow = pow(1.0 - max(dot(normal, viewDir), 0.0), 5.0) * 0.5;
+  
+  // Calculate final color
+  vec3 color = ambientLight + (lightColor * lightIntensity * diffuse * flicker);
+  
+  // Add subtle white-blue tint that's characteristic of the Severance offices
+  color = mix(color, vec3(0.9, 0.95, 1.0), 0.15);
+  
+  // Add edge glow effect
+  color += vec3(0.9, 0.95, 1.0) * edgeGlow;
+  
+  // Add subtle vignette effect
+  float vignetteAmount = 0.8;
+  float vignette = smoothstep(0.0, vignetteAmount, length(vUv - 0.5) * 1.5);
+  color = mix(color, color * 0.6, vignette);
+  
+  gl_FragColor = vec4(color, 1.0);
+} 

dist/shaders/corridor_floor.glsl

@@ -0,0 +1,65 @@
+// Twin Peaks Lodge-inspired chevron floor shader (Tim Rodenbroeker style)
+// Perspective-corrected black and white chevron pattern for corridors
+
+uniform float time;
+uniform vec3 playerPos;
+varying vec2 vUv;
+varying vec4 vWorldPosition;
+
+// Perfect pattern constants
+#define CHEVRON_COUNT 10.0    // Increased density for more consistent pattern
+#define PERSPECTIVE_CORRECTION 0.85  // Corrects distortion in long corridors
+
+// Anti-aliasing for crisp edges
+float smoothPattern(float value) {
+    float width = fwidth(value) * 0.5;
+    return smoothstep(0.5 - width, 0.5 + width, value);
+}
+
+void main() {
+    // Use world position for seamless pattern
+    vec2 uv = vWorldPosition.xz;
+    
+    // Normalize world coordinates to a reasonable scale for pattern tiling
+    uv /= 5.0; // Adjust denominator for pattern scale as needed
+    
+    // Scale UVs for pattern density
+    uv.x *= CHEVRON_COUNT;
+    
+    // Create a coordinate system where chevrons are regular regardless of corridor length
+    float rowHeight = 0.2; // Height of each row as fraction of total height
+    float y = uv.y / rowHeight;
+    float row = floor(y);
+    float fraction = fract(y);
+    
+    // Alternate chevron direction each row
+    float direction = mod(row, 2.0) * 2.0 - 1.0; // -1 or 1
+    float offset = (fraction - 0.5) * 0.8; // Scaling factor for chevron steepness
+    
+    // Calculate chevron pattern with consistent width-to-height ratio
+    float chevronX = uv.x + direction * offset;
+    
+    // Create sharp alternating black/white pattern
+    float pattern = mod(floor(chevronX), 2.0);
+    
+    // Anti-alias edges
+    float patternSmooth = smoothPattern(fract(chevronX));
+    pattern = mix(pattern, 1.0 - pattern, patternSmooth);
+    
+    // Define crisp black and white colors
+    vec3 black = vec3(0.03, 0.03, 0.04);
+    vec3 white = vec3(0.97, 0.97, 0.97);
+    
+    // Mix colors based on pattern
+    vec3 color = mix(black, white, pattern);
+    
+    // Add subtle glossy highlight near player position (in world coordinates)
+    float distToPlayer = length((vWorldPosition.xz - playerPos.xz) / 5.0);
+    float sheen = 0.04 * smoothstep(0.5, 0.0, distToPlayer);
+    color += vec3(sheen);
+    
+    // Extremely subtle red tint for the Severance/Twin Peaks mood
+    color = mix(color, color + vec3(0.03, 0.0, 0.0), 0.05);
+    
+    gl_FragColor = vec4(color, 1.0);
+}