[Stardust] Pixel3D with a brilliant radiance | wonderfl build flash online

※現在、「wonderfl build flash online」求人コンテンツ制作に関してのアンケートを実施中です！みなさまのお力添えを頂いて、続々とアンケート結果が集まっていますが、まだまだ募集しております。ご協力のほど、どうぞよろしくお願いいたします！

wonderfl運営事務局
→アンケートページ（※ログインしてからお答えいただけるようになっています。）

[Stardust] Pixel3D with a brilliant radiance

add to favorites

paq

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

forked : 9
favorite : 49
lines : 191
license : MIT License
modified : 2010-01-23 03:41:09

embed

Twitterでつぶやく

package 
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.BlendMode;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.filters.BlurFilter;
	import flash.geom.Matrix;
	import flash.geom.Point;
	import frocessing.color.FColor;
	import idv.cjcat.stardust.common.clocks.SteadyClock;
	import idv.cjcat.stardust.common.emitters.Emitter;
	import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObject3DRenderer;
	import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObjectRenderer;
	import org.papervision3d.core.effects.BitmapLayerEffect;
	import org.papervision3d.core.effects.view.ReflectionView;
	import org.papervision3d.core.geom.Pixels;
	import org.papervision3d.core.geom.renderables.Pixel3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.view.layer.BitmapEffectLayer;
	
	/**
	 * ...
	 * @author paq89
	 */
	[SWF(width = 465, height = 465, backgroundColor = 0xFFFFFF, frameRate = 60)]
	public class Main extends BasicView
	{
		private const ZERO_POINT:Point = new Point(0, 0);
		private const BLUR:BlurFilter = new BlurFilter(4, 4, 1);
		
		private var _emitter:Pixel3DEmitter;
		private var _pixels:Pixels;
		private var _canvas:BitmapData;
		private var _matrix:Matrix;
		private var _rotation:Number = 0;
		
		public function Main():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
		
		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
			
			// 背景色を設定
			opaqueBackground = 0x000000;
			
			// レンダリング開始
			startRendering();
			
			// キラキラエフェクト用BitmapEffectLayer
			var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, 465, 465, true, 0, "clear_pre", true);
            layer.clearBeforeRender = true;
            viewport.containerSprite.addLayer(layer);
			
			// Pixels
			_pixels = new Pixels(layer);
			scene.addChild(_pixels);
			
			// エミッター
			_emitter = new Pixel3DEmitter(new SteadyClock(10));
			
			// レンダラー
			var renderer:PV3DPixelsRenderer = new PV3DPixelsRenderer(_pixels);
            renderer.addEmitter(_emitter);
			
			// キラキラエフェクト
			_canvas=new BitmapData(465 / 4, 465 / 4, false, 0x000000);
            var bmp:Bitmap=new Bitmap(_canvas, "never", true);
            bmp.scaleX=bmp.scaleY=4;
            bmp.smoothing=true;
            bmp.blendMode=BlendMode.ADD;
            addChild(bmp);
            _matrix = new Matrix(0.25, 0, 0, 0.25);
			
			// イベントリスナー
			addEventListener(Event.ENTER_FRAME, loop);
		}
		
		private function loop(e:Event):void 
		{
			// キラキラ
			//_canvas.fillRect(_canvas.rect, 0x000000);
			_canvas.applyFilter(_canvas, _canvas.rect, ZERO_POINT, BLUR);
            _canvas.draw(viewport, _matrix);
			
			// パーティクルの発生元をくるくる
			_rotation += 3;
			_emitter.pointA.x = 400 * Math.sin(_rotation * Number3D.toRADIANS);
			_emitter.pointA.y = 400 * Math.cos(_rotation * Number3D.toRADIANS);
			_emitter.pointB.z = 400 * Math.cos(_rotation * Number3D.toRADIANS);
			_emitter.pointB.y = 400 * Math.sin(_rotation * Number3D.toRADIANS);
			_emitter.sphereCap.rotationX = 90;
            _emitter.sphereCap.rotationZ = -_rotation - 90;
			_pixels.rotationX += 0.2;
			_pixels.rotationY += 1;
			
			// エミッター更新
			_emitter.step();
		}
		
	}
	
}
import frocessing.color.ColorHSV;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.clocks.Clock;
import idv.cjcat.stardust.common.events.EmitterEvent;
import idv.cjcat.stardust.common.initializers.CompositeInitializer;
import idv.cjcat.stardust.common.initializers.SwitchInitializer;
import idv.cjcat.stardust.common.particles.ParticleIterator
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;
import idv.cjcat.stardust.common.renderers.Renderer;
import idv.cjcat.stardust.threeD.actions.Accelerate3D;
import idv.cjcat.stardust.threeD.actions.Move3D;
import idv.cjcat.stardust.threeD.emitters.Emitter3D;
import idv.cjcat.stardust.threeD.initializers.DisplayObjectClass3D;
import idv.cjcat.stardust.threeD.initializers.Position3D;
import idv.cjcat.stardust.threeD.initializers.Velocity3D;
import idv.cjcat.stardust.threeD.particles.Particle3D;
import idv.cjcat.stardust.threeD.zones.SinglePoint3D;
import idv.cjcat.stardust.threeD.zones.SphereCap;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;

/**
 * エミッター
 * @author paq89
 */
