@woosh/meep-engine 2.40.1 → 2.42.0

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/common.glsl

@@ -0,0 +1,206 @@
+struct ImposterData
+{
+    vec2 uv;
+    vec2 grid;
+    vec4 frame0;
+    vec4 frame1;
+    vec4 frame2;
+    vec4 vertex;
+};
+
+struct Ray
+{
+    vec3 Origin;
+    vec3 Direction;
+};
+
+//for hemisphere
+vec3 OctaHemiEnc(vec2 coord)
+{
+    coord = vec2(coord.x + coord.y, coord.x - coord.y) * 0.5;
+    vec3 vec = vec3(coord.x, 1.0 - dot(vec2(1.0, 1.0), abs(coord.xy)), coord.y);
+    return vec;
+}
+//for sphere
+vec3 OctaSphereEnc(vec2 coord)
+{
+    vec3 vec = vec3(coord.x, 1.0 - dot(vec2(1.0), abs(coord)), coord.y);
+    if (vec.y < 0.0)
+    {
+        vec2 flip = vec.xz >= 0.0 ? vec2(1.0, 1.0) : vec2(-1.0, -1.0);
+        vec.xz = (1-abs(vec.zx)) * flip;
+    }
+    return vec;
+}
+
+vec3 GridToVector(vec2 coord)
+{
+    vec3 vec;
+    if (_ImposterFullSphere)
+    {
+        vec = OctaSphereEnc(coord);
+    }
+    else
+    {
+        vec = OctaHemiEnc(coord);
+    }
+    return vec;
+}
+
+//for hemisphere
+vec2 VecToHemiOct(vec3 vec)
+{
+    vec.xz /= dot(1.0, abs(vec));
+    return vec2(vec.x + vec.z, vec.x - vec.z);
+}
+
+vec2 VecToSphereOct(vec3 vec)
+{
+    vec.xz /= dot(1, abs(vec));
+    if (vec.y <= 0)
+    {
+        vec2 flip = vec.xz >= 0 ? vec2(1, 1) : vec2(-1, -1);
+        vec.xz = (1-abs(vec.zx)) * flip;
+    }
+    return vec.xz;
+}
+
+vec2 VectorToGrid(vec3 vec)
+{
+    vec2 coord;
+
+    if (_ImposterFullSphere)
+    {
+        coord = VecToSphereOct(vec);
+    }
+    else
+    {
+        vec.y = max(0.001, vec.y);
+        vec = normalize(vec);
+        coord = VecToHemiOct(vec);
+    }
+    return coord;
+}
+
+vec3 SpriteProjection(vec3 pivotToCameraRayLocal, float frames, vec2 size, vec2 coord){
+    vec3 gridVec = pivotToCameraRayLocal;
+
+    //octahedron vector, pivot to camera
+    vec3 y = normalize(gridVec);
+
+    vec3 x = normalize(cross(y, vec3(0.0, 1.0, 0.0)));
+    vec3 z = normalize(cross(x, y));
+
+    vec2 uv = ((coord*frames)-0.5) * 2.0;//-1 to 1
+
+    vec3 newX = x * uv.x;
+    vec3 newZ = z * uv.y;
+
+    vec2 halfSize = size*0.5;
+
+    newX *= halfSize.x;
+    newZ *= halfSize.y;
+
+    vec3 res = newX + newZ;
+
+    return res;
+}
+
+vec4 TriangleInterpolate(vec2 uv){
+    uv = frac(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 = saturate(ceil(uv.x-uv.y));
+
+    return res;
+}
+
+//frame and framecout, returns
+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
+    f = (f-0.5)*2.0;
+
+    //convert to vector, either full sphere or hemi sphere
+    vec3 vec = GridToVector(f);
+
+    vec = normalize(vec);
+
+    return vec;
+}
+
+vec3 ITBasis(vec3 vec, vec3 basedX, vec3 basedY, vec3 basedZ)
+{
+    return vec3(dot(basedX, vec), dot(basedY, vec), dot(basedZ, vec));
+}
+
+vec3 FrameTransform(vec3 projRay, vec3 frameRay, out vec3 worldX, out vec3 worldZ)
+{
+    //TODO something might be wrong here
+    worldX = normalize(vec3(-frameRay.z, 0, frameRay.x));
+    worldZ = normalize(cross(worldX, frameRay));
+
+    projRay *= -1.0;
+
+    vec3 local = normalize(ITBasis(projRay, worldX, frameRay, worldZ));
+    return local;
+}
+
+
+vec4 ImposterBlendWeights(sampler2D tex, vec2 uv, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec2 ddxy)
+{
+    vec4 samp0 = tex2Dgrad(tex, frame0, ddxy.x, ddxy.y);
+    vec4 samp1 = tex2Dgrad(tex, frame1, ddxy.x, ddxy.y);
+    vec4 samp2 = tex2Dgrad(tex, frame2, ddxy.x, ddxy.y);
+
+    //vec4 samp0 = tex2Dlod( tex, float4(frame0,0,0) );
+    //vec4 samp1 = tex2Dlod( tex, float4(frame1,0,0) );
+    //vec4 samp2 = tex2Dlod( tex, float4(frame2,0,0) );
+
+    vec4 result = samp0*weights.x + samp1*weights.y + samp2*weights.z;
+
+    return result;
+}
+
+vec2 VirtualPlaneUV(vec3 planeNormal, vec3 planeX, vec3 planeZ, vec3 center, vec2 uvScale, Ray rayLocal){
+    float normalDotOrigin = dot(planeNormal, rayLocal.Origin);
+    float normalDotCenter = dot(planeNormal, center);
+    float normalDotRay = dot(planeNormal, rayLocal.Direction);
+
+    float planeDistance = normalDotOrigin-normalDotCenter;
+    planeDistance *= -1.0;
+
+    float intersect = planeDistance / normalDotRay;
+
+    vec3 intersection = ((rayLocal.Direction * intersect) + rayLocal.Origin) - center;
+
+    float dx = dot(planeX, intersection);
+    float dz = dot(planeZ, intersection);
+
+    vec2 uv = vec2(0, 0);
+
+    if (intersect > 0)
+    {
+        uv = vec2(dx, dz);
+    }
+    else
+    {
+        uv = vec2(0, 0);
+    }
+
+    uv /= uvScale;
+    uv += vec2(0.5, 0.5);
+    return uv;
+}

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);
+}