wgge 0.0.1

package/core/ActivatedTreeNode.js

@@ -0,0 +1,187 @@
+import NumberHelper from "./helper/NumberHelper";
+
+export default class ActivatedTreeNode {
+
+	/**
+	 * @type ActivatedTreeNode[]
+	 */
+	children;
+
+	/**
+	 * @type ActivatedTreeNode
+	 */
+	parent;
+
+	/**
+	 * @type boolean
+	 */
+	isActivated;
+
+	/**
+	 *
+	 * @type {[{param}]}
+	 * @type param.node {ModelNode}
+	 * @type param.event {string}
+	 * @type param.handler {(ep) => any}
+	 */
+	autoRegisterEvents = null;
+
+	constructor() {
+		this.isActivated = false;
+		this.parent = null;
+		this.children = [];
+	}
+
+	isRoot() {
+		return (this.parent === null);
+	}
+
+	findRoot() {
+		return (this.isRoot()) ? this : this.parent.findRoot();
+	}
+
+	/**
+	 *
+	 * @param node ActivatedTreeNode
+	 * @returns ActivatedTreeNode
+	 */
+	addChild(node) {
+		node.parent = this;
+		this.children.push(node);
+		if (this.isActivated) {
+			node.activate();
+		}
+		return node;
+	}
+
+	hasChildren() {
+		return this.children.length > 0;
+	}
+
+	removeChild(node) {
+		const index = this.children.indexOf(node);
+		if (index >= 0) {
+			this.children.splice(index, 1);
+			node.deactivate();
+			node.parent = null;
+			return node;
+		}
+		for (let i = 0, max = this.children.length; i < max; i++) {
+			const child = this.children[i];
+			const result = child.removeChild(node);
+			if (result) {
+				return result;
+			}
+		}
+	}
+
+	removeMyself() {
+		if (this.parent) {
+			this.parent.removeChild(this);
+		} else {
+			this.deactivate();
+		}
+	}
+
+	resetChildren() {
+		this.children.forEach((child) => child.deactivate());
+		this.children = [];
+	}
+
+	forEach(func) {
+		func(this);
+		for (let i = 0, max = this.children.length; i < max; i++) {
+			const child = this.children[i];
+			child.forEach(func);
+		}
+	}
+
+	activate() {
+		if (!this.isActivated) {
+			this.activateInternal();
+
+			if (this.autoRegisterEvents) {
+				this.autoRegisterEvents.forEach((event) => {
+					event.node.addEventListener(event.name, event.handler);
+					if (event.runOnActivate) {
+						event.handler();
+					}
+				});
+			}
+
+			this.children.forEach((c) => c.activate());
+			this.isActivated = true;
+
+			this.afterActivatedInternal();
+		}
+	}
+
+	activateInternal() {
+
+	}
+
+	afterActivatedInternal() {
+
+	}
+
+	deactivate() {
+		if (this.isActivated) {
+			if (this.autoRegisterEvents) {
+				this.autoRegisterEvents.forEach((event) => {
+					event.node.removeEventListener(event.name, event.handler);
+				});
+			}
+
+			this.children.forEach((c) => c.deactivate());
+			this.deactivateInternal();
+			this.isActivated = false;
+		}
+	}
+
+	deactivateInternal() {
+
+	}
+
+	/**
+	 *
+	 * @param node ModelNode
+	 * @param event string
+	 * @param handler (param) => any
+	 * @param runOnActivate bool
+	 */
+	addAutoEvent(node, event, handler, runOnActivate = false) {
+		if ((!node) || typeof node.addEventListener !== 'function') {
+			console.error('Node with addEventListener was not provided!', node);
+		}
+		if (!this.autoRegisterEvents) {
+			this.autoRegisterEvents = [];
+		}
+		this.autoRegisterEvents.push({node: node, name: event, handler: handler, runOnActivate: runOnActivate});
+	}
+
+	addAutoEvents(node, events, handler, runOnActivate = false) {
+		events.forEach((event) => this.addAutoEvent(node, event, handler, runOnActivate));
+	}
+
+	addAutoEventMultiple(nodes, event, handler, runOnActivate = false) {
+		if (!Array.isArray(nodes)) {
+			console.error('Node array was not provided!');
+		}
+		nodes.forEach((n, i) => this.addAutoEvent(n, event, handler, i === 0 && runOnActivate));
+	}
+
+	addAutoEventsMultiple(nodes, events, handler, runOnActivate = false) {
+		events.forEach((event) => this.addAutoEventMultiple(nodes, event, handler, runOnActivate));
+	}
+
+	removeAutoEvent(node, name, handler) {
+		if (!this.autoRegisterEvents) {
+			return;
+		}
+		const event = this.autoRegisterEvents.find((e) => e.handler === handler && e.name === name && e.node === node);
+		if (event) {
+			NumberHelper.arrayRemove(this.autoRegisterEvents, event);
+		}
+	}
+
+}

