@woosh/meep-engine 2.75.7 → 2.75.9

package/src/engine/ecs/systems/CharacterControlSystem.js

@@ -1,134 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 7/4/2014
- * Time: 09:17
- */
-import { System } from '../System.js';
-import CharacterController from '../components/CharacterController.js';
-import { Transform } from '../transform/Transform.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import Vector3 from "../../../core/geom/Vector3.js";
-
-
-class CharacterControlSystem extends System {
-    constructor() {
-        super();
-        //
-        this.entityManager = null;
-
-        this.dependencies = [CharacterController];
-    }
-
-    remove(component) {
-    }
-
-    add(component) {
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-        const PhysicsSystemType = entityManager.getSystemIdByComponentClass(PhysicalBody);
-        const physicsSystem = entityManager.systems[PhysicsSystemType];
-        entityManager.traverseEntities([CharacterController, PhysicalBody, Transform], function (controller, physicalBody, transform) {
-            if (controller.lockedTimeout > 0) {
-                //controlls are locked - can't do anything
-                controller.lockedTimeout -= timeDelta;
-                if (controller.lockedTieout < 0) {
-                    controller.lockedTimeout = 0;
-                }
-            } else {
-                //controls aren't locked
-                setOnSolidSurface(transform, controller, physicsSystem);
-                updatePosition(controller, physicalBody.body, transform, physicsSystem);
-                if (controller.attacking) {
-                    console.log("pow!");
-                }
-            }
-        });
-
-    }
-}
-
-
-function setOnSolidSurface(transform, controller, physicsSystem) {
-    const from = transform.position.clone();
-    const to = from.clone().add(new Vector3(0, -100, 0));
-    physicsSystem.rayTest(from, to, function (success, point) {
-        if (success) {
-            const v = new Vector3();
-            v.copy(point);
-            const number = v.distanceTo(from);
-            if (number <= controller.height / 2 + 0.06) {
-                controller.onSolidSurface = true;
-            } else {
-                controller.onSolidSurface = false;
-            }
-        } else {
-            controller.onSolidSurface = false;
-        }
-    });
-}
-
-function updatePosition(controls, body, transform) {
-    let z = 0;
-    let x = 0;
-    if (controls.forward) {
-        z -= 1;
-    }
-    if (controls.back) {
-        z += 1;
-    }
-    if (controls.right) {
-        x += 1;
-    }
-    if (controls.left) {
-        x -= 1;
-    }
-    const moving = (x !== 0 || z !== 0);
-    let vector;
-    const notTakingOff = body.linearVelocity.y <= 0.00001;
-    if (controls.onSolidSurface && notTakingOff) {
-        if (moving) {
-            const y = body.linearVelocity.y;
-            //obtain facing direction
-            const euler = new THREE.Euler();
-            euler.setFromQuaternion(transform.rotation);
-            //vector pointing in the direction of travel
-            vector = new THREE.Vector3(x, 0, z);
-            const rotationMatrix = new THREE.Matrix4().makeRotationFromQuaternion(transform.rotation);
-            vector.applyMatrix4(rotationMatrix);
-            vector.y = y;
-            //enforce movement speed
-            let scalar = controls.movementSpeed;
-            if (controls.sprinting) {
-                //apply sprinting multiplier
-                scalar *= controls.sprintingMultiplier;
-            }
-            //scale facing direction vector by the movement speed
-            vector.normalize().multiplyScalar(scalar);
-            //write the property
-            body.linearVelocity.copy(vector);
-        } else {
-            //when on ground and not moving - stand still
-            const v = body.linearVelocity;
-            if (v.x !== 0 || v.z !== 0) {
-                v.set(0, 0, 0);
-            }
-        }
-        if (controls.jump) {
-            //perform jump
-            const up = new Vector3(0, 1, 0);
-            const magnitude = (8 * body.mass);
-            const force = up.scale(magnitude);
-            body.applyCentralImpulse(force);
-
-            controls.onSolidSurface = false;  //prevent further jumps
-            controls.lockedTimeout = 0.1; //lock controls to prevent some race conditions
-        }
-    }
-
-    //set jump to false
-    controls.jump = false;
-}
-
-export default CharacterControlSystem;

package/src/engine/ecs/systems/PhysicsSystem.js

