@woosh/meep-engine 2.41.0 → 2.42.1

package/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js

@@ -0,0 +1,349 @@
+import {
+    AddEquation,
+    CustomBlending,
+    GLSL3,
+    OneFactor,
+    OneMinusSrcAlphaFactor,
+    RawShaderMaterial,
+    Vector3
+} from "three";
+
+/*
+ *
+ * For ray projection using projection matrix : https://encreative.blogspot.com/2019/05/computing-ray-origin-and-direction-from.html
+ */
+const shader_vx = `
+    
+    in vec2 uv;
+    in vec3 position;
+    in vec3 normal;
+    
+    out vec2 vUv;
+    out vec4 plane0;
+    out vec4 plane1;
+    out vec4 plane2;
+       
+    out vec3 local_ray_near;
+    out vec3 local_ray_far;
+
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+    uniform mat3 normalMatrix;
+    
+    uniform vec3 uOffset;
+    uniform float uRadius;
+    uniform float uFrames;
+    
+    void main() {
+        vUv = uv;
+        
+        vec2 framesMinusOne = uFrames - vec2(1.0);
+        
+        mat4 m4 = modelViewMatrix;
+        
+        m4[0][0] = 1.0;
+        m4[0][1] = 0.0;
+        m4[0][2] = 0.0;
+
+        m4[1][0] = 0.0;
+        m4[1][1] = 1.0;
+        m4[1][2] = 0.0;
+
+        m4[2][0] = 0.0;
+        m4[2][1] = 0.0;
+        m4[2][2] = 1.0;
+        
+        vec3 object_scale = vec3(
+            length(modelViewMatrix[0].xyz),
+            length(modelViewMatrix[1].xyz),
+            length(modelViewMatrix[2].xyz)
+        ); 
+        
+        // scale by object's baking bounding sphere's radius
+        float card_diameter = uRadius*2.0;
+        object_scale *= card_diameter;
+        
+        vec3 transformedNormal = normalize(normalMatrix * normal);
+        
+        vec4 mvPosition = m4 * vec4( object_scale*(position+uOffset/card_diameter), 1.0 );
+                
+        gl_Position = projectionMatrix * mvPosition;
+        
+        mat4 inverse_matrix = inverse(projectionMatrix * modelViewMatrix);
+        
+        //
+        //get 2D projection of this vertex in normalized device coordinates
+        vec2 pos = gl_Position.xy/gl_Position.w;
+       
+        //compute ray's start and end as inversion of this coordinates
+        //in near and far clip planes
+        vec4 near_4 = inverse_matrix * (vec4(pos, -1.0, 1.0));       
+        vec4 far_4 = inverse_matrix * (vec4(pos, 1.0, 1.0));
+        
+        local_ray_near = near_4.xyz / near_4.w;
+        local_ray_far = far_4.xyz/ far_4.w;
+    }
+`;
+const shader_fg = `
+    precision highp float;
+    precision highp int;
+    
+    const float depth_scale = 0.5;
+
+    in vec2 vUv;
+    
+    in vec4 plane0;
+    in vec4 plane1;
+    in vec4 plane2;
+    
+    in vec3 vViewPosition; 
+    in vec3 vFacingDirection; 
+    
+    out vec4 color_out;
+    
+    uniform sampler2D tBase;
+    uniform sampler2D tGeometry;
+    uniform float uFrames;
+    uniform float uDepthScale;
+    uniform bool uIsFullSphere;
+    
+    
+    in vec3 local_ray_near;
+    in vec3 local_ray_far;
+    
+    struct Material{
+        vec3 diffuse;
+        vec3 normal;
+        float depth;
+        float occlusion;
+        float roughness;
+        float metalness;
+    };
+    
+    vec2 VecToSphereOct(vec3 pivotToCamera)
+    {
+        vec3 octant = sign(pivotToCamera);
+    
+        //  |x| + |y| + |z| = 1
+        float sum = dot(pivotToCamera, octant);
+        vec3 octahedron = pivotToCamera / sum;
+    
+        if (octahedron.y < 0.0){
+            vec3 absolute = abs(octahedron);
+            octahedron.xz = octant.xz * vec2(1.0 - absolute.z, 1.0 - absolute.x);
+        }
+        return octahedron.xz;
+    }
+    
+    //for hemisphere
+    vec2 VecToHemiSphereOct(vec3 vec)
+    {        
+        vec.y = max(vec.y, 0.001);
+        vec = normalize(vec);
+        vec3 octant = sign(vec);
+    
+        //  |x| + |y| + |z| = 1
+        float sum = dot(vec, octant);
+        vec3 octahedron = vec / sum;
+    
+        return vec2(
+            octahedron.x + octahedron.z,
+            octahedron.z - octahedron.x
+        );
+    }
+    
+    vec2 VectorToGrid(vec3 vec)
+    {
+        if (uIsFullSphere)
+        {
+            return VecToSphereOct(vec);
+        }
+        else
+        {
+            return VecToHemiSphereOct(vec);
+        }
+    }
+    
+    vec4 TriangleInterpolate(vec2 uv){
+        uv = fract(uv);
+    
+        vec2 omuv = vec2(1.0, 1.0) - uv.xy;
+    
+        vec4 res = vec4(0, 0, 0, 0);
+        //frame 0
+        res.x = min(omuv.x, omuv.y);
+        //frame 1
+        res.y = abs(dot(uv, vec2(1.0, -1.0)));
+        //frame 2
+        res.z = min(uv.x, uv.y);
+        //mask
+        res.w = clamp(ceil(uv.x-uv.y),0.0, 1.0);
+    
+        return res;
+    }
+    
+    
+    vec4 ImposterBlendWeights(sampler2D tex, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec4 ddxy)
+    {
+        vec4 samp0 = textureGrad(tex, frame0, ddxy.xy, ddxy.zw);
+        vec4 samp1 = textureGrad(tex, frame1, ddxy.xy, ddxy.zw);
+        vec4 samp2 = textureGrad(tex, frame2, ddxy.xy, ddxy.zw);
+    
+        vec4 result = samp0*weights.x + samp1*weights.y + samp2*weights.z;
+    
+        return result;
+    }
+    
+    vec2 recalculateUV(vec2 uv_f,  vec2 frame, vec2 xy_f, vec2 frame_size, float d_scale, sampler2D depthTexture)
+    {
+        //clamp for parallax sampling
+        uv_f = clamp(uv_f, vec2(0), vec2(1));
+        vec2 uv_quad = frame_size * (frame + uv_f);
+        //paralax
+        float n_depth = (texture( depthTexture, uv_quad, -16.0 )).a;
+        uv_f = xy_f * (0.5-n_depth) * d_scale + uv_f;
+        //clamp parallax offset
+        uv_f = clamp(uv_f, vec2(0), vec2(1));
+        uv_f =  frame_size * (frame + uv_f);
+        //clamped full UV
+        return clamp(uv_f, vec2(0), vec2(1));
+    }
+    
+    void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
+    {
+        vec3 up = vec3(0,1,0);
+            //cross product doesnt work if we look directly from bottom
+        if (abs(plane_normal.y) > 0.999f)
+        {
+            up = vec3(0,0,1);
+        }
+        plane_x = normalize(cross(plane_normal, up));
+        plane_y = normalize(cross(plane_x, plane_normal));
+    }
+
+    vec3 projectOnPlaneBasis(vec3 ray, vec3 plane_normal, vec3 plane_x, vec3 plane_y)
+    {
+        //reproject plane normal onto planeXY basos
+        return normalize(vec3( 
+            dot(plane_x,ray), 
+            dot(plane_y,ray), 
+            dot(plane_normal,ray) 
+        ));
+    }
+    
+    vec2 recompute_uv(vec2 frame, vec2 frame_uv, sampler2D gBuffer){
+        vec2 frame_size = vec2(1.0/ uFrames);
+        
+        vec2 source_uv = (frame + frame_uv)*frame_size;
+        
+        float n_depth = texture(gBuffer, source_uv).a;
+    
+        vec2 offset = clamp(length(frame_uv*2.0 - 1.0)*vec2(0.5-n_depth )*depth_scale, 0.0, 1.0);
+        
+        return clamp(( frame + frame_uv+offset)*frame_size,0.0, 1.0);
+        // return source_uv;
+    }
+    
+    void main(){
+        vec3 view_direction = normalize(local_ray_near-local_ray_far);
+        
+        vec2 octahedral_uv = clamp(VectorToGrid(view_direction)*0.5 + 0.5, 0.0, 1.0);
+        vec2 grid =  octahedral_uv * vec2(uFrames - 1.0);
+        
+        vec2 gridFrac = fract(grid);
+        vec2 gridFloor = floor(grid);
+                
+        vec4 weights = TriangleInterpolate( gridFrac ); 
+        
+        //3 nearest frames
+        vec2 frame0 = gridFloor;
+        vec2 frame1 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
+        vec2 frame2 = gridFloor + vec2(1.0,1.0);
+        
+        vec4 ddxy = vec4( dFdx(vUv.xy), dFdy(vUv.xy) );
+        
+        vec2 frame_uv = vUv;
+        vec2 frame_size = vec2(1.0/ uFrames);
+                
+        vec4 texel_color = ImposterBlendWeights(
+            tBase,
+            (frame0 + frame_uv) * frame_size,
+            (frame1 + frame_uv) * frame_size,
+            (frame2 + frame_uv) * frame_size,
+            weights, ddxy
+        );        
+        
+        // texel_color = vec4(texel_color.aaa, 1.0);
+        
+        if(texel_color.a <= 0.5){
+            texel_color.r = 1.0;
+            discard;
+        }
+    
+        color_out = texel_color;
+        // color_out = vec4(  snapped_oct_uv, 1.0, 1.0);
+    }
+`;
+
+export class ImpostorShaderV0 extends RawShaderMaterial {
+    constructor() {
+        super({
+            fragmentShader: shader_fg,
+            vertexShader: shader_vx,
+            uniforms: {
+                /**
+                 * RGB + Alpha
+                 */
+                tBase: {
+                    value: null
+                },
+                /**
+                 * Normal+Depth
+                 */
+                tGeometry: {
+                    value: null
+                },
+                /**
+                 * Material properties: Occlusion, Roughness, Metalness
+                 * Alpha unused
+                 */
+                tMaterial: {
+                    value: null
+                },
+                /**
+                 * Number of frames
+                 */
+                uFrames: {
+                    value: 0
+                },
+                /**
+                 * Radius of bounding sphere of the impostor
+                 */
+                uRadius: {
+                    value: 0
+                },
+                /**
+                 * Impostor offset
+                 */
+                uOffset: {
+                    value: new Vector3(0, 0, 0)
+                },
+                uIsFullSphere: {
+                    value: false
+                },
+                uDepthScale:{
+                    // value should be in range between 0 and 1
+                    value:1
+                }
+            },
+            glslVersion: GLSL3
+        });
+
+        // Save some effort by disabling blending
+        this.blending = CustomBlending;
+        this.blendEquation = AddEquation;
+        this.blendSrc = OneFactor;
+        this.blendDst = OneMinusSrcAlphaFactor;
+
+    }
+}