package/core/Collection.js

@@ -0,0 +1,156 @@
+import NodeWithEvents from "./model/event/NodeWithEvents";
+
+export default class Collection extends NodeWithEvents {
+
+	/**
+	 * @type array
+	 */
+	items;
+
+	constructor() {
+		super();
+		this.items = [];
+	}
+
+	asArray() {
+		return this.items;
+	}
+
+	add(element) {
+		this.items.push(element);
+		this.triggerEvent('add', element);
+		this.triggerEvent('change');
+		return element;
+	}
+
+	insert(element, index) {
+		this.items.splice(index, 0, element);
+		this.triggerEvent('insert', element);
+		this.triggerEvent('change');
+		return element;
+	}
+
+	prepend(element) {
+		return this.insert(element, 0);
+	}
+
+	remove(element) {
+		const index = this.items.indexOf(element);
+		return this.removeInternal(index, element);
+	}
+
+	removeByIndex(index) {
+		if (index >= 0 && index < this.count()) {
+			return this.removeInternal(index, this.items[index]);
+		}
+		return false;
+	}
+
+	removeInternal(index, element) {
+		if (index >= 0) {
+			this.items.splice(index, 1);
+		}
+		if (element) {
+			this.triggerEvent('remove', element);
+			this.triggerEvent('change');
+			return element;
+		}
+		return false;
+	}
+
+	reset() {
+		while (this.removeFirst()) {
+		}
+	}
+
+	isEmpty() {
+		return this.count() <= 0;
+	}
+
+	count() {
+		return this.items.length;
+	}
+
+	contains(item) {
+		return this.items.includes(item);
+	}
+
+	removeFirst() {
+		return this.removeByIndex(0);
+	}
+
+	removeLast() {
+		return this.removeByIndex(this.count() - 1);
+	}
+
+	swap(childA, childB) {
+		const indexA = this.items.indexOf(childA);
+		if (indexA < 0) {
+			return;
+		}
+		this.removeInternal(indexA, childA);
+
+		const indexB = this.items.indexOf(childB);
+		if (indexB < 0) {
+			this.insert(childA, indexA);
+			return;
+		}
+		this.removeInternal(indexB, childB);
+
+		this.insert(childA, indexB);
+		this.insert(childB, indexA);
+	}
+
+	first() {
+		return this.items[0];
+	}
+
+	last() {
+		return this.items[this.items.length - 1];
+	}
+
+	forEach(func) {
+		this.items.forEach(func);
+	}
+
+	filter(func) {
+		return this.items.filter(func);
+	}
+
+	find(func) {
+		return this.items.find(func);
+	}
+
+	exists(func) {
+		return (this.find(func) !== undefined);
+	}
+
+	map(transform) {
+		return this.items.map(transform);
+	}
+
+	reduce(callback, initial) {
+		return this.items.reduce(callback, initial);
+	}
+
+	sort(sortFunc) {
+		return this.items.sort(sortFunc);
+	}
+
+	addOnRemoveListener(listener) {
+		this.addEventListener('remove', listener);
+	}
+
+	removeOnRemoveListener(listener) {
+		this.removeEventListener('remove', listener);
+	}
+
+	addOnAddListener(listener) {
+		this.addEventListener('add', listener);
+	}
+
+	removeOnAddListener(listener) {
+		this.removeEventListener('add', listener);
+	}
+
+}

package/core/Dictionary.js

@@ -0,0 +1,83 @@
+import NodeWithEvents from "./model/event/NodeWithEvents";
+import ChangeEvent from "./model/event/ChangeEvent";
+
+const DEBUG_HASH_TABLE = false;
+
+/**
+ * Triggers Events: add, set, remove
+ */
+export default class Dictionary extends NodeWithEvents {
+
+	/**
+	 * @type object
+	 */
+	keyValues;
+
+	constructor(init = {}) {
+		super();
+		this.keyValues = init;
+	}
+
+	get(key) {
+		return this.keyValues[key];
+	}
+
+	exists(key) {
+		return (this.keyValues[key] !== undefined);
+	}
+
+	add(key, value = null) {
+		return this.set(key, value);
+	}
+
+	set(key, value = null) {
+		const old = this.get(key);
+		const existed = old !== undefined;
+		this.keyValues[key] = value;
+
+		if (existed) {
+			this.triggerEvent('set', new ChangeEvent(value, old, key));
+		} else {
+			this.triggerEvent('add', new ChangeEvent(value, undefined, key));
+		}
+		return value;
+	}
+
+	remove(key) {
+		if (!this.exists(key)) return;
+
+		const element = this.get(key);
+		delete this.keyValues[key];
+		this.triggerEvent('remove', new ChangeEvent(undefined, element, key));
+		return element;
+	}
+
+	rename(key, newKey) {
+		this.add(newKey, this.remove(key));
+	}
+
+	reset() {
+		const keys = this.keys();
+		keys.forEach((key) => this.remove(key));
+		this.keyValues = {};
+	}
+
+	count() {
+		return this.keys().length;
+	}
+
+	isEmpty() {
+		return (this.count() === 0);
+	}
+
+	keys() {
+		return Object.keys(this.keyValues);
+	}
+
+	forEach(func) {
+		for (let key in this.keyValues) {
+			func(key, this.keyValues[key]);
+		}
+	}
+
+}

