Commit Progress

lib/display/Stage3D.ts

@@ -1,6 +1,7 @@
 import { ContextGLProfile, ContextMode, Stage as AwayStage, Stage, StageManager } from "@awayjs/stage";
 import { EventDispatcher } from "../events/EventDispatcher";
 import { Context3D } from "../display3D/Context3D";
+import { Event } from '../events/Event';
 import { Context3DProfile } from "../display3D/Context3DProfile";
 import { AVMStage } from "@awayfl/swf-loader";
 
@@ -24,6 +25,10 @@ export class Stage3D extends EventDispatcher {
 
     }
 
+    public get context3D():Context3D {
+        return this._context3D
+    }
+
     public requestContext3D(context3DRenderMode:String = "auto", profile:String = "baseline"):void
     {
         this._context3D = new Context3D(this._adaptee, profile)
@@ -49,6 +54,6 @@ export class Stage3D extends EventDispatcher {
                 break;
 
         }
-
+        super.dispatchEvent(new Event(Event.CONTEXT3D_CREATE))
     }
 }

lib/display3D/Context3D.ts

@@ -1,83 +1,85 @@
-import { ContextWebGL, Stage as AwayStage, StageEvent } from '@awayjs/stage';
+import { ContextGLDrawMode, ContextGLVertexBufferFormat, Stage as AwayStage, StageEvent } from '@awayjs/stage';
 import { EventDispatcher } from "../events/EventDispatcher";
