forked from: code on 2008-12-27
PolyTest.as
Control: Arrow keys or [WASD] keys.
// forked from erakan's code on 2008-12-27
// PolyTest.as
// Control: Arrow keys or [WASD] keys.
package
{
import flash.display.Shape;
import flash.display.Sprite;
import flash.display.BitmapData;
import flash.display.Bitmap;
import flash.display.Graphics;
import flash.geom.Vector3D;
import flash.geom.Matrix3D;
import flash.geom.Point;
import flash.geom.Transform;
import flash.geom.Matrix;
import flash.geom.PerspectiveProjection;
import flash.text.*;
import flash.events.Event;
import flash.events.KeyboardEvent;
[SWF(width="465", height="465", backgroundColor="0x000000", frameRate="30")]
public class PolyTest extends Sprite
{
private const SCREEN_WIDTH:int = 465;
private const SCREEN_HEIGHT:int = 465;
private const FRAME_RATE:int = 30;
private const BACK_COLOR:MyColor = new MyColor(210, 190, 240);
private var _buffer:BitmapData;
private var _screen:Bitmap;
private const SCREEN_FOV:Number = 90.0;
// private const SCREEN_FOV:Number = 60.0;
private const NEAR_PLANE_DISTANCE:Number = 0.1;
private const CULL_MIN_Z:Number = -1.0;
private const CULL_MAX_Z:Number = 5.0;
private const FOG_MIN_Z:Number = 1.0;
private const FOG_MAX_Z:Number = 5.0;
private var _input:Input = new Input();
private const PLAYER_SPEED:Number = 0.2;
private const PLAYER_YAW_PER_SEC:Number = 180;
private const PLAYER_START_Y:Number = 0.5;
private const PLAYER_START_ANGLE:Number = 0;
private var _player:Player = new Player();
private var _items:Vector.<Item> = new Vector.<Item>();
private var _itemObj:TextField = new TextField();
private var _localProj:Sprite;
private var _localShift:Sprite;
private var _localView:Sprite;
private const BLOCK_WIDTH:Number = 1.0;
private const BLOCK_HEIGHT:Number = 1.0;
private const BLOCK_THICK:Number = 0.2;
private const BLOCK_COLOR:MyColor = new MyColor(0, 0, 0xcc);
private var _matProj:Matrix3D;
private var _maze:Maze = new Maze( Vector.<String>([
"################",
"# #",
"# #",
"# #",
"# #",
"# #",
"# #", "# #",
"# > S #",
"################",
]) );
private const ROTATE_CYCLE:int = 60;
private var _rotateFrame:int = 0;
private var _polys:Vector.<MyPoly> = new Vector.<MyPoly>();
////////////////////////////////////////////////////////
public function PolyTest()
{
// coodinate player
_player.pos = getPlayerPositionFromMaze(_maze);
_player.pos.y = PLAYER_START_Y; // eye height adjust
_player.angle = Math.PI * PLAYER_START_ANGLE / 180;
// get items
_items = getItemsFromMaze(_maze);
// make maze polygons
addMazePolys(_polys, _maze);
// pre-compute projection and screen matrix
_matProj = MyUtil.getMatrixPerspectiveFovLH(
Math.PI * SCREEN_FOV / 180.0,
SCREEN_WIDTH / SCREEN_HEIGHT);
// frame buffer settings
_buffer = new BitmapData(SCREEN_WIDTH, SCREEN_HEIGHT, false, 0);
_screen = new Bitmap(_buffer);
addChild(_screen);
// item object
var textFormat:TextFormat = new TextFormat();
textFormat.color = "0xff0000";
textFormat.size = 48;
textFormat.bold = true;
_itemObj.defaultTextFormat = textFormat;
_itemObj.text = "?";
//------------------------------------------------------
// fl object coordinate
// +Z
// |
// |
// |0 width
//------+-------+X
// |` /
// | ` /
// | `/
// | @(AS3's camera pos?)
_localView = new Sprite();
_localView.addChild(_itemObj);
_localShift = new Sprite();
_localShift.addChild(_localView);
_localProj = new Sprite();
_localProj.addChild(_localShift);
// set projection
var pp:PerspectiveProjection = new PerspectiveProjection();
pp.projectionCenter = new Point(SCREEN_WIDTH/2.0, SCREEN_HEIGHT/2.0);
pp.fieldOfView = SCREEN_FOV;
_localProj.transform.perspectiveProjection = pp;
// maybe focalLength will updated when the setter invoked.
// get camera distance
pp = _localProj.transform.perspectiveProjection;
var camDistance:Number = pp.focalLength;
// matirix to flip down:+y to up:+y
var matFlipY:Matrix3D = new Matrix3D();
matFlipY.appendScale(1, -1, 1);
// matrix to scale to avoid near clip
// (near clip distance will 0.05 * focalLength?)
var matNorm:Matrix3D = new Matrix3D();
matNorm.appendScale(camDistance, camDistance, camDistance);
// matrix to move origin to '@'
var matShift:Matrix3D = new Matrix3D();
matShift.appendTranslation(
SCREEN_WIDTH / 2.0,
SCREEN_HEIGHT / 2.0,
- camDistance);
// set shift node
var matTmp:Matrix3D = new Matrix3D();
matTmp.append(matFlipY);
matTmp.append(matNorm);
matTmp.append(matShift);
_localShift.transform.matrix3D = matTmp;
//------------------------------------------------------
// flash settings
stage.addEventListener(KeyboardEvent.KEY_DOWN, _input.onKeyDown);
stage.addEventListener(KeyboardEvent.KEY_UP, _input.onKeyUp);
addEventListener(Event.ENTER_FRAME, onEnterFrame);
}
private function onEnterFrame(evt:Event):void
{
////////////////////////////////////////////////////////
// control
var stride:Vector3D = _player.getDirection();
stride.x *= PLAYER_SPEED;
stride.z *= PLAYER_SPEED;
var move:Vector3D = new Vector3D();
if (_input.up)
{
move.x = stride.x;
move.z = stride.z;
}
else if (_input.down)
{
move.x = -stride.x;
move.z = -stride.z;
}
var theta:Number = Math.PI * PLAYER_YAW_PER_SEC / 180 / FRAME_RATE;
if (_input.right)
{
_player.angle -= theta;
}
else if (_input.left)
{
_player.angle += theta;
}
_player.pos.x += move.x;
fitToWall(_player.pos, _maze, true);
_player.pos.z += move.z;
fitToWall(_player.pos, _maze, false);
_rotateFrame = (_rotateFrame + 1) % ROTATE_CYCLE;
////////////////////////////////////////////////////////
// begin render
_buffer.lock();
//------------------------------------------------------
// render background
_buffer.fillRect(_buffer.rect, BACK_COLOR.rgb);
var nodes:Vector.<MyNode>;
//------------------------------------------------------
// transform polygons
var dir:Vector3D = _player.getDirection();
var matView:Matrix3D = MyUtil.getMatrixLookAtLH(
_player.pos,
_player.pos.add(dir),
new Vector3D(0, 1, 0));
// world view matrix
var matWV:Matrix3D = matView.clone();
var cullPolys:Vector.<MyPoly> = MyUtil.getDistanceCullPolys(
_polys, _player.pos, dir, CULL_MIN_Z, CULL_MAX_Z);
var viewPolys:Vector.<MyPoly> = MyUtil.transformPolys(
cullPolys, matWV);
var clipPolys:Vector.<MyPoly> = MyUtil.getNearClipPolys(
viewPolys, NEAR_PLANE_DISTANCE);
nodes = MyUtil.transformPolysToScreen(
clipPolys, _matProj, SCREEN_WIDTH, SCREEN_HEIGHT);
//------------------------------------------------------
// transform items
for each (var it:Item in _items)
{
var tmp:Vector3D = matView.transformVector(it);
var newNode:MyNode = new MyNode();
newNode.type = NodeType.DECAL;
newNode.z = tmp.z;
newNode.obj = it;
nodes.push(newNode);
}
//------------------------------------------------------
// sort nodes
nodes.sort(MyUtil.onSortNode);
//------------------------------------------------------
// render polygons
// for polygon render
var shape:Shape = new Shape();
var g:Graphics = shape.graphics;
// g.lineStyle (1, 0x000000, 1.0);
// for decal render
_localView.transform.matrix3D = matView;
// item model matrix
var matModel:Matrix3D = new Matrix3D();
matModel.appendTranslation(-12, -24, 0); // centering
matModel.appendScale(1.0/48, -1.0/48, 1.0/48); // 48dot -> 1m and Y flip
matModel.appendRotation(360 * _rotateFrame / ROTATE_CYCLE, Vector3D.Y_AXIS); // spin
for each (var node:MyNode in nodes)
{
switch (node.type)
{
case 0: // flat polygon
{
var prim:MyPrim = node.obj as MyPrim;
var color:int;
if (node.z <= FOG_MIN_Z)
{
color = BLOCK_COLOR.rgb;
}
else if (node.z >= FOG_MAX_Z)
{
color = BACK_COLOR.rgb;
}
else
{
var t:Number = (node.z - FOG_MIN_Z)
/ (FOG_MAX_Z - FOG_MIN_Z);
color =
(int)(BLOCK_COLOR.r + (BACK_COLOR.r - BLOCK_COLOR.r) * t) * 0x10000 +
(int)(BLOCK_COLOR.g + (BACK_COLOR.g - BLOCK_COLOR.g) * t) * 0x100 +
(int)(BLOCK_COLOR.b + (BACK_COLOR.b - BLOCK_COLOR.b) * t);
}
g.clear();
g.beginFill(color);
var isFirst:Boolean = true;
for each (var v:Point in prim.vertices)
{
if (isFirst)
{
isFirst = false;
g.moveTo(v.x, v.y);
}
else
{
g.lineTo(v.x, v.y);
}
}
g.endFill();
_buffer.draw(shape);
}
break;
case 1: // item
{
var item:Item = node.obj as Item;
var matWorld:Matrix3D = matModel.clone();
matWorld.appendTranslation(item.x, item.y, item.z); // position
_itemObj.transform.matrix3D = matWorld;
_buffer.draw(_localProj);
}
break;
}
}
//------------------------------------------------------
// end render
_buffer.unlock();
}
////////////////////////////////////////////////////////
// for maze
public function addMazePolys(polys:Vector.<MyPoly>, maze:Maze):void
{
for (var my:int = 0; my < maze.height; my++)
{
for (var mx:int = 0; mx < maze.width; mx++)
{
var symbol:String = maze.getSymbol(mx, my);
if (symbol == "#")
{
addBlockPolys(polys, mx * BLOCK_WIDTH, -(my * BLOCK_WIDTH));
}
}
}
}
public function addBlockPolys(polys:Vector.<MyPoly>, x0:Number, z0:Number):void
{
var x1:Number = x0 + BLOCK_WIDTH;
var z1:Number = z0 + -(BLOCK_WIDTH);
var y0:Number = BLOCK_HEIGHT;
var y1:Number = 0;
var poly:MyPoly;
// -Z
poly = new MyPoly();
poly.vertices.push(new Vector3D(x1, y0, z0));
poly.vertices.push(new Vector3D(x0, y0, z0));
poly.vertices.push(new Vector3D(x0, y1, z0));
poly.vertices.push(new Vector3D(x1, y1, z0));
polys.push(poly);
// +Z
poly = new MyPoly();
poly.vertices.push(new Vector3D(x0, y0, z1));
poly.vertices.push(new Vector3D(x1, y0, z1));
poly.vertices.push(new Vector3D(x1, y1, z1));
poly.vertices.push(new Vector3D(x0, y1, z1));
polys.push(poly);
// -X
poly = new MyPoly();
poly.vertices.push(new Vector3D(x0, y0, z0));
poly.vertices.push(new Vector3D(x0, y0, z1));
poly.vertices.push(new Vector3D(x0, y1, z1));
poly.vertices.push(new Vector3D(x0, y1, z0));
polys.push(poly);
// +X
poly = new MyPoly();
poly.vertices.push(new Vector3D(x1, y0, z1));
poly.vertices.push(new Vector3D(x1, y0, z0));
poly.vertices.push(new Vector3D(x1, y1, z0));
poly.vertices.push(new Vector3D(x1, y1, z1));
polys.push(poly);
}
public function getPlayerPositionFromMaze(maze:Maze):Vector3D
{
for (var my:int = 0; my < maze.height; my++)
{
for (var mx:int = 0; mx < maze.width; mx++)
{
var symbol:String = maze.getSymbol(mx, my);
if (symbol == "S")
{
return new Vector3D(
mx * BLOCK_WIDTH + BLOCK_WIDTH/2,
0,
-(my * BLOCK_WIDTH + BLOCK_WIDTH/2));
}
}
}
return new Vector3D();
}
public function getItemsFromMaze(maze:Maze):Vector.<Item>
{
var items:Vector.<Item> = new Vector.<Item>();
for (var my:int = 0; my < maze.height; my++)
{
for (var mx:int = 0; mx < maze.width; mx++)
{
var symbol:String = maze.getSymbol(mx, my);
switch (symbol)
{
case "#":
case " ":
case "S":
break;
default:
items.push(new Item(
mx * BLOCK_WIDTH + BLOCK_WIDTH/2,
0.5,
-(my * BLOCK_WIDTH + BLOCK_WIDTH/2) ));
break;
}
}
}
return items;
}
public function fitToWall(pos:Vector3D, maze:Maze, isXMode:Boolean):void
{
var mx0:int = (int)((pos.x - BLOCK_THICK) / BLOCK_WIDTH);
var mx1:int = (int)((pos.x + BLOCK_THICK) / BLOCK_WIDTH);
var my1:int = -(int)((pos.z - BLOCK_THICK) / BLOCK_WIDTH);
var my0:int = -(int)((pos.z + BLOCK_THICK) / BLOCK_WIDTH);
for (var my:int = my0; my <= my1; my++)
{
for (var mx:int = mx0; mx <= mx1; mx++)
{
var symbol:String = maze.getSymbol(mx, my);
if (symbol != "#") { continue; }
var x0:Number = (mx) * BLOCK_WIDTH - BLOCK_THICK;
var x1:Number = (mx + 1) * BLOCK_WIDTH + BLOCK_THICK;
var z1:Number = -((my) * BLOCK_WIDTH - BLOCK_THICK);
var z0:Number = -((my + 1) * BLOCK_WIDTH + BLOCK_THICK);
if (pos.x > x0 && pos.x < x1 &&
pos.z > z0 && pos.z < z1)
{
if (isXMode)
{
pos.x = (pos.x < (x0+x1)/2) ? x0 : x1;
}
else
{
pos.z = (pos.z < (z0+z1)/2) ? z0 : z1;
}
}
}
}
}
}
}
function traceMatrix(m:Matrix3D):void
{
trace(m.rawData[ 0], m.rawData[ 1], m.rawData[ 2], m.rawData[ 3]);
trace(m.rawData[ 4], m.rawData[ 5], m.rawData[ 6], m.rawData[ 7]);
trace(m.rawData[ 8], m.rawData[ 9], m.rawData[10], m.rawData[11]);
trace(m.rawData[12], m.rawData[13], m.rawData[14], m.rawData[15]);
}
//////////////////////////////////////////////////////
class Maze
{
public var _lines:Vector.<String> = new Vector.<String>();
public var _longestWidth:int = 0;
public function Maze(lines:Vector.<String>)
{
_lines = lines;
_longestWidth = 0;
for each (var line:String in _lines)
{
if (line.length > _longestWidth)
{
_longestWidth = line.length;
}
}
}
public function get width():int
{
return _longestWidth;
}
public function get height():int
{
return _lines.length;
}
public function getSymbol(mx:int, my:int):String
{
if (my < 0 || my >= _lines.length) { return " "; }
var line:String = _lines[my];
if (mx < 0 || mx >= line.length) { return " "; }
return line.charAt(mx);
}
}
import flash.geom.Vector3D;
import flash.geom.Matrix3D;
import flash.geom.Point;
//////////////////////////////////////////////////////
class Player
{
public var pos:Vector3D = new Vector3D();
public var angle:Number = 0;
public function getDirection():Vector3D
{
return new Vector3D(
Math.cos(angle),
0,
Math.sin(angle));
}
}
//////////////////////////////////////////////////////
class Item extends Vector3D
{
public function Item(x:Number = 0, y:Number = 0, z:Number = 0, w:Number = 0)
{
super(x, y, z, w);
}
}
//////////////////////////////////////////////////////
class Input
{
import flash.events.Event;
import flash.events.KeyboardEvent;
public var left:Boolean = false;
public var up:Boolean = false;
public var right:Boolean = false;
public var down:Boolean = false;
public function onKeyUp(evt:KeyboardEvent):void
{
switch (evt.keyCode)
{
case 0x25: // [<]
case 0x41: // [A]
left = false;
break;
case 0x26: // [^]
case 0x57: // [W]
up = false;
break;
case 0x27: // [>]
case 0x44: // [D]
right = false;
break;
case 0x28: // [v]
case 0x53: // [S]
down = false;
break;
}
}
public function onKeyDown(evt:KeyboardEvent):void
{
switch (evt.keyCode)
{
case 0x25: // [<]
case 0x41: // [A]
left = true;
break;
case 0x26: // [^]
case 0x57: // [W]
up = true;
break;
case 0x27: // [>]
case 0x44: // [D]
right = true;
break;
case 0x28: // [v]
case 0x53: // [S]
down = true;
break;
}
}
}
//////////////////////////////////////////////////////
class MyColor
{
public function MyColor(ir:int = 0, ig:int = 0, ib:int = 0)
{
r = ir;
g = ig;
b = ib;
}
public var r:Number;
public var g:Number;
public var b:Number;
public function get rgb():int
{
return 0x10000 * r + 0x100 * g + b;
}
}
//////////////////////////////////////////////////////
class MyPoly
{
public var vertices:Vector.<Vector3D> = new Vector.<Vector3D>();
}
class MyPrim
{
public var vertices:Vector.<Point> = new Vector.<Point>();
public var color:int;
}
class MyNode
{
public var type:int;
public var z:Number;
public var obj:Object;
}
class NodeType
{
public static const POLYGON:int = 0;
public static const DECAL:int = 1;
}
//////////////////////////////////////////////////////
class MyUtil
{
public static function getMatrixLookAtLH(eye:Vector3D, at:Vector3D, up:Vector3D):Matrix3D
{
var zaxis:Vector3D = at.subtract(eye);
// var zaxis:Vector3D = eye.subtract(at); for RH
zaxis.normalize();
var xaxis:Vector3D = up.crossProduct(zaxis);
zaxis.normalize();
var yaxis:Vector3D = zaxis.crossProduct(xaxis);
return new Matrix3D( Vector.<Number>([
xaxis.x, yaxis.x, zaxis.x, 0,
xaxis.y, yaxis.y, zaxis.y, 0,
xaxis.z, yaxis.z, zaxis.z, 0,
- xaxis.dotProduct(eye), - yaxis.dotProduct(eye), - zaxis.dotProduct(eye), 1
]) );
}
public static function getMatrixPerspectiveFovLH(fovY:Number, aspect:Number):Matrix3D
{
var yScale:Number = 1.0 / Math.tan(fovY/2);
var xScale:Number = yScale / aspect;
return new Matrix3D( Vector.<Number>([
xScale, 0, 0, 0,
0, yScale, 0, 0,
0, 0, 1, 1,
0, 0, 0, 0,
// 0, 0, zf / (zf-zn), -1,
// 0, 0, zn*zf / (zf-zn), 0,
]) );
/* for RH
return new Matrix3D( Vector.<Number>([
xScale, 0, 0, 0,
0, yScale, 0, 0,
0, 0, -1, -1,
0, 0, 0, 0,
// 0, 0, -zf / (zf-zn), -1,
// 0, 0, zn*zf / (zf-zn), 0,
]) );
*/
}
public static function transformPolys(polys:Vector.<MyPoly>, m:Matrix3D):Vector.<MyPoly>
{
var outPolys:Vector.<MyPoly> = new Vector.<MyPoly>();
for each (var poly:MyPoly in polys)
{
var outPoly:MyPoly = new MyPoly();
for each (var v:Vector3D in poly.vertices)
{
outPoly.vertices.push(m.transformVector(v));
}
outPolys.push(outPoly);
}
return outPolys;
}
public static function getDistanceCullPolys(
polys:Vector.<MyPoly>,
pos:Vector3D,
dir:Vector3D,
minZ:Number,
maxZ:Number):Vector.<MyPoly>
{
var outPolys:Vector.<MyPoly> = new Vector.<MyPoly>();
for each (var poly:MyPoly in polys)
{
var diff:Vector3D = poly.vertices[0].subtract(pos);
var dot:Number = diff.dotProduct(dir);
if (dot < minZ || dot > maxZ)
{
continue;
}
outPolys.push(poly);
}
return outPolys;
}
public static function getNearClipPolys(polys:Vector.<MyPoly>, dist:Number):Vector.<MyPoly>
{
var outPolys:Vector.<MyPoly> = new Vector.<MyPoly>();
for each (var poly:MyPoly in polys)
{
var outPoly:MyPoly = new MyPoly();
var isPrevClipped:Boolean = true;
var prevPos:Vector3D = null;
// near clip
for (var i:int = 0; i < poly.vertices.length + 1; i++)
{
var v:Vector3D = poly.vertices[i % poly.vertices.length];
var isClipped:Boolean = (v.z < dist);
if (isClipped != isPrevClipped && prevPos != null)
{
outPoly.vertices.push(
MyUtil.getNearClipPosition(prevPos, v, dist));
}
if (i >= poly.vertices.length)
{
continue; // clip only
}
if (!isClipped)
{
outPoly.vertices.push(v);
}
isPrevClipped = isClipped;
prevPos = v;
}
if (outPoly.vertices.length >= 3)
{
outPolys.push(outPoly);
}
}
return outPolys;
}
public static function getNearClipPosition(a:Vector3D, b:Vector3D, nearZ:Number):Vector3D
{
var diffX:Number = a.x - b.x;
var diffY:Number = a.y - b.y;
var diffZ:Number = a.z - b.z;
var tmpZ :Number = nearZ - b.z;
return new Vector3D(
b.x + diffX * tmpZ / diffZ,
b.y + diffY * tmpZ / diffZ,
nearZ);
}
public static function transformPolysToScreen(
polys:Vector.<MyPoly>,
matProj:Matrix3D,
screenWidth:Number,
screenHeight:Number
):Vector.<MyNode>
{
var nodes:Vector.<MyNode> = new Vector.<MyNode>();
for each (var poly:MyPoly in polys)
{
var prim:MyPrim = new MyPrim();
var sumZ:Number = 0;
for each (var v:Vector3D in poly.vertices)
{
var outPos:Point = new Point();
var tmp:Vector3D = matProj.transformVector(v);
tmp.project();
outPos.x = (tmp.x * 0.5 + 0.5) * screenWidth;
outPos.y = (tmp.y * -0.5 + 0.5) * screenHeight;
sumZ += v.z;
prim.vertices.push(outPos);
}
// normal clip
var p0:Point = prim.vertices[0];
var p1:Point = prim.vertices[1];
var p2:Point = prim.vertices[2];
var v1:Point = new Point(p1.x - p0.x, p1.y - p0.y);
var v2:Point = new Point(p2.x - p0.x, p2.y - p0.y);
if (v1.x * v2.y - v1.y * v2.x <= 0)
{
continue;
}
var node:MyNode = new MyNode();
node.type = NodeType.POLYGON;
node.z = sumZ / poly.vertices.length;
node.obj = prim;
nodes.push(node);
}
return nodes;
}
public static function onSortNode(p1:MyNode, p2:MyNode):Number
{
if (p1.z > p2.z) { return -1; }
else if (p1.z < p2.z) { return 1; }
else { return 0; }
}
} // MyUtil