package/core/animation/3d/AnimatedVector3.js

@@ -0,0 +1,35 @@
+import NumberHelper from "../../helper/NumberHelper";
+import ProgressVector3 from "./ProgressVector3";
+import {EASING_FLAT} from "../ProgressValue";
+
+export default class AnimatedVector3 {
+	progressVector;
+	duration;
+	elapsed;
+
+	constructor(start, end, duration, easing = EASING_FLAT, elapsed = 0) {
+		this.progressVector = new ProgressVector3(start, end, easing, elapsed);
+		this.duration = duration;
+		this.elapsed = elapsed;
+		this.updateProgress();
+	}
+
+	addElapsed(delta) {
+		this.elapsed += delta;
+		this.updateProgress();
+	}
+
+	updateProgress() {
+		this.progressVector.setProgress(NumberHelper.between(0, 1, this.elapsed / this.duration));
+	}
+
+	get(delta = null) {
+		if (delta !== null) this.addElapsed(delta);
+		return this.progressVector.get();
+	}
+
+	isFinished() {
+		return (this.elapsed >= this.duration);
+	}
+
+}

package/core/animation/3d/AnimationHelper.js

@@ -0,0 +1,103 @@
+import * as THREE from "three";
+
+export default class AnimationHelper {
+
+	constructor(mesh, animations) {
+		this.mesh = mesh;
+		this.actions = [];
+		this.currentAction = null;
+		this.speed = 1;
+		this.lastUpdated = null;
+
+		this.mesh.traverse( function (object ) {
+			if (object.isMesh) {
+				object.castShadow = true;
+				object.receiveShadow = true;
+				object.frustumCulled = false;
+			 }
+		});
+
+		this.mixer = new THREE.AnimationMixer(this.mesh);
+
+		for (let i = 0; i < animations.length; i++) {
+			let animation = animations[i];
+			let action = this.mixer.clipAction(animation);
+			this.actions[animation.name] = action;
+			action.play();
+			if (!this.currentAction) {
+				this.currentAction = action;
+				this.setWeight(this.currentAction, 1);
+			} else {
+				this.setWeight(action, 0);
+			}
+		}
+
+		//console.log(this.actions);
+	}
+
+	update() {
+		if (this.mixer && this.currentAction) {
+			const now = performance.now();
+			const delta = (this.lastUpdated) ? (now - this.lastUpdated) : 1;
+			this.lastUpdated = now;
+			this.mixer.update(this.speed * delta / 1000);
+		}
+	}
+
+	activateAction(name, duration, synchronize) {
+		const action = this.actions[name];
+		if (this.currentAction === action) {
+			this.currentAction.reset();
+			return;
+		}
+
+		if (synchronize)
+			this.synchronizeCrossFade(this.currentAction, action, duration);
+		else
+			this.executeCrossFade(this.currentAction, action, duration);
+	}
+
+	synchronizeCrossFade(startAction, endAction, duration) {
+		this.mixer.addEventListener('loop', onLoopFinished );
+		const _this = this;
+		function onLoopFinished(event) {
+			if (event.action === startAction) {
+				_this.mixer.removeEventListener('loop', onLoopFinished);
+				_this.executeCrossFade(startAction, endAction, duration);
+			}
+		}
+	}
+
+	executeCrossFade(startAction, endAction, duration) {
+		//console.log(endAction._clip.name);
+
+		// Not only the start action, but also the end action must get a weight of 1 before fading
+		if (startAction) this.setWeight(startAction, 1);
+
+		const durationSecs = duration / 1000;
+
+		if (endAction) {
+			this.setWeight(endAction, 1);
+			endAction.time = 0;
+
+			if (startAction) {
+				// Crossfade with warping
+				startAction.crossFadeTo(endAction, durationSecs, true);
+			} else {
+				endAction.fadeIn(durationSecs);
+			}
+			this.currentAction = endAction;
+		} else if (startAction) {
+			startAction.fadeOut(durationSecs);
+		}
+	}
+
+	// This function is needed, since animationAction.crossFadeTo() disables its start action and sets
+	// the start action's timeScale to ((start animation's duration) / (end animation's duration))
+	setWeight(action, weight) {
+		action.enabled = true;
+		action.setEffectiveTimeScale(1);
+		action.setEffectiveWeight(weight);
+	}
+
+}