package/engine/graphics/impostors/octahedral/shader/ImpostorShaderV1.js

@@ -0,0 +1,74 @@
+import {
+    AddEquation,
+    CustomBlending,
+    GLSL3,
+    OneFactor,
+    OneMinusSrcAlphaFactor,
+    RawShaderMaterial,
+    Vector3
+} from "three";
+import shader_vx from '../shader/glsl/v1/vertex.glsl';
+import shader_fg from '../shader/glsl/v1/flagment.glsl';
+
+export class ImpostorShaderV1 extends RawShaderMaterial {
+    constructor() {
+        super({
+            fragmentShader: shader_fg,
+            vertexShader: shader_vx,
+            uniforms: {
+                /**
+                 * RGB + Alpha
+                 */
+                tBase: {
+                    value: null
+                },
+                /**
+                 * Normal+Depth
+                 */
+                tGeometry: {
+                    value: null
+                },
+                /**
+                 * Material properties: Occlusion, Roughness, Metalness
+                 * Alpha unused
+                 */
+                tMaterial: {
+                    value: null
+                },
+                /**
+                 * Number of frames
+                 */
+                uFrames: {
+                    value: 0
+                },
+                /**
+                 * Radius of bounding sphere of the impostor
+                 */
+                uRadius: {
+                    value: 0
+                },
+                /**
+                 * Impostor offset
+                 */
+                uOffset: {
+                    value: new Vector3(0, 0, 0)
+                },
+                uIsFullSphere: {
+                    value: false
+                },
+                uDepthScale:{
+                    // value should be in range between 0 and 1
+                    value:1
+                }
+            },
+            glslVersion: GLSL3
+        });
+
+        // Save some effort by disabling blending
+        this.blending = CustomBlending;
+        this.blendEquation = AddEquation;
+        this.blendSrc = OneFactor;
+        this.blendDst = OneMinusSrcAlphaFactor;
+
+    }
+}