@@ -1,89 +0,0 @@
-/**
- * Created by Alex on 01/04/2014.
- */
-import { System } from '../System.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import { Transform } from '../transform/Transform.js';
-import PhysicsWorld from '../../physics/ammo/World.js';
-
-
-class PhysicsSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [PhysicalBody];
-    }
-
-    rayTest(from, to, callback) {
-        this.physics.rayTest(from, to, callback);
-    }
-
-    startup(entityManager, readyCallback, errorCallback) {
-        this.entityManager = entityManager;
-        this.physics = new PhysicsWorld(readyCallback);
-    }
-
-    shutdown(entityManager, readyCallback, errorCallback) {
-        try {
-            this.physics = null;
-            readyCallback();
-        } catch (e) {
-            errorCallback(e);
-        }
-    }
-
-    add(component, entity) {
-        const body = component.body;
-        body.__entity = entity;
-        this.physics.addBody(body);
-        //collisions
-        if (component.notifyCollision) {
-            const entityManager = this.entityManager;
-
-            body.onCollision(function (other) {
-                entityManager.sendEvent(entity, "collision", other.__entity);
-            });
-        }
-    }
-
-    remove(component) {
-        const body = component.body;
-        this.physics.removeBody(body);
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-        let signals = entityManager.eventManager.signals;
-        //set position to physical body
-        entityManager.traverseEntities([PhysicalBody, Transform], function (physicalBody, transform) {
-            //copy position into body
-            const body = physicalBody.body;
-            body.position.copy(transform.position);
-            body.rotation.copy(transform.rotation);
-        });
-
-
-        const stepFinishedCallback = function () {
-            //set position from physical body
-            entityManager.traverseEntities([PhysicalBody, Transform], function (physicalBody, transform, entity) {
-                //copy position from body
-                const body = physicalBody.body;
-                const previousPosition = transform.previousPosition;
-                const currentPosition = transform.position;
-                if (previousPosition.x != currentPosition.x || previousPosition.y != currentPosition.y || previousPosition.z != currentPosition.z) {
-                    //write previous position is the current position is different from before
-                    previousPosition.copy(currentPosition);
-                }
-                currentPosition.copy(body.position);
-                //                transform.rotation.copy(body.rotation);
-            });
-        };
-        this.physics.simulate(timeDelta, stepFinishedCallback);
-    }
-}
-
-
-function collisionHandler() {
-}
-
-export default PhysicsSystem;

package/src/engine/ecs/systems/PropertySetSystem.js

@@ -1,18 +0,0 @@
-/**
- * Created by Alex on 13/04/2017.
- */
-
-
-import { System } from '../System.js';
-import PropertySet from '../components/PropertySet.js';
-
-class PropertySetSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [PropertySet];
-    }
-}
-
-
-export default PropertySetSystem;

package/src/engine/ecs/systems/SteeringSystem.js