package/core/animation/3d/ProgressVector3.js

@@ -0,0 +1,26 @@
+import ProgressValue, {EASING_FLAT} from "../ProgressValue";
+import Vector3 from "../../model/vector/Vector3";
+
+export default class ProgressVector3 {
+	progressX;
+	progressY;
+	progressZ;
+
+	constructor(start, end, easing = EASING_FLAT, progress = 0) {
+		this.progressX = new ProgressValue(start.x, end.x, easing, progress);
+		this.progressY = new ProgressValue(start.y, end.y, easing, progress);
+		this.progressZ = new ProgressValue(start.z, end.z, easing, progress);
+	}
+
+	setProgress(progress) {
+		this.progressX.progress = progress;
+		this.progressY.progress = progress;
+		this.progressZ.progress = progress;
+	}
+
+	get(progress = null) {
+		if (progress !== null) this.setProgress(progress);
+		return new Vector3(this.progressX.get(), this.progressY.get(), this.progressZ.get());
+	}
+
+}

package/core/animation/AnimatedRotation.js

@@ -0,0 +1,44 @@
+import NumberHelper from "../helper/NumberHelper";
+import ProgressRotation from "./ProgressRotation";
+import {EASING_FLAT} from "./ProgressValue";
+
+export default class AnimatedRotation {
+
+	/**
+	 * @type ProgressRotation
+	 */
+	progress;
+
+	/**
+	 * @type Number
+	 */
+	duration;
+
+	/**
+	 * @type Number
+	 */
+	elapsed;
+
+	/**
+	 *
+	 * @param {Number} start
+	 * @param {Number} end
+	 * @param {Number} duration
+	 * @param {Number} elapsed
+	 */
+	constructor(start, end, duration, easing = EASING_FLAT, elapsed = 0) {
+		this.progress = new ProgressRotation(start, end, easing);
+		this.duration = duration;
+		this.elapsed = elapsed;
+	}
+
+	get(delta = null) {
+		if (delta !== null) this.elapsed += delta;
+		return this.progress.get(NumberHelper.between(0, 1, this.elapsed / this.duration));
+	}
+
+	isFinished() {
+		return (this.elapsed >= this.duration);
+	}
+
+}

package/core/animation/AnimatedValue.js

@@ -0,0 +1,33 @@
+import ProgressValue, {EASING_FLAT} from "./ProgressValue";
+import NumberHelper from "../helper/NumberHelper";
+
+export default class AnimatedValue {
+	progressValue;
+	duration;
+
+	constructor(start, end, duration, easing = EASING_FLAT, elapsed = 0) {
+		this.progressValue = new ProgressValue(start, end, easing, elapsed);
+		this.duration = duration;
+		this.elapsed = elapsed;
+		this.updateProgress();
+	}
+
+	addElapsed(delta) {
+		this.elapsed += delta;
+		this.updateProgress();
+	}
+
+	updateProgress() {
+		this.progressValue.progress = NumberHelper.between(0, 1, this.elapsed / this.duration);
+	}
+
+	get(delta = null) {
+		if (delta !== null) this.addElapsed(delta);
+		return this.progressValue.get();
+	}
+
+	isFinished() {
+		return (this.elapsed >= this.duration);
+	}
+
+}

package/core/animation/AnimatedVector2.js

@@ -0,0 +1,35 @@
+import ProgressVector2 from "./ProgressVector2";
+import NumberHelper from "../helper/NumberHelper";
+import {EASING_FLAT} from "./ProgressValue";
+
+export default class AnimatedVector2 {
+	progressVector;
+	duration;
+	elapsed;
+
+	constructor(start, end, duration, easing = EASING_FLAT, elapsed = 0) {
+		this.progressVector = new ProgressVector2(start, end, easing, elapsed);
+		this.duration = duration;
+		this.elapsed = elapsed;
+		this.updateProgress();
+	}
+
+	addElapsed(delta) {
+		this.elapsed += delta;
+		this.updateProgress();
+	}
+
+	updateProgress() {
+		this.progressVector.setProgress(NumberHelper.between(0, 1, this.elapsed / this.duration));
+	}
+
+	get(delta = null) {
+		if (delta !== null) this.addElapsed(delta);
+		return this.progressVector.get();
+	}
+
+	isFinished() {
+		return (this.elapsed >= this.duration);
+	}
+
+}