class Pixel3DEmitter extends Emitter3D
{
	public var pointA:SinglePoint3D = new SinglePoint3D();
	public var pointB:SinglePoint3D = new SinglePoint3D();
	public var sphereCap:SphereCap = new SphereCap(0, 0, 0, 1, 0, 40);
	
	public function Pixel3DEmitter(clock:Clock)
	{
		super(clock);
		
		var compInitA:CompositeInitializer = new CompositeInitializer();
		compInitA.addInitializer(new Position3D(pointA));
		compInitA.addInitializer(new DisplayObjectClass3D(PixelParticleA));
		var compInitB:CompositeInitializer = new CompositeInitializer();
		compInitB.addInitializer(new Position3D(pointB));
		compInitB.addInitializer(new DisplayObjectClass3D(PixelParticleB));
		var switchInit:SwitchInitializer = new SwitchInitializer([compInitA, compInitB],[1,1]);
		addInitializer(switchInit);
		addInitializer(new Life(new UniformRandom(90, 0)));
		addInitializer(new Velocity3D(sphereCap));
		
		addAction(new Move3D());
		addAction(new Age());
        addAction(new DeathLife());
		addAction(new Accelerate3D(0.05));
	}
}

/**
 * パーティクル
 * @author paq89
 */
class PixelParticleA extends Pixel3D
{
	private static var hsv:ColorHSV = new ColorHSV(0, 1, 0.7);
	
	public function PixelParticleA()
	{
		hsv.h += 0.1;
		super(hsv.value32);
	}
}
class PixelParticleB extends Pixel3D
{
	private static var hsv:ColorHSV = new ColorHSV(70, 1, 0.7);
	
	public function PixelParticleB()
	{
		hsv.h += 0.1;
		super(hsv.value32);
	}
}

/**
 * Pixel3D専用レンダラー
 * @author paq89
 */
class PV3DPixelsRenderer extends Renderer
{
	private var container:Pixels;
	
	public function PV3DPixelsRenderer(container:Pixels = null)
	{
		this.container = container;
	}
	
	override protected function particlesAdded(e:EmitterEvent):void
	{
		if (!container) return;
		var particle:Particle3D;
		var iter:ParticleIterator = e.particles.getIterator();
		while (particle = iter.particle as Particle3D)
		{
			var pixel:Pixel3D = particle.target;
			container.addPixel3D(pixel);
			particle.dictionary[PV3DPixelsRenderer] = container;
			
			iter.next();
		}
	}
	
	override protected function particlesRemoved(e:EmitterEvent):void
	{
		var particle:Particle3D;
		var iter:ParticleIterator = e.particles.getIterator();
		while (particle = iter.particle as Particle3D)
		{
			var pixel:Pixel3D = particle.target;
			var container:Pixels = particle.dictionary[PV3DPixelsRenderer] as Pixels;
			
			container.removePixel3D(pixel);
			
			iter.next();
		}
	}
	
	override protected function render(e:EmitterEvent):void
	{
		var particle:Particle3D;
		var iter:ParticleIterator = e.particles.getIterator();
		while (particle = iter.particle as Particle3D)
		{
			var pixel:Pixel3D = particle.target;
			
			pixel.x = particle.x;
			pixel.y = particle.y;
			pixel.z = particle.z;
			
			iter.next();
		}
	}
}

3D beautifl chef d'oeuvre effect glow particles pv3d stardust ディズニー光

gensui

yoshimax

alumican_net

moco

thumb_bolt_on

mex_ny

heckmeck

ucyu

imajuk

PROT830

fardeen

djankey

tkinjo

key

Dorara

shevchenko

nki2

berian

t_matsuda

oreore

Murai

katapad

hacker_aft9cz2z

osamX

kitsionchen

jonas

flabaka

skn

ayuzak

yooKo

Nyarineko

nanlow

nabe

taqumi

flasher_bbb

steph63 :

chef d'oeuvremagnifique !!!!

monodoya :

yoshiakiokabe :

[Stardust] Pixel3D with a brilliant radiance

otias :

光 pv3d惚れた

hacker_kasfd2p8 :

キレイー

mastafrog :

stardust particles glow 3d

kappaLab :

particles stardust

a440hlz :

beautifl 3D effect

clockmaker :

StardustStardustのRendererをカスタマイズ。美しい。

keim_at_Si :

stardust

soundkitchen :

ディズニーディズニー系な感じ

OKASUKE :

stardustステキ

cjcat2266 :

Beautiful!

matsu4512 :

キレイ！

>sort

[Stardust] Pixel3D with a brilliant radiance forked from: [Stardust] Pixel3D with a brilliant radiance [diff(1)]

steph63

