Initial commit

C#/TSEngine/Core/Assets/IAsset.ts

@@ -0,0 +1,11 @@
+namespace TSE {
+
+    export interface IAsset {
+
+        readonly name: string;
+
+        readonly data: any;
+
+    }
+
+}

C#/TSEngine/Core/Assets/IAssetLoader.ts

@@ -0,0 +1,11 @@
+namespace TSE {
+
+    export interface IAssetLoader {
+
+        readonly supportedExtensions: string[];
+
+        loadAsset(assetName: string): void;
+
+    }
+
+}

C#/TSEngine/Core/Assets/assetManager.ts

@@ -0,0 +1,54 @@
+namespace TSE {
+
+    export const MESSAGE_ASSET_LOADER_ASSET_LOADED = "MESSAGE_ASSET_LOADER_ASSET_LOADED::";
+
+    export class AssetManager {
+
+        private static _loaders: IAssetLoader[] = [];
+        private static _loadedAssets: { [name: string]: IAsset } = {};
+
+        private constructor() {}
+
+        public static initialize(): void {
+            this.registerLoader(new ImageAssetLoader());
+            this.registerLoader(new JsonAssetLoader());
+        }
+
+        public static registerLoader(loader: IAssetLoader): void {
+            AssetManager._loaders.push(loader);
+        }
+
+        public static onAssetLoaded(asset: IAsset): void {
+            AssetManager._loadedAssets[asset.name] = asset;
+            Message.send(MESSAGE_ASSET_LOADER_ASSET_LOADED + asset.name, this, asset);
+        }
+
+        public static loadAsset(assetName: string): void {
+            let extention = assetName.split('.').pop().toLowerCase();
+            for (let loader of AssetManager._loaders) {
+                if (loader.supportedExtensions.indexOf(extention) !== -1) {
+                    loader.loadAsset(assetName);
+                    return;
+                }
+            }
+
+            console.warn("Unable to load asset with extention: '" + extention + "'. no loader was found.");
+        }
+
+        public static isAssetLoaded(assetName: string): boolean {
+            return AssetManager._loadedAssets[assetName] !== undefined;
+        }
+
+        public static getAsset(assetName: string): IAsset {
+            if (AssetManager.isAssetLoaded(assetName)) {
+                return AssetManager._loadedAssets[assetName];
+            } else {
+                AssetManager.loadAsset(assetName);
+            }
+
+            return undefined;
+        }
+
+    }
+
+}

C#/TSEngine/Core/Assets/imageAssetLoader.ts

@@ -0,0 +1,42 @@
+namespace TSE {
+
+    export class ImageAsset implements IAsset {
+
+        public readonly name: string;
+
+        public readonly data: HTMLImageElement;
+
+        public constructor(name: string, data: HTMLImageElement) {
+            this.name = name;
+            this.data = data;
+        }
+
+        public get width(): number {
+            return this.data.width;
+        }
+
+        public get height(): number {
+            return this.data.height;
+        }
+
+    }
+
+    export class ImageAssetLoader implements IAssetLoader {
+
+        public get supportedExtensions(): string[] { return ["png", "gif", "jpg", "jpeg"] }
+
+        public loadAsset(assetName: string): void {
+            let image: HTMLImageElement = new Image();
+            image.onload = this.onImageLoaded.bind(this, assetName, image);
+            image.src = assetName;
+        }
+
+        private onImageLoaded(assetName: string, image: HTMLImageElement): void {
+            console.log("onImageLoaded: assetName/image", assetName, image);
+            let asset = new ImageAsset(assetName, image);
+            AssetManager.onAssetLoaded(asset);
+        }
+
+    }
+
+}

C#/TSEngine/Core/Assets/jsonAssetLoader.ts

@@ -0,0 +1,39 @@
+namespace TSE {
+
+    export class JsonAsset implements IAsset {
+
+        public readonly name: string;
+
+        public readonly data: any;
+
+        public constructor(name: string, data: any) {
+            this.name = name;
+            this.data = data;
+        }
+
+    }
+
+    export class JsonAssetLoader implements IAssetLoader {
+
+        public get supportedExtensions(): string[] { return ["json"] }
+
+        public loadAsset(assetName: string): void {
+            let request: XMLHttpRequest = new XMLHttpRequest();
+            request.open("GET", assetName);
+            request.addEventListener("load", this.onJsonLoaded.bind(this, assetName, request));
+            request.send();
+        }
+
+        private onJsonLoaded(assetName: string, request: XMLHttpRequest): void {
+            console.log("onJsonLoaded: assetName/request", assetName, request);
+
+            if (request.readyState === request.DONE) {
+                let json = JSON.parse(request.responseText);
+                let asset = new JsonAsset(assetName, json);
+                AssetManager.onAssetLoaded(asset);
+            }
+        }
+
+    }
+
+}