@@ -1,171 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 1/6/2014
- * Time: 08:37
- */
-import { max2 } from "../../../core/math/max2.js";
-import { min2 } from "../../../core/math/min2.js";
-import { System } from '../System.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import Motion from '../components/Motion.js';
-import { Transform } from '../transform/Transform.js';
-import Steering, { SteeringEvents, SteeringFlags } from '../components/Steering.js';
-import Vector3 from "../../../core/geom/Vector3.js";
-import { alignToVector } from "../terrain/ecs/cling/ClingToTerrainSystem.js";
-import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
-import { solveQuadratic } from "../../../core/math/solveQuadratic.js";
-
-/**
- *
- * @param {Vector3} result
- * @param {Vector3} source
- * @param {Vector3} target
- * @param {Vector3} targetVelocity
- * @param {number} sourceSpeed
- * @return {boolean}
- */
-function computeInterceptPoint(result, source, target, targetVelocity, sourceSpeed) {
-    const d_ts_x = target.x - source.x;
-    const d_ts_y = target.y - source.y;
-    const d_ts_z = target.z - source.z;
-
-    // Get quadratic equation components
-    const a = targetVelocity.dot(targetVelocity) - sourceSpeed * sourceSpeed;
-    const b = 2 * v3_dot(targetVelocity.x, targetVelocity.y, targetVelocity.z, d_ts_x, d_ts_y, d_ts_z);
-
-    const c = v3_dot(
-        d_ts_x, d_ts_y, d_ts_z,
-        d_ts_x, d_ts_y, d_ts_z
-    );
-
-    // Solve quadratic
-    const ts = [];
-    const root_count = solveQuadratic(ts, 0, a, b, c); // See quad(), below
-
-    // Find smallest positive solution
-    if (root_count > 0) {
-        const t0 = ts[0], t1 = ts[1];
-        let t = Math.min(t0, t1);
-        if (t < 0) t = Math.max(t0, t1);
-
-        if (t > 0) {
-            result.copy(targetVelocity).multiplyScalar(t).add(target);
-            return true;
-        }
-
-    }
-    return false;
-}
-
-class SteeringSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [Steering];
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-
-        const ecd = entityManager.dataset;
-
-        if (ecd === null) {
-            return;
-        }
-
-        /**
-         *
-         * @param {number} entity
-         * @param {Steering} steering
-         * @param {Transform} transform
-         * @param {Vector3} velocity
-         */
-        function process(entity, steering, transform, velocity) {
-            if (!steering.getFlag(SteeringFlags.Active)) {
-                //steering is inactive
-                return;
-            }
-
-            const destination = steering.destination;
-
-            const delta = destination.clone().sub(transform.position);
-            delta.normalize();
-
-            const distanceWithError = computeDistanceWithError(transform.position, destination, steering.targetMargin);
-
-            if (distanceWithError > 0) {
-                //not at the target yet
-                const d = steering.maxSpeed;
-
-                const angularLimit = steering.rotationSpeed * timeDelta;
-
-                alignToVector(transform.rotation, delta, angularLimit, Vector3.up, Vector3.forward);
-
-                //compute forward vector
-                const v = Vector3.forward.clone();
-                v.applyQuaternion(transform.rotation);
-                v.normalize();
-
-
-                //check old velocity to avoid flying past target
-                if (distanceWithError < d * timeDelta) {
-                    const distance = delta.length();
-                    const adjustedVelocity = min2(d, distance / timeDelta);
-                    v.multiplyScalar(adjustedVelocity);
-                } else {
-                    v.multiplyScalar(d);
-                }
-
-                velocity.copy(v);
-
-            } else {
-                //goal is reached, de-activate
-                steering.clearFlag(SteeringFlags.Active);
-
-                //drop velocity
-                velocity.set(0, 0, 0);
-
-                //dispatch
-                ecd.sendEvent(entity, SteeringEvents.DestinationReached, steering);
-            }
-        }
-
-        //Make sure physical bodies exist
-        if (ecd.isComponentTypeRegistered(PhysicalBody)) {
-
-            ecd.traverseEntities([Steering, PhysicalBody, Transform], function (steering, physicalBody, transform, entity) {
-
-                const body = physicalBody.body;
-
-                process(entity, steering, transform, body.linearVelocity);
-
-            });
-
-        }
-
-        ecd.traverseEntities([Steering, Motion, Transform], function (steering, motion, transform, entity) {
-            process(entity, steering, transform, motion.velocity);
-        });
-    }
-}
-
-/**
- *
- * @param {Vector3} v0
- * @param {Vector3} v1
- * @param {Vector3} error
- * @return {number}
- */
-function computeDistanceWithError(v0, v1, error) {
-    const absDelta = v0.clone().sub(v1).abs();
-
-    absDelta.set(
-        max2(absDelta.x - error.x, 0),
-        max2(absDelta.y - error.y, 0),
-        max2(absDelta.z - error.z, 0)
-    );
-
-    return absDelta.length();
-}
-
-export default SteeringSystem;

package/src/engine/ecs/systems/TagSystem.d.ts

@@ -1,5 +0,0 @@
-import {System} from "../System";
-
-export class TagSystem extends System {
-
-}

package/src/engine/ecs/systems/TagSystem.js

@@ -1,31 +0,0 @@
-/**
- * Created by Alex on 23/04/2014.
- */
-import { System } from '../System.js';
-import Tag from '../components/Tag.js';
-
-
-class TagSystem extends System {
-
-    dependencies = [Tag];
-
-    /**
-     *
-     * @param {string} tag
-     * @param {EntityComponentDataset} ecd
-     * @returns  {number[]}
-     */
-    static find_entities_with_tag(tag, ecd) {
-        const r = [];
-        ecd.traverseComponents(Tag, (t, e) => {
-            if (t.contains(tag)) {
-                r.push(e);
-            }
-        });
-
-        return r;
-    }
-}
-
-
-export default TagSystem;