// forked from paq's [Stardust] Pixel3D with a brilliant radiance
package
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BlurFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import frocessing.color.FColor;
import idv.cjcat.stardust.common.clocks.SteadyClock;
import idv.cjcat.stardust.common.emitters.Emitter;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObject3DRenderer;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObjectRenderer;
import org.papervision3d.core.effects.BitmapLayerEffect;
import org.papervision3d.core.effects.view.ReflectionView;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
import org.papervision3d.core.math.Number3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.view.BasicView;
import org.papervision3d.view.layer.BitmapEffectLayer;
/**
* ...
* @author paq89
*/
[SWF(width = 465, height = 465, backgroundColor = 0xFFFFFF, frameRate = 60)]
public class Main extends BasicView
{
private const ZERO_POINT:Point = new Point(0, 0);
private const BLUR:BlurFilter = new BlurFilter(4, 4, 1);
private var _emitter:Pixel3DEmitter;
private var _pixels:Pixels;
private var _canvas:BitmapData;
private var _matrix:Matrix;
private var _rotation:Number = 0;
public function Main():void
{
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
private function init(e:Event = null):void
{
removeEventListener(Event.ADDED_TO_STAGE, init);
// 背景色を設定
opaqueBackground = 0x000000;
// レンダリング開始
startRendering();
// キラキラエフェクト用BitmapEffectLayer
var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, 465, 465, true, 0, "clear_pre", true);
layer.clearBeforeRender = true;
viewport.containerSprite.addLayer(layer);
// Pixels
_pixels = new Pixels(layer);
scene.addChild(_pixels);
// エミッター
_emitter = new Pixel3DEmitter(new SteadyClock(10));
// レンダラー
var renderer:PV3DPixelsRenderer = new PV3DPixelsRenderer(_pixels);
renderer.addEmitter(_emitter);
// キラキラエフェクト
_canvas=new BitmapData(465 / 4, 465 / 4, false, 0x000000);
var bmp:Bitmap=new Bitmap(_canvas, "never", true);
bmp.scaleX=bmp.scaleY=4;
bmp.smoothing=true;
bmp.blendMode=BlendMode.ADD;
addChild(bmp);
_matrix = new Matrix(0.25, 0, 0, 0.25);
// イベントリスナー
addEventListener(Event.ENTER_FRAME, loop);
}
private function loop(e:Event):void
{
// キラキラ
//_canvas.fillRect(_canvas.rect, 0x000000);
_canvas.applyFilter(_canvas, _canvas.rect, ZERO_POINT, BLUR);
_canvas.draw(viewport, _matrix);
// パーティクルの発生元をくるくる
_rotation += 3;
_emitter.pointA.x = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.pointA.y = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.z = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.y = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.sphereCap.rotationX = 90;
_emitter.sphereCap.rotationZ = -_rotation - 90;
_pixels.rotationX += 0.2;
_pixels.rotationY += 1;
// エミッター更新
_emitter.step();
}
}
}
import frocessing.color.ColorHSV;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.clocks.Clock;
import idv.cjcat.stardust.common.events.EmitterEvent;
import idv.cjcat.stardust.common.initializers.CompositeInitializer;
import idv.cjcat.stardust.common.initializers.SwitchInitializer;
import idv.cjcat.stardust.common.particles.ParticleIterator
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;
import idv.cjcat.stardust.common.renderers.Renderer;
import idv.cjcat.stardust.threeD.actions.Accelerate3D;
import idv.cjcat.stardust.threeD.actions.Move3D;
import idv.cjcat.stardust.threeD.emitters.Emitter3D;
import idv.cjcat.stardust.threeD.initializers.DisplayObjectClass3D;
import idv.cjcat.stardust.threeD.initializers.Position3D;
import idv.cjcat.stardust.threeD.initializers.Velocity3D;
import idv.cjcat.stardust.threeD.particles.Particle3D;
import idv.cjcat.stardust.threeD.zones.SinglePoint3D;
import idv.cjcat.stardust.threeD.zones.SphereCap;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
/**
* エミッター
* @author paq89
*/
class Pixel3DEmitter extends Emitter3D
{
public var pointA:SinglePoint3D = new SinglePoint3D();
public var pointB:SinglePoint3D = new SinglePoint3D();
public var sphereCap:SphereCap = new SphereCap(0, 0, 0, 1, 0, 40);
public function Pixel3DEmitter(clock:Clock)
{
super(clock);
var compInitA:CompositeInitializer = new CompositeInitializer();
compInitA.addInitializer(new Position3D(pointA));
compInitA.addInitializer(new DisplayObjectClass3D(PixelParticleA));
var compInitB:CompositeInitializer = new CompositeInitializer();
compInitB.addInitializer(new Position3D(pointB));
compInitB.addInitializer(new DisplayObjectClass3D(PixelParticleB));
var switchInit:SwitchInitializer = new SwitchInitializer([compInitA, compInitB],[1,1]);
addInitializer(switchInit);
addInitializer(new Life(new UniformRandom(90, 0)));
addInitializer(new Velocity3D(sphereCap));
addAction(new Move3D());
addAction(new Age());
addAction(new DeathLife());
addAction(new Accelerate3D(0.05));
}
}
/**
* パーティクル
* @author paq89
*/
class PixelParticleA extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(0, 1, 0.7);
public function PixelParticleA()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
class PixelParticleB extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(70, 1, 0.7);
public function PixelParticleB()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
/**
* Pixel3D専用レンダラー
* @author paq89
*/
class PV3DPixelsRenderer extends Renderer
{
private var container:Pixels;
public function PV3DPixelsRenderer(container:Pixels = null)
{
this.container = container;
}
override protected function particlesAdded(e:EmitterEvent):void
{
if (!container) return;
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
container.addPixel3D(pixel);
particle.dictionary[PV3DPixelsRenderer] = container;
iter.next();
}
}
override protected function particlesRemoved(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
var container:Pixels = particle.dictionary[PV3DPixelsRenderer] as Pixels;
container.removePixel3D(pixel);
iter.next();
}
}
override protected function render(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
pixel.x = particle.x;
pixel.y = particle.y;
pixel.z = particle.z;
iter.next();
}
}
}

