Mine

d,package {
	
	import org.papervision3d.core.*;
	import org.papervision3d.core.proto.*;
	import org.papervision3d.core.geom.*;
	import org.papervision3d.objects.*;
	import org.papervision3d.objects.primitives.*;
	import org.papervision3d.materials.utils.*;	
	import org.papervision3d.materials.*;	
	//import org.papervision3d.core.geom.renderables.Triangle3D;
	//import org.papervision3d.core.geom.renderables.Vertex3D;
	//import org.papervision3d.core.math.NumberUV;
	
	import LevelMap;
	
	public class LevelGeometry extends DisplayObject3D {
		
		var height:uint=200;//aka yScale
		var xScale:uint=200;
		var zScale:uint=200;
		
		private var segments:uint=5;
		
		private var xWalls=new Array(new Array());
		private var zWalls=new Array(new Array());
		private var cells = new Array(new Array());
		
		public function LevelGeometry(ld:LevelMap, initObject:Object = null) {
			super(null,null,initObject);
			
			this.materials=new MaterialsList( {
				pinkwall:   new WireframeMaterial(0xff00ff, 1),
				all:    new WireframeMaterial(0xff0000, 1),
				greenwall:  new WireframeMaterial(0x00ff00, 1),
				yellowwall: new ColorMaterial(0xffff00),
				brownwall:  new WireframeMaterial(0x660000, 1),
				bluewall:   new WireframeMaterial(0x0000ff, 1)
			});
			
			//var upNormal;
			//var downNormal;
			//var leftNormal;
			//var rightNormal;
			
			var height:Number=300;
			var xScale:Number=300;
			var zScale:Number=300;
			
			var iy:uint,ix:uint;
			
			xWalls=new Array();
			for(iy=0;iy<=ld.ySize;iy++) {
				xWalls[iy]=new Array();
				for(ix=0;ix<ld.xSize;ix++) {
					xWalls[iy][ix]=null;
				}
			}
			
			zWalls=new Array();
			for(iy=0;iy<ld.ySize;iy++) {
				zWalls[iy]=new Array();
				for(ix=0;ix<=ld.xSize;ix++) {
					zWalls[iy][ix]=null;
				}
			}
			
			cells=new Array();
			for(iy=0;iy<ld.ySize;iy++) {
				cells[iy]=new Array();
				for(ix=0;ix<ld.xSize;ix++) {
					cells[iy][ix]=new DisplayCell();
				}
			}
			
			updateWalls(ld);
			
		}
		
		private function updateWalls(ld:LevelMap) {
			
			var ix:uint, iy:uint;
			var pl:Plane;
						
			//warning, these loops WILL access outside of the normal data range
			for(iy=1;iy<ld.ySize-1;iy++) {
				var iy1=iy+1;
				for(ix=1;ix<ld.xSize-1;ix++) {
					var ix1=ix+1;
					
					var top:uint=ld[iy][ix-1];
					var bottom:uint=ld[iy][ix1];
					var left:uint=ld[iy-1][ix];
					var right:uint=ld[iy1][ix];
					var here:uint=ld[iy][ix];
					var needWall:Boolean;
					
					if((here & LevelMap.LOWER)==LevelMap.LOWER) {
					
						needWall=(top & LevelMap.LOWER)!=LevelMap.LOWER;
						if(xWalls[iy1][ix]!=null && !needWall) {
							removeChild(xWalls[iy1][ix]);
							xWalls[iy1][ix]=null;
						} else if(xWalls[iy1][ix]==null && needWall) {
							xWalls[iy1][ix]=pl=new Plane(
								getWallMat(here,top),
								xScale, height,
								segments, segments,
								{
									x: ix*xScale,
									y: 0,
									z: iy1*zScale,
									rotationX: 0,
									rotationY: 0,
									rotationZ: 0
								}
							);
							addChild(pl);
						} else if(cells[iy1][ix].selected) {}
					
						needWall=(bottom & LevelMap.LOWER)!=LevelMap.LOWER;
						if(xWalls[iy][ix]!=null && !needWall) {
							removeChild(xWalls[iy][ix]);
							xWalls[iy][ix]=null;
						} else if(xWalls[iy][ix]==null && needWall) {
							xWalls[iy][ix]=pl=new Plane(
								getWallMat(here,bottom,true),//hack to get differnt texture for debuging
								xScale, height,
								segments, segments,
								{
									x: (ix-1)*xScale,
									y: 0,
									z: iy*zScale,
									rotationX: 0,
									rotationY: 180,
									rotationZ: 0
								}
							);
							addChild(pl);
						} else if(cells[iy1][ix].selected) {}

					}
					/*if((bottom & LevelData.lower)!=(here & LevelData.lower)) {
						generatewall("back",u,v,LevelData.wallTypes[bottom & LevelData.wallTypesMask]);
					}
						
					if((left & LevelData.lower)!=(here & LevelData.lower)) {
						generatewall("left",u,v,LevelData.wallTypes[left & LevelData.wallTypesMask]);
					}
						
					if((right & LevelData.lower)!=(here & LevelData.lower)) {
						generatewall("right",u,v,LevelData.wallTypes[right & LevelData.wallTypesMask]);
					}
					
					//TODO: add top wall
					
					trace("floor");
					
					buildPlane(
						materials.getMaterialByName("greenwall"),
						"x","z",
						xScale,zScale,
						((here & LevelData.lower)==LevelData.lower) ? 0 : height,
						false,
						(u-1)*xScale,0,0
					);
					*/
					
				}//end for
			}//end for
			
			
					
			//mergeVertices();
	
			//this.geometry.ready = true;
			
		} // end of constructor
		
		private function getWallMat(here:uint,there:uint,selected:Boolean=false):MaterialObject3D {
			
			switch(selected) {
				
				case false:			
					switch(here) {
						case LevelMap.OPEN:
						case LevelMap.WATER:
						case LevelMap.LAVA:
							switch(there) {
								case LevelMap.ROCK:
									return materials.getMaterialByName("brownwall");
								break;
						
								case LevelMap.DIRT:
									return materials.getMaterialByName("greenwall");
								break;
								
								case LevelMap.GOLD:
									return materials.getMaterialByName("yellowwall");
								break;
								
								case LevelMap.GEMS:
									return materials.getMaterialByName("pinkwall");
								break;
								
								default:
									return materials.getMaterialByName("redwall");
								break;
							}
						break;
					}
				break;
				
				case true:
					switch(there) {
						case LevelMap.GOLD:
							return materials.getMaterialByName("yellowwall");
						break;
						
						case LevelMap.DIRT:
							return materials.getMaterialByName("bluewall");
						break;
					}
				break;
			}
			return null;
		}
		
	}//end of class
	
}//end of package