package/src/engine/graphics/render/webgpu/sample/MeshInstance.js

@@ -1,108 +0,0 @@
-import { array_copy } from "../../../../../core/collection/array/array_copy.js";
-
-const BIND_GROUP_MATERIAL = 1;
-
-export class MeshInstance {
-    constructor() {
-
-        /**
-         *
-         * @type {THREE.BufferGeometry|null}
-         */
-        this.geometry = null;
-
-        /**
-         *
-         * @type {null}
-         */
-        this.material = null;
-
-        /**
-         *
-         * @type {GPUBuffer|null}
-         */
-        this.vertex_buffer = null;
-
-        /**
-         *
-         * @type {GPUBuffer|null}
-         */
-        this.index_buffer = null;
-    }
-
-    /**
-     *
-     * @param {GPUDevice} device
-     */
-    init(device) {
-        const mesh = this.geometry;
-
-        const kVertexStride = 8;
-        const attribute_position = mesh.getAttribute('position');
-        const vertexBuffer = device.createBuffer({
-            // position: vec3, normal: vec3, uv: vec2
-            size: attribute_position.array.length * kVertexStride * Float32Array.BYTES_PER_ELEMENT,
-            usage: GPUBufferUsage.VERTEX,
-            mappedAtCreation: true,
-        });
-
-        {
-            const mapping = new Float32Array(vertexBuffer.getMappedRange());
-
-            const attribute_normal = mesh.getAttribute('normal');
-            const attribute_uv = mesh.getAttribute('uv');
-
-            const vertex_count = attribute_position.count;
-
-            for (let i = 0; i < vertex_count; ++i) {
-                const address = kVertexStride * i;
-                array_copy(attribute_position.array, i * 3, mapping, address, 3);
-                array_copy(attribute_normal.array, i * 3, mapping, address + 3, 3);
-                array_copy(attribute_uv.array, i * 2, mapping, address + 6, 2);
-            }
-            vertexBuffer.unmap();
-        }
-
-        this.vertex_buffer = vertexBuffer;
-
-        const indexCount = mesh.getIndex().array.length;
-        const indexBuffer = device.createBuffer({
-            size: indexCount * Uint32Array.BYTES_PER_ELEMENT,
-            usage: GPUBufferUsage.INDEX,
-            mappedAtCreation: true,
-        });
-        {
-            const mapping = new Uint32Array(indexBuffer.getMappedRange());
-
-            mapping.set(mesh.getIndex().array);
-
-            indexBuffer.unmap();
-        }
-
-        this.index_buffer = indexBuffer;
-
-    }
-
-    /**
-     *
-     * @param {GPURenderPassEncoder} pass
-     */
-    preparePass(pass) {
-
-    }
-
-    /**
-     *
-     * @param {GPURenderPassEncoder} pass
-     */
-    draw(pass) {
-        // set material bindings
-
-        // pass.setBindGroup(BIND_GROUP_MATERIAL, {});
-
-        pass.setVertexBuffer(0, this.vertex_buffer);
-        pass.setIndexBuffer(this.index_buffer, 'uint32');
-
-        pass.drawIndexed(this.geometry.getIndex().array.length);
-    }
-}

package/src/engine/graphics/render/webgpu/sample/fragmentDeferredRendering.wgsl