[Stardust] Pixel3D with a brilliant radiance forked from: [Stardust] Pixel3D with a brilliant radiance [diff(1)]

hacker_47ryxtat

// forked from paq's [Stardust] Pixel3D with a brilliant radiance
package
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BlurFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import frocessing.color.FColor;
import idv.cjcat.stardust.common.clocks.SteadyClock;
import idv.cjcat.stardust.common.emitters.Emitter;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObject3DRenderer;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObjectRenderer;
import org.papervision3d.core.effects.BitmapLayerEffect;
import org.papervision3d.core.effects.view.ReflectionView;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
import org.papervision3d.core.math.Number3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.view.BasicView;
import org.papervision3d.view.layer.BitmapEffectLayer;
/**
* ...
* @author paq89
*/
[SWF(width = 465, height = 465, backgroundColor = 0xFFFFFF, frameRate = 60)]
public class Main extends BasicView
{
private const ZERO_POINT:Point = new Point(0, 0);
private const BLUR:BlurFilter = new BlurFilter(4, 4, 1);
private var _emitter:Pixel3DEmitter;
private var _pixels:Pixels;
private var _canvas:BitmapData;
private var _matrix:Matrix;
private var _rotation:Number = 0;
public function Main():void
{
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
private function init(e:Event = null):void
{
removeEventListener(Event.ADDED_TO_STAGE, init);
// 背景色を設定
opaqueBackground = 0x000000;
// レンダリング開始
startRendering();
// キラキラエフェクト用BitmapEffectLayer
var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, 465, 465, true, 0, "clear_pre", true);
layer.clearBeforeRender = true;
viewport.containerSprite.addLayer(layer);
// Pixels
_pixels = new Pixels(layer);
scene.addChild(_pixels);
// エミッター
_emitter = new Pixel3DEmitter(new SteadyClock(10));
// レンダラー
var renderer:PV3DPixelsRenderer = new PV3DPixelsRenderer(_pixels);
renderer.addEmitter(_emitter);
// キラキラエフェクト
_canvas=new BitmapData(465 / 4, 465 / 4, false, 0x000000);
var bmp:Bitmap=new Bitmap(_canvas, "never", true);
bmp.scaleX=bmp.scaleY=4;
bmp.smoothing=true;
bmp.blendMode=BlendMode.ADD;
addChild(bmp);
_matrix = new Matrix(0.25, 0, 0, 0.25);
// イベントリスナー
addEventListener(Event.ENTER_FRAME, loop);
}
private function loop(e:Event):void
{
// キラキラ
//_canvas.fillRect(_canvas.rect, 0x000000);
_canvas.applyFilter(_canvas, _canvas.rect, ZERO_POINT, BLUR);
_canvas.draw(viewport, _matrix);
// パーティクルの発生元をくるくる
_rotation += 3;
_emitter.pointA.x = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.pointA.y = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.z = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.y = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.sphereCap.rotationX = 90;
_emitter.sphereCap.rotationZ = -_rotation - 90;
_pixels.rotationX += 0.2;
_pixels.rotationY += 1;
// エミッター更新
_emitter.step();
}
}
}
import frocessing.color.ColorHSV;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.clocks.Clock;
import idv.cjcat.stardust.common.events.EmitterEvent;
import idv.cjcat.stardust.common.initializers.CompositeInitializer;
import idv.cjcat.stardust.common.initializers.SwitchInitializer;
import idv.cjcat.stardust.common.particles.ParticleIterator
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;
import idv.cjcat.stardust.common.renderers.Renderer;
import idv.cjcat.stardust.threeD.actions.Accelerate3D;
import idv.cjcat.stardust.threeD.actions.Move3D;
import idv.cjcat.stardust.threeD.emitters.Emitter3D;
import idv.cjcat.stardust.threeD.initializers.DisplayObjectClass3D;
import idv.cjcat.stardust.threeD.initializers.Position3D;
import idv.cjcat.stardust.threeD.initializers.Velocity3D;
import idv.cjcat.stardust.threeD.particles.Particle3D;
import idv.cjcat.stardust.threeD.zones.SinglePoint3D;
import idv.cjcat.stardust.threeD.zones.SphereCap;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
/**
* エミッター
* @author paq89
*/
class Pixel3DEmitter extends Emitter3D
{
public var pointA:SinglePoint3D = new SinglePoint3D();
public var pointB:SinglePoint3D = new SinglePoint3D();
public var sphereCap:SphereCap = new SphereCap(0, 0, 0, 1, 0, 40);
public function Pixel3DEmitter(clock:Clock)
{
super(clock);
var compInitA:CompositeInitializer = new CompositeInitializer();
compInitA.addInitializer(new Position3D(pointA));
compInitA.addInitializer(new DisplayObjectClass3D(PixelParticleA));
var compInitB:CompositeInitializer = new CompositeInitializer();
compInitB.addInitializer(new Position3D(pointB));
compInitB.addInitializer(new DisplayObjectClass3D(PixelParticleB));
var switchInit:SwitchInitializer = new SwitchInitializer([compInitA, compInitB],[1,1]);
addInitializer(switchInit);
addInitializer(new Life(new UniformRandom(90, 0)));
addInitializer(new Velocity3D(sphereCap));
addAction(new Move3D());
addAction(new Age());
addAction(new DeathLife());
addAction(new Accelerate3D(0.05));
}
}
/**
* パーティクル
* @author paq89
*/
class PixelParticleA extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(0, 1, 0.7);
public function PixelParticleA()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
class PixelParticleB extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(70, 1, 0.7);
public function PixelParticleB()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
/**
* Pixel3D専用レンダラー
* @author paq89
*/
class PV3DPixelsRenderer extends Renderer
{
private var container:Pixels;
public function PV3DPixelsRenderer(container:Pixels = null)
{
this.container = container;
}
override protected function particlesAdded(e:EmitterEvent):void
{
if (!container) return;
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
container.addPixel3D(pixel);
particle.dictionary[PV3DPixelsRenderer] = container;
iter.next();
}
}
override protected function particlesRemoved(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
var container:Pixels = particle.dictionary[PV3DPixelsRenderer] as Pixels;
container.removePixel3D(pixel);
iter.next();
}
}
override protected function render(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
pixel.x = particle.x;
pixel.y = particle.y;
pixel.z = particle.z;
iter.next();
}
}
}

