add rewritten (but still unused) core folder

Author: Sascha Braun

src/v2/core/Application.ts

@@ -0,0 +1,63 @@
+import { AssetManager } from "./AssetManager";
+import { CameraManager } from "./CameraManager";
+import { Loader } from "./Loader";
+import { RendererManager } from "./RendererManager";
+import { SceneManager } from "./SceneManager";
+
+export class Application {
+  private _scenes = new SceneManager(this);
+  private _cameras = new CameraManager(this);
+  private _renderers = new RendererManager(this);
+  private _assets = new AssetManager(this);
+  private _loader = new Loader();
+
+  private _lastUpdate = 0;
+  private _animationFrame?: number;
+
+  private _onBeforeUpdate = new EventDispatcher<() => void>();
+  private _onUpdate = new EventDispatcher<(dt: number) => void>();
+  private _onAfterUpdate = new EventDispatcher<() => void>();
+
+  public get loader() {
+    return this._loader;
+  }
+  public get scenes() {
+    return this._scenes;
+  }
+  public get cameras() {
+    return this._cameras;
+  }
+  public get renderers() {
+    return this._renderers;
+  }
+  public get assets() {
+    return this._assets;
+  }
+
+  public activate() {
+    if (!this._animationFrame) {
+      this._lastUpdate = Date.now();
+      this.update();
+    }
+  }
+
+  public deactivate() {
+    if (this._animationFrame) {
+      cancelAnimationFrame(this._animationFrame);
+      this._animationFrame = undefined;
+    }
+  }
+
+  private update = () => {
+    const now = Date.now();
+    const deltaTime = (now - this._lastUpdate) * 0.001;
+    this._animationFrame = requestAnimationFrame(this.update);
+    this._lastUpdate = now;
+
+    this._onBeforeUpdate.listeners.forEach(fn => fn());
+    this._onUpdate.listeners.forEach(fn => fn(deltaTime));
+    this._onAfterUpdate.listeners.forEach(fn => fn());
+
+    this.renderers.render();
+  };
+}

src/v2/core/AssetManager.ts

@@ -0,0 +1,35 @@
+import { Application } from "./Application";
+import { AssetMap } from "./AssetMap";
+import { GeometryType, MaterialType, ModelType, TextureType } from "./AssetTypes";
+import { BundleManager } from "./BundleManager";
+
+export class AssetManager {
+  private _app: Application;
+  private _bundles = new BundleManager(this._app);
+
+  private _textures = new AssetMap<TextureType>();
+  private _materials = new AssetMap<MaterialType>();
+  private _geometries = new AssetMap<GeometryType>();
+  private _models = new AssetMap<ModelType>();
+
+  constructor(app: Application) {
+    this._app = app;
+  }
+
+  public get bundles() {
+    return this._bundles;
+  }
+
+  public get textures() {
+    return this._textures;
+  }
+  public get materials() {
+    return this._materials;
+  }
+  public get geometries() {
+    return this._geometries;
+  }
+  public get models() {
+    return this._models;
+  }
+}

src/v2/core/AssetMap.ts

@@ -0,0 +1,40 @@
+import { HandlerMapErrors } from "./Errors";
+
+interface DisposableAsset {
+  dispose?: () => void;
+}
+
+export class AssetMap<T> {
+  protected _data = new Map<string, Promise<T>>();
+
+  public set(name: string, asset: Promise<T>): void {
+    if (this._data.has(name)) {
+      throw HandlerMapErrors.ALREADY_EXISTS;
+    }
+    this._data.set(name, asset);
+  }
+  public get(name: string): Promise<T> | undefined {
+    return this._data.get(name);
+  }
+  public dispose(name?: string) {
+    if (!name) {
+      this._data.forEach(item => {
+        this.disposeHook(item);
+      });
+      this._data.clear();
+      return;
+    }
+
+    const handler = this._data.get(name);
+    if (handler) {
+      this.disposeHook(handler);
+    }
+  }
+
+  protected disposeHook(asset: Promise<T>) {
+    const disposable = asset as DisposableAsset;
+    if (disposable.dispose) {
+      disposable.dispose();
+    }
+  }
+}

src/v2/core/AssetTypes.ts

@@ -0,0 +1,28 @@
+import * as THREE from "three";
+
+import { Application } from "./Application";
+
+export type TextureType = THREE.Texture;
+export type MaterialType =
+  | THREE.MeshBasicMaterial
+  | THREE.MeshDepthMaterial
+  | THREE.MeshFaceMaterial
+  | THREE.MeshLambertMaterial
+  | THREE.MeshNormalMaterial
+  | THREE.MeshPhongMaterial
+  | THREE.MeshStandardMaterial
+  | THREE.ShaderMaterial
+  | THREE.ShadowMaterial;
+export type GeometryType = THREE.Geometry | THREE.BufferGeometry;
+export type ModelType = THREE.Object3D;
+export type LightType = THREE.Light;
+export type CameraType = THREE.Camera;
+
+export type AssetType = GeometryType | MaterialType | TextureType | ModelType;
+
+export type ModelFactory = (app: Application) => Promise<ModelType>;
+export type GeometryFactory = (app: Application) => Promise<GeometryType>;
+export type MaterialFactory = (app: Application) => Promise<MaterialType>;
+export type TextureFactory = (app: Application) => Promise<TextureType>;
+export type LightFactory = (app: Application) => Promise<LightType>;
+export type CameraFactory = (app: Application) => Promise<CameraType>;

src/v2/core/BundleHandle.ts

@@ -0,0 +1,154 @@
+import { AssetType } from "./AssetTypes";
+import { Handle } from "./Handle";
+
+export class BundleHandle extends Handle {
+  private _assets: Array<Promise<AssetType>> = [];
+  private _dependencies: BundleHandle[] = [];
+  private _registered = this.queue;
+
+  private _onLoadProgress = new EventDispatcher<
+    (amount: number, total: number) => Promise<void>
+  >();
+
+  public get onLoadProgress() {
+    return this._onLoadProgress;
+  }
+
+  /**
+   * Register asset
+   * @param bundles
+   */
+  public registerAsset(pAsset: Promise<AssetType>) {
+    this._assets.push(pAsset);
+  }
+
+  /**
+   * Register dependency
+   * @param bundle
+   */
+  public registerDependency(bundle: BundleHandle) {
+    this._dependencies.push(bundle);
+    bundle.use();
+    // we don't need to wait until it is completely loaded
+    // only until all assets are registered
+    return bundle._registered;
+  }
+
+  /**
+   * Register multiple dependencies
+   * @param bundles
+   */
+  public registerDependencies(bundles: BundleHandle[]) {
+    const p = bundles.map(bundle => this.registerDependency(bundle));
+    return Promise.all(p);
+  }
+
+  /**
+   * Count total number of assets across all given bundle and all their dependencies
+   * @param bundles
+   */
+  public static countAssets(bundles: BundleHandle[]): number {
+    const countMap = new Map<BundleHandle, number>();
+    bundles.forEach(bundle => this.recursiveCountAssets(countMap, bundle));
+
+    let total = 0;
+    countMap.forEach(amount => {
+      total += amount;
+    });
+    return total;
+  }
+  /**
+   * Count total number of assets across this bundle and all dependencies
+   */
+  public countAssets() {
+    return BundleHandle.countAssets([this]);
+  }
+
+  /**
+   * List of all assets across all given bundles and all their dependencies
+   * @param bundles
+   */
+  public static listAssets(bundles: BundleHandle[]): Array<Promise<AssetType>> {
+    const map = new Map<BundleHandle, Array<Promise<AssetType>>>();
+    bundles.forEach(bundle => this.recursiveListAssets(map, bundle));
+
+    const arr: Array<Promise<AssetType>> = [];
+    const list = Array.from(map.values());
+    const assets = arr.concat(...list);
+    return assets;
+  }
+  /**
+   * List of all assets across this bundle and all dependencies
+   */
+  public listAssets() {
+    return BundleHandle.listAssets([this]);
+  }
+
+  protected load() {
+    this._registered = super.load();
+    return this._registered
+      .then(() => {
+        // go to next tick to allow user code to execute first before ready
+        return new Promise(r => setTimeout(r, 0));
+      })
+      .then(() => {
+        return this.awaitAllAssets();
+      });
+  }
+
+  protected unload() {
+    const p = super.unload();
+    return p
+      .then(() => {
+        const deps = this._dependencies.map(dep => dep.unuse());
+        return Promise.all(deps) as Promise<any>;
+      })
+      .then(() => {
+        this._dependencies = [];
+        this._assets = [];
+        return Promise.resolve();
+      });
+  }
+
+  private awaitAllAssets(): Promise<void> {
+    const allAssets = this.listAssets();
+    const total = allAssets.length;
+    let count = 0;
+
+    const pAssets = allAssets.map(assets => {
+      return assets.then(() => {
+        ++count;
+        const progress = this._onLoadProgress.listeners.map(fn =>
+          fn(count, total)
+        );
+        return Promise.all(progress);
+      });
+    });
+
+    return Promise.all(pAssets).then(Promise.resolve);
+  }
+
+  private static recursiveCountAssets(
+    map: Map<BundleHandle, number>,
+    pBundle: BundleHandle
+  ) {
+    if (!map.has(pBundle)) {
+      map.set(pBundle, pBundle._assets.length);
+    }
+    pBundle._dependencies.forEach(bundle => {
+      this.recursiveCountAssets(map, bundle);
+    });
+  }
+
+  private static recursiveListAssets(
+    map: Map<BundleHandle, Array<Promise<AssetType>>>,
+    pBundle: BundleHandle
+  ) {
+    if (!map.has(pBundle)) {
+      map.set(pBundle, pBundle._assets);
+    }
+    pBundle._dependencies.forEach(bundle => {
+      this.recursiveListAssets(map, bundle);
+    });
+  }
+}

src/v2/core/BundleManager.ts

@@ -0,0 +1,9 @@
+import { Application } from "./Application";
+import { BundleHandle } from "./BundleHandle";
+import { HandleMap } from "./HandleMap";
+
+export class BundleManager extends HandleMap<BundleHandle> {
+  constructor(private app: Application) {
+    super(BundleHandle);
+  }
+}

src/v2/core/CameraHandle.ts

@@ -0,0 +1,14 @@
+import { Camera } from "three";
+
+import { Handle } from "./Handle";
+
+export class CameraHandle extends Handle {
+  private _camera?: Camera;
+
+  public set(camera?: Camera) {
+    this._camera = camera;
+  }
+  public get() {
+    return this._camera;
+  }
+}

src/v2/core/CameraManager.ts

@@ -0,0 +1,9 @@
+import { Application } from "./Application";
+import { CameraHandle } from "./CameraHandle";
+import { HandleMap } from "./HandleMap";
+
+export class CameraManager extends HandleMap<CameraHandle> {
+  constructor(private app: Application) {
+    super(CameraHandle);
+  }
+}

src/v2/core/Errors.ts

@@ -0,0 +1,6 @@
+export const HandlerMapErrors = {
+  ALREADY_EXISTS: {
+    code: "entry_already_exists",
+    message: "An handler with the given name already exists"
+  }
+};

src/v2/core/EventDispatcher.ts

@@ -0,0 +1,21 @@
+class EventDispatcher<Func extends Function> {
+  private _listeners: Func[] = [];
+
+  public get listeners() {
+    return this._listeners;
+  }
+
+  public on(fn: Func): void {
+    this._listeners.push(fn);
+  }
+  public off(fn?: Func): void {
+    if (!fn) {
+      this._listeners = [];
+      return;
+    }
+    const index = this._listeners.indexOf(fn);
+    if (index !== -1) {
+      this._listeners.splice(index, 1);
+    }
+  }
+}