1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

package com.everydayflash.pv3d {
	
   import flash.display.Bitmap;
   import flash.display.BitmapData;
   import flash.display.Sprite;
   import flash.geom.Point;
   import org.papervision3d.cameras.Camera3D;
   import org.papervision3d.core.geom.renderables.Vertex3D;
   import org.papervision3d.core.proto.MaterialObject3D;
   import org.papervision3d.materials.BitmapFileMaterial;
   import org.papervision3d.materials.ColorMaterial;
   import org.papervision3d.materials.WireframeMaterial;
   import org.papervision3d.objects.primitives.Plane;
   import org.papervision3d.render.BasicRenderEngine;
   import org.papervision3d.scenes.Scene3D;
   import org.papervision3d.view.Viewport3D;
   import flash.events.Event;
   import flash.events.MouseEvent;
   import flash.system.fscommand;
   
   import flash.display.StageScaleMode;
   import flash.display.StageQuality;
   import flash.display.StageAlign;
   import flash.display.BitmapDataChannel;

   public class PerlinCarpet extends Sprite {
	   
        private var viewport:Viewport3D;
        private var scene:Scene3D;
        private var camera:Camera3D;
        private var renderer:BasicRenderEngine;
		
		private var plane:Plane;
		private var angle:Number = 0;
		private var offset:Number = .5;
		
		private var perlin:BitmapData;
		private var seed:int = 8790;
		private var move:Number = 0;
		private var speed:Number = 30;
		
		private var size:int = 21;
		
		private var mats:Array;
		private var matPointer:int = 0;

        public function PerlinCarpet() {
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.quality = StageQuality.LOW;
			stage.align = StageAlign.TOP_LEFT;
			
			mats = new Array();
			mats.push(new BitmapFileMaterial("../assets/sea.jpg"));
			mats.push(new WireframeMaterial(0x0000dd));
			
            initPapervision3D();
			buildPlane();
			buildPerlin();
			
			addEventListener(Event.ENTER_FRAME, render);
			stage.addEventListener(MouseEvent.CLICK, swapMaterial);
        }
		
		private function swapMaterial(me:MouseEvent=null):void {
			plane.material = mats[matPointer];
			matPointer++;
			if (matPointer == mats.length) matPointer = 0;
		}
		
		private function buildPerlin():void {
			perlin = new BitmapData(size, size, false);
			perlinize();
		}

        private function initPapervision3D():void{
            viewport = new Viewport3D(stage.stageWidth, stage.stageHeight);
            addChild(viewport);
            scene = new Scene3D();
            camera = new Camera3D();
			camera.zoom = 16;
            renderer = new BasicRenderEngine();
		}
		
		private function buildPlane():void {
			plane = new Plane(null, 300, 300, size - 1, size - 1);
			swapMaterial();
			plane.z = 0;
			plane.rotationX = -60;
			plane.rotationY = -30;
			plane.y += 50;
			scene.addChild(plane);
		}

		private function perlinize(e:Event = null):void {
			var p:Point = new Point(move, 0);
			perlin.perlinNoise(size, size, 3, seed, false, true, BitmapDataChannel.RED, true, [p,p,p]);
			move += size/speed;
		}
		
		private function render(e:Event):void {
			perlinize();
			
			var vs:Array = plane.geometry.vertices;
			var vc:int = vs.length;

			for (var i:int = 0; i < vc; i++) {
				var px:int = i % size;
				var py:int = i / size;
				var v:Vertex3D = vs[i] as Vertex3D;
				var vzpos:Number = perlin.getPixel(px, py) & 0xff;
				v.z = (128 - vzpos) * (mouseX / stage.stageWidth);
			}

            renderer.renderScene(scene, camera, viewport);
        }
   }
}