PS2 Firework (Particles and Motion blur)

add to favorites

notice: Flash editor updated! Join the development! Thanks to MiniBuilder

forked : 47
favorite : 215
lines : 310
license : MIT License
modified : 2009/01/21 13:00:29

embed

package {
	import flash.display.*;
	import flash.events.*;
	import flash.filters.*;
	import flash.geom.*;
	import flash.text.*;
	import flash.utils.*;

[SWF(width="465", height="465", frameRate="40")]
	public class Firework extends Sprite
	{
		// 火花
		private var position:Vector.<Number> = new Vector.<Number>();
		private var velocity:Vector.<Number> = new Vector.<Number>();
		private var diameters:Vector.<Number> = new Vector.<Number>();
		private var sparkNumber:Number = 0;
		
		private var projectedPosition:Vector.<Number> = new Vector.<Number>();
		private var uvts:Vector.<Number> = new Vector.<Number>();
		
		private var sparkBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>();
		private var sparkBitmapDataRectangles:Vector.<Rectangle> = new Vector.<Rectangle>();
		private const SPARK_COLOR:uint = 0x664020;
		
		private const GRAVITY:Number = 0.02;
		private const AIR_RESISTANCE:Number = 0.999;
		
		// 1フレームに放出する火花の数
		private const EMIT_SPARK_NUMBER:int = 3;
		
		// 照り返し
		private var reflectionBitmapData:BitmapData;
		private const REFLECTION_COLOR:uint = 0xFF1800;
		private const REFLECTION_RADIUS:Number = 16;
		
		// フレームバッファ
		private var displayBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
		private var splitBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
		private const NUMBER_OF_SPLIT_FRAME:int = 10;
		
		private var perspective:PerspectiveProjection = new PerspectiveProjection();
		private var projectionMatrix:Matrix3D = new Matrix3D();
		
		private var viewRotationY:Number = 0;
		private var viewRotationX:Number = 25;
		
		private const CENTER_X:Number = stage.stageWidth / 2;
		private const CENTER_Y:Number = stage.stageHeight * 0.65;
		
		private var stats:TextField = new TextField();
		
		public function Firework()
		{
			addChild(new Bitmap(displayBuffer));

stats.x = 5;
			stats.y = 5;
			stats.autoSize = TextFieldAutoSize.LEFT;
			stats.textColor = 0xFFFFFF;
			addChild(stats);
			
			var shape:Shape = new Shape();
			var g:Graphics = shape.graphics;
			
			// 火花のプリレンダリング
			var bitmapData:BitmapData = new BitmapData(1, 1, true, SPARK_COLOR);
			sparkBitmapDatas.push(bitmapData);
			sparkBitmapDataRectangles.push(bitmapData.rect);
			
			for (var diameter:int = 1; diameter <= 32; diameter++) {
				bitmapData = new BitmapData(diameter, diameter, true, 0);
				
				g.clear();
				g.beginFill(SPARK_COLOR);
				var radius:Number = diameter / 2;
				g.drawCircle(radius, radius, radius);
				g.endFill();
				bitmapData.draw(shape);
				
				sparkBitmapDatas.push(bitmapData);
				sparkBitmapDataRectangles.push(bitmapData.rect);
				// bitmapData.rectはアクセサで重いのでキャッシュしておく。これにより30%ほど高速化
			}
			
			// 照り返しのプリレンダリング
			reflectionBitmapData = new BitmapData(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, true, 0);
			g.clear();
			var matrix:Matrix = new Matrix();
			matrix.createGradientBox(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, 0, 0, 0);
			g.beginGradientFill(GradientType.RADIAL, [ REFLECTION_COLOR, REFLECTION_COLOR ], [ 1, 0 ], [ 0, 255 ], matrix);
			g.drawCircle(REFLECTION_RADIUS, REFLECTION_RADIUS, REFLECTION_RADIUS);
			g.endFill();
			reflectionBitmapData.draw(shape);
			
			createFireworkModel();
			
			addEventListener(Event.ENTER_FRAME, enterFrameHandler);
//			stage.addEventListener(MouseEvent.CLICK, function (e:Event):void {
//				emitSpark();
//			});
		}
		
		private function enterFrameHandler(e:Event):void
		{
			displayBuffer.fillRect(displayBuffer.rect, 0);
			
			setupProjectionMatrix();
			
			var startTime:uint = getTimer();
			renderFloor();
			var floorRenderingTime:uint = getTimer() - startTime;
			
			startTime = getTimer();
			for (var i:int = 0; i < NUMBER_OF_SPLIT_FRAME; i++) {
				const FACTOR:Number = 0.06;
				viewRotationY += (getTimer() * 0.01 + (-(CENTER_X - mouseX) * 0.4) - viewRotationY) * FACTOR;
				viewRotationX += ((27 + (CENTER_Y - mouseY) * 0.15) - viewRotationX) * FACTOR;
				
				setupProjectionMatrix();
				
				for (var j:int = 0; j < EMIT_SPARK_NUMBER; j++) {
					emitSpark();
				}
				updateSparks();
				renderSparks();
			}
			var sparksRenderingTime:uint = getTimer() - startTime;
			
			stats.text = 
				"Number of Sparks : " + sparkNumber + "\n" + 
				"Floor Rendering Time : " + floorRenderingTime + " ms\n" + 
				"Sparks Rendering Time : " + sparksRenderingTime + " ms \n";
		}
		
		private function setupProjectionMatrix():void
		{
			perspective.fieldOfView = 60;
			
			projectionMatrix.identity();
			projectionMatrix.appendRotation(viewRotationY, Vector3D.Y_AXIS);
			projectionMatrix.appendRotation(viewRotationX, Vector3D.X_AXIS);
			projectionMatrix.appendTranslation(0, 0, perspective.focalLength);
			projectionMatrix.append(perspective.toMatrix3D());
			
			correctMatrix3DMultiplyBug(projectionMatrix);
		}
		
		private function correctMatrix3DMultiplyBug(matrix:Matrix3D):void
		{
			// see http://bugs.adobe.com/jira/browse/FP-670
			var m1:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 1, 0 ]));
			var m2:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 1,  0, 0, 0, 0 ]));
			m1.append(m2);
			if (m1.rawData[15] == 20) {
				// バグ持ち！
				var rawData:Vector.<Number> = matrix.rawData;
				rawData[15] /= 20;
				matrix.rawData = rawData;
			}
		}
		
		private function createSpark(x:Number, y:Number, z:Number, vx:Number, vy:Number, vz:Number, diameter:Number):void
		{
			position.push(x, y, z);
			velocity.push(vx, vy, vz);
			diameters.push(diameter);
			sparkNumber++;
		}
		
		private function emitSpark():void
		{
			var azimuth:Number = Math.random() * 2 * Math.PI;
			var vy:Number = -(Math.random() * 0.06 + 0.94);
			var vx:Number = Math.sqrt(1 - vy * vy) * Math.cos(azimuth);
			var vz:Number = Math.sqrt(1 - vy * vy) * Math.sin(azimuth);
			
			var speed:Number = Math.random() * 2.3 + 0.7;
			vx *= speed;
			vy *= speed;
			vz *= speed;
			
			var diameter:Number = 3 + Math.random() * 3;
			createSpark(0, -FIREWORK_HEIGHT, 0, vx, vy, vz, diameter);
		}
		
		private function updateSparks():void
		{
			for (var i:int = 0; i < sparkNumber; ) {
				var xIndex:int = i * 3;
				var yIndex:int = xIndex + 1;
				var zIndex:int = xIndex + 2;
				
				velocity[yIndex] += GRAVITY;
				
				velocity[xIndex] *= AIR_RESISTANCE;
				velocity[yIndex] *= AIR_RESISTANCE;
				velocity[zIndex] *= AIR_RESISTANCE;
				
				if (position[yIndex] + velocity[yIndex] > 0) {
					velocity[yIndex] = -velocity[yIndex] * 0.2;
					
					position[xIndex] += velocity[xIndex];
					position[yIndex] += velocity[yIndex];
					position[zIndex] += velocity[zIndex];
					
					// 小さい火花に分割
					const DIAMETER_MIN:Number = 2;
					if (diameters[i] > DIAMETER_MIN) {
						var diameterLimit:Number = diameters[i];
						
						while (1) {
							var diameter:Number = Math.random() * (4 - DIAMETER_MIN) + DIAMETER_MIN;
							diameterLimit -= diameter;
							if (diameterLimit < 0) {
								break;
							}
							var azimuth:Number = Math.random() * 2 * Math.PI;
							var r:Number = Math.random() * 2;
							
							createSpark(position[xIndex], position[yIndex], position[zIndex], 
								(velocity[xIndex] + Math.cos(azimuth) * r) * 0.5, 
								velocity[yIndex], 
								(velocity[zIndex] + Math.sin(azimuth) * r) * 0.5, 
								diameter);
						}
					}
					
					// spliceは重い！
//					position.splice(xIndex, 3);
//					velocity.splice(xIndex, 3); 
//					diameters.splice(i, 1);

position[xIndex] = position[sparkNumber * 3 - 3];
					position[yIndex] = position[sparkNumber * 3 - 2];
					position[zIndex] = position[sparkNumber * 3 - 1];

velocity[xIndex] = velocity[sparkNumber * 3 - 3];
					velocity[yIndex] = velocity[sparkNumber * 3 - 2];
					velocity[zIndex] = velocity[sparkNumber * 3 - 1];
					
					diameters[i] = diameters[sparkNumber - 1];
					
					position.pop();
					position.pop();
					position.pop();

velocity.pop();
					velocity.pop();
					velocity.pop();
					
					diameters.pop();
					
					sparkNumber--;
					continue;
				}
				position[xIndex] += velocity[xIndex];
				position[yIndex] += velocity[yIndex];
				position[zIndex] += velocity[zIndex];
				
				i++;
			}
		}
		
		private function renderSparks():void
		{
			splitBuffer.fillRect(splitBuffer.rect, 0x000000);
			
			Utils3D.projectVectors(projectionMatrix, position, projectedPosition, uvts);
			
			// ループ外に追い出したら30%以上高速化
			var p:Point = new Point();
			var focalLength:Number = perspective.focalLength;
			
			for (var i:int = 0; i < sparkNumber; i++) {
				// パーティクルの大きさ = 1/z * focalLength * pixel
				var diameter:int = uvts[i * 3 + 2] * focalLength * diameters[i] + 0.5;
				// (i * 2) => (i << 1)で10%ほど高速化
				p.x = CENTER_X + projectedPosition[(i << 1)    ] - diameter / 2;
				p.y = CENTER_Y + projectedPosition[(i << 1) + 1] - diameter / 2;
				splitBuffer.copyPixels(sparkBitmapDatas[diameter], sparkBitmapDataRectangles[diameter], p);
			}
			
			displayBuffer.draw(splitBuffer, null, null, BlendMode.ADD);
		}
		
		private const FLOOR_SIZE:Number = 300;
		private const FLOOR_HALFSIZE:Number = FLOOR_SIZE / 2;
		private const FLOOR_VERTICES:Vector.<Number> = Vector.<Number>([
			 FLOOR_HALFSIZE, 0,  FLOOR_HALFSIZE, 
			-FLOOR_HALFSIZE, 0,  FLOOR_HALFSIZE, 
			-FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE, 
			 FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE, 
			 
			 FLOOR_HALFSIZE, 0,               0, 
			-FLOOR_HALFSIZE, 0,               0, 
			              0, 0,  FLOOR_HALFSIZE, 
			              0, 0, -FLOOR_HALFSIZE, 
		]);
		private const FLOOR_VERTEX_NUMBER:int = FLOOR_VERTICES.length / 3;
		
		private var floorProjectedVertices:Vector.<Number> = new Vector.<Number>();
		private var floorIndices:Vector.<int> = Vector.<int>([
			0, 1, 2,  2, 3, 0
		]);
		private var floorUvts:Vector.<Number> = Vector.<Number>([
			1, 0, 0,  0, 0, 0,  0, 1, 0,  1, 1, 0,  
			0, 0, 0,  0, 0, 0,  0, 0, 0,  0, 0, 0
		]);
		
		private const TEXTURE_SIZE:int = 150;
		private var floorTexture:BitmapData = new BitmapData(TEXTURE_SIZE, TEXTURE_SIZE, false);
		
		private const WIREFRAME_COLOR:uint = 0x555566;
		
		private var sprite:Sprite = new Sprite();
		
		private function renderFloor():void
		{
			// 照り返しを描画する閾値
			const THRESHOLD_Y:Number = 50;
			
			var matrix:Matrix = new Matrix();
			var colorTransform:ColorTransform = new ColorTransform();
			
			floorTexture.fillRect(floorTexture.rect, 0x180C00);
			
			for (var i:int = 0; i < sparkNumber; i++) {
				var yIndex:int = i * 3 + 1;
				
				if (position[yIndex] > -THRESHOLD_Y) {
					var xIndex:int = i * 3;
					var zIndex:int = i * 3 + 2;
					
					matrix.identity();
					var scale:Number = (0.2 - (position[yIndex] / THRESHOLD_Y) * 0.8) * diameters[i];
					matrix.scale(scale, scale);
					matrix.translate(FLOOR_HALFSIZE + position[xIndex] - REFLECTION_RADIUS * scale, FLOOR_HALFSIZE - position[zIndex] - REFLECTION_RADIUS * scale);
					matrix.scale(TEXTURE_SIZE / FLOOR_SIZE, TEXTURE_SIZE / FLOOR_SIZE);
					
					colorTransform.alphaMultiplier = 1 + position[yIndex] / THRESHOLD_Y;
					floorTexture.draw(reflectionBitmapData, matrix, colorTransform, BlendMode.ADD);
				}
			}
			
			Utils3D.projectVectors(projectionMatrix, FLOOR_VERTICES, floorProjectedVertices, floorUvts);
			for (i = 0; i < FLOOR_VERTEX_NUMBER; i++) {
				floorProjectedVertices[(i << 1)    ] += CENTER_X;
				floorProjectedVertices[(i << 1) + 1] += CENTER_Y;
			}
			
			Utils3D.projectVectors(projectionMatrix, fireworkVertices, fireworkProjectedVertices, fireworkUvts);
			for (i = 0; i < fireworkProjectedVertices.length / 2; i++) {
				fireworkProjectedVertices[(i << 1)    ] += CENTER_X;
				fireworkProjectedVertices[(i << 1) + 1] += CENTER_Y;
			}
			
			var g:Graphics = sprite.graphics;
			g.clear();
			g.beginBitmapFill(floorTexture);
			g.drawTriangles(floorProjectedVertices, floorIndices, floorUvts);
			g.endFill();
			displayBuffer.draw(sprite);
			
			g.clear();
			g.lineStyle(1, WIREFRAME_COLOR);
			g.moveTo(floorProjectedVertices[0], floorProjectedVertices[1]);
			g.lineTo(floorProjectedVertices[2], floorProjectedVertices[3]);
			g.lineTo(floorProjectedVertices[4], floorProjectedVertices[5]);
			g.lineTo(floorProjectedVertices[6], floorProjectedVertices[7]);
			g.lineTo(floorProjectedVertices[0], floorProjectedVertices[1]);
			
			g.moveTo(floorProjectedVertices[8], floorProjectedVertices[9]);
			g.lineTo(floorProjectedVertices[10], floorProjectedVertices[11]);
			g.moveTo(floorProjectedVertices[12], floorProjectedVertices[13]);
			g.lineTo(floorProjectedVertices[14], floorProjectedVertices[15]);
			displayBuffer.draw(sprite, null, null, BlendMode.ADD);
			
			g.clear();
			g.beginFill(FIREWORK_COLOR);
			g.drawTriangles(fireworkProjectedVertices, fireworkIndices);
			g.endFill();
			displayBuffer.draw(sprite);
		}
		
		private const FIREWORK_RADIUS:Number = 8;
		private const FIREWORK_HEIGHT:Number = 40;
		private const FIREWORK_COLOR:uint = 0xAACCFF;
		
		private var fireworkVertices:Vector.<Number> = new Vector.<Number>();
		private var fireworkIndices:Vector.<int> = new Vector.<int>();
		private var fireworkProjectedVertices:Vector.<Number> = new Vector.<Number>();
		private var fireworkUvts:Vector.<Number> = new Vector.<Number>();
		
		private function createFireworkModel():void
		{
			const SEGMENT:int = 8;
			for (var i:int = 0; i < SEGMENT; i++) {
				var x:Number = Math.cos(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
				var z:Number = Math.sin(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
				fireworkVertices.push(x, -FIREWORK_HEIGHT, z);
				fireworkVertices.push(x, 0, z);
				
				var i0:int = (i * 2    ) % (SEGMENT * 2);
				var i1:int = (i * 2 + 1) % (SEGMENT * 2);
				var i2:int = (i * 2 + 2) % (SEGMENT * 2);
				var i3:int = (i * 2 + 3) % (SEGMENT * 2);
				fireworkIndices.push(i2, i0, i1);
				fireworkIndices.push(i1, i3, i2);
			}
		}
	}
}