[Stardust] Pixel3D with a brilliant radiance forked from: [Stardust] Pixel3D with a brilliant radiance [diff(1)]

ayumegu0615

// forked from paq's [Stardust] Pixel3D with a brilliant radiance
package
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BlurFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import frocessing.color.FColor;
import idv.cjcat.stardust.common.clocks.SteadyClock;
import idv.cjcat.stardust.common.emitters.Emitter;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObject3DRenderer;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObjectRenderer;
import org.papervision3d.core.effects.BitmapLayerEffect;
import org.papervision3d.core.effects.view.ReflectionView;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
import org.papervision3d.core.math.Number3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.view.BasicView;
import org.papervision3d.view.layer.BitmapEffectLayer;
/**
* ...
* @author paq89
*/
[SWF(width = 465, height = 465, backgroundColor = 0xFFFFFF, frameRate = 60)]
public class Main extends BasicView
{
private const ZERO_POINT:Point = new Point(0, 0);
private const BLUR:BlurFilter = new BlurFilter(4, 4, 1);
private var _emitter:Pixel3DEmitter;
private var _pixels:Pixels;
private var _canvas:BitmapData;
private var _matrix:Matrix;
private var _rotation:Number = 0;
public function Main():void
{
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
private function init(e:Event = null):void
{
removeEventListener(Event.ADDED_TO_STAGE, init);
// 背景色を設定
opaqueBackground = 0x000000;
// レンダリング開始
startRendering();
// キラキラエフェクト用BitmapEffectLayer
var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, 465, 465, true, 0, "clear_pre", true);
layer.clearBeforeRender = true;
viewport.containerSprite.addLayer(layer);
// Pixels
_pixels = new Pixels(layer);
scene.addChild(_pixels);
// エミッター
_emitter = new Pixel3DEmitter(new SteadyClock(10));
// レンダラー
var renderer:PV3DPixelsRenderer = new PV3DPixelsRenderer(_pixels);
renderer.addEmitter(_emitter);
// キラキラエフェクト
_canvas=new BitmapData(465 / 4, 465 / 4, false, 0x000000);
var bmp:Bitmap=new Bitmap(_canvas, "never", true);
bmp.scaleX=bmp.scaleY=4;
bmp.smoothing=true;
bmp.blendMode=BlendMode.ADD;
addChild(bmp);
_matrix = new Matrix(0.25, 0, 0, 0.25);
// イベントリスナー
addEventListener(Event.ENTER_FRAME, loop);
}
private function loop(e:Event):void
{
// キラキラ
//_canvas.fillRect(_canvas.rect, 0x000000);
_canvas.applyFilter(_canvas, _canvas.rect, ZERO_POINT, BLUR);
_canvas.draw(viewport, _matrix);
// パーティクルの発生元をくるくる
_rotation += 3;
_emitter.pointA.x = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.pointA.y = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.z = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.y = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.sphereCap.rotationX = 90;
_emitter.sphereCap.rotationZ = -_rotation - 90;
_pixels.rotationX += 0.2;
_pixels.rotationY += 1;
// エミッター更新
_emitter.step();
}
}
}
import frocessing.color.ColorHSV;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.clocks.Clock;
import idv.cjcat.stardust.common.events.EmitterEvent;
import idv.cjcat.stardust.common.initializers.CompositeInitializer;
import idv.cjcat.stardust.common.initializers.SwitchInitializer;
import idv.cjcat.stardust.common.particles.ParticleIterator
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;
import idv.cjcat.stardust.common.renderers.Renderer;
import idv.cjcat.stardust.threeD.actions.Accelerate3D;
import idv.cjcat.stardust.threeD.actions.Move3D;
import idv.cjcat.stardust.threeD.emitters.Emitter3D;
import idv.cjcat.stardust.threeD.initializers.DisplayObjectClass3D;
import idv.cjcat.stardust.threeD.initializers.Position3D;
import idv.cjcat.stardust.threeD.initializers.Velocity3D;
import idv.cjcat.stardust.threeD.particles.Particle3D;
import idv.cjcat.stardust.threeD.zones.SinglePoint3D;
import idv.cjcat.stardust.threeD.zones.SphereCap;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
/**
* エミッター
* @author paq89
*/
class Pixel3DEmitter extends Emitter3D
{
public var pointA:SinglePoint3D = new SinglePoint3D();
public var pointB:SinglePoint3D = new SinglePoint3D();
public var sphereCap:SphereCap = new SphereCap(0, 0, 0, 1, 0, 40);
public function Pixel3DEmitter(clock:Clock)
{
super(clock);
var compInitA:CompositeInitializer = new CompositeInitializer();
compInitA.addInitializer(new Position3D(pointA));
compInitA.addInitializer(new DisplayObjectClass3D(PixelParticleA));
var compInitB:CompositeInitializer = new CompositeInitializer();
compInitB.addInitializer(new Position3D(pointB));
compInitB.addInitializer(new DisplayObjectClass3D(PixelParticleB));
var switchInit:SwitchInitializer = new SwitchInitializer([compInitA, compInitB],[1,1]);
addInitializer(switchInit);
addInitializer(new Life(new UniformRandom(90, 0)));
addInitializer(new Velocity3D(sphereCap));
addAction(new Move3D());
addAction(new Age());
addAction(new DeathLife());
addAction(new Accelerate3D(0.05));
}
}
/**
* パーティクル
* @author paq89
*/
class PixelParticleA extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(0, 1, 0.7);
public function PixelParticleA()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
class PixelParticleB extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(70, 1, 0.7);
public function PixelParticleB()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
/**
* Pixel3D専用レンダラー
* @author paq89
*/
class PV3DPixelsRenderer extends Renderer
{
private var container:Pixels;
public function PV3DPixelsRenderer(container:Pixels = null)
{
this.container = container;
}
override protected function particlesAdded(e:EmitterEvent):void
{
if (!container) return;
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
container.addPixel3D(pixel);
particle.dictionary[PV3DPixelsRenderer] = container;
iter.next();
}
}
override protected function particlesRemoved(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
var container:Pixels = particle.dictionary[PV3DPixelsRenderer] as Pixels;
container.removePixel3D(pixel);
iter.next();
}
}
override protected function render(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
pixel.x = particle.x;
pixel.y = particle.y;
pixel.z = particle.z;
iter.next();
}
}
}