+import { Context3DVertexBufferFormat } from "../display3D/Context3DVertexBufferFormat"
+import { IndexBuffer3D } from "../display3D/IndexBuffer3D"
+import { VertexBuffer3D } from "../display3D/VertexBuffer3D"
+import { Program3D } from "../display3D/Program3D"
+import { Matrix3D } from "../geom/Matrix3D"
+
 
 export class Context3D extends EventDispatcher {
         private _adaptee:AwayStage
-        private _errorChecking:boolean
 
         constructor(awayStage:AwayStage, profile) {
             super()
-            awayStage.addEventListener(StageEvent.CONTEXT_CREATED, function() {
-                this._adaptee = awayStage }
+            awayStage.addEventListener(StageEvent.CONTEXT_CREATED, 
+                function() {
+                    this._adaptee = awayStage
+                }
             )}
 
-        // Properties
-        public get backBufferHeight():number {
-            return this._adaptee.height
-        }
-
-        public set backBufferHeight(value:number) {
-            this._adaptee.height = value
-        }
-
-        public get backBufferWidth():number {
-            return this._adaptee.width
-        }
-
-        public set backBufferWidth(value:number) {
-            this._adaptee.width = value
-        }
-
-        public get driverInfo():string {
-            return ""
-        }
-
-        public get enableErrorChecking():boolean {
-            return this._errorChecking
-        }
-
-        public set enableErrorChecking(value:boolean) {
-            this._errorChecking = value
+        public clear(red:number = 0.0, green:number = 0.0, blue:number = 0.0, alpha:number = 1.0, depth:number = 1.0, stencil:number = 0, mask:number = 0xffffffff):void
+        {
+            console.log("Mask: " + mask)
+            this._adaptee.clear(red, green, blue, alpha, depth, stencil, mask)
         }
 
-
-        public get maxBackBufferHeight():number {
-            return
+        public configureBackBuffer(width:number, height:number, antiAlias:number, enableDepthAndStencil:boolean = true, wantsBestResolution:Boolean = false, wantsBestResolutionOnBrowserZoom:Boolean = false):void {
+            this._adaptee.configureBackBuffer(width, height, antiAlias, enableDepthAndStencil)
         }
 
-        public set maxBackBufferHeight(value:number) {
-
+        public createIndexBuffer(numIndices:number, bufferUsage:string = "staticDraw"):IndexBuffer3D {
+            return new IndexBuffer3D(this._adaptee.context, numIndices)
         }
 
-        public get maxBackBufferWidth():number {
-            return this._adaptee.width
+        public createProgram():Program3D{
+            return new Program3D(this._adaptee.context)
         }
 
-        public set maxBackBufferWidth(value:number) {
-
+        public createVertexBuffer(numVertices:number, data32PerVertex:number, bufferUsage:string = "staticDraw"):VertexBuffer3D {
+            return new VertexBuffer3D(this._adaptee.context, numVertices, data32PerVertex)
         }
 
-        public get profile():string {
-            return this.profile
+        public drawTriangles(indexBuffer:IndexBuffer3D, firstIndex:number = 0, numTriangles:number = -1):void {
+            if (numTriangles != -1){
+                var numIndices = numTriangles
+            } else {
+                var numIndices = numTriangles*3
+            }
+            this._adaptee.context.drawIndices(ContextGLDrawMode.TRIANGLES, indexBuffer._adaptee, firstIndex, numIndices)
         }
 
-        public static get supportsVideoTexture():boolean {
-            return false
+        public present():void{
+            this._adaptee.present()
         }
 
-        public get totalGPUMemory():number{
-            return 512
+        public setProgram(program:Program3D):void{
+            this._adaptee.context.setProgram(program._adaptee)
         }
 
-        //Functions
-        public clear(red:number = 0.0, green:number = 0.0, blue:number = 0.0, alpha:number = 1.0, depth:number = 1.0, stencil:number = 0, mask:number = 0xffffffff):void
-        {
-            console.log("Mask: " + mask)
-            this._adaptee.clear(red, green, blue, alpha, depth, stencil, mask)
+        public setProgramConstantsFromMatrix(programType:string, firstRegister:number, matrix:Matrix3D, transposedMatrix:boolean = false):void {
+            //TODO: Figure out how to use ContextGL's setProgramConstantsFromArray with a Matrix3D
         }
 
-        public configureBackBuffer(width:number, height:number, antiAlias:number, enableDepthAndStencil:boolean = true, wantsBestResolution:Boolean = false, wantsBestResolutionOnBrowserZoom:Boolean = false):void {
-            this._adaptee.configureBackBuffer(width, height, antiAlias, enableDepthAndStencil)
+        public setVertexBufferAt(index:number, buffer:VertexBuffer3D, bufferOffset:number = 0, format:String = "float4"):void{
+            switch(format) {
+                case Context3DVertexBufferFormat.BYTES_4:
+                    var awayFormat = ContextGLVertexBufferFormat.BYTE_4
+                    break;
+                case Context3DVertexBufferFormat.FLOAT_1:
+                    var awayFormat = ContextGLVertexBufferFormat.FLOAT_1
+                    break;
+                case Context3DVertexBufferFormat.FLOAT_2:
+                    var awayFormat = ContextGLVertexBufferFormat.FLOAT_2
+                    break;
+                case Context3DVertexBufferFormat.FLOAT_3:
+                    var awayFormat = ContextGLVertexBufferFormat.FLOAT_3
+                    break;
+                case Context3DVertexBufferFormat.FLOAT_4:
+                    var awayFormat = ContextGLVertexBufferFormat.FLOAT_4
+                    break;
+            }
+            this._adaptee.context.setVertexBufferAt(index, buffer._adaptee, bufferOffset, awayFormat)
         }
 
 }

lib/display3D/Context3DVertexBufferFormat.ts

@@ -0,0 +1,7 @@
+export enum Context3DVertexBufferFormat{
+    BYTES_4 = "bytes4",
+    FLOAT_1 = "float1",
+    FLOAT_2 = "float2",
+    FLOAT_3 = "float3",
+    FLOAT_4 = "float4"
+}

lib/display3D/IndexBuffer3D.ts

@@ -0,0 +1,21 @@
+import { ASObject } from "@awayfl/avm2";
+import { IContextGL, IIndexBuffer } from "@awayjs/stage";
+
+export class IndexBuffer3D extends ASObject {
+    static classInitializer = null;
+
+	static axClass: typeof IndexBuffer3D;
+
+    public _adaptee:IIndexBuffer
+
+    constructor(context: IContextGL, numIndices: number) {
+        super()
+        this._adaptee = context.createIndexBuffer(numIndices)
+    }
+
+    public uploadFromVector(data:Array<number>, startOffset:number, count:number):void{
+        var uint16ArrayData = new Uint16Array(data)
+        this._adaptee.uploadFromArray(uint16ArrayData, startOffset, count)
+    }
+
+}

lib/display3D/Program3D.ts

@@ -0,0 +1,27 @@
+import { ASObject } from "@awayfl/avm2";
+import { ByteArray as AwayByteArray } from "@awayjs/core";
+import { IContextGL, IProgram } from "@awayjs/stage";
+import { ByteArray } from "../utils/ByteArray";
+
+export class Program3D extends ASObject {
+    static classInitializer = null;
+
+	static axClass: typeof Program3D;
+
+    public _adaptee:IProgram
+
+    constructor(context:IContextGL){
+        super()
+        this._adaptee = context.createProgram()
+
+    }
+
+    public dispose(){
+        this._adaptee.dispose()
+    }
+
+    public upload(vertexProgram:ByteArray, fragmentProgram:ByteArray):void {
+        AwayByteArray
+        this._adaptee.upload(vertexProgram, fragmentProgram)
+    }
+}

lib/display3D/VertexBuffer3D.ts

@@ -0,0 +1,20 @@
+import { ASObject } from "@awayfl/avm2";
+import { IContextGL, IVertexBuffer, VertexBufferWebGL } from "@awayjs/stage";
+
+export class VertexBuffer3D extends ASObject {
+    public _adaptee:IVertexBuffer
+
+    static classInitializer = null;
+
+	static axClass: typeof VertexBuffer3D;
+
+    constructor(context:IContextGL, numVertices, dataPerVertex) {
+        super()
+        this._adaptee = context.createVertexBuffer(numVertices, dataPerVertex)
+    }
+
+    public uploadFromVector(data:Array<number>, startVertex:number, numVertices){
+        var dataFloat32Array:Float32Array = new Float32Array(data)
+        this._adaptee.uploadFromArray(dataFloat32Array, startVertex, numVertices)
+    }
+}