TRICHORD blog

Papervision3D 2.0 で鏡のような表示をしてみたくて、がんばってみました。

(クリックすると表示されます)

【使ったツール】
・Papervision3D 2.0 GreatWhite

【参考にしたページ】
・PV3D 2.0: How to do simple realtime shadows

【ソース】

package {

	import flash.display.Bitmap;

	import flash.display.BitmapData;

	import flash.display.StageAlign;

	import flash.display.StageQuality;

	import flash.display.StageScaleMode;

	import flash.events.Event;

	import flash.geom.Matrix;

	

	import org.papervision3d.cameras.Camera3D;

	import org.papervision3d.materials.BitmapViewportMaterial;

	import org.papervision3d.materials.ColorMaterial;

	import org.papervision3d.materials.WireframeMaterial;

	import org.papervision3d.materials.special.CompositeMaterial;

	import org.papervision3d.materials.utils.MaterialsList;

	import org.papervision3d.objects.primitives.Cube;

	import org.papervision3d.objects.primitives.Plane;

	import org.papervision3d.view.BasicView;

	import org.papervision3d.view.BitmapViewport3D;

	

	[SWF(backgroundColor='0xFFFFFF', frameRate='30', width=640, height=480)]

	public class MirrorTest extends BasicView {

		public var camera_mirror:Camera3D		

		

		public var viewport_mirror:BitmapViewport3D

		

		private var background:Bitmap


		private var cube1:Cube

		private var cube2:Cube

		private var cube3:Cube

		private var cube4:Cube

		private var theta:Number = 0

		

		public function MirrorTest() {

			stage.quality = StageQuality.LOW

			stage.align = StageAlign.TOP_LEFT

			stage.scaleMode = StageScaleMode.NO_SCALE			

			

			init3D()

			sceneSetup()

			

			startRendering()

		}

		protected override function onRenderTick(event:Event = null):void

		{

			loop()

			renderer.renderScene(scene, _camera, viewport)

		}

		

		public function init3D():void {

			camera_mirror = new Camera3D()

			viewport_mirror = new BitmapViewport3D(640, 480)

			background = new Bitmap(new BitmapData(640, 480, false, 0x000080))

			addChild(background)

			addChild(viewport)

		}

		

		

		public function sceneSetup():void {

			var material:CompositeMaterial

			

			material = new CompositeMaterial()

			material.addMaterial(new WireframeMaterial(0x808080))

			material.addMaterial(new ColorMaterial(0xff0000))

			cube1 = new Cube( new MaterialsList({all:material}), 200, 200, 200)

			cube1.x = 300

			scene.addChild(cube1)

			

			material = new CompositeMaterial()

			material.addMaterial(new WireframeMaterial(0x808080))

			material.addMaterial(new ColorMaterial(0x00ff00))

			cube2 = new Cube( new MaterialsList({all:material}), 200, 200, 200)

			cube2.y = 300

			scene.addChild(cube2)

			

			material = new CompositeMaterial()

			material.addMaterial(new WireframeMaterial(0x808080))

			material.addMaterial(new ColorMaterial(0x0000ff))

			cube3 = new Cube( new MaterialsList({all:material}), 200, 200, 200)

			cube3.y = -300

			scene.addChild(cube3)

			

			material = new CompositeMaterial()

			material.addMaterial(new WireframeMaterial(0x808080))

			material.addMaterial(new ColorMaterial(0xc0c0c0))

			cube4 = new Cube( new MaterialsList({all:material}), 200, 200, 200)

			cube4.x = -300

			scene.addChild(cube4)

			

			var floor:Plane = new Plane(new ColorMaterial(0xffffff, 0.5), 2000, 2000,10,10)

			scene.addChild(floor)

		}

		private function loop():void {

			camera.x += ((mouseX - stage.stageWidth / 2) * 5 - camera.x ) / 3

			camera.y += ((mouseY - stage.stageHeight / 2) * 5 - camera.y) / 3

			camera.z += ( ( (-mouseY) * 2 - 500 ) - camera.z ) /3

			

			camera_mirror.x = camera.x

			camera_mirror.y = camera.y

			camera_mirror.z = -camera.z

			

			cube1.z = - (1 + Math.sin(theta + Math.PI * 0 / 4)) * 100 - 110

			cube2.z = - (1 + Math.sin(theta + Math.PI * 1 / 4)) * 100 - 110

			cube3.z = - (1 + Math.sin(theta + Math.PI * 2 / 4)) * 100 - 110

			cube4.z = - (1 + Math.sin(theta + Math.PI * 3 / 4)) * 100 - 110

			theta += Math.PI / 10

			

			// render mirror

			renderer.renderScene(scene, camera_mirror, viewport_mirror)

			// render background

			var b:BitmapData = new BitmapViewportMaterial(viewport_mirror).bitmap

			var b2:BitmapData = new BitmapData(b.width, b.height)

			var m1:Matrix = new Matrix()

			m1.scale(-1, 1) // reverse

			m1.translate(b.width, 0)

			b2.draw(b, m1)

			background.bitmapData.draw(b2)

		}

	}

}