[Stardust] Pixel3D with a brilliant radiance forked from: [Stardust] Pixel3D with a brilliant radiance [diff(1)]

elecgon

// forked from paq's [Stardust] Pixel3D with a brilliant radiance
package
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BlurFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import frocessing.color.FColor;
import idv.cjcat.stardust.common.clocks.SteadyClock;
import idv.cjcat.stardust.common.emitters.Emitter;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObject3DRenderer;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObjectRenderer;
import org.papervision3d.core.effects.BitmapLayerEffect;
import org.papervision3d.core.effects.view.ReflectionView;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
import org.papervision3d.core.math.Number3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.view.BasicView;
import org.papervision3d.view.layer.BitmapEffectLayer;
/**
* ...
* @author paq89
*/
[SWF(width = 465, height = 465, backgroundColor = 0xFFFFFF, frameRate = 60)]
public class Main extends BasicView
{
private const ZERO_POINT:Point = new Point(0, 0);
private const BLUR:BlurFilter = new BlurFilter(4, 4, 1);
private var _emitter:Pixel3DEmitter;
private var _pixels:Pixels;
private var _canvas:BitmapData;
private var _matrix:Matrix;
private var _rotation:Number = 0;
public function Main():void
{
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
private function init(e:Event = null):void
{
removeEventListener(Event.ADDED_TO_STAGE, init);
// 背景色を設定
opaqueBackground = 0x000000;
// レンダリング開始
startRendering();
// キラキラエフェクト用BitmapEffectLayer
var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, 465, 465, true, 0, "clear_pre", true);
layer.clearBeforeRender = true;
viewport.containerSprite.addLayer(layer);
// Pixels
_pixels = new Pixels(layer);
scene.addChild(_pixels);
// エミッター
_emitter = new Pixel3DEmitter(new SteadyClock(10));
// レンダラー
var renderer:PV3DPixelsRenderer = new PV3DPixelsRenderer(_pixels);
renderer.addEmitter(_emitter);
// キラキラエフェクト
_canvas=new BitmapData(465 / 4, 465 / 4, false, 0x000000);
var bmp:Bitmap=new Bitmap(_canvas, "never", true);
bmp.scaleX=bmp.scaleY=4;
bmp.smoothing=true;
bmp.blendMode=BlendMode.ADD;
addChild(bmp);
_matrix = new Matrix(0.25, 0, 0, 0.25);
// イベントリスナー
addEventListener(Event.ENTER_FRAME, loop);
}
private function loop(e:Event):void
{
// キラキラ
//_canvas.fillRect(_canvas.rect, 0x000000);
_canvas.applyFilter(_canvas, _canvas.rect, ZERO_POINT, BLUR);
_canvas.draw(viewport, _matrix);
// パーティクルの発生元をくるくる
_rotation += 3;
_emitter.pointA.x = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.pointA.y = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.z = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.y = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.sphereCap.rotationX = 90;
_emitter.sphereCap.rotationZ = -_rotation - 90;
_pixels.rotationX += 0.2;
_pixels.rotationY += 1;
// エミッター更新
_emitter.step();
}
}
}
import frocessing.color.ColorHSV;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.clocks.Clock;
import idv.cjcat.stardust.common.events.EmitterEvent;
import idv.cjcat.stardust.common.initializers.CompositeInitializer;
import idv.cjcat.stardust.common.initializers.SwitchInitializer;
import idv.cjcat.stardust.common.particles.ParticleIterator
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;
import idv.cjcat.stardust.common.renderers.Renderer;
import idv.cjcat.stardust.threeD.actions.Accelerate3D;
import idv.cjcat.stardust.threeD.actions.Move3D;
import idv.cjcat.stardust.threeD.emitters.Emitter3D;
import idv.cjcat.stardust.threeD.initializers.DisplayObjectClass3D;
import idv.cjcat.stardust.threeD.initializers.Position3D;
import idv.cjcat.stardust.threeD.initializers.Velocity3D;
import idv.cjcat.stardust.threeD.particles.Particle3D;
import idv.cjcat.stardust.threeD.zones.SinglePoint3D;
import idv.cjcat.stardust.threeD.zones.SphereCap;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
/**
* エミッター
* @author paq89
*/
class Pixel3DEmitter extends Emitter3D
{
public var pointA:SinglePoint3D = new SinglePoint3D();
public var pointB:SinglePoint3D = new SinglePoint3D();
public var sphereCap:SphereCap = new SphereCap(0, 0, 0, 1, 0, 40);
public function Pixel3DEmitter(clock:Clock)
{
super(clock);
var compInitA:CompositeInitializer = new CompositeInitializer();
compInitA.addInitializer(new Position3D(pointA));
compInitA.addInitializer(new DisplayObjectClass3D(PixelParticleA));
var compInitB:CompositeInitializer = new CompositeInitializer();
compInitB.addInitializer(new Position3D(pointB));
compInitB.addInitializer(new DisplayObjectClass3D(PixelParticleB));
var switchInit:SwitchInitializer = new SwitchInitializer([compInitA, compInitB],[1,1]);
addInitializer(switchInit);
addInitializer(new Life(new UniformRandom(90, 0)));
addInitializer(new Velocity3D(sphereCap));
addAction(new Move3D());
addAction(new Age());
addAction(new DeathLife());
addAction(new Accelerate3D(0.05));
}
}
/**
* パーティクル
* @author paq89
*/
class PixelParticleA extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(0, 1, 0.7);
public function PixelParticleA()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
class PixelParticleB extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(70, 1, 0.7);
public function PixelParticleB()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
/**
* Pixel3D専用レンダラー
* @author paq89
*/
class PV3DPixelsRenderer extends Renderer
{
private var container:Pixels;
public function PV3DPixelsRenderer(container:Pixels = null)
{
this.container = container;
}
override protected function particlesAdded(e:EmitterEvent):void
{
if (!container) return;
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
container.addPixel3D(pixel);
particle.dictionary[PV3DPixelsRenderer] = container;
iter.next();
}
}
override protected function particlesRemoved(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
var container:Pixels = particle.dictionary[PV3DPixelsRenderer] as Pixels;
container.removePixel3D(pixel);
iter.next();
}
}
override protected function render(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
pixel.x = particle.x;
pixel.y = particle.y;
pixel.z = particle.z;
iter.next();
}
}
}

[Stardust] Pixel3D with a brilliant radiance forked from: [Stardust] Pixel3D with a brilliant radiance [diff(1)]

namagome

// forked from paq's [Stardust] Pixel3D with a brilliant radiance
package
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BlurFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import frocessing.color.FColor;
import idv.cjcat.stardust.common.clocks.SteadyClock;
import idv.cjcat.stardust.common.emitters.Emitter;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObject3DRenderer;
import idv.cjcat.stardust.threeD.papervision3d.renderers.PV3DDisplayObjectRenderer;
import org.papervision3d.core.effects.BitmapLayerEffect;
import org.papervision3d.core.effects.view.ReflectionView;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
import org.papervision3d.core.math.Number3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.view.BasicView;
import org.papervision3d.view.layer.BitmapEffectLayer;
/**
* ...
* @author paq89
*/
[SWF(width = 465, height = 465, backgroundColor = 0xFFFFFF, frameRate = 60)]
public class Main extends BasicView
{
private const ZERO_POINT:Point = new Point(0, 0);
private const BLUR:BlurFilter = new BlurFilter(4, 4, 1);
private var _emitter:Pixel3DEmitter;
private var _pixels:Pixels;
private var _canvas:BitmapData;
private var _matrix:Matrix;
private var _rotation:Number = 0;
public function Main():void
{
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
private function init(e:Event = null):void
{
removeEventListener(Event.ADDED_TO_STAGE, init);
// 背景色を設定
opaqueBackground = 0x000000;
// レンダリング開始
startRendering();
// キラキラエフェクト用BitmapEffectLayer
var layer:BitmapEffectLayer=new BitmapEffectLayer(viewport, 465, 465, true, 0, "clear_pre", true);
layer.clearBeforeRender = true;
viewport.containerSprite.addLayer(layer);
// Pixels
_pixels = new Pixels(layer);
scene.addChild(_pixels);
// エミッター
_emitter = new Pixel3DEmitter(new SteadyClock(10));
// レンダラー
var renderer:PV3DPixelsRenderer = new PV3DPixelsRenderer(_pixels);
renderer.addEmitter(_emitter);
// キラキラエフェクト
_canvas=new BitmapData(465 / 4, 465 / 4, false, 0x000000);
var bmp:Bitmap=new Bitmap(_canvas, "never", true);
bmp.scaleX=bmp.scaleY=4;
bmp.smoothing=true;
bmp.blendMode=BlendMode.ADD;
addChild(bmp);
_matrix = new Matrix(0.25, 0, 0, 0.25);
// イベントリスナー
addEventListener(Event.ENTER_FRAME, loop);
}
private function loop(e:Event):void
{
// キラキラ
//_canvas.fillRect(_canvas.rect, 0x000000);
_canvas.applyFilter(_canvas, _canvas.rect, ZERO_POINT, BLUR);
_canvas.draw(viewport, _matrix);
// パーティクルの発生元をくるくる
_rotation += 3;
_emitter.pointA.x = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.pointA.y = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.z = 400 * Math.cos(_rotation * Number3D.toRADIANS);
_emitter.pointB.y = 400 * Math.sin(_rotation * Number3D.toRADIANS);
_emitter.sphereCap.rotationX = 90;
_emitter.sphereCap.rotationZ = -_rotation - 90;
_pixels.rotationX += 0.2;
_pixels.rotationY += 1;
// エミッター更新
_emitter.step();
}
}
}
import frocessing.color.ColorHSV;
import idv.cjcat.stardust.common.actions.Age;
import idv.cjcat.stardust.common.actions.DeathLife;
import idv.cjcat.stardust.common.clocks.Clock;
import idv.cjcat.stardust.common.events.EmitterEvent;
import idv.cjcat.stardust.common.initializers.CompositeInitializer;
import idv.cjcat.stardust.common.initializers.SwitchInitializer;
import idv.cjcat.stardust.common.particles.ParticleIterator
import idv.cjcat.stardust.common.initializers.Life;
import idv.cjcat.stardust.common.math.UniformRandom;
import idv.cjcat.stardust.common.renderers.Renderer;
import idv.cjcat.stardust.threeD.actions.Accelerate3D;
import idv.cjcat.stardust.threeD.actions.Move3D;
import idv.cjcat.stardust.threeD.emitters.Emitter3D;
import idv.cjcat.stardust.threeD.initializers.DisplayObjectClass3D;
import idv.cjcat.stardust.threeD.initializers.Position3D;
import idv.cjcat.stardust.threeD.initializers.Velocity3D;
import idv.cjcat.stardust.threeD.particles.Particle3D;
import idv.cjcat.stardust.threeD.zones.SinglePoint3D;
import idv.cjcat.stardust.threeD.zones.SphereCap;
import org.papervision3d.core.geom.Pixels;
import org.papervision3d.core.geom.renderables.Pixel3D;
/**
* エミッター
* @author paq89
*/
class Pixel3DEmitter extends Emitter3D
{
public var pointA:SinglePoint3D = new SinglePoint3D();
public var pointB:SinglePoint3D = new SinglePoint3D();
public var sphereCap:SphereCap = new SphereCap(0, 0, 0, 1, 0, 40);
public function Pixel3DEmitter(clock:Clock)
{
super(clock);
var compInitA:CompositeInitializer = new CompositeInitializer();
compInitA.addInitializer(new Position3D(pointA));
compInitA.addInitializer(new DisplayObjectClass3D(PixelParticleA));
var compInitB:CompositeInitializer = new CompositeInitializer();
compInitB.addInitializer(new Position3D(pointB));
compInitB.addInitializer(new DisplayObjectClass3D(PixelParticleB));
var switchInit:SwitchInitializer = new SwitchInitializer([compInitA, compInitB],[1,1]);
addInitializer(switchInit);
addInitializer(new Life(new UniformRandom(90, 0)));
addInitializer(new Velocity3D(sphereCap));
addAction(new Move3D());
addAction(new Age());
addAction(new DeathLife());
addAction(new Accelerate3D(0.05));
}
}
/**
* パーティクル
* @author paq89
*/
class PixelParticleA extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(0, 1, 0.7);
public function PixelParticleA()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
class PixelParticleB extends Pixel3D
{
private static var hsv:ColorHSV = new ColorHSV(70, 1, 0.7);
public function PixelParticleB()
{
hsv.h += 0.1;
super(hsv.value32);
}
}
/**
* Pixel3D専用レンダラー
* @author paq89
*/
class PV3DPixelsRenderer extends Renderer
{
private var container:Pixels;
public function PV3DPixelsRenderer(container:Pixels = null)
{
this.container = container;
}
override protected function particlesAdded(e:EmitterEvent):void
{
if (!container) return;
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
container.addPixel3D(pixel);
particle.dictionary[PV3DPixelsRenderer] = container;
iter.next();
}
}
override protected function particlesRemoved(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
var container:Pixels = particle.dictionary[PV3DPixelsRenderer] as Pixels;
container.removePixel3D(pixel);
iter.next();
}
}
override protected function render(e:EmitterEvent):void
{
var particle:Particle3D;
var iter:ParticleIterator = e.particles.getIterator();
while (particle = iter.particle as Particle3D)
{
var pixel:Pixel3D = particle.target;
pixel.x = particle.x;
pixel.y = particle.y;
pixel.z = particle.z;
iter.next();
}
}
}