action-engine-js 1.0.0

package/actionengine/display/gl/shaders/particleshader.js

@@ -0,0 +1,43 @@
+// game/display/gl/shaders/particleshader.js
+class ParticleShader {
+    getParticleVertexShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        ${isWebGL2 ? "in" : "attribute"} vec3 aPosition;
+        ${isWebGL2 ? "in" : "attribute"} float aSize;
+        ${isWebGL2 ? "in" : "attribute"} vec4 aColor;
+    
+        uniform mat4 uProjectionMatrix;
+        uniform mat4 uViewMatrix;
+    
+        ${isWebGL2 ? "out" : "varying"} vec4 vColor;
+    
+        void main() {
+            gl_Position = uProjectionMatrix * uViewMatrix * vec4(aPosition, 1.0);
+            gl_PointSize = aSize;
+            vColor = aColor;
+        }`;
+    }
+
+    getParticleFragmentShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        precision mediump float;
+        ${isWebGL2 ? "in" : "varying"} vec4 vColor;
+        ${isWebGL2 ? "out vec4 fragColor;\n" : ""}
+        uniform int uParticleType;
+        void main() {
+            vec2 coord = gl_PointCoord * 2.0 - 1.0;
+            if (uParticleType == 1 || uParticleType == 2) {  // Rain types
+                coord.y *= 12.0; // Longer streaks
+                float r = dot(coord, coord);
+                float streak = smoothstep(1.0, 0.0, r);
+                float trail = smoothstep(1.0, 0.0, coord.y);
+                float droplet = streak * trail;
+                ${isWebGL2 ? "fragColor" : "gl_FragColor"} = vec4(0.8, 0.85, 1.0, 1.0); // Blueish tint, more transparent
+            } else {
+                float r = dot(coord, coord);
+                if (r > 1.0) discard;
+                ${isWebGL2 ? "fragColor" : "gl_FragColor"} = vColor;
+            }
+        }`;
+    }
+}

package/actionengine/display/gl/shaders/shadowshader.js