@@ -1,71 +0,0 @@
-[[group(0), binding(0)]] var gBufferPosition: texture_2d<f32>;
-[[group(0), binding(1)]] var gBufferNormal: texture_2d<f32>;
-[[group(0), binding(2)]] var gBufferAlbedo: texture_2d<f32>;
-
-struct LightData {
-  position : vec4<f32>;
-  color : vec3<f32>;
-  radius : f32;
-};
-
-struct LightsBuffer {
-  lights: array<LightData>;
-};
-
-[[group(1), binding(0)]] var<storage, read> lightsBuffer: LightsBuffer;
-
-struct Config {
-  numLights : u32;
-};
-
-[[group(1), binding(1)]] var<uniform> config: Config;
-
-struct CanvasConstants {
-  size: vec2<f32>;
-};
-
-[[group(2), binding(0)]] var<uniform> canvas : CanvasConstants;
-
-[[stage(fragment)]]
-fn main([[builtin(position)]] coord : vec4<f32>)
-     -> [[location(0)]] vec4<f32> {
-  var result = vec3<f32>(0.0, 0.0, 0.0);
-
-  let position = textureLoad(
-    gBufferPosition,
-    vec2<i32>(floor(coord.xy)),
-    0
-  ).xyz;
-
-  if (position.z > 10000.0) {
-    discard;
-  }
-
-  let normal = textureLoad(
-    gBufferNormal,
-    vec2<i32>(floor(coord.xy)),
-    0
-  ).xyz;
-
-  let albedo = textureLoad(
-    gBufferAlbedo,
-    vec2<i32>(floor(coord.xy)),
-    0
-  ).rgb;
-
-  for (var i : u32 = 0u; i < config.numLights; i = i + 1u) {
-    let L = lightsBuffer.lights[i].position.xyz - position;
-    let distance = length(L);
-    if (distance > lightsBuffer.lights[i].radius) {
-        continue;
-    }
-    let lambert = max(dot(normal, normalize(L)), 0.0);
-    result = result + vec3<f32>(
-      lambert * pow(1.0 - distance / lightsBuffer.lights[i].radius, 2.0) * lightsBuffer.lights[i].color * albedo);
-  }
-
-  // some manual ambient
-  result = result + vec3<f32>(0.2, 0.2, 0.2);
-
-  return vec4<f32>(result, 1.0);
-}

package/src/engine/graphics/render/webgpu/sample/fragmentGBuffersDebugView.wgsl

@@ -1,39 +0,0 @@
-[[group(0), binding(0)]] var gBufferPosition: texture_2d<f32>;
-[[group(0), binding(1)]] var gBufferNormal: texture_2d<f32>;
-[[group(0), binding(2)]] var gBufferAlbedo: texture_2d<f32>;
-
-struct CanvasConstants {
-  size: vec2<f32>;
-};
-
-[[group(1), binding(0)]] var<uniform> canvas : CanvasConstants;
-
-[[stage(fragment)]]
-fn main([[builtin(position)]] coord : vec4<f32>)
-     -> [[location(0)]] vec4<f32> {
-  var result : vec4<f32>;
-  let c = coord.xy / canvas.size;
-  if (c.x < 0.33333) {
-    result = textureLoad(
-      gBufferPosition,
-      vec2<i32>(floor(coord.xy)),
-      0
-    );
-  } else if (c.x < 0.66667) {
-    result = textureLoad(
-      gBufferNormal,
-      vec2<i32>(floor(coord.xy)),
-      0
-    );
-    result.x = (result.x + 1.0) * 0.5;
-    result.y = (result.y + 1.0) * 0.5;
-    result.z = (result.z + 1.0) * 0.5;
-  } else {
-    result = textureLoad(
-      gBufferAlbedo,
-      vec2<i32>(floor(coord.xy)),
-      0
-    );
-  }
-  return result;
-}

package/src/engine/graphics/render/webgpu/sample/fragmentWriteGBuffers.wgsl

@@ -1,21 +0,0 @@
-struct GBufferOutput {
-  [[location(0)]] position : vec4<f32>;
-  [[location(1)]] normal : vec4<f32>;
-
-  // Textures: diffuse color, specular color, smoothness, emissive etc. could go here
-  [[location(2)]] albedo : vec4<f32>;
-};
-
-[[stage(fragment)]]
-fn main([[location(0)]] fragPosition: vec3<f32>,
-        [[location(1)]] fragNormal: vec3<f32>,
-        [[location(2)]] fragUV : vec2<f32>) -> GBufferOutput {
-    var output : GBufferOutput;
-    output.position = vec4<f32>(fragPosition, 1.0);
-    output.normal = vec4<f32>(fragNormal, 1.0);
-    // faking some kind of checkerboard texture
-    let uv = floor(30.0 * fragUV);
-    let c = 0.2 + 0.5 * ((uv.x + uv.y) - 2.0 * floor((uv.x + uv.y) / 2.0));
-    output.albedo = vec4<f32>(c, c, c, 1.0);
-    return output;
-}