package/engine/graphics/impostors/octahedral/shader/glsl/v1/common.glsl

@@ -0,0 +1,209 @@
+vec2 VecToSphereOct(vec3 pivotToCamera)
+{
+    vec3 octant = sign(pivotToCamera);
+
+    //  |x| + |y| + |z| = 1
+    float sum = dot(pivotToCamera, octant);
+    vec3 octahedron = pivotToCamera / sum;
+
+    if (octahedron.y < 0f)
+    {
+        vec3 absolute = abs(octahedron);
+        octahedron.xz = octant.xz * vec2(1.0f - absolute.z, 1.0f - absolute.x);
+    }
+    return octahedron.xz;
+}
+
+vec2 VecToHemiSphereOct(vec3 pivotToCamera)
+{
+    pivotToCamera.y = max(pivotToCamera.y, 0.001);
+    pivotToCamera = normalize(pivotToCamera);
+    vec3 octant = sign(pivotToCamera);
+
+    //  |x| + |y| + |z| = 1
+    float sum = dot(pivotToCamera, octant);
+    vec3 octahedron = pivotToCamera / sum;
+
+    return vec2(
+    octahedron.x + octahedron.z,
+    octahedron.z - octahedron.x);
+}
+
+vec2 VectorToGrid(vec3 vec)
+{
+    if (isFullSphere)
+    {
+        return VecToSphereOct(vec);
+    }
+    else
+    {
+        return VecToHemiSphereOct(vec);
+    }
+}
+
+//for sphere
+vec3 OctaSphereEnc(vec2 coord)
+{
+    coord = (coord - 0.5) * 2.0;
+    vec3 position = vec3(coord.x, 0f, coord.y);
+    vec2 absolute = abs(position.xz);
+    position.y = 1f - absolute.x - absolute.y;
+
+    if (position.y < 0f)
+    {
+        position.xz = sign(position.xz) * vec2(1.0f - absolute.y, 1.0f - absolute.x);
+    }
+
+    return position;
+}
+
+//for hemisphere
+vec3 OctaHemiSphereEnc(vec2 coord)
+{
+    //coord = (0, 0.27)
+    //pos = -0.27, 0, -0.63
+
+    vec3 position = vec3(coord.x - coord.y, 0f, -1.0 + coord.x + coord.y);
+    vec2 absolute = abs(position.xz);
+    position.y = 1f - absolute.x - absolute.y;
+    return position;
+}
+
+vec3 GridToVector(vec2 coord)
+{
+    if (isFullSphere)
+    {
+        return OctaSphereEnc(coord);
+    }
+    else
+    {
+        return OctaHemiSphereEnc(coord);
+    }
+}
+
+vec3 FrameXYToRay(vec2 frame, vec2 frameCountMinusOne)
+{
+    //divide frame x y by framecount minus one to get 0-1
+    vec2 f = (frame.xy/ frameCountMinusOne);
+    //bias and scale to -1 to 1
+
+    vec3 vec = GridToVector(f);
+    vec = normalize(vec);
+    return vec;
+}
+
+vec3 SpriteProjection(vec3 pivotToCameraRayLocal, vec2 size, vec2 loc_uv)
+{
+    vec3 z = normalize(pivotToCameraRayLocal);
+    vec3 x, y;
+    vec3 up = vec3(0,1,0);
+    //cross product doesnt work if we look directly from bottom
+    if (abs(z.y) > 0.999f)
+    {
+        up = vec3(0,0,-1);
+    }
+    x = normalize(cross(up, z));
+    y = normalize(cross(x, z));
+
+    loc_uv -= vec2(0.5,0.5);
+    vec2 uv = (loc_uv) * 2.0; //-1 to 1
+
+    vec3 newX = x * uv.x;
+    vec3 newY = y * uv.y;
+
+    vec2 vecSize = size * 0.5;
+
+    newX *= vecSize.x;
+    newY *= vecSize.y;
+
+    return newX + newY;
+}
+
+vec4 quadBlendWieghts(vec2 coords)
+{
+    vec4 res;
+    /* 0 0 0
+    0 0 0
+    1 0 0 */
+    res.x = min(1f - coords.x, 1f - coords.y);
+    /* 1 0 0
+    0 0 0
+    0 0 1 */
+    res.y = abs(coords.x - coords.y);
+    /* 0 0 1
+    0 0 0
+    0 0 0 */
+    res.z = min(coords.x, coords.y);
+    /* 0 0 0
+    0 0 1
+    0 1 1 */
+    res.w = ceil(coords.x - coords.y);
+    //res.xyz /= (res.x + res.y + res.z);
+    return res;
+}
+
+
+//this function works well in orthogonal projection. It works okeyish with further distances of perspective projection
+vec2 virtualPlaneUV(vec3 plane_normal,vec3  plane_x, vec3  plane_y, vec3 pivotToCameraRay, vec3 vertexToCameraRay, float size)
+{
+    plane_normal = normalize(plane_normal);
+    plane_x = normalize(plane_x);
+    plane_y = normalize(plane_y);
+
+    // plane_normal is normalized but pivotToCameraRay & vertexToCameraRay are NOT
+    // so what are we doing here ?
+    // We are calculating length of pivotToCameraRay projected onto plane_normal
+    // so pivotToCameraRay is vector to camera from CENTER OF object
+    // we are recalculting this distance taking into account new plane normal
+    float projectedNormalRayLength = dot(plane_normal, pivotToCameraRay);
+    // tihs is direction is almost the same as origin, but its to individual vertex
+    // not sure this is correct for perspective projection
+    float projectedVertexRayLength = dot(plane_normal, vertexToCameraRay);
+    // basically its length difference betwen center and vertex - "not precise"
+    // projectedVertexRayLength is bigger than projectedNormalRayLength when vertex is
+    // further than "main front facing billboard"
+    // so offsetLength is getting smaller, otherwise is getting bigger
+    float offsetLength = projectedNormalRayLength/projectedVertexRayLength;
+
+    // ok so offsetLength is just a length
+    // we want a vector so we multiply it by vertexToCameraRay to get this offset
+    // now what are we REALY doing is calculuating distance difference
+    // se are SUBSTRACTING pivotToCameraRay vector
+    // we would get difference between center of plane and vertex rotated
+    vec3 offsetVector = vertexToCameraRay * offsetLength - pivotToCameraRay;
+
+    // we got the offset of rotated vertex, but we need to offset it from correct plane axis
+    // so again we projecting length of intersection (offset of rotated vertex) onto plane_x
+    // and plane_y
+    vec2 duv = vec2(
+    dot(plane_x , offsetVector),
+    dot(plane_y, offsetVector)
+    );
+
+    //we are in space -1 to 1
+    duv /= 2.0 * size;
+    duv += 0.5;
+    return duv;
+}
+
+void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
+{
+    vec3 up = vec3(0,1,0);
+    //cross product doesnt work if we look directly from bottom
+    if (abs(plane_normal.y) > 0.999f)
+    {
+        up = vec3(0,0,1);
+    }
+    plane_x = normalize(cross(plane_normal, up));
+    plane_y = normalize(cross(plane_x, plane_normal));
+}
+
+vec3 projectOnPlaneBasis(vec3 ray, vec3 plane_normal, vec3 plane_x, vec3 plane_y)
+{
+    //reproject plane normal onto planeXY basos
+    return normalize(vec3(
+    dot(plane_x,ray),
+    dot(plane_y,ray),
+    dot(plane_normal,ray)
+    ));
+}

package/engine/graphics/impostors/octahedral/shader/glsl/v1/flagment.glsl

@@ -0,0 +1,80 @@
+precision highp float;
+precision highp int;
+
+const float depth_scale = 1.0;
+
+uniform float uFrames;
+uniform sampler2D tBase;
+uniform sampler2D tGeometry;
+
+out vec4 color_out;
+
+in vec2 uv_frame1;
+in vec2 xy_frame1;
+flat in  vec2 frame1;
+flat in  vec3 frame1_normal;
+in vec2 uv_frame2;
+in vec2 xy_frame2;
+flat in  vec2 frame2;
+flat in  vec3 frame2_normal;
+in vec2 uv_frame3;
+in vec2 xy_frame3;
+flat in  vec2 frame3;
+flat in  vec3 frame3_normal;
+in vec4 quad_blend_weights;
+
+vec2 recalculateUV(vec2 uv_f, vec2 frame, vec2 xy_f, vec2 frame_size, float d_scale, sampler2D depthTexture)
+{
+    //clamp for parallax sampling
+    uv_f = clamp(uv_f, 0.0, 1.0);
+    vec2 uv_quad = frame_size * (frame + uv_f);
+    //paralax
+    float n_depth = texture(depthTexture, uv_quad).a;
+    uv_f = xy_f * (0.5-n_depth) * d_scale + uv_f;
+    //clamp parallax offset
+    uv_f = clamp(uv_f, 0.0, 1.0);
+    uv_f =  frame_size * (frame + uv_f);
+    //clamped full UV
+    return clamp(uv_f, 0.0, 1.0);
+}
+
+vec4 blenderColors(vec2 uv_1, vec2 uv_2, vec2 uv_3, vec4 grid_weights, sampler2D atlasTexture)
+{
+    vec4 quad_a, quad_b, quad_c;
+
+    quad_a = texture(atlasTexture, uv_1);
+    quad_b = texture(atlasTexture, uv_2);
+    quad_c = texture(atlasTexture, uv_3);
+    return quad_a * grid_weights.x + quad_b * grid_weights.y + quad_c * grid_weights.z;
+}
+
+void main()
+{
+    vec2 quad_size = vec2(1.0) / uFrames;
+    vec2 uv_f1 = recalculateUV(uv_frame1, frame1, xy_frame1, quad_size, depth_scale, tGeometry);
+    vec2 uv_f2 = recalculateUV(uv_frame2, frame2, xy_frame2, quad_size, depth_scale, tGeometry);
+    vec2 uv_f3 = recalculateUV(uv_frame3, frame3, xy_frame3, quad_size, depth_scale, tGeometry);
+
+    vec4 baseTex = blenderColors(uv_f1, uv_f2, uv_f3, quad_blend_weights, tBase);
+
+    //    vec4 ormTex = blenderColors(uv_f1, uv_f2, uv_f3, quad_blend_weights, imposterTextureOrm);
+    //
+    //    vec3 normalTex = blendedNormals(
+    //    uv_f1, frame1_normal,
+    //    uv_f2, frame2_normal,
+    //    uv_f3, frame3_normal,
+    //    TANGENT, BINORMAL,
+    //    quad_blend_weights, imposterTextureNormal
+    //    );
+    //
+    //    ALBEDO = baseTex.rgb * albedo.rgb;
+    //    NORMAL =normalTex.xyz;
+    //
+    //    METALLIC = ormTex.b * metallic;
+    //    SPECULAR = specular;
+    //    ROUGHNESS = ormTex.g * roughness;
+
+
+    color_out = baseTex;
+    //    color_out = vec4(1.0);
+}