/// <summary>
		/// [static] Returns the angle in radians between two vectors.
		/// </summary>
		public static double angleBetween(Vector3D a, Vector3D b)
		{
			return default(double);
		}
		/// <summary>
		/// Returns a new Vector3D object that is perpendicular (at a right angle) to the current Vector3D and another Vector3D object.
		/// </summary>
		public Vector3D crossProduct(Vector3D a)
		{
			return default(Vector3D);
		}
		/// <summary>
		/// Subtracts the value of the x, y, and z elements of the current Vector3D object from the values of the x, y, and z elements of another Vector3D object.
		/// </summary>
		public Vector3D subtract(Vector3D a)
		{
			return default(Vector3D);
		}
		public double z; // { get; set; }

		#endregion

		#region Methods
		/// <summary>
		/// Adds the value of the x, y, and z elements of the current Vector3D object to the values of the x, y, and z elements of another Vector3D object.
		/// </summary>
		public Vector3D add(Vector3D a)
		{
			return default(Vector3D);
		}
 private Vector<double> vec3DtoVec(Vector3D vec3D)
 {
     return new[] { vec3D.x, vec3D.y, vec3D.z, vec3D.w };
 }
		/// <summary>
		/// Compares the elements of the current Vector3D object with the elements of a specified Vector3D object to determine whether they are nearly equal.
		/// </summary>
		public bool nearEquals(Vector3D toCompare, double tolerance)
		{
			return default(bool);
		}
		/// <summary>
		/// Determines whether two Vector3D objects are equal by comparing the x, y, and z elements of the current Vector3D object with a specified Vector3D object.
		/// </summary>
		public bool equals(Vector3D toCompare, bool allFour)
		{
			return default(bool);
		}
		/// <summary>
		/// If the current Vector3D object and the one specified as the parameter are unit vertices, this method returns the cosine of the angle between the two vertices.
		/// </summary>
		public double dotProduct(Vector3D a)
		{
			return default(double);
		}
		/// <summary>
		/// Appends an incremental rotation to a Matrix3D object.
		/// </summary>
		public void appendRotation(double degrees, Vector3D axis)
		{
		}
		/// <summary>
		/// Uses the transformation matrix without its translation elements to transforms a Vector3D object from one space coordinate to another.
		/// </summary>
		public Vector3D deltaTransformVector(Vector3D v)
		{
			return default(Vector3D);
		}
		/// <summary>
		/// Appends an incremental rotation to a Matrix3D object.
		/// </summary>
		public void appendRotation(double degrees, Vector3D axis, Vector3D pivotPoint)
		{
		}
		/// <summary>
		/// Rotates the display object so that it faces a specified position.
		/// </summary>
		public void pointAt(Vector3D pos)
		{
		}
		/// <summary>
		/// Rotates the display object so that it faces a specified position.
		/// </summary>
		public void pointAt(Vector3D pos, Vector3D at)
		{
		}
		/// <summary>
		/// Decrements the value of the x, y, and z elements of the current Vector3D object by the values of the x, y, and z elements of specified Vector3D object.
		/// </summary>
		public void decrementBy(Vector3D a)
		{
		}
		/// <summary>
		/// Determines whether two Vector3D objects are equal by comparing the x, y, and z elements of the current Vector3D object with a specified Vector3D object.
		/// </summary>
		public bool equals(Vector3D toCompare)
		{
			return default(bool);
		}
		/// <summary>
		/// [static] Returns the distance between two Vector3D objects.
		/// </summary>
		public static double distance(Vector3D pt1, Vector3D pt2)
		{
			return default(double);
		}
		/// <summary>
		/// Increments the value of the x, y, and z elements of the current Vector3D object by the values of the x, y, and z elements of a specified Vector3D object.
		/// </summary>
		public void incrementBy(Vector3D a)
		{
		}
        public ApplicationSprite()
        {
            // Set the default stage behavior
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;

            // Request a 3D context instance
            stage3D = stage.stage3Ds[0];
            //stage3D.addEventListener(Event.CONTEXT3D_CREATE, contextReady, false, 0, true);

            stage3D.context3DCreate +=
                delegate
                {
                    //stage3D.removeEventListener(Event.CONTEXT3D_CREATE, contextReady);

                    // Get the new context
                    context = stage3D.context3D;
                    //trace("Got context!  " + context);

                    // Configure back buffer
                    context.configureBackBuffer(DefaultWidth, DefaultHeight, 2, true);
                    context.setCulling(Context3DTriangleFace.BACK);
                    stage3D.x = stage3D.y = 0;

                    // Prepare vertex data:  x,y,z, nx,ny,nz, u,v  (position, normal, texture)
                    Vector<double> vertexData = new double[] {
				         0.5,  0.5, -0.5,	0,0,-1,		1,0,	// 	Front
				        -0.5,  0.5, -0.5,	0,0,-1,		0,0,	// 
				        -0.5, -0.5, -0.5,	0,0,-1,		0,1,	// 
				         0.5, -0.5, -0.5,	0,0,-1,		1,1,	// 
				                           
				         0.5, -0.5, -0.5,	0,-1,0,		1,0,	//  Bottom
				        -0.5, -0.5, -0.5,	0,-1,0,		0,0,	// 
				        -0.5, -0.5,  0.5,	0,-1,0,		0,1,	// 
				         0.5, -0.5,  0.5,	0,-1,0,		1,1,	// 
				                           
				        -0.5,  0.5,  0.5,	0,0,1, 		1,0,	// 	Back
				         0.5,  0.5,  0.5,	0,0,1,		0,0,	// 
				         0.5, -0.5,  0.5,	0,0,1,		0,1,	// 
				        -0.5, -0.5,  0.5,	0,0,1,		1,1,	// 
				                           
				        -0.5,  0.5,  0.5,	0,1,0, 		1,0,	// 	Top
				         0.5,  0.5,  0.5,	0,1,0,		0,0,	// 
				         0.5,  0.5, -0.5,	0,1,0,		0,1,	// 
				        -0.5,  0.5, -0.5,	0,1,0,		1,1,	// 
				                           
				        -0.5,  0.5, -0.5,	-1,0,0,		1,0,	// 	Left
				        -0.5,  0.5,  0.5,	-1,0,0,		0,0,	// 
				        -0.5, -0.5,  0.5,	-1,0,0,		0,1,	// 
				        -0.5, -0.5, -0.5,	-1,0,0,		1,1,	// 
				                           
				         0.5,  0.5,  0.5,	1,0,0, 		1,0,	// 	Right
				         0.5,  0.5, -0.5,	1,0,0,		0,0,	// 
				         0.5, -0.5, -0.5,	1,0,0,		0,1,	// 
				         0.5, -0.5,  0.5,	1,0,0,		1,1		// 	  	
			        };


                    Vector<uint> indexData = new uint[] {
				        0, 1, 2,		0, 2, 3,		// Front face
				        4, 5, 6,		4, 6, 7,        // Bottom face
				        8, 9, 10,		8, 10, 11,      // Back face
				        14, 13, 12,		15, 14, 12,     // Top face
				        16, 17, 18,		16, 18, 19,     // Left face
				        20, 21, 22,		20, 22, 23      // Right face
			        };

                    // Prep the bitmap data to be used as a texture
                    var texture = new ActionScript.Images.box().bitmapData;

                    // Prepare a shader for rendering
                    shader = new LightedRender();
                    shader.upload(context);
                    shader.setGeometry(vertexData, indexData, texture);

                    // The projection defines a 3D perspective to be rendered
                    projection = new PerspectiveMatrix3D();
                    projection.perspectiveFieldOfViewRH(45, (double)DefaultWidth / (double)DefaultHeight, 1, 500);

                    // The pivot will keep track of the model's current rotation
                    pivot = new Vector3D();

                    // Prepare a matrix which we'll use to apply transformations to the model
                    modelMatrix = new Matrix3D();
                    modelMatrix.identity();
                    modelMatrix.appendRotation(45, Vector3D.X_AXIS, pivot);
                    modelMatrix.appendRotation(45, Vector3D.Y_AXIS, pivot);
                    modelMatrix.appendRotation(45, Vector3D.Z_AXIS, pivot);

                    // The view matrix will contain the concatenation of all transformations
                    viewMatrix = new Matrix3D();

                    // Prepare lighting
                    lightColor = new Vector3D(0.95, 0.80, 0.55, 0.8);  // R,G,B,strength
                    ambient = new Vector3D(0.00, 0.05, 0.1);
                    lightPos = new Vector3D(1.0, 1.0, -4.0, 0.2);

                    // Start rendering frames
                    //addEventListener(Event.ENTER_FRAME, renderFrame, false, 0, true);

                    this.enterFrame +=
                        delegate
                        {
                            // Clear away the old frame render
                            context.clear(0.05, 0.12, 0.18);  // Dark grey background

                            // Rotate the model matrix
                            modelMatrix.appendRotation(0.4, Vector3D.X_AXIS, pivot);
                            modelMatrix.appendRotation(0.3, Vector3D.Y_AXIS, pivot);

                            // Calculate the view matrix, and run the shader program!
                            viewMatrix.identity();
                            viewMatrix.append(modelMatrix);
                            viewMatrix.appendTranslation(0, 0, -2);
                            viewMatrix.append(projection);
                            viewMatrix.transpose();

                            shader.render(viewMatrix, lightPos, lightColor, ambient);

                            // Show the newly rendered frame on screen
                            context.present();
                        };

                    // Created with EasyAGAL!
                    //var bitmap:Bitmap = new createdWith();
                    //bitmap.y = CONTEXT_HEIGHT - bitmap.height;
                    //addChild(bitmap);

                };

            stage3D.requestContext3D(Context3DRenderMode.AUTO);

            //trace("Awaiting context...");
        }
        public void render(Matrix3D viewMatrix, Vector3D lightPos, Vector3D lightColor, Vector3D ambient)
        {
            // Set ATTRIBUTE Registers to point at vertex data
            context.setVertexBufferAt(0, vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3); // x,y,z
            context.setVertexBufferAt(1, vertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_3); // nx,ny,nz
            context.setVertexBufferAt(2, vertexBuffer, 6, Context3DVertexBufferFormat.FLOAT_2); // u,v

            // Set SAMPLER Register
            context.setTextureAt(0, texture3D);

            // Pass viewMatrix into constant registers
            context.setProgramConstantsFromMatrix(Context3DProgramType.VERTEX, 0, viewMatrix);

            // Pass a vector for the (world space) location of the light
            context.setProgramConstantsFromVector(Context3DProgramType.VERTEX, 4, vec3DtoVec(lightPos), 1);

            // Pass light parameters
            context.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, vec3DtoVec(lightColor), 1);
            context.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 1, vec3DtoVec(ambient), 1);
            context.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 2, new double[] { 0, 1 / 3, 1, 0.5 }, 1);

            // Tell the 3D context that this is the current shader program to be rendered
            context.setProgram(program);

            // Render the shader!
            context.drawTriangles(indexBuffer);
        }