@@ -0,0 +1,319 @@
+// actionengine/display/gl/shaders/shadowshader.js
+class ShadowShader {
+    /**
+     * Dedicated vertex shader for directional shadow mapping
+     * This is the clean version that only handles directional shadows
+     */
+    getDirectionalShadowVertexShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        ${isWebGL2 ? "in" : "attribute"} vec3 aPosition;
+        
+        uniform mat4 uLightSpaceMatrix;
+        uniform mat4 uModelMatrix;
+        
+        void main() {
+            gl_Position = uLightSpaceMatrix * uModelMatrix * vec4(aPosition, 1.0);
+        }`;
+    }
+    
+    /**
+     * Vertex shader for the shadow mapping pass
+     * This shader simply transforms vertices to light space
+     */
+    getShadowVertexShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        ${isWebGL2 ? "in" : "attribute"} vec3 aPosition;
+        
+        uniform mat4 uLightSpaceMatrix;
+        uniform mat4 uModelMatrix;
+        ${isWebGL2 ? "out" : "varying"} vec4 vWorldPos; // For omnidirectional shadows
+        uniform vec3 uLightPos; // For omnidirectional shadows
+        
+        void main() {
+            vec4 worldPos = uModelMatrix * vec4(aPosition, 1.0);
+            vWorldPos = worldPos;
+            gl_Position = uLightSpaceMatrix * worldPos;
+        }`;
+    }
+    
+    /**
+     * Get the vertex shader for omnidirectional shadow mapping
+     * This variant is optimized for point lights with cubemap shadows
+     */
+    getOmniShadowVertexShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        ${isWebGL2 ? "in" : "attribute"} vec3 aPosition;
+        
+        uniform mat4 uLightSpaceMatrix;
+        uniform mat4 uModelMatrix;
+        uniform vec3 uLightPos;
+        
+        ${isWebGL2 ? "out" : "varying"} vec3 vFragPos;
+        
+        void main() {
+            vec4 worldPos = uModelMatrix * vec4(aPosition, 1.0);
+            vFragPos = worldPos.xyz;
+            gl_Position = uLightSpaceMatrix * worldPos;
+        }`;
+    }
+
+    /**
+     * Fragment shader for the shadow mapping pass
+     * This shader outputs depth values to the shadow map
+     */
+    getDirectionalShadowFragmentShader(isWebGL2) {
+        if (isWebGL2) {
+            return `#version 300 es
+            precision mediump float;
+            
+            // Debug uniforms
+            uniform bool uDebugShadowMap;
+            uniform bool uForceShadowMapTest;
+            uniform float uShadowMapSize;
+            
+            out vec4 fragColor;
+            
+            void main() {
+                // DIRECTIONAL ONLY: Direct depth from gl_FragCoord.z
+                float depth = gl_FragCoord.z;
+                
+                // Apply forcing if in test mode
+                if (uForceShadowMapTest) {
+                    vec2 center = vec2(0.5, 0.5);
+                    vec2 normalizedCoord = gl_FragCoord.xy / uShadowMapSize;
+                    
+                    float testSize = 256.0 / uShadowMapSize;
+                    if (abs(normalizedCoord.x - center.x) < testSize && 
+                        abs(normalizedCoord.y - center.y) < testSize) {
+                        depth = 0.5; // Force a mid-range depth value in test area
+                    }
+                }
+                
+                // Pack depth into RGBA (manual encoding for better precision)
+                const vec4 bitShift = vec4(1.0, 256.0, 256.0*256.0, 256.0*256.0*256.0);
+                const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);
+                vec4 encodedDepth = fract(depth * bitShift);
+                encodedDepth -= encodedDepth.gbaa * bitMask;
+                
+                fragColor = encodedDepth;
+            }`;
+        } else {
+            // WebGL1 version
+            return `precision highp float;
+            
+            // Debug uniforms
+            uniform bool uDebugShadowMap;
+            uniform bool uForceShadowMapTest;
+            uniform float uShadowMapSize;
+            
+            void main() {
+                // DIRECTIONAL ONLY: Direct depth from gl_FragCoord.z
+                float depth = gl_FragCoord.z;
+                
+                // Create test pattern if enabled
+                if (uForceShadowMapTest) {
+                    vec2 center = vec2(0.5, 0.5);
+                    vec2 normalizedCoord = gl_FragCoord.xy / uShadowMapSize;
+                    
+                    float testSize = 256.0 / uShadowMapSize;
+                    if (abs(normalizedCoord.x - center.x) < testSize && 
+                        abs(normalizedCoord.y - center.y) < testSize) {
+                        // For WebGL1, we need to encode depth as RGBA
+                        gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); // White = 1.0 depth
+                        return;
+                    }
+                }
+                
+                if (uDebugShadowMap) {
+                    // For debug visualization
+                    gl_FragColor = vec4(depth, depth * 0.5, depth * 0.2, 1.0);
+                    
+                    // Show test area if enabled
+                    if (uForceShadowMapTest) {
+                        vec2 center = vec2(0.5, 0.5);
+                        vec2 normalizedCoord = gl_FragCoord.xy / uShadowMapSize;
+                        
+                        float testSize = 256.0 / uShadowMapSize;
+                        if (abs(normalizedCoord.x - center.x) < testSize && 
+                            abs(normalizedCoord.y - center.y) < testSize) {
+                            gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); // Red for test area
+                        }
+                    }
+                } else {
+                    // Pack depth into RGBA (bit-wise encoding) for normal operation
+                    const vec4 bitShift = vec4(1.0, 256.0, 256.0*256.0, 256.0*256.0*256.0);
+                    const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);
+                    vec4 color = fract(depth * bitShift);
+                    color -= color.gbaa * bitMask;
+                    
+                    gl_FragColor = color;
+                }
+            }`;
+        }
+    }
+    
+    getShadowFragmentShader(isWebGL2) {
+        if (isWebGL2) {
+            return `#version 300 es
+        precision mediump float;
+        
+        // Debug uniforms
+        uniform bool uDebugShadowMap;
+        uniform bool uForceShadowMapTest;
+        uniform float uShadowMapSize;  // New uniform for shadow map size
+        
+        // For omnidirectional shadows
+        in vec4 vWorldPos;
+        uniform vec3 uLightPos;
+        uniform float uFarPlane;
+        
+        out vec4 fragColor;
+        
+        void main() {
+    // For omnidirectional shadows, compute distance from light to fragment
+    vec3 fragToLight = vWorldPos.xyz - uLightPos;
+    float lightDistance = length(fragToLight);
+    
+    // Normalize to [0,1] range based on far plane
+    float depth = lightDistance / uFarPlane;
+    
+    // Apply forcing if in test mode
+    if (uForceShadowMapTest) {
+        vec2 center = vec2(0.5, 0.5);
+        vec2 normalizedCoord = gl_FragCoord.xy / uShadowMapSize;
+        
+        float testSize = 256.0 / uShadowMapSize;
+        if (abs(normalizedCoord.x - center.x) < testSize && 
+            abs(normalizedCoord.y - center.y) < testSize) {
+            depth = 0.5; // Force a mid-range depth value in test area
+        }
+    }
+    
+    // Pack depth into RGBA (manual encoding for better precision)
+    const vec4 bitShift = vec4(1.0, 256.0, 256.0*256.0, 256.0*256.0*256.0);
+    const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);
+    vec4 encodedDepth = fract(depth * bitShift);
+    encodedDepth -= encodedDepth.gbaa * bitMask;
+    
+    fragColor = encodedDepth;
+}`;
+        } else {
+            // WebGL1 version
+            return `precision highp float;
+        
+        // Debug uniforms
+        uniform bool uDebugShadowMap;
+        uniform bool uForceShadowMapTest;
+        uniform float uShadowMapSize;  // New uniform for shadow map size
+        
+        // For omnidirectional shadows
+        varying vec4 vWorldPos;
+        uniform vec3 uLightPos;
+        uniform float uFarPlane;
+        
+        void main() {
+            // For omnidirectional shadows, compute distance from light to fragment
+            vec3 fragToLight = vWorldPos.xyz - uLightPos;
+            float lightDistance = length(fragToLight);
+            
+            // Normalize to [0,1] range based on far plane
+            float depth = lightDistance / uFarPlane;
+            
+            // Create test pattern if enabled
+            if (uForceShadowMapTest) {
+                vec2 center = vec2(0.5, 0.5);
+                vec2 normalizedCoord = gl_FragCoord.xy / uShadowMapSize;
+                
+                float testSize = 256.0 / uShadowMapSize;
+                if (abs(normalizedCoord.x - center.x) < testSize && 
+                    abs(normalizedCoord.y - center.y) < testSize) {
+                    // For WebGL1, we need to encode depth as RGBA
+                    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); // White = 1.0 depth
+                    return;
+                }
+            }
+            
+            if (uDebugShadowMap) {
+                // For debug visualization
+                gl_FragColor = vec4(depth, depth * 0.5, depth * 0.2, 1.0);
+                
+                // Show test area if enabled
+                if (uForceShadowMapTest) {
+                    vec2 center = vec2(0.5, 0.5);
+                    vec2 normalizedCoord = gl_FragCoord.xy / uShadowMapSize;
+                    
+                    float testSize = 256.0 / uShadowMapSize;
+                    if (abs(normalizedCoord.x - center.x) < testSize && 
+                        abs(normalizedCoord.y - center.y) < testSize) {
+                        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); // Red for test area
+                    }
+                }
+            } else {
+                // Pack depth into RGBA (bit-wise encoding) for normal operation
+                const vec4 bitShift = vec4(1.0, 256.0, 256.0*256.0, 256.0*256.0*256.0);
+                const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);
+                vec4 color = fract(depth * bitShift);
+                color -= color.gbaa * bitMask;
+                
+                gl_FragColor = color;
+            }
+        }`;
+        }
+    }
+    
+    /**
+     * Fragment shader specifically for omnidirectional shadow mapping
+     * Optimized for point lights with cubemap shadows
+     */
+    getOmniShadowFragmentShader(isWebGL2) {
+        if (isWebGL2) {
+            return `#version 300 es
+        precision mediump float;
+        
+        in vec3 vFragPos;
+        uniform vec3 uLightPos;
+        uniform float uFarPlane;
+        
+        out vec4 fragColor;
+        
+        void main() {
+            // Get distance between fragment and light source
+            float lightDistance = length(vFragPos - uLightPos);
+            
+            // Map to [0,1] range by dividing by far plane
+            lightDistance = lightDistance / uFarPlane;
+            
+            // Write this as depth value
+            const vec4 bitShift = vec4(1.0, 256.0, 256.0*256.0, 256.0*256.0*256.0);
+            const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);
+            vec4 encodedDepth = fract(lightDistance * bitShift);
+            encodedDepth -= encodedDepth.gbaa * bitMask;
+            
+            fragColor = encodedDepth;
+        }`;
+        } else {
+            // WebGL1 version
+            return `precision highp float;
+        
+        varying vec3 vFragPos;
+        uniform vec3 uLightPos;
+        uniform float uFarPlane;
+        
+        void main() {
+            // Get distance between fragment and light source
+            float lightDistance = length(vFragPos - uLightPos);
+            
+            // Map to [0,1] range by dividing by far plane
+            lightDistance = lightDistance / uFarPlane;
+            
+            // Write this as depth value
+            const vec4 bitShift = vec4(1.0, 256.0, 256.0*256.0, 256.0*256.0*256.0);
+            const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);
+            vec4 color = fract(lightDistance * bitShift);
+            color -= color.gbaa * bitMask;
+            
+            gl_FragColor = color;
+        }`;
+        }
+    }
+}

package/actionengine/display/gl/shaders/spriteshader.js

@@ -0,0 +1,100 @@
+// actionengine/display/gl/shaders/spriteshader.js
+
+class SpriteShader {
+    constructor() {
+        // No variants needed for sprites - keep it simple
+    }
+
+    /**
+     * Get sprite vertex shader
+     * @param {boolean} isWebGL2 - Whether WebGL2 is being used
+     * @returns {string} - Vertex shader source code
+     */
+    getVertexShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        precision mediump float;
+        
+        ${isWebGL2 ? "in" : "attribute"} vec3 aPosition;
+        ${isWebGL2 ? "in" : "attribute"} vec2 aTexCoord;
+        
+        uniform mat4 uProjectionMatrix;
+        uniform mat4 uViewMatrix;
+        uniform vec3 uSpritePosition;  // World position of the sprite
+        uniform vec2 uSpriteSize;      // Width and height of the sprite
+        uniform vec3 uCameraPosition;
+        uniform vec3 uCameraRight;
+        uniform vec3 uCameraUp;
+        uniform bool uIsBillboard;     // Whether to use billboard mode
+        uniform vec3 uSpriteForward;   // Sprite forward direction (for non-billboard)
+        uniform vec3 uSpriteUp;        // Sprite up direction (for non-billboard)
+        
+        ${isWebGL2 ? "out" : "varying"} vec2 vTexCoord;
+        
+        void main() {
+            vec3 worldPos;
+
+            if (uIsBillboard) {
+                // Calculate billboard position in world space
+                // aPosition.xy contains the quad vertices (-0.5 to 0.5)
+                worldPos = uSpritePosition
+                         + uCameraRight * aPosition.x * uSpriteSize.x
+                         + uCameraUp * aPosition.y * uSpriteSize.y;
+            } else {
+                // Non-billboard mode: Use sprite's own orientation
+                // Create a basis using sprite's forward and up vectors
+                vec3 forward = normalize(uSpriteForward);
+                vec3 up = normalize(uSpriteUp);
+
+                // Calculate right vector (perpendicular to forward and up)
+                vec3 right = normalize(cross(forward, up));
+
+                // Recalculate up to ensure orthogonality (in case forward/up weren't perfectly perpendicular)
+                vec3 correctedUp = normalize(cross(right, forward));
+
+                // Calculate world position using sprite's local coordinate system
+                worldPos = uSpritePosition
+                         + right * aPosition.x * uSpriteSize.x
+                         + correctedUp * aPosition.y * uSpriteSize.y;
+            }
+
+            // Transform to screen space
+            vec4 viewPos = uViewMatrix * vec4(worldPos, 1.0);
+            gl_Position = uProjectionMatrix * viewPos;
+
+            // Pass through texture coordinates
+            vTexCoord = aTexCoord;
+        }`;
+    }
+
+    /**
+     * Get billboard fragment shader
+     * @param {boolean} isWebGL2 - Whether WebGL2 is being used
+     * @returns {string} - Fragment shader source code
+     */
+    getFragmentShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        precision mediump float;
+        
+        ${isWebGL2 ? "in" : "varying"} vec2 vTexCoord;
+        
+        uniform sampler2D uTexture;
+        uniform vec3 uColor;       // Color tint
+        uniform float uAlpha;      // Alpha value
+        
+        ${isWebGL2 ? "out vec4 fragColor;" : ""}
+        
+        void main() {
+            vec4 texColor = texture${isWebGL2 ? "" : "2D"}(uTexture, vTexCoord);
+            
+            // Apply color tint and alpha
+            vec4 finalColor = vec4(texColor.rgb * uColor, texColor.a * uAlpha);
+            
+            // Discard transparent pixels
+            if (finalColor.a < 0.01) {
+                discard;
+            }
+            
+            ${isWebGL2 ? "fragColor = finalColor;" : "gl_FragColor = finalColor;"}
+        }`;
+    }
+}

package/actionengine/display/gl/shaders/watershader.js

@@ -0,0 +1,67 @@
+class WaterShader {
+    getWaterVertexShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        ${isWebGL2 ? "in" : "attribute"} vec3 aPosition;
+        ${isWebGL2 ? "in" : "attribute"} vec3 aNormal;
+        ${isWebGL2 ? "in" : "attribute"} vec2 aTexCoord;
+        
+        uniform mat4 uProjectionMatrix;
+        uniform mat4 uViewMatrix;
+        uniform mat4 uModelMatrix;
+        uniform float uTime;
+        
+        ${isWebGL2 ? "out" : "varying"} vec3 vPosition;
+        ${isWebGL2 ? "out" : "varying"} vec3 vNormal;
+        ${isWebGL2 ? "out" : "varying"} vec2 vTexCoord;
+        
+        void main() {
+            vec3 pos = aPosition;
+            
+            float wave = sin(pos.x * 2.0 + uTime) * 2.0 + 
+                        sin(pos.z * 1.5 + uTime * 0.8) * 1.8;
+            pos.y += wave;
+            
+            vec3 normal = aNormal;
+            normal.xz += cos(pos.xz * 2.0 + uTime) * 0.2;
+            normal = normalize(normal);
+            
+            vPosition = (uModelMatrix * vec4(pos, 1.0)).xyz;
+            vNormal = normal;
+            vTexCoord = aTexCoord;
+            
+            gl_Position = uProjectionMatrix * uViewMatrix * vec4(vPosition, 1.0);
+        }`;
+    }
+
+    getWaterFragmentShader(isWebGL2) {
+        return `${isWebGL2 ? "#version 300 es\n" : ""}
+        precision highp float;
+        
+        ${isWebGL2 ? "in" : "varying"} vec3 vPosition;
+        ${isWebGL2 ? "in" : "varying"} vec3 vNormal;
+        ${isWebGL2 ? "in" : "varying"} vec2 vTexCoord;
+        
+        uniform vec3 uCameraPos;
+        uniform vec3 uLightDir;
+        uniform float uTime;
+        
+        ${isWebGL2 ? "out vec4 fragColor;\n" : ""}
+        
+        void main() {
+            vec3 viewDir = normalize(uCameraPos - vPosition);
+            
+            vec3 waterColor = vec3(0.0, 0.4, 0.6);
+            
+            float fresnel = pow(1.0 - max(dot(viewDir, vNormal), 0.0), 3.0);
+            
+            vec3 reflectDir = reflect(-uLightDir, vNormal);
+            float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);
+            
+            vec3 finalColor = waterColor + fresnel * 0.5 + spec;
+            
+            float alpha = mix(0.6, 0.9, fresnel);
+            
+            ${isWebGL2 ? "fragColor" : "gl_FragColor"} = vec4(finalColor, alpha);
+        }`;
+    }
+}