/// <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);
}