peixinho

kappanuki

hacker_ddk_rp8z

tmrtks

Donyz

matacat

ashitaka

dacyou

sekiryou

mojojo

sasakawazu

ongaeshi

kenz

self_oriented

mathatelle

lanayade

KoheiTAKAMIYA

FlashFit

Lowmid

sk4

idle_niyak

PROT830

klever

metals_rattrap

lewis

larryzzl_flex

djankey

kazeta

nukerito

hacker_3g2q8uci

bluepix

PESakaTFM

madrius31

yutaka

baado_mixi

kimo0517

umihara

nki2

hacker_iy9stsa6

rthesaint

reptileaz

Adrian

yoshihiko

ross

kidaipu

hirosi25

nupperabo

CLAPTAPS

teageek

partlyhuman

tarot

hacker_7qph49q_

narahater

web_shiino

superspecialmonkeymagic

yasohachi

Redstar

chimanaco

kyurun

AM300

beatspace

Exey

soundkitchen

runouw

twelvetoes

mokehehe

yonatan

octech

asamoan

digitrick

harubou

NaoHachi

arksat

hacker_vxaylgg6

hikipuro

harasho

pecoco

esukei

awef

micmac88

wanson

hacker_nekomaru

webpenta

tan_go238

nki

uly

proto_jp

ms_space

_oppei

hacker_alqfxqhw

paO

Murai

fmtonakai

5ivestar

sharkattack51

mame

noenoe

r1ntap

psyark

RoundRoom

mash

dizgid

Laqu

dealforest

cellfusion

muraken

llcheesell

sadamitsu

tobetchi

katapad

keiso

HaraMakoto

yd_niku

as3study :

3d3d

mastafrog :

particles firework glow physics 3d

rettuce :

3D Particle軽い！

Yogr :

Cool!

froyd :

fx fire

morimato :

firework,3D

lune :

3D パーティクル花火火花 Matrix3D花火きれい！逆さまだとシュール…

you :

3D Particle軽い！

yumgsta :

animation firework particles

mex_ichikawa :

Particles

kitsionchen :

nice

pixelmagic :

particle 3d firework

nilloc :

effects particles 3dwow...

chicism :

Particle

taki1052 :

Particleと物理シミュレーション

esabear :

火花

takaki8 :

3D Matrix3D Vector火花が3Dに飛び散る　マウスによって角度が変わる

h1ro :

パーティクル

scoder :

beautiful!

davev :

sparks

rafabarros :

firework 3d effect blur glow algorithm animation art random motionblur motion

dubfrog :

particles

kojo :

hanabi

tokashiki :

花火 particle

lyokato :

particle

Damien_GIT :

3D étincelles

spongebob :

no 3th classfirework

AtuyL :

Particle 3D motionblur

Kevin_Yin :

particle physics 3D effect

pochy :

Particleすげえ

bkzen :

きれいだなぁ

ki_ki :

パーティクルすごい

flasher_bbb :

パーティクル

hackercrack :

that's amazing!!xD

berian :

particle 3d

toyoshim :

パーティクル

vasari :

wow

zmaxlin :

particles motion blur effect

cjcat2266 :

particlesThis is friggin awesome!

signamo :

Particle 3D light

ysformen :

花火

waneck :

particles 3dparticles 3d

darman :

パーティクル祭 vector

tyoppu :

パーティクル花火

fallen :

fire physics effect

Lorenz82 :

Volcanowow this is great!

GariGariKun :

すごいパーティクル

akiravillage :

hanabi

bioRex21 :

hypnotic(lol)Particles 3DWow, beautiful

jucina :

firework blur particlewonderfull!!

hi_noon :

3D花火 3D

sr_forest :

firework Particle

oshige :

花火だー

fazeaction :

particlesparticles firework

7to3 :

ライブラリなしでここまでできるとは。

milkmidi :

matriax3d ,flash10firework

timothyd :

3D Particle firework light particle physics

sketchbookgames :

fireworkwow, thats neat, very polished effect

hina :

particle

toby :

Particle particle physics 3dPS2デモっぽいパーティクルエフェクト

tkinjo :

particle fireworks

hacker_cd64e6vz :

yaimo :

Particle

valz :

hanabi

orangemittoo :

3d hanabi

mjclab :

particle light

everdibe :

particle 3D physics

fdjr :

light particle random

paq :

76人目！

Kay :

Dragon

oreorenji :

3D particle

hacker_7daxapax :

スゴ

hacker_wfcn49d6 :

fire 3d

demouth :

hacker_d6m54tlb :

3D particle physics

kimucha :

3D physics particle

arfyasu :

花火！ファイアー

vetter :

awesome !

spog :

Feuerwerk

hacker_b4s23qwu :

ファイヤー

tatzuro :

ワンダフルでPS的なパーティクルの実験

peko :

Nice fx

alt :

火花

mas :

wonderfl

szktkhr :

はなび

atsumo :

すごい！！

ton :

お、おお・・！！！

USK :

すご

naggg :

うひょー

seagirl :

すごい

ll_koba_ll :

すげ！！！！　花火3D

minon :

すげー

northprint :

スパーク！！

mnordine :

sparks

clockmaker :

超すごい

nitoyon :

particleスパーク！

keim_at_Si :

3D physicsおぉ美しい．

ish_xxxx :

すげー

zahir :

スパーク

naoto5959 :

fire

nabe :

噴火っぽい

masika :

花火！すごい！

>sort

PS2 Firework (Particles and Motion blur) forked from: PS2 Firework (Particles and Motion blur) [diff(1)]

STR55

// forked from k0rin's PS2 Firework (Particles and Motion blur)
package {
import flash.display.*;
import flash.events.*;
import flash.filters.*;
import flash.geom.*;
import flash.text.*;
import flash.utils.*;
[SWF(width="465", height="465", frameRate="40")]
public class Firework extends Sprite
{
// 火花
private var position:Vector.<Number> = new Vector.<Number>();
private var velocity:Vector.<Number> = new Vector.<Number>();
private var diameters:Vector.<Number> = new Vector.<Number>();
private var sparkNumber:Number = 0;
private var projectedPosition:Vector.<Number> = new Vector.<Number>();
private var uvts:Vector.<Number> = new Vector.<Number>();
private var sparkBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>();
private var sparkBitmapDataRectangles:Vector.<Rectangle> = new Vector.<Rectangle>();
private const SPARK_COLOR:uint = 0x664020;
private const GRAVITY:Number = 0.02;
private const AIR_RESISTANCE:Number = 0.999;
// 1フレームに放出する火花の数
private const EMIT_SPARK_NUMBER:int = 3;
// 照り返し
private var reflectionBitmapData:BitmapData;
private const REFLECTION_COLOR:uint = 0xFF1800;
private const REFLECTION_RADIUS:Number = 16;
// フレームバッファ
private var displayBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private var splitBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private const NUMBER_OF_SPLIT_FRAME:int = 10;
private var perspective:PerspectiveProjection = new PerspectiveProjection();
private var projectionMatrix:Matrix3D = new Matrix3D();
private var viewRotationY:Number = 0;
private var viewRotationX:Number = 25;
private const CENTER_X:Number = stage.stageWidth / 2;
private const CENTER_Y:Number = stage.stageHeight * 0.65;
private var stats:TextField = new TextField();
public function Firework()
{
addChild(new Bitmap(displayBuffer));
stats.x = 5;
stats.y = 5;
stats.autoSize = TextFieldAutoSize.LEFT;
stats.textColor = 0xFFFFFF;
addChild(stats);
var shape:Shape = new Shape();
var g:Graphics = shape.graphics;
// 火花のプリレンダリング
var bitmapData:BitmapData = new BitmapData(1, 1, true, SPARK_COLOR);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
for (var diameter:int = 1; diameter <= 32; diameter++) {
bitmapData = new BitmapData(diameter, diameter, true, 0);
g.clear();
g.beginFill(SPARK_COLOR);
var radius:Number = diameter / 2;
g.drawCircle(radius, radius, radius);
g.endFill();
bitmapData.draw(shape);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
// bitmapData.rectはアクセサで重いのでキャッシュしておく。これにより30%ほど高速化
}
// 照り返しのプリレンダリング
reflectionBitmapData = new BitmapData(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, true, 0);
g.clear();
var matrix:Matrix = new Matrix();
matrix.createGradientBox(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, 0, 0, 0);
g.beginGradientFill(GradientType.RADIAL, [ REFLECTION_COLOR, REFLECTION_COLOR ], [ 1, 0 ], [ 0, 255 ], matrix);
g.drawCircle(REFLECTION_RADIUS, REFLECTION_RADIUS, REFLECTION_RADIUS);
g.endFill();
reflectionBitmapData.draw(shape);
createFireworkModel();
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
// stage.addEventListener(MouseEvent.CLICK, function (e:Event):void {
// emitSpark();
// });
}
private function enterFrameHandler(e:Event):void
{
displayBuffer.fillRect(displayBuffer.rect, 0);
setupProjectionMatrix();
var startTime:uint = getTimer();
renderFloor();
var floorRenderingTime:uint = getTimer() - startTime;
startTime = getTimer();
for (var i:int = 0; i < NUMBER_OF_SPLIT_FRAME; i++) {
const FACTOR:Number = 0.06;
viewRotationY += (getTimer() * 0.01 + (-(CENTER_X - mouseX) * 0.4) - viewRotationY) * FACTOR;
viewRotationX += ((27 + (CENTER_Y - mouseY) * 0.15) - viewRotationX) * FACTOR;
setupProjectionMatrix();
for (var j:int = 0; j < EMIT_SPARK_NUMBER; j++) {
emitSpark();
}
updateSparks();
renderSparks();
}
var sparksRenderingTime:uint = getTimer() - startTime;
stats.text =
"Number of Sparks : " + sparkNumber + "\n" +
"Floor Rendering Time : " + floorRenderingTime + " ms\n" +
"Sparks Rendering Time : " + sparksRenderingTime + " ms \n";
}
private function setupProjectionMatrix():void
{
perspective.fieldOfView = 60;
projectionMatrix.identity();
projectionMatrix.appendRotation(viewRotationY, Vector3D.Y_AXIS);
projectionMatrix.appendRotation(viewRotationX, Vector3D.X_AXIS);
projectionMatrix.appendTranslation(0, 0, perspective.focalLength);
projectionMatrix.append(perspective.toMatrix3D());
correctMatrix3DMultiplyBug(projectionMatrix);
}
private function correctMatrix3DMultiplyBug(matrix:Matrix3D):void
{
// see http://bugs.adobe.com/jira/browse/FP-670
var m1:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]));
var m2:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ]));
m1.append(m2);
if (m1.rawData[15] == 20) {
// バグ持ち！
var rawData:Vector.<Number> = matrix.rawData;
rawData[15] /= 20;
matrix.rawData = rawData;
}
}
private function createSpark(x:Number, y:Number, z:Number, vx:Number, vy:Number, vz:Number, diameter:Number):void
{
position.push(x, y, z);
velocity.push(vx, vy, vz);
diameters.push(diameter);
sparkNumber++;
}
private function emitSpark():void
{
var azimuth:Number = Math.random() * 2 * Math.PI;
var vy:Number = -(Math.random() * 0.06 + 0.94);
var vx:Number = Math.sqrt(1 - vy * vy) * Math.cos(azimuth);
var vz:Number = Math.sqrt(1 - vy * vy) * Math.sin(azimuth);
var speed:Number = Math.random() * 2.3 + 0.7;
vx *= speed;
vy *= speed;
vz *= speed;
var diameter:Number = 3 + Math.random() * 3;
createSpark(0, -FIREWORK_HEIGHT, 0, vx, vy, vz, diameter);
}
private function updateSparks():void
{
for (var i:int = 0; i < sparkNumber; ) {
var xIndex:int = i * 3;
var yIndex:int = xIndex + 1;
var zIndex:int = xIndex + 2;
velocity[yIndex] += GRAVITY;
velocity[xIndex] *= AIR_RESISTANCE;
velocity[yIndex] *= AIR_RESISTANCE;
velocity[zIndex] *= AIR_RESISTANCE;
if (position[yIndex] + velocity[yIndex] > 0) {
velocity[yIndex] = -velocity[yIndex] * 0.2;
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
// 小さい火花に分割
const DIAMETER_MIN:Number = 2;
if (diameters[i] > DIAMETER_MIN) {
var diameterLimit:Number = diameters[i];
while (1) {
var diameter:Number = Math.random() * (4 - DIAMETER_MIN) + DIAMETER_MIN;
diameterLimit -= diameter;
if (diameterLimit < 0) {
break;
}
var azimuth:Number = Math.random() * 2 * Math.PI;
var r:Number = Math.random() * 2;
createSpark(position[xIndex], position[yIndex], position[zIndex],
(velocity[xIndex] + Math.cos(azimuth) * r) * 0.5,
velocity[yIndex],
(velocity[zIndex] + Math.sin(azimuth) * r) * 0.5,
diameter);
}
}
// spliceは重い！
// position.splice(xIndex, 3);
// velocity.splice(xIndex, 3);
// diameters.splice(i, 1);
position[xIndex] = position[sparkNumber * 3 - 3];
position[yIndex] = position[sparkNumber * 3 - 2];
position[zIndex] = position[sparkNumber * 3 - 1];
velocity[xIndex] = velocity[sparkNumber * 3 - 3];
velocity[yIndex] = velocity[sparkNumber * 3 - 2];
velocity[zIndex] = velocity[sparkNumber * 3 - 1];
diameters[i] = diameters[sparkNumber - 1];
position.pop();
position.pop();
position.pop();
velocity.pop();
velocity.pop();
velocity.pop();
diameters.pop();
sparkNumber--;
continue;
}
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
i++;
}
}
private function renderSparks():void
{
splitBuffer.fillRect(splitBuffer.rect, 0x000000);
Utils3D.projectVectors(projectionMatrix, position, projectedPosition, uvts);
// ループ外に追い出したら30%以上高速化
var p:Point = new Point();
var focalLength:Number = perspective.focalLength;
for (var i:int = 0; i < sparkNumber; i++) {
// パーティクルの大きさ = 1/z * focalLength * pixel
var diameter:int = uvts[i * 3 + 2] * focalLength * diameters[i] + 0.5;
// (i * 2) => (i << 1)で10%ほど高速化
p.x = CENTER_X + projectedPosition[(i << 1) ] - diameter / 2;
p.y = CENTER_Y + projectedPosition[(i << 1) + 1] - diameter / 2;
splitBuffer.copyPixels(sparkBitmapDatas[diameter], sparkBitmapDataRectangles[diameter], p);
}
displayBuffer.draw(splitBuffer, null, null, BlendMode.ADD);
}
private const FLOOR_SIZE:Number = 300;
private const FLOOR_HALFSIZE:Number = FLOOR_SIZE / 2;
private const FLOOR_VERTICES:Vector.<Number> = Vector.<Number>([
FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, 0,
-FLOOR_HALFSIZE, 0, 0,
0, 0, FLOOR_HALFSIZE,
0, 0, -FLOOR_HALFSIZE,
]);
private const FLOOR_VERTEX_NUMBER:int = FLOOR_VERTICES.length / 3;
private var floorProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var floorIndices:Vector.<int> = Vector.<int>([
0, 1, 2, 2, 3, 0
]);
private var floorUvts:Vector.<Number> = Vector.<Number>([
1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]);
private const TEXTURE_SIZE:int = 150;
private var floorTexture:BitmapData = new BitmapData(TEXTURE_SIZE, TEXTURE_SIZE, false);
private const WIREFRAME_COLOR:uint = 0x555566;
private var sprite:Sprite = new Sprite();
private function renderFloor():void
{
// 照り返しを描画する閾値
const THRESHOLD_Y:Number = 50;
var matrix:Matrix = new Matrix();
var colorTransform:ColorTransform = new ColorTransform();
floorTexture.fillRect(floorTexture.rect, 0x180C00);
for (var i:int = 0; i < sparkNumber; i++) {
var yIndex:int = i * 3 + 1;
if (position[yIndex] > -THRESHOLD_Y) {
var xIndex:int = i * 3;
var zIndex:int = i * 3 + 2;
matrix.identity();
var scale:Number = (0.2 - (position[yIndex] / THRESHOLD_Y) * 0.8) * diameters[i];
matrix.scale(scale, scale);
matrix.translate(FLOOR_HALFSIZE + position[xIndex] - REFLECTION_RADIUS * scale, FLOOR_HALFSIZE - position[zIndex] - REFLECTION_RADIUS * scale);
matrix.scale(TEXTURE_SIZE / FLOOR_SIZE, TEXTURE_SIZE / FLOOR_SIZE);
colorTransform.alphaMultiplier = 1 + position[yIndex] / THRESHOLD_Y;
floorTexture.draw(reflectionBitmapData, matrix, colorTransform, BlendMode.ADD);
}
}
Utils3D.projectVectors(projectionMatrix, FLOOR_VERTICES, floorProjectedVertices, floorUvts);
for (i = 0; i < FLOOR_VERTEX_NUMBER; i++) {
floorProjectedVertices[(i << 1) ] += CENTER_X;
floorProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
Utils3D.projectVectors(projectionMatrix, fireworkVertices, fireworkProjectedVertices, fireworkUvts);
for (i = 0; i < fireworkProjectedVertices.length / 2; i++) {
fireworkProjectedVertices[(i << 1) ] += CENTER_X;
fireworkProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
var g:Graphics = sprite.graphics;
g.clear();
g.beginBitmapFill(floorTexture);
g.drawTriangles(floorProjectedVertices, floorIndices, floorUvts);
g.endFill();
displayBuffer.draw(sprite);
g.clear();
g.lineStyle(1, WIREFRAME_COLOR);
g.moveTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.lineTo(floorProjectedVertices[2], floorProjectedVertices[3]);
g.lineTo(floorProjectedVertices[4], floorProjectedVertices[5]);
g.lineTo(floorProjectedVertices[6], floorProjectedVertices[7]);
g.lineTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.moveTo(floorProjectedVertices[8], floorProjectedVertices[9]);
g.lineTo(floorProjectedVertices[10], floorProjectedVertices[11]);
g.moveTo(floorProjectedVertices[12], floorProjectedVertices[13]);
g.lineTo(floorProjectedVertices[14], floorProjectedVertices[15]);
displayBuffer.draw(sprite, null, null, BlendMode.ADD);
g.clear();
g.beginFill(FIREWORK_COLOR);
g.drawTriangles(fireworkProjectedVertices, fireworkIndices);
g.endFill();
displayBuffer.draw(sprite);
}
private const FIREWORK_RADIUS:Number = 8;
private const FIREWORK_HEIGHT:Number = 40;
private const FIREWORK_COLOR:uint = 0xAACCFF;
private var fireworkVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkIndices:Vector.<int> = new Vector.<int>();
private var fireworkProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkUvts:Vector.<Number> = new Vector.<Number>();
private function createFireworkModel():void
{
const SEGMENT:int = 8;
for (var i:int = 0; i < SEGMENT; i++) {
var x:Number = Math.cos(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
var z:Number = Math.sin(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
fireworkVertices.push(x, -FIREWORK_HEIGHT, z);
fireworkVertices.push(x, 0, z);
var i0:int = (i * 2 ) % (SEGMENT * 2);
var i1:int = (i * 2 + 1) % (SEGMENT * 2);
var i2:int = (i * 2 + 2) % (SEGMENT * 2);
var i3:int = (i * 2 + 3) % (SEGMENT * 2);
fireworkIndices.push(i2, i0, i1);
fireworkIndices.push(i1, i3, i2);
}
}
}
}

PS2 Firework (Particles and Motion blur) forked from: PS2 Firework (Particles and Motion blur) [diff(1)]

yumgsta

// forked from k0rin's PS2 Firework (Particles and Motion blur)
package {
import flash.display.*;
import flash.events.*;
import flash.filters.*;
import flash.geom.*;
import flash.text.*;
import flash.utils.*;
[SWF(width="465", height="465", frameRate="40")]
public class Firework extends Sprite
{
// 火花
private var position:Vector.<Number> = new Vector.<Number>();
private var velocity:Vector.<Number> = new Vector.<Number>();
private var diameters:Vector.<Number> = new Vector.<Number>();
private var sparkNumber:Number = 0;
private var projectedPosition:Vector.<Number> = new Vector.<Number>();
private var uvts:Vector.<Number> = new Vector.<Number>();
private var sparkBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>();
private var sparkBitmapDataRectangles:Vector.<Rectangle> = new Vector.<Rectangle>();
private const SPARK_COLOR:uint = 0x664020;
private const GRAVITY:Number = 0.02;
private const AIR_RESISTANCE:Number = 0.999;
// 1フレームに放出する火花の数
private const EMIT_SPARK_NUMBER:int = 3;
// 照り返し
private var reflectionBitmapData:BitmapData;
private const REFLECTION_COLOR:uint = 0xFF1800;
private const REFLECTION_RADIUS:Number = 16;
// フレームバッファ
private var displayBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private var splitBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private const NUMBER_OF_SPLIT_FRAME:int = 10;
private var perspective:PerspectiveProjection = new PerspectiveProjection();
private var projectionMatrix:Matrix3D = new Matrix3D();
private var viewRotationY:Number = 0;
private var viewRotationX:Number = 25;
private const CENTER_X:Number = stage.stageWidth / 2;
private const CENTER_Y:Number = stage.stageHeight * 0.65;
private var stats:TextField = new TextField();
public function Firework()
{
addChild(new Bitmap(displayBuffer));
stats.x = 5;
stats.y = 5;
stats.autoSize = TextFieldAutoSize.LEFT;
stats.textColor = 0xFFFFFF;
addChild(stats);
var shape:Shape = new Shape();
var g:Graphics = shape.graphics;
// 火花のプリレンダリング
var bitmapData:BitmapData = new BitmapData(1, 1, true, SPARK_COLOR);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
for (var diameter:int = 1; diameter <= 32; diameter++) {
bitmapData = new BitmapData(diameter, diameter, true, 0);
g.clear();
g.beginFill(SPARK_COLOR);
var radius:Number = diameter / 2;
g.drawCircle(radius, radius, radius);
g.endFill();
bitmapData.draw(shape);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
// bitmapData.rectはアクセサで重いのでキャッシュしておく。これにより30%ほど高速化
}
// 照り返しのプリレンダリング
reflectionBitmapData = new BitmapData(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, true, 0);
g.clear();
var matrix:Matrix = new Matrix();
matrix.createGradientBox(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, 0, 0, 0);
g.beginGradientFill(GradientType.RADIAL, [ REFLECTION_COLOR, REFLECTION_COLOR ], [ 1, 0 ], [ 0, 255 ], matrix);
g.drawCircle(REFLECTION_RADIUS, REFLECTION_RADIUS, REFLECTION_RADIUS);
g.endFill();
reflectionBitmapData.draw(shape);
createFireworkModel();
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
// stage.addEventListener(MouseEvent.CLICK, function (e:Event):void {
// emitSpark();
// });
}
private function enterFrameHandler(e:Event):void
{
displayBuffer.fillRect(displayBuffer.rect, 0);
setupProjectionMatrix();
var startTime:uint = getTimer();
renderFloor();
var floorRenderingTime:uint = getTimer() - startTime;
startTime = getTimer();
for (var i:int = 0; i < NUMBER_OF_SPLIT_FRAME; i++) {
const FACTOR:Number = 0.06;
viewRotationY += (getTimer() * 0.01 + (-(CENTER_X - mouseX) * 0.4) - viewRotationY) * FACTOR;
viewRotationX += ((27 + (CENTER_Y - mouseY) * 0.15) - viewRotationX) * FACTOR;
setupProjectionMatrix();
for (var j:int = 0; j < EMIT_SPARK_NUMBER; j++) {
emitSpark();
}
updateSparks();
renderSparks();
}
var sparksRenderingTime:uint = getTimer() - startTime;
stats.text =
"Number of Sparks : " + sparkNumber + "\n" +
"Floor Rendering Time : " + floorRenderingTime + " ms\n" +
"Sparks Rendering Time : " + sparksRenderingTime + " ms \n";
}
private function setupProjectionMatrix():void
{
perspective.fieldOfView = 60;
projectionMatrix.identity();
projectionMatrix.appendRotation(viewRotationY, Vector3D.Y_AXIS);
projectionMatrix.appendRotation(viewRotationX, Vector3D.X_AXIS);
projectionMatrix.appendTranslation(0, 0, perspective.focalLength);
projectionMatrix.append(perspective.toMatrix3D());
correctMatrix3DMultiplyBug(projectionMatrix);
}
private function correctMatrix3DMultiplyBug(matrix:Matrix3D):void
{
// see http://bugs.adobe.com/jira/browse/FP-670
var m1:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]));
var m2:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ]));
m1.append(m2);
if (m1.rawData[15] == 20) {
// バグ持ち！
var rawData:Vector.<Number> = matrix.rawData;
rawData[15] /= 20;
matrix.rawData = rawData;
}
}
private function createSpark(x:Number, y:Number, z:Number, vx:Number, vy:Number, vz:Number, diameter:Number):void
{
position.push(x, y, z);
velocity.push(vx, vy, vz);
diameters.push(diameter);
sparkNumber++;
}
private function emitSpark():void
{
var azimuth:Number = Math.random() * 2 * Math.PI;
var vy:Number = -(Math.random() * 0.06 + 0.94);
var vx:Number = Math.sqrt(1 - vy * vy) * Math.cos(azimuth);
var vz:Number = Math.sqrt(1 - vy * vy) * Math.sin(azimuth);
var speed:Number = Math.random() * 2.3 + 0.7;
vx *= speed;
vy *= speed;
vz *= speed;
var diameter:Number = 3 + Math.random() * 3;
createSpark(0, -FIREWORK_HEIGHT, 0, vx, vy, vz, diameter);
}
private function updateSparks():void
{
for (var i:int = 0; i < sparkNumber; ) {
var xIndex:int = i * 3;
var yIndex:int = xIndex + 1;
var zIndex:int = xIndex + 2;
velocity[yIndex] += GRAVITY;
velocity[xIndex] *= AIR_RESISTANCE;
velocity[yIndex] *= AIR_RESISTANCE;
velocity[zIndex] *= AIR_RESISTANCE;
if (position[yIndex] + velocity[yIndex] > 0) {
velocity[yIndex] = -velocity[yIndex] * 0.2;
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
// 小さい火花に分割
const DIAMETER_MIN:Number = 2;
if (diameters[i] > DIAMETER_MIN) {
var diameterLimit:Number = diameters[i];
while (1) {
var diameter:Number = Math.random() * (4 - DIAMETER_MIN) + DIAMETER_MIN;
diameterLimit -= diameter;
if (diameterLimit < 0) {
break;
}
var azimuth:Number = Math.random() * 2 * Math.PI;
var r:Number = Math.random() * 2;
createSpark(position[xIndex], position[yIndex], position[zIndex],
(velocity[xIndex] + Math.cos(azimuth) * r) * 0.5,
velocity[yIndex],
(velocity[zIndex] + Math.sin(azimuth) * r) * 0.5,
diameter);
}
}
// spliceは重い！
// position.splice(xIndex, 3);
// velocity.splice(xIndex, 3);
// diameters.splice(i, 1);
position[xIndex] = position[sparkNumber * 3 - 3];
position[yIndex] = position[sparkNumber * 3 - 2];
position[zIndex] = position[sparkNumber * 3 - 1];
velocity[xIndex] = velocity[sparkNumber * 3 - 3];
velocity[yIndex] = velocity[sparkNumber * 3 - 2];
velocity[zIndex] = velocity[sparkNumber * 3 - 1];
diameters[i] = diameters[sparkNumber - 1];
position.pop();
position.pop();
position.pop();
velocity.pop();
velocity.pop();
velocity.pop();
diameters.pop();
sparkNumber--;
continue;
}
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
i++;
}
}
private function renderSparks():void
{
splitBuffer.fillRect(splitBuffer.rect, 0x000000);
Utils3D.projectVectors(projectionMatrix, position, projectedPosition, uvts);
// ループ外に追い出したら30%以上高速化
var p:Point = new Point();
var focalLength:Number = perspective.focalLength;
for (var i:int = 0; i < sparkNumber; i++) {
// パーティクルの大きさ = 1/z * focalLength * pixel
var diameter:int = uvts[i * 3 + 2] * focalLength * diameters[i] + 0.5;
// (i * 2) => (i << 1)で10%ほど高速化
p.x = CENTER_X + projectedPosition[(i << 1) ] - diameter / 2;
p.y = CENTER_Y + projectedPosition[(i << 1) + 1] - diameter / 2;
splitBuffer.copyPixels(sparkBitmapDatas[diameter], sparkBitmapDataRectangles[diameter], p);
}
displayBuffer.draw(splitBuffer, null, null, BlendMode.ADD);
}
private const FLOOR_SIZE:Number = 300;
private const FLOOR_HALFSIZE:Number = FLOOR_SIZE / 2;
private const FLOOR_VERTICES:Vector.<Number> = Vector.<Number>([
FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, 0,
-FLOOR_HALFSIZE, 0, 0,
0, 0, FLOOR_HALFSIZE,
0, 0, -FLOOR_HALFSIZE,
]);
private const FLOOR_VERTEX_NUMBER:int = FLOOR_VERTICES.length / 3;
private var floorProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var floorIndices:Vector.<int> = Vector.<int>([
0, 1, 2, 2, 3, 0
]);
private var floorUvts:Vector.<Number> = Vector.<Number>([
1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]);
private const TEXTURE_SIZE:int = 150;
private var floorTexture:BitmapData = new BitmapData(TEXTURE_SIZE, TEXTURE_SIZE, false);
private const WIREFRAME_COLOR:uint = 0x555566;
private var sprite:Sprite = new Sprite();
private function renderFloor():void
{
// 照り返しを描画する閾値
const THRESHOLD_Y:Number = 50;
var matrix:Matrix = new Matrix();
var colorTransform:ColorTransform = new ColorTransform();
floorTexture.fillRect(floorTexture.rect, 0x180C00);
for (var i:int = 0; i < sparkNumber; i++) {
var yIndex:int = i * 3 + 1;
if (position[yIndex] > -THRESHOLD_Y) {
var xIndex:int = i * 3;
var zIndex:int = i * 3 + 2;
matrix.identity();
var scale:Number = (0.2 - (position[yIndex] / THRESHOLD_Y) * 0.8) * diameters[i];
matrix.scale(scale, scale);
matrix.translate(FLOOR_HALFSIZE + position[xIndex] - REFLECTION_RADIUS * scale, FLOOR_HALFSIZE - position[zIndex] - REFLECTION_RADIUS * scale);
matrix.scale(TEXTURE_SIZE / FLOOR_SIZE, TEXTURE_SIZE / FLOOR_SIZE);
colorTransform.alphaMultiplier = 1 + position[yIndex] / THRESHOLD_Y;
floorTexture.draw(reflectionBitmapData, matrix, colorTransform, BlendMode.ADD);
}
}
Utils3D.projectVectors(projectionMatrix, FLOOR_VERTICES, floorProjectedVertices, floorUvts);
for (i = 0; i < FLOOR_VERTEX_NUMBER; i++) {
floorProjectedVertices[(i << 1) ] += CENTER_X;
floorProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
Utils3D.projectVectors(projectionMatrix, fireworkVertices, fireworkProjectedVertices, fireworkUvts);
for (i = 0; i < fireworkProjectedVertices.length / 2; i++) {
fireworkProjectedVertices[(i << 1) ] += CENTER_X;
fireworkProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
var g:Graphics = sprite.graphics;
g.clear();
g.beginBitmapFill(floorTexture);
g.drawTriangles(floorProjectedVertices, floorIndices, floorUvts);
g.endFill();
displayBuffer.draw(sprite);
g.clear();
g.lineStyle(1, WIREFRAME_COLOR);
g.moveTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.lineTo(floorProjectedVertices[2], floorProjectedVertices[3]);
g.lineTo(floorProjectedVertices[4], floorProjectedVertices[5]);
g.lineTo(floorProjectedVertices[6], floorProjectedVertices[7]);
g.lineTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.moveTo(floorProjectedVertices[8], floorProjectedVertices[9]);
g.lineTo(floorProjectedVertices[10], floorProjectedVertices[11]);
g.moveTo(floorProjectedVertices[12], floorProjectedVertices[13]);
g.lineTo(floorProjectedVertices[14], floorProjectedVertices[15]);
displayBuffer.draw(sprite, null, null, BlendMode.ADD);
g.clear();
g.beginFill(FIREWORK_COLOR);
g.drawTriangles(fireworkProjectedVertices, fireworkIndices);
g.endFill();
displayBuffer.draw(sprite);
}
private const FIREWORK_RADIUS:Number = 8;
private const FIREWORK_HEIGHT:Number = 40;
private const FIREWORK_COLOR:uint = 0xAACCFF;
private var fireworkVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkIndices:Vector.<int> = new Vector.<int>();
private var fireworkProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkUvts:Vector.<Number> = new Vector.<Number>();
private function createFireworkModel():void
{
const SEGMENT:int = 8;
for (var i:int = 0; i < SEGMENT; i++) {
var x:Number = Math.cos(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
var z:Number = Math.sin(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
fireworkVertices.push(x, -FIREWORK_HEIGHT, z);
fireworkVertices.push(x, 0, z);
var i0:int = (i * 2 ) % (SEGMENT * 2);
var i1:int = (i * 2 + 1) % (SEGMENT * 2);
var i2:int = (i * 2 + 2) % (SEGMENT * 2);
var i3:int = (i * 2 + 3) % (SEGMENT * 2);
fireworkIndices.push(i2, i0, i1);
fireworkIndices.push(i1, i3, i2);
}
}
}
}

PS2 Firework (Particles and Motion blur) forked from: PS2 Firework (Particles and Motion blur) [diff(2)]

hacker_fi8ovzz6

// forked from k0rin's PS2 Firework (Particles and Motion blur)
package {
import flash.display.*;
import flash.events.*;
import flash.filters.*;
import flash.geom.*;
import flash.text.*;
import flash.utils.*;
[SWF(width="465", height="465", frameRate="40")]
public class Firework extends Sprite
{
// 火花
private var position:Vector.<Number> = new Vector.<Number>();
private var velocity:Vector.<Number> = new Vector.<Number>();
private var diameters:Vector.<Number> = new Vector.<Number>();
private var sparkNumber:Number = 0;
private var projectedPosition:Vector.<Number> = new Vector.<Number>();
private var uvts:Vector.<Number> = new Vector.<Number>();
private var sparkBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>();
private var sparkBitmapDataRectangles:Vector.<Rectangle> = new Vector.<Rectangle>();
private const SPARK_COLOR:uint = 0x004066;
private const GRAVITY:Number = 0.02;
private const AIR_RESISTANCE:Number = 0.999;
// 1フレームに放出する火花の数
private const EMIT_SPARK_NUMBER:int = 3;
// 照り返し
private var reflectionBitmapData:BitmapData;
private const REFLECTION_COLOR:uint = 0xFF1800;
private const REFLECTION_RADIUS:Number = 16;
// フレームバッファ
private var displayBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private var splitBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private const NUMBER_OF_SPLIT_FRAME:int = 10;
private var perspective:PerspectiveProjection = new PerspectiveProjection();
private var projectionMatrix:Matrix3D = new Matrix3D();
private var viewRotationY:Number = 0;
private var viewRotationX:Number = 25;
private const CENTER_X:Number = stage.stageWidth / 2;
private const CENTER_Y:Number = stage.stageHeight * 0.65;
private var stats:TextField = new TextField();
public function Firework()
{
addChild(new Bitmap(displayBuffer));
stats.x = 5;
stats.y = 5;
stats.autoSize = TextFieldAutoSize.LEFT;
stats.textColor = 0xFFFFFF;
addChild(stats);
var shape:Shape = new Shape();
var g:Graphics = shape.graphics;
// 火花のプリレンダリング
var bitmapData:BitmapData = new BitmapData(1, 1, true, SPARK_COLOR);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
for (var diameter:int = 1; diameter <= 32; diameter++) {
bitmapData = new BitmapData(diameter, diameter, true, 0);
g.clear();
g.beginFill(SPARK_COLOR);
var radius:Number = diameter / 2;
g.drawCircle(radius, radius, radius);
g.endFill();
bitmapData.draw(shape);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
// bitmapData.rectはアクセサで重いのでキャッシュしておく。これにより30%ほど高速化
}
// 照り返しのプリレンダリング
reflectionBitmapData = new BitmapData(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, true, 0);
g.clear();
var matrix:Matrix = new Matrix();
matrix.createGradientBox(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, 0, 0, 0);
g.beginGradientFill(GradientType.RADIAL, [ REFLECTION_COLOR, REFLECTION_COLOR ], [ 1, 0 ], [ 0, 255 ], matrix);
g.drawCircle(REFLECTION_RADIUS, REFLECTION_RADIUS, REFLECTION_RADIUS);
g.endFill();
reflectionBitmapData.draw(shape);
createFireworkModel();
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
// stage.addEventListener(MouseEvent.CLICK, function (e:Event):void {
// emitSpark();
// });
}
private function enterFrameHandler(e:Event):void
{
displayBuffer.fillRect(displayBuffer.rect, 0);
setupProjectionMatrix();
var startTime:uint = getTimer();
renderFloor();
var floorRenderingTime:uint = getTimer() - startTime;
startTime = getTimer();
for (var i:int = 0; i < NUMBER_OF_SPLIT_FRAME; i++) {
const FACTOR:Number = 0.06;
viewRotationY += (getTimer() * 0.01 + (-(CENTER_X - mouseX) * 0.4) - viewRotationY) * FACTOR;
viewRotationX += ((27 + (CENTER_Y - mouseY) * 0.15) - viewRotationX) * FACTOR;
setupProjectionMatrix();
for (var j:int = 0; j < EMIT_SPARK_NUMBER; j++) {
emitSpark();
}
updateSparks();
renderSparks();
}
var sparksRenderingTime:uint = getTimer() - startTime;
stats.text =
"Number of Sparks : " + sparkNumber + "\n" +
"Floor Rendering Time : " + floorRenderingTime + " ms\n" +
"Sparks Rendering Time : " + sparksRenderingTime + " ms \n";
}
private function setupProjectionMatrix():void
{
perspective.fieldOfView = 60;
projectionMatrix.identity();
projectionMatrix.appendRotation(viewRotationY, Vector3D.Y_AXIS);
projectionMatrix.appendRotation(viewRotationX, Vector3D.X_AXIS);
projectionMatrix.appendTranslation(0, 0, perspective.focalLength);
projectionMatrix.append(perspective.toMatrix3D());
correctMatrix3DMultiplyBug(projectionMatrix);
}
private function correctMatrix3DMultiplyBug(matrix:Matrix3D):void
{
// see http://bugs.adobe.com/jira/browse/FP-670
var m1:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]));
var m2:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ]));
m1.append(m2);
if (m1.rawData[15] == 20) {
// バグ持ち！
var rawData:Vector.<Number> = matrix.rawData;
rawData[15] /= 20;
matrix.rawData = rawData;
}
}
private function createSpark(x:Number, y:Number, z:Number, vx:Number, vy:Number, vz:Number, diameter:Number):void
{
position.push(x, y, z);
velocity.push(vx, vy, vz);
diameters.push(diameter);
sparkNumber++;
}
private function emitSpark():void
{
var azimuth:Number = Math.random() * 2 * Math.PI;
var vy:Number = -(Math.random() * 0.06 + 0.94);
var vx:Number = Math.sqrt(1 - vy * vy) * Math.cos(azimuth);
var vz:Number = Math.sqrt(1 - vy * vy) * Math.sin(azimuth);
var speed:Number = Math.random() * 2.3 + 0.7;
vx *= speed;
vy *= speed;
vz *= speed;
var diameter:Number = 3 + Math.random() * 3;
createSpark(0, -FIREWORK_HEIGHT, 0, vx, vy, vz, diameter);
}
private function updateSparks():void
{
for (var i:int = 0; i < sparkNumber; ) {
var xIndex:int = i * 3;
var yIndex:int = xIndex + 1;
var zIndex:int = xIndex + 2;
velocity[yIndex] += GRAVITY;
velocity[xIndex] *= AIR_RESISTANCE;
velocity[yIndex] *= AIR_RESISTANCE;
velocity[zIndex] *= AIR_RESISTANCE;
if (position[yIndex] + velocity[yIndex] > 0) {
velocity[yIndex] = -velocity[yIndex] * 0.2;
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
// 小さい火花に分割
const DIAMETER_MIN:Number = 2;
if (diameters[i] > DIAMETER_MIN) {
var diameterLimit:Number = diameters[i];
while (1) {
var diameter:Number = Math.random() * (4 - DIAMETER_MIN) + DIAMETER_MIN;
diameterLimit -= diameter;
if (diameterLimit < 0) {
break;
}
var azimuth:Number = Math.random() * 2 * Math.PI;
var r:Number = Math.random() * 2;
createSpark(position[xIndex], position[yIndex], position[zIndex],
(velocity[xIndex] + Math.cos(azimuth) * r) * 0.5,
velocity[yIndex],
(velocity[zIndex] + Math.sin(azimuth) * r) * 0.5,
diameter);
}
}
// spliceは重い！
// position.splice(xIndex, 3);
// velocity.splice(xIndex, 3);
// diameters.splice(i, 1);
position[xIndex] = position[sparkNumber * 3 - 3];
position[yIndex] = position[sparkNumber * 3 - 2];
position[zIndex] = position[sparkNumber * 3 - 1];
velocity[xIndex] = velocity[sparkNumber * 3 - 3];
velocity[yIndex] = velocity[sparkNumber * 3 - 2];
velocity[zIndex] = velocity[sparkNumber * 3 - 1];
diameters[i] = diameters[sparkNumber - 1];
position.pop();
position.pop();
position.pop();
velocity.pop();
velocity.pop();
velocity.pop();
diameters.pop();
sparkNumber--;
continue;
}
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
i++;
}
}
private function renderSparks():void
{
splitBuffer.fillRect(splitBuffer.rect, 0x000000);
Utils3D.projectVectors(projectionMatrix, position, projectedPosition, uvts);
// ループ外に追い出したら30%以上高速化
var p:Point = new Point();
var focalLength:Number = perspective.focalLength;
for (var i:int = 0; i < sparkNumber; i++) {
// パーティクルの大きさ = 1/z * focalLength * pixel
var diameter:int = uvts[i * 3 + 2] * focalLength * diameters[i] + 0.5;
// (i * 2) => (i << 1)で10%ほど高速化
p.x = CENTER_X + projectedPosition[(i << 1) ] - diameter / 2;
p.y = CENTER_Y + projectedPosition[(i << 1) + 1] - diameter / 2;
splitBuffer.copyPixels(sparkBitmapDatas[diameter], sparkBitmapDataRectangles[diameter], p);
}
displayBuffer.draw(splitBuffer, null, null, BlendMode.ADD);
}
private const FLOOR_SIZE:Number = 300;
private const FLOOR_HALFSIZE:Number = FLOOR_SIZE / 2;
private const FLOOR_VERTICES:Vector.<Number> = Vector.<Number>([
FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, 0,
-FLOOR_HALFSIZE, 0, 0,
0, 0, FLOOR_HALFSIZE,
0, 0, -FLOOR_HALFSIZE,
]);
private const FLOOR_VERTEX_NUMBER:int = FLOOR_VERTICES.length / 3;
private var floorProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var floorIndices:Vector.<int> = Vector.<int>([
0, 1, 2, 2, 3, 0
]);
private var floorUvts:Vector.<Number> = Vector.<Number>([
1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]);
private const TEXTURE_SIZE:int = 150;
private var floorTexture:BitmapData = new BitmapData(TEXTURE_SIZE, TEXTURE_SIZE, false);
private const WIREFRAME_COLOR:uint = 0x555566;
private var sprite:Sprite = new Sprite();
private function renderFloor():void
{
// 照り返しを描画する閾値
const THRESHOLD_Y:Number = 50;
var matrix:Matrix = new Matrix();
var colorTransform:ColorTransform = new ColorTransform();
floorTexture.fillRect(floorTexture.rect, 0x180C00);
for (var i:int = 0; i < sparkNumber; i++) {
var yIndex:int = i * 3 + 1;
if (position[yIndex] > -THRESHOLD_Y) {
var xIndex:int = i * 3;
var zIndex:int = i * 3 + 2;
matrix.identity();
var scale:Number = (0.2 - (position[yIndex] / THRESHOLD_Y) * 0.8) * diameters[i];
matrix.scale(scale, scale);
matrix.translate(FLOOR_HALFSIZE + position[xIndex] - REFLECTION_RADIUS * scale, FLOOR_HALFSIZE - position[zIndex] - REFLECTION_RADIUS * scale);
matrix.scale(TEXTURE_SIZE / FLOOR_SIZE, TEXTURE_SIZE / FLOOR_SIZE);
colorTransform.alphaMultiplier = 1 + position[yIndex] / THRESHOLD_Y;
floorTexture.draw(reflectionBitmapData, matrix, colorTransform, BlendMode.ADD);
}
}
Utils3D.projectVectors(projectionMatrix, FLOOR_VERTICES, floorProjectedVertices, floorUvts);
for (i = 0; i < FLOOR_VERTEX_NUMBER; i++) {
floorProjectedVertices[(i << 1) ] += CENTER_X;
floorProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
Utils3D.projectVectors(projectionMatrix, fireworkVertices, fireworkProjectedVertices, fireworkUvts);
for (i = 0; i < fireworkProjectedVertices.length / 2; i++) {
fireworkProjectedVertices[(i << 1) ] += CENTER_X;
fireworkProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
var g:Graphics = sprite.graphics;
g.clear();
g.beginBitmapFill(floorTexture);
g.drawTriangles(floorProjectedVertices, floorIndices, floorUvts);
g.endFill();
displayBuffer.draw(sprite);
g.clear();
g.lineStyle(1, WIREFRAME_COLOR);
g.moveTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.lineTo(floorProjectedVertices[2], floorProjectedVertices[3]);
g.lineTo(floorProjectedVertices[4], floorProjectedVertices[5]);
g.lineTo(floorProjectedVertices[6], floorProjectedVertices[7]);
g.lineTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.moveTo(floorProjectedVertices[8], floorProjectedVertices[9]);
g.lineTo(floorProjectedVertices[10], floorProjectedVertices[11]);
g.moveTo(floorProjectedVertices[12], floorProjectedVertices[13]);
g.lineTo(floorProjectedVertices[14], floorProjectedVertices[15]);
displayBuffer.draw(sprite, null, null, BlendMode.ADD);
g.clear();
g.beginFill(FIREWORK_COLOR);
g.drawTriangles(fireworkProjectedVertices, fireworkIndices);
g.endFill();
displayBuffer.draw(sprite);
}
private const FIREWORK_RADIUS:Number = 8;
private const FIREWORK_HEIGHT:Number = 40;
private const FIREWORK_COLOR:uint = 0xAACCFF;
private var fireworkVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkIndices:Vector.<int> = new Vector.<int>();
private var fireworkProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkUvts:Vector.<Number> = new Vector.<Number>();
private function createFireworkModel():void
{
const SEGMENT:int = 8;
for (var i:int = 0; i < SEGMENT; i++) {
var x:Number = Math.cos(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
var z:Number = Math.sin(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
fireworkVertices.push(x, -FIREWORK_HEIGHT, z);
fireworkVertices.push(x, 0, z);
var i0:int = (i * 2 ) % (SEGMENT * 2);
var i1:int = (i * 2 + 1) % (SEGMENT * 2);
var i2:int = (i * 2 + 2) % (SEGMENT * 2);
var i3:int = (i * 2 + 3) % (SEGMENT * 2);
fireworkIndices.push(i2, i0, i1);
fireworkIndices.push(i1, i3, i2);
}
}
}
}

PS2 Firework (Particles and Motion blur) forked from: PS2 Firework (Particles and Motion blur) [diff(1)]

hacker_fi8ovzz6

// forked from k0rin's PS2 Firework (Particles and Motion blur)
package {
import flash.display.*;
import flash.events.*;
import flash.filters.*;
import flash.geom.*;
import flash.text.*;
import flash.utils.*;
[SWF(width="465", height="465", frameRate="40")]
public class Firework extends Sprite
{
// 火花
private var position:Vector.<Number> = new Vector.<Number>();
private var velocity:Vector.<Number> = new Vector.<Number>();
private var diameters:Vector.<Number> = new Vector.<Number>();
private var sparkNumber:Number = 0;
private var projectedPosition:Vector.<Number> = new Vector.<Number>();
private var uvts:Vector.<Number> = new Vector.<Number>();
private var sparkBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>();
private var sparkBitmapDataRectangles:Vector.<Rectangle> = new Vector.<Rectangle>();
private const SPARK_COLOR:uint = 0x664020;
private const GRAVITY:Number = 0.02;
private const AIR_RESISTANCE:Number = 0.999;
// 1フレームに放出する火花の数
private const EMIT_SPARK_NUMBER:int = 3;
// 照り返し
private var reflectionBitmapData:BitmapData;
private const REFLECTION_COLOR:uint = 0xFF1800;
private const REFLECTION_RADIUS:Number = 16;
// フレームバッファ
private var displayBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private var splitBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private const NUMBER_OF_SPLIT_FRAME:int = 10;
private var perspective:PerspectiveProjection = new PerspectiveProjection();
private var projectionMatrix:Matrix3D = new Matrix3D();
private var viewRotationY:Number = 0;
private var viewRotationX:Number = 25;
private const CENTER_X:Number = stage.stageWidth / 2;
private const CENTER_Y:Number = stage.stageHeight * 0.65;
private var stats:TextField = new TextField();
public function Firework()
{
addChild(new Bitmap(displayBuffer));
stats.x = 5;
stats.y = 5;
stats.autoSize = TextFieldAutoSize.LEFT;
stats.textColor = 0xFFFFFF;
addChild(stats);
var shape:Shape = new Shape();
var g:Graphics = shape.graphics;
// 火花のプリレンダリング
var bitmapData:BitmapData = new BitmapData(1, 1, true, SPARK_COLOR);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
for (var diameter:int = 1; diameter <= 32; diameter++) {
bitmapData = new BitmapData(diameter, diameter, true, 0);
g.clear();
g.beginFill(SPARK_COLOR);
var radius:Number = diameter / 2;
g.drawCircle(radius, radius, radius);
g.endFill();
bitmapData.draw(shape);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
// bitmapData.rectはアクセサで重いのでキャッシュしておく。これにより30%ほど高速化
}
// 照り返しのプリレンダリング
reflectionBitmapData = new BitmapData(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, true, 0);
g.clear();
var matrix:Matrix = new Matrix();
matrix.createGradientBox(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, 0, 0, 0);
g.beginGradientFill(GradientType.RADIAL, [ REFLECTION_COLOR, REFLECTION_COLOR ], [ 1, 0 ], [ 0, 255 ], matrix);
g.drawCircle(REFLECTION_RADIUS, REFLECTION_RADIUS, REFLECTION_RADIUS);
g.endFill();
reflectionBitmapData.draw(shape);
createFireworkModel();
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
// stage.addEventListener(MouseEvent.CLICK, function (e:Event):void {
// emitSpark();
// });
}
private function enterFrameHandler(e:Event):void
{
displayBuffer.fillRect(displayBuffer.rect, 0);
setupProjectionMatrix();
var startTime:uint = getTimer();
renderFloor();
var floorRenderingTime:uint = getTimer() - startTime;
startTime = getTimer();
for (var i:int = 0; i < NUMBER_OF_SPLIT_FRAME; i++) {
const FACTOR:Number = 0.06;
viewRotationY += (getTimer() * 0.01 + (-(CENTER_X - mouseX) * 0.4) - viewRotationY) * FACTOR;
viewRotationX += ((27 + (CENTER_Y - mouseY) * 0.15) - viewRotationX) * FACTOR;
setupProjectionMatrix();
for (var j:int = 0; j < EMIT_SPARK_NUMBER; j++) {
emitSpark();
}
updateSparks();
renderSparks();
}
var sparksRenderingTime:uint = getTimer() - startTime;
stats.text =
"Number of Sparks : " + sparkNumber + "\n" +
"Floor Rendering Time : " + floorRenderingTime + " ms\n" +
"Sparks Rendering Time : " + sparksRenderingTime + " ms \n";
}
private function setupProjectionMatrix():void
{
perspective.fieldOfView = 60;
projectionMatrix.identity();
projectionMatrix.appendRotation(viewRotationY, Vector3D.Y_AXIS);
projectionMatrix.appendRotation(viewRotationX, Vector3D.X_AXIS);
projectionMatrix.appendTranslation(0, 0, perspective.focalLength);
projectionMatrix.append(perspective.toMatrix3D());
correctMatrix3DMultiplyBug(projectionMatrix);
}
private function correctMatrix3DMultiplyBug(matrix:Matrix3D):void
{
// see http://bugs.adobe.com/jira/browse/FP-670
var m1:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]));
var m2:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ]));
m1.append(m2);
if (m1.rawData[15] == 20) {
// バグ持ち！
var rawData:Vector.<Number> = matrix.rawData;
rawData[15] /= 20;
matrix.rawData = rawData;
}
}
private function createSpark(x:Number, y:Number, z:Number, vx:Number, vy:Number, vz:Number, diameter:Number):void
{
position.push(x, y, z);
velocity.push(vx, vy, vz);
diameters.push(diameter);
sparkNumber++;
}
private function emitSpark():void
{
var azimuth:Number = Math.random() * 2 * Math.PI;
var vy:Number = -(Math.random() * 0.06 + 0.94);
var vx:Number = Math.sqrt(1 - vy * vy) * Math.cos(azimuth);
var vz:Number = Math.sqrt(1 - vy * vy) * Math.sin(azimuth);
var speed:Number = Math.random() * 2.3 + 0.7;
vx *= speed;
vy *= speed;
vz *= speed;
var diameter:Number = 3 + Math.random() * 3;
createSpark(0, -FIREWORK_HEIGHT, 0, vx, vy, vz, diameter);
}
private function updateSparks():void
{
for (var i:int = 0; i < sparkNumber; ) {
var xIndex:int = i * 3;
var yIndex:int = xIndex + 1;
var zIndex:int = xIndex + 2;
velocity[yIndex] += GRAVITY;
velocity[xIndex] *= AIR_RESISTANCE;
velocity[yIndex] *= AIR_RESISTANCE;
velocity[zIndex] *= AIR_RESISTANCE;
if (position[yIndex] + velocity[yIndex] > 0) {
velocity[yIndex] = -velocity[yIndex] * 0.2;
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
// 小さい火花に分割
const DIAMETER_MIN:Number = 2;
if (diameters[i] > DIAMETER_MIN) {
var diameterLimit:Number = diameters[i];
while (1) {
var diameter:Number = Math.random() * (4 - DIAMETER_MIN) + DIAMETER_MIN;
diameterLimit -= diameter;
if (diameterLimit < 0) {
break;
}
var azimuth:Number = Math.random() * 2 * Math.PI;
var r:Number = Math.random() * 2;
createSpark(position[xIndex], position[yIndex], position[zIndex],
(velocity[xIndex] + Math.cos(azimuth) * r) * 0.5,
velocity[yIndex],
(velocity[zIndex] + Math.sin(azimuth) * r) * 0.5,
diameter);
}
}
// spliceは重い！
// position.splice(xIndex, 3);
// velocity.splice(xIndex, 3);
// diameters.splice(i, 1);
position[xIndex] = position[sparkNumber * 3 - 3];
position[yIndex] = position[sparkNumber * 3 - 2];
position[zIndex] = position[sparkNumber * 3 - 1];
velocity[xIndex] = velocity[sparkNumber * 3 - 3];
velocity[yIndex] = velocity[sparkNumber * 3 - 2];
velocity[zIndex] = velocity[sparkNumber * 3 - 1];
diameters[i] = diameters[sparkNumber - 1];
position.pop();
position.pop();
position.pop();
velocity.pop();
velocity.pop();
velocity.pop();
diameters.pop();
sparkNumber--;
continue;
}
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
i++;
}
}
private function renderSparks():void
{
splitBuffer.fillRect(splitBuffer.rect, 0x000000);
Utils3D.projectVectors(projectionMatrix, position, projectedPosition, uvts);
// ループ外に追い出したら30%以上高速化
var p:Point = new Point();
var focalLength:Number = perspective.focalLength;
for (var i:int = 0; i < sparkNumber; i++) {
// パーティクルの大きさ = 1/z * focalLength * pixel
var diameter:int = uvts[i * 3 + 2] * focalLength * diameters[i] + 0.5;
// (i * 2) => (i << 1)で10%ほど高速化
p.x = CENTER_X + projectedPosition[(i << 1) ] - diameter / 2;
p.y = CENTER_Y + projectedPosition[(i << 1) + 1] - diameter / 2;
splitBuffer.copyPixels(sparkBitmapDatas[diameter], sparkBitmapDataRectangles[diameter], p);
}
displayBuffer.draw(splitBuffer, null, null, BlendMode.ADD);
}
private const FLOOR_SIZE:Number = 300;
private const FLOOR_HALFSIZE:Number = FLOOR_SIZE / 2;
private const FLOOR_VERTICES:Vector.<Number> = Vector.<Number>([
FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, 0,
-FLOOR_HALFSIZE, 0, 0,
0, 0, FLOOR_HALFSIZE,
0, 0, -FLOOR_HALFSIZE,
]);
private const FLOOR_VERTEX_NUMBER:int = FLOOR_VERTICES.length / 3;
private var floorProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var floorIndices:Vector.<int> = Vector.<int>([
0, 1, 2, 2, 3, 0
]);
private var floorUvts:Vector.<Number> = Vector.<Number>([
1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]);
private const TEXTURE_SIZE:int = 150;
private var floorTexture:BitmapData = new BitmapData(TEXTURE_SIZE, TEXTURE_SIZE, false);
private const WIREFRAME_COLOR:uint = 0x555566;
private var sprite:Sprite = new Sprite();
private function renderFloor():void
{
// 照り返しを描画する閾値
const THRESHOLD_Y:Number = 50;
var matrix:Matrix = new Matrix();
var colorTransform:ColorTransform = new ColorTransform();
floorTexture.fillRect(floorTexture.rect, 0x180C00);
for (var i:int = 0; i < sparkNumber; i++) {
var yIndex:int = i * 3 + 1;
if (position[yIndex] > -THRESHOLD_Y) {
var xIndex:int = i * 3;
var zIndex:int = i * 3 + 2;
matrix.identity();
var scale:Number = (0.2 - (position[yIndex] / THRESHOLD_Y) * 0.8) * diameters[i];
matrix.scale(scale, scale);
matrix.translate(FLOOR_HALFSIZE + position[xIndex] - REFLECTION_RADIUS * scale, FLOOR_HALFSIZE - position[zIndex] - REFLECTION_RADIUS * scale);
matrix.scale(TEXTURE_SIZE / FLOOR_SIZE, TEXTURE_SIZE / FLOOR_SIZE);
colorTransform.alphaMultiplier = 1 + position[yIndex] / THRESHOLD_Y;
floorTexture.draw(reflectionBitmapData, matrix, colorTransform, BlendMode.ADD);
}
}
Utils3D.projectVectors(projectionMatrix, FLOOR_VERTICES, floorProjectedVertices, floorUvts);
for (i = 0; i < FLOOR_VERTEX_NUMBER; i++) {
floorProjectedVertices[(i << 1) ] += CENTER_X;
floorProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
Utils3D.projectVectors(projectionMatrix, fireworkVertices, fireworkProjectedVertices, fireworkUvts);
for (i = 0; i < fireworkProjectedVertices.length / 2; i++) {
fireworkProjectedVertices[(i << 1) ] += CENTER_X;
fireworkProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
var g:Graphics = sprite.graphics;
g.clear();
g.beginBitmapFill(floorTexture);
g.drawTriangles(floorProjectedVertices, floorIndices, floorUvts);
g.endFill();
displayBuffer.draw(sprite);
g.clear();
g.lineStyle(1, WIREFRAME_COLOR);
g.moveTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.lineTo(floorProjectedVertices[2], floorProjectedVertices[3]);
g.lineTo(floorProjectedVertices[4], floorProjectedVertices[5]);
g.lineTo(floorProjectedVertices[6], floorProjectedVertices[7]);
g.lineTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.moveTo(floorProjectedVertices[8], floorProjectedVertices[9]);
g.lineTo(floorProjectedVertices[10], floorProjectedVertices[11]);
g.moveTo(floorProjectedVertices[12], floorProjectedVertices[13]);
g.lineTo(floorProjectedVertices[14], floorProjectedVertices[15]);
displayBuffer.draw(sprite, null, null, BlendMode.ADD);
g.clear();
g.beginFill(FIREWORK_COLOR);
g.drawTriangles(fireworkProjectedVertices, fireworkIndices);
g.endFill();
displayBuffer.draw(sprite);
}
private const FIREWORK_RADIUS:Number = 8;
private const FIREWORK_HEIGHT:Number = 40;
private const FIREWORK_COLOR:uint = 0xAACCFF;
private var fireworkVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkIndices:Vector.<int> = new Vector.<int>();
private var fireworkProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkUvts:Vector.<Number> = new Vector.<Number>();
private function createFireworkModel():void
{
const SEGMENT:int = 8;
for (var i:int = 0; i < SEGMENT; i++) {
var x:Number = Math.cos(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
var z:Number = Math.sin(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
fireworkVertices.push(x, -FIREWORK_HEIGHT, z);
fireworkVertices.push(x, 0, z);
var i0:int = (i * 2 ) % (SEGMENT * 2);
var i1:int = (i * 2 + 1) % (SEGMENT * 2);
var i2:int = (i * 2 + 2) % (SEGMENT * 2);
var i3:int = (i * 2 + 3) % (SEGMENT * 2);
fireworkIndices.push(i2, i0, i1);
fireworkIndices.push(i1, i3, i2);
}
}
}
}

PS2 Firework (Particles and Motion blur) forked from: PS2 Firework (Particles and Motion blur) [diff(1)]

PESakaTFM

// forked from k0rin's PS2 Firework (Particles and Motion blur)
package {
import flash.display.*;
import flash.events.*;
import flash.filters.*;
import flash.geom.*;
import flash.text.*;
import flash.utils.*;
[SWF(width="465", height="465", frameRate="40")]
public class Firework extends Sprite
{
// 火花
private var position:Vector.<Number> = new Vector.<Number>();
private var velocity:Vector.<Number> = new Vector.<Number>();
private var diameters:Vector.<Number> = new Vector.<Number>();
private var sparkNumber:Number = 0;
private var projectedPosition:Vector.<Number> = new Vector.<Number>();
private var uvts:Vector.<Number> = new Vector.<Number>();
private var sparkBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>();
private var sparkBitmapDataRectangles:Vector.<Rectangle> = new Vector.<Rectangle>();
private const SPARK_COLOR:uint = 0x664020;
private const GRAVITY:Number = 0.02;
private const AIR_RESISTANCE:Number = 0.999;
// 1フレームに放出する火花の数
private const EMIT_SPARK_NUMBER:int = 3;
// 照り返し
private var reflectionBitmapData:BitmapData;
private const REFLECTION_COLOR:uint = 0xFF1800;
private const REFLECTION_RADIUS:Number = 16;
// フレームバッファ
private var displayBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private var splitBuffer:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight, false);
private const NUMBER_OF_SPLIT_FRAME:int = 10;
private var perspective:PerspectiveProjection = new PerspectiveProjection();
private var projectionMatrix:Matrix3D = new Matrix3D();
private var viewRotationY:Number = 0;
private var viewRotationX:Number = 25;
private const CENTER_X:Number = stage.stageWidth / 2;
private const CENTER_Y:Number = stage.stageHeight * 0.65;
private var stats:TextField = new TextField();
public function Firework()
{
addChild(new Bitmap(displayBuffer));
stats.x = 5;
stats.y = 5;
stats.autoSize = TextFieldAutoSize.LEFT;
stats.textColor = 0xFFFFFF;
addChild(stats);
var shape:Shape = new Shape();
var g:Graphics = shape.graphics;
// 火花のプリレンダリング
var bitmapData:BitmapData = new BitmapData(1, 1, true, SPARK_COLOR);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
for (var diameter:int = 1; diameter <= 32; diameter++) {
bitmapData = new BitmapData(diameter, diameter, true, 0);
g.clear();
g.beginFill(SPARK_COLOR);
var radius:Number = diameter / 2;
g.drawCircle(radius, radius, radius);
g.endFill();
bitmapData.draw(shape);
sparkBitmapDatas.push(bitmapData);
sparkBitmapDataRectangles.push(bitmapData.rect);
// bitmapData.rectはアクセサで重いのでキャッシュしておく。これにより30%ほど高速化
}
// 照り返しのプリレンダリング
reflectionBitmapData = new BitmapData(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, true, 0);
g.clear();
var matrix:Matrix = new Matrix();
matrix.createGradientBox(REFLECTION_RADIUS * 2, REFLECTION_RADIUS * 2, 0, 0, 0);
g.beginGradientFill(GradientType.RADIAL, [ REFLECTION_COLOR, REFLECTION_COLOR ], [ 1, 0 ], [ 0, 255 ], matrix);
g.drawCircle(REFLECTION_RADIUS, REFLECTION_RADIUS, REFLECTION_RADIUS);
g.endFill();
reflectionBitmapData.draw(shape);
createFireworkModel();
addEventListener(Event.ENTER_FRAME, enterFrameHandler);
// stage.addEventListener(MouseEvent.CLICK, function (e:Event):void {
// emitSpark();
// });
}
private function enterFrameHandler(e:Event):void
{
displayBuffer.fillRect(displayBuffer.rect, 0);
setupProjectionMatrix();
var startTime:uint = getTimer();
renderFloor();
var floorRenderingTime:uint = getTimer() - startTime;
startTime = getTimer();
for (var i:int = 0; i < NUMBER_OF_SPLIT_FRAME; i++) {
const FACTOR:Number = 0.06;
viewRotationY += (getTimer() * 0.01 + (-(CENTER_X - mouseX) * 0.4) - viewRotationY) * FACTOR;
viewRotationX += ((27 + (CENTER_Y - mouseY) * 0.15) - viewRotationX) * FACTOR;
setupProjectionMatrix();
for (var j:int = 0; j < EMIT_SPARK_NUMBER; j++) {
emitSpark();
}
updateSparks();
renderSparks();
}
var sparksRenderingTime:uint = getTimer() - startTime;
stats.text =
"Number of Sparks : " + sparkNumber + "\n" +
"Floor Rendering Time : " + floorRenderingTime + " ms\n" +
"Sparks Rendering Time : " + sparksRenderingTime + " ms \n";
}
private function setupProjectionMatrix():void
{
perspective.fieldOfView = 60;
projectionMatrix.identity();
projectionMatrix.appendRotation(viewRotationY, Vector3D.Y_AXIS);
projectionMatrix.appendRotation(viewRotationX, Vector3D.X_AXIS);
projectionMatrix.appendTranslation(0, 0, perspective.focalLength);
projectionMatrix.append(perspective.toMatrix3D());
correctMatrix3DMultiplyBug(projectionMatrix);
}
private function correctMatrix3DMultiplyBug(matrix:Matrix3D):void
{
// see http://bugs.adobe.com/jira/browse/FP-670
var m1:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]));
var m2:Matrix3D = new Matrix3D(Vector.<Number>([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ]));
m1.append(m2);
if (m1.rawData[15] == 20) {
// バグ持ち！
var rawData:Vector.<Number> = matrix.rawData;
rawData[15] /= 20;
matrix.rawData = rawData;
}
}
private function createSpark(x:Number, y:Number, z:Number, vx:Number, vy:Number, vz:Number, diameter:Number):void
{
position.push(x, y, z);
velocity.push(vx, vy, vz);
diameters.push(diameter);
sparkNumber++;
}
private function emitSpark():void
{
var azimuth:Number = Math.random() * 2 * Math.PI;
var vy:Number = -(Math.random() * 0.06 + 0.94);
var vx:Number = Math.sqrt(1 - vy * vy) * Math.cos(azimuth);
var vz:Number = Math.sqrt(1 - vy * vy) * Math.sin(azimuth);
var speed:Number = Math.random() * 2.3 + 0.7;
vx *= speed;
vy *= speed;
vz *= speed;
var diameter:Number = 3 + Math.random() * 3;
createSpark(0, -FIREWORK_HEIGHT, 0, vx, vy, vz, diameter);
}
private function updateSparks():void
{
for (var i:int = 0; i < sparkNumber; ) {
var xIndex:int = i * 3;
var yIndex:int = xIndex + 1;
var zIndex:int = xIndex + 2;
velocity[yIndex] += GRAVITY;
velocity[xIndex] *= AIR_RESISTANCE;
velocity[yIndex] *= AIR_RESISTANCE;
velocity[zIndex] *= AIR_RESISTANCE;
if (position[yIndex] + velocity[yIndex] > 0) {
velocity[yIndex] = -velocity[yIndex] * 0.2;
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
// 小さい火花に分割
const DIAMETER_MIN:Number = 2;
if (diameters[i] > DIAMETER_MIN) {
var diameterLimit:Number = diameters[i];
while (1) {
var diameter:Number = Math.random() * (4 - DIAMETER_MIN) + DIAMETER_MIN;
diameterLimit -= diameter;
if (diameterLimit < 0) {
break;
}
var azimuth:Number = Math.random() * 2 * Math.PI;
var r:Number = Math.random() * 2;
createSpark(position[xIndex], position[yIndex], position[zIndex],
(velocity[xIndex] + Math.cos(azimuth) * r) * 0.5,
velocity[yIndex],
(velocity[zIndex] + Math.sin(azimuth) * r) * 0.5,
diameter);
}
}
// spliceは重い！
// position.splice(xIndex, 3);
// velocity.splice(xIndex, 3);
// diameters.splice(i, 1);
position[xIndex] = position[sparkNumber * 3 - 3];
position[yIndex] = position[sparkNumber * 3 - 2];
position[zIndex] = position[sparkNumber * 3 - 1];
velocity[xIndex] = velocity[sparkNumber * 3 - 3];
velocity[yIndex] = velocity[sparkNumber * 3 - 2];
velocity[zIndex] = velocity[sparkNumber * 3 - 1];
diameters[i] = diameters[sparkNumber - 1];
position.pop();
position.pop();
position.pop();
velocity.pop();
velocity.pop();
velocity.pop();
diameters.pop();
sparkNumber--;
continue;
}
position[xIndex] += velocity[xIndex];
position[yIndex] += velocity[yIndex];
position[zIndex] += velocity[zIndex];
i++;
}
}
private function renderSparks():void
{
splitBuffer.fillRect(splitBuffer.rect, 0x000000);
Utils3D.projectVectors(projectionMatrix, position, projectedPosition, uvts);
// ループ外に追い出したら30%以上高速化
var p:Point = new Point();
var focalLength:Number = perspective.focalLength;
for (var i:int = 0; i < sparkNumber; i++) {
// パーティクルの大きさ = 1/z * focalLength * pixel
var diameter:int = uvts[i * 3 + 2] * focalLength * diameters[i] + 0.5;
// (i * 2) => (i << 1)で10%ほど高速化
p.x = CENTER_X + projectedPosition[(i << 1) ] - diameter / 2;
p.y = CENTER_Y + projectedPosition[(i << 1) + 1] - diameter / 2;
splitBuffer.copyPixels(sparkBitmapDatas[diameter], sparkBitmapDataRectangles[diameter], p);
}
displayBuffer.draw(splitBuffer, null, null, BlendMode.ADD);
}
private const FLOOR_SIZE:Number = 300;
private const FLOOR_HALFSIZE:Number = FLOOR_SIZE / 2;
private const FLOOR_VERTICES:Vector.<Number> = Vector.<Number>([
FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, FLOOR_HALFSIZE,
-FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, -FLOOR_HALFSIZE,
FLOOR_HALFSIZE, 0, 0,
-FLOOR_HALFSIZE, 0, 0,
0, 0, FLOOR_HALFSIZE,
0, 0, -FLOOR_HALFSIZE,
]);
private const FLOOR_VERTEX_NUMBER:int = FLOOR_VERTICES.length / 3;
private var floorProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var floorIndices:Vector.<int> = Vector.<int>([
0, 1, 2, 2, 3, 0
]);
private var floorUvts:Vector.<Number> = Vector.<Number>([
1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]);
private const TEXTURE_SIZE:int = 150;
private var floorTexture:BitmapData = new BitmapData(TEXTURE_SIZE, TEXTURE_SIZE, false);
private const WIREFRAME_COLOR:uint = 0x555566;
private var sprite:Sprite = new Sprite();
private function renderFloor():void
{
// 照り返しを描画する閾値
const THRESHOLD_Y:Number = 50;
var matrix:Matrix = new Matrix();
var colorTransform:ColorTransform = new ColorTransform();
floorTexture.fillRect(floorTexture.rect, 0x180C00);
for (var i:int = 0; i < sparkNumber; i++) {
var yIndex:int = i * 3 + 1;
if (position[yIndex] > -THRESHOLD_Y) {
var xIndex:int = i * 3;
var zIndex:int = i * 3 + 2;
matrix.identity();
var scale:Number = (0.2 - (position[yIndex] / THRESHOLD_Y) * 0.8) * diameters[i];
matrix.scale(scale, scale);
matrix.translate(FLOOR_HALFSIZE + position[xIndex] - REFLECTION_RADIUS * scale, FLOOR_HALFSIZE - position[zIndex] - REFLECTION_RADIUS * scale);
matrix.scale(TEXTURE_SIZE / FLOOR_SIZE, TEXTURE_SIZE / FLOOR_SIZE);
colorTransform.alphaMultiplier = 1 + position[yIndex] / THRESHOLD_Y;
floorTexture.draw(reflectionBitmapData, matrix, colorTransform, BlendMode.ADD);
}
}
Utils3D.projectVectors(projectionMatrix, FLOOR_VERTICES, floorProjectedVertices, floorUvts);
for (i = 0; i < FLOOR_VERTEX_NUMBER; i++) {
floorProjectedVertices[(i << 1) ] += CENTER_X;
floorProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
Utils3D.projectVectors(projectionMatrix, fireworkVertices, fireworkProjectedVertices, fireworkUvts);
for (i = 0; i < fireworkProjectedVertices.length / 2; i++) {
fireworkProjectedVertices[(i << 1) ] += CENTER_X;
fireworkProjectedVertices[(i << 1) + 1] += CENTER_Y;
}
var g:Graphics = sprite.graphics;
g.clear();
g.beginBitmapFill(floorTexture);
g.drawTriangles(floorProjectedVertices, floorIndices, floorUvts);
g.endFill();
displayBuffer.draw(sprite);
g.clear();
g.lineStyle(1, WIREFRAME_COLOR);
g.moveTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.lineTo(floorProjectedVertices[2], floorProjectedVertices[3]);
g.lineTo(floorProjectedVertices[4], floorProjectedVertices[5]);
g.lineTo(floorProjectedVertices[6], floorProjectedVertices[7]);
g.lineTo(floorProjectedVertices[0], floorProjectedVertices[1]);
g.moveTo(floorProjectedVertices[8], floorProjectedVertices[9]);
g.lineTo(floorProjectedVertices[10], floorProjectedVertices[11]);
g.moveTo(floorProjectedVertices[12], floorProjectedVertices[13]);
g.lineTo(floorProjectedVertices[14], floorProjectedVertices[15]);
displayBuffer.draw(sprite, null, null, BlendMode.ADD);
g.clear();
g.beginFill(FIREWORK_COLOR);
g.drawTriangles(fireworkProjectedVertices, fireworkIndices);
g.endFill();
displayBuffer.draw(sprite);
}
private const FIREWORK_RADIUS:Number = 8;
private const FIREWORK_HEIGHT:Number = 40;
private const FIREWORK_COLOR:uint = 0xAACCFF;
private var fireworkVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkIndices:Vector.<int> = new Vector.<int>();
private var fireworkProjectedVertices:Vector.<Number> = new Vector.<Number>();
private var fireworkUvts:Vector.<Number> = new Vector.<Number>();
private function createFireworkModel():void
{
const SEGMENT:int = 8;
for (var i:int = 0; i < SEGMENT; i++) {
var x:Number = Math.cos(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
var z:Number = Math.sin(2 * Math.PI * i / SEGMENT) * FIREWORK_RADIUS;
fireworkVertices.push(x, -FIREWORK_HEIGHT, z);
fireworkVertices.push(x, 0, z);
var i0:int = (i * 2 ) % (SEGMENT * 2);
var i1:int = (i * 2 + 1) % (SEGMENT * 2);
var i2:int = (i * 2 + 2) % (SEGMENT * 2);
var i3:int = (i * 2 + 3) % (SEGMENT * 2);
fireworkIndices.push(i2, i0, i1);
fireworkIndices.push(i1, i3, i2);
}
}
}
}