Initial commit

C#/TSEngine/Core/Graphics/sprite.ts

@@ -0,0 +1,151 @@
+namespace TSE {
+
+    export class Sprite {
+        protected _buffer: GLBuffer;
+
+        protected _width: number;
+        protected _height: number;
+        protected _name: string;
+
+        protected _material: Material;
+        protected _vertices: Vertex[] = [];
+
+        public constructor(name: string, materialName: string, width: number = 100, height: number = 100) {
+            this._name = name;
+            this._width = width;
+            this._height = height;
+            this._material = MaterialManager.getMaterial(materialName);
+        }
+
+        public load(): void {
+            this._buffer = new GLBuffer();
+
+            this._buffer.addAttributeLocation(new AttributeInfo(0, 3)); //Position
+            this._buffer.addAttributeLocation(new AttributeInfo(1, 2)); //UVs
+
+            this._vertices = [
+                new Vertex(0, 0, 0, 0, 0),
+                new Vertex(0, this._height, 0, 0, 1.0),
+                new Vertex(this._width, this._height, 0, 1.0, 1.0),
+
+                new Vertex(this._width, this._height, 0, 1.0, 1.0),
+                new Vertex(this._width, 0, 0, 1.0, 0),
+                new Vertex(0, 0, 0, 0, 0)
+            ];
+
+            this._buffer.pushBackData(Vertex.vertexArray(this._vertices));
+            this._buffer.upload();
+            this._buffer.unbind();
+        }
+
+        public destroy(): void {
+            this._buffer.destroy();
+            MaterialManager.releaseMaterial(this._material.name);
+            delete this._material;
+        }
+
+        public update(time: number): void {
+
+        }
+
+        public draw(shader: Shader, model: Matrix4x4): void {
+            let modelLocation = shader.getUniformLocation("u_model");
+            gl.uniformMatrix4fv(modelLocation, false, model.toFloat32Array());
+
+            let colorLocation = shader.getUniformLocation("u_tint");
+            gl.uniform4fv(colorLocation, this._material.tint.toFloat32Array());
+
+            if (this._material.diffuseTexture !== undefined) {
+                this._material.diffuseTexture.activateAndBind(0);
+                let diffuseLocation = shader.getUniformLocation("u_diffuse");
+                gl.uniform1i(diffuseLocation, 0);
+            }
+
+            this._buffer.bind();
+            this._buffer.draw();
+        }
+
+        public get name(): string { return this._name; }
+
+    }
+
+    export class AnimatedSprite extends Sprite {
+
+        private _frameHeight: number;
+        private _frameWidth: number;
+        private _frameCount: number;
+        private _frameSequence: number[];
+
+        private _currentFrame: number = 0;
+        private currentTime: number = 0;
+        private _frameTime: number = 300;
+        private _frameUVs: Vector2[][];
+        private _loaded: boolean = false;
+
+        public constructor(name: string, materialName: string, frameWidth: number = 10, frameHeight: number = 10, frameCount: number = 1, frameSequence: number[] = []) {
+            super(name, materialName, frameWidth, frameHeight);
+            this._frameWidth = frameWidth;
+            this._frameHeight = frameHeight;
+            this._frameCount = frameCount;
+            this._frameSequence = frameSequence;
+        }
+
+        public load() {
+            super.load();
+            this.calculateUVs();
+        }
+
+        private calculateUVs(): void {
+            setTimeout(() => {
+                this._frameUVs = [];
+
+                let totalWidth: number = 0;
+                let totalHeight: number = 0;
+                for (let i = 0; i < this._frameCount; i++) {
+                    totalWidth += this._frameWidth;
+                    if (totalWidth > this._material.diffuseTexture.width) {
+                        totalWidth = 0;
+                        totalHeight++;
+                    }
+
+                    const u = (i * this._frameWidth) / this._material.diffuseTexture.width;
+                    const v = (totalHeight * this._frameHeight) / this._material.diffuseTexture.height;
+                    const um = ((i * this._frameWidth) + this._frameWidth) / this._material.diffuseTexture.width;
+                    const vm = ((totalHeight * this._frameHeight) + this._frameHeight) / this._material.diffuseTexture.height;
+                    this._frameUVs.push([new Vector2(u, v), new Vector2(um, vm)]);
+                }
+                this._loaded = true;
+            }, 0);
+        }
+
+        public update(time: number) {
+            if (!this._loaded) return;
+            this.currentTime += time;
+            if (this.currentTime > this._frameTime) {
+                this._currentFrame++;
+                this.currentTime = 0;
+
+                if (this._currentFrame >= this._frameSequence.length)
+                    this._currentFrame = 0;
+
+                const frameUVs = this._frameUVs[this._frameSequence[this._currentFrame]];
+
+                this._vertices[0].texCoords.copyFrom(frameUVs[0]);
+                this._vertices[1].texCoords = new Vector2(frameUVs[0].x, frameUVs[1].y);
+                this._vertices[2].texCoords.copyFrom(frameUVs[1]);
+
+                this._vertices[3].texCoords.copyFrom(frameUVs[1]);
+                this._vertices[4].texCoords = new Vector2(frameUVs[1].x, frameUVs[0].y);
+                this._vertices[5].texCoords.copyFrom(frameUVs[0]);
+
+                this._buffer.setData(Vertex.vertexArray(this._vertices));
+                this._buffer.upload();
+                this._buffer.unbind();
+            }
+
+            super.update(time);
+        }
+
+    }
+
+}