I forrige tutorial brukte vi initializers og handlinger fra de vanlige og twoD pakker. I denne opplæringen, vil vi fortsatt være å bruke elementer fra den vanlige pakken, men ikke fra twoD pakken. I stedet vil vi benytte elementer fra threeD pakken.

klassestrukturen i threeD pakken er stort sett den samme som i den twoD pakken, med unntak av at elementene har en ekstra dimensjon. En 3D-element besitter samme navn som sin 2D motstykke, men navnet slutter med "3D". For eksempel Move3D
handling i 3D pakkeoppdateringer partikkel stillinger i 3D-rom i henhold til de hastighetene, akkurat som sin 2D motstykke i 2D pakken, Flytt
handling.

Denne koden går i StarEmitter konstruktør funksjon.
addInitializer (nytt liv (ny UniformRandom (LIFE_AVG, LIFE_VAR))); addInitializer (ny Scale (ny UniformRandom (SCALE_AVG, SCALE_VAR))); addInitializer (ny Position3D (ny SinglePoint3D ())); addInitializer (ny Velocity3D (ny SphereShell (0, 0, 0, SPEED_AVG , SPEED_VAR))); addInitializer (ny Rotation3D (null, null, ny UniformRandom (0, 180))); addInitializer (ny Omega3D (null, null, ny UniformRandom (OMEGA_AVG, OMEGA_VAR)));

Lag en sammensatt handling, og legge til noen handlinger til det. Deretter legger denne sammensatte tiltak for å emitter; dette vil gjøre partiklene utføre handlingene. Du har sett disse handlingene i forrige tutorial (noen av dem i 2D-versjon), så jeg vil ikke forklare dem på nytt. Igjen, går denne koden i StarEmitter konstruktør funksjon:
pausibleActions = new CompositeAction (); pausibleActions.addAction (New Age ()); pausibleActions.addAction (ny DeathLife ()); pausibleActions.addAction (ny Move3D ()); pausibleActions.addAction (ny Spin3D ()); pausibleActions.addAction (ny Damping3D (demping)); pausibleActions.addAction (ny ScaleCurve (GROWING_TIME, SHRINKING_TIME)); addAction (pausibleActions);

Greit, vi er ferdige med emitter. Nå er det på tide å bygge vårt dokument klasse

Først erklærer konstanter for bane kameraets radius, kameraet avstanden fra origo og emitter rate:
privat statisk konst CAMERA_RADIUS: Nummer = 250; privat statisk. konst PARTICLE_RATE: Nummer = 0,5;

(Som før consts gå inn i klassen, men utenfor konstruksjonsfunksjonen.)

Deretter deklarere variabler for en emitter, en stabil klokke og en DisplayObjectRenderer3D (i samme sted som consts):
private Var emitter: StarEmitter; private Var klokke: SteadyClock; private Var renderer: DisplayObjectRenderer3D;

I konstruktøren, initialisere klokke, emitter og renderer. Sett også innledende kameraets posisjon og retning, slik at det ser på opprinnelsen:
//skape klokken og emitterclock = new SteadyClock (PARTICLE_RATE); emitter = new StarEmitter (klokke); //vi kan gjøre dette fordi vi ga StarEmitter konstruktør en klokke parameter //skape renderer og emballasjen spritevar container: Sprite = new Sprite (); container.x = 320, container.y = 200; renderer = new DisplayObjectRenderer3D (container ); renderer.addEmitter (emitter); //legger beholderen til stageaddChild (container); //legge på pauseknappen igjen, slik at det er på toppen av containeraddChild (pause_btn); //satt kameraets utgangsposisjonen og directionrenderer .camera.position.set (0, 0, -CAMERA_RADIUS); renderer.camera.direction.set (0, 0, CAMERA_RADIUS);

Opprett en handler funksjon i dokumentet klassen til å håndtere et klikk tilfelle på pauseknappen:
privat funksjon togglePause (e: MouseEvent): void {if (e.target.label == "Pause") {e.target.label = "Gjenoppta"; clock.ticksPerCall = 0; //stoppe klokken emitter.pausibleActions.active = false; //deaktivere emitter handlinger} else {e.target.label = "Pause"; clock.ticksPerCall = PARTICLE_RATE; //starter klokken emitter.pausibleActions.active = true; //reaktivere emitter handlinger}}

.. deretter registrere lytteren for pauseknappen, i konstruktør-funksjon:
pause_btn.addEventListener (MouseEvent.CLICK, togglePause);

Opprett et behandlingsprogram for ENTER_FRAME hendelsen. Dette er vårt viktigste loop. Den oppdaterer kameraets posisjon ved å ringe updateCamera () metode (som vi vil kode i et minutt) og kaller emitter er trinn () -metoden, som holder partikkel effekter kjører:
privat funksjon mainLoop (e: Hendelses): void {updateCamera (); emitter.step ();}

Igjen, registrere en lytter i konstruktøren:
addEventListener (Event.ENTER_FRAME, mainLoop);

Nå definerer updateCamera () metode som kalles i forrige trinn. Dette brukes for å flytte kameraet i 3D-rom avhengig av musens posisjon. (Hvis du ønsker mer informasjon om hvordan det fungerer sjekk ut denne Wikipedia-artikkelen.)

Den magiske tall som brukes til å generere theta og phi er bare et resultat av prøving og feiling; gjerne prøve dine egne ligninger
privat funksjon updateCamera (): void {var theta: Number = 0,02 * (mouseX - 320);. Var phi: Number = 0,02 * (mousey - 200); phi = StardustMath.clamp (phi, -StardustMath.HALF_PI, StardustMath.HALF_PI); var x: Number = CAMERA_RADIUS * Math.cos (theta) * Math.cos (phi); Var y: Number = CAMERA_RADIUS * tak i Math.sin (phi); Var z: Number = CAMERA_RADIUS * tak i Math.sin (theta) * Math.cos (phi); renderer.camera.position.set (x, y, z); renderer.camera.direction.set (-x, -y, -z);}

Legg merke til at jeg brukte StardustMath.clamp () metoden; dette gjør at phi verdien holdes mellom positive og negative halv PI

Ok, vi er ferdig! Det er alt vi trenger å gjøre for å få en 3D-emitter jobbe med Stardust har native 3D-motor. La oss se på resultatet. Du kan klikke på pauseknappen for å stanse partikkel effekt, og flytte musen rundt i bane kameraet:
Demo se det på nettet

Hvis du ønsker å se hele kildekoden, se i mappen som heter " 01 -. Stardust Native 3D Engine "i kilde

Hvis du vil bytte fra Stardust innfødt 3D-motor til Papervision3D er enkelt. Vi må bare bruke en annen renderer og vise objekt initializer.

(Aldri brukt Papervision3D før? Ta en titt på denne nybegynner opplæringen.)

Først vil vi bruke Papervision3D sin Partikler klasse . Du er kanskje ikke kjent med dette; Jeg skal vise deg hvordan du bruker den mer vanlige DisplayObject3D klassen senere

Endre følgende kode i emitter klassen:
Var doc1: DisplayObjectClass3D = new DisplayObjectClass3D (Star); Var doc2: DisplayObjectClass3D = new DisplayObjectClass3D (Circle);

til dette:
Var mat1: MovieParticleMaterial = new MovieParticleMaterial (ny stjerne ()); Var mat2: MovieParticleMaterial = ny MovieParticleMaterial (ny sirkel ()); Var doc1: PV3DParticle = new PV3DParticle ([mat1]); Var doc2: PV3DParticle = new PV3DParticle ([mat2]);

Som du kanskje allerede vet, gjør at MovieParticleMaterial klassen oss til bruke visningsobjekter som partikler 'opptreden i Papervision3D. Vi skaper en stjerne og Circle eksempel skal brukes som partikkelmateriale. Den PV3DParticle initializer tar plassen til den DisplayObjectClass3D initializer; sin konstruktør godtar en rekke parametre, som alle vil bli lagt til en Particles objekt.

Dette er alt vi har å gjøre med hensyn til emitter. Neste vi vil endre dokumentet klassen

Målet beholder for vår renderer er ikke lenger en Sprite objekt. I stedet skal vi skape partikler i en Partikler objekt. Vi må slå renderer type fra DisplayObjectRenderer3D til PV3DParticleRenderer

Erklærer følgende variabler for Papervision3D-relaterte gjenstander:
private Var scene: SceneObject3D; private Var partikler. Partikler; privat Div kamera: Camera3D; private Var opprinnelse: DisplayObject3D; private Var renderEngine: BasicRenderEngine; private Var view: Viewport3D;

Koden i dokumentet klassens konstruktør er nå:
initPV3D (); //dette er ny klokke = new SteadyClock (PARTICLE_RATE);! emitter = new StarEmitter (klokke); renderer = new PV3DParticleRenderer (partikler); //dette er nytt renderer.addEmitter (emitter);! pause_btn.addEventListener (MouseEvent.CLICK, togglePause); addEventListener (Event.ENTER_FRAME, mainLoop);

initPV3D () metoden setter opp Papervision3D Miljø. Her er koden:
privat funksjon initPV3D (): void {//oppretter scene scene = new SceneObject3D (); //oppretter Partikler protestere partikler = nye partikler (); //oppretter kameraet og initial sin posisjon kamera = new Camera3D (); camera.position.x = 0; camera.position.y = 0; camera.position.z = -CAMERA_RADIUS; //oppretter et DO3D representerer opprinnelsen opprinnelse = new DisplayObject3D (); origin.x = origin.y = origin.z = 0; //peker kameraet til opprinnelsen camera.target = opprinnelse; scene.addChild (opprinnelse); scene.addChild (partikler); //oppretter gjengi motor og view renderEngine = new BasicRenderEngine (); view = new Viewport3D (640, 400); //legger synsfeltet til scenen addChild (view); //legger på pauseknappen igjen, slik at det er på toppen av synsfeltet addChild (pause_btn);}

Nå Stardust bare oppdaterer 3D-objektenes egenskaper; Papervision3D sin gjengi motoren tar over ansvaret for rendering. Dette er hva vår nye hoved sløyfe ut:
privat funksjon mainLoop (e: Hendelses): void {updateCamera (); emitter.step (); renderEngine.renderScene (scene, kamera, view); //dette er ny}

Nå som vi bruker Papervision3D kamera, vil vi også nødt til å endre updateCamera () metode:
privat funksjon updateCamera (): void {var theta: Number = 0,02 * (mouseX - 320); Var phi: Number = 0,02 * (mousey - 200); phi = StardustMath.clamp (phi, -StardustMath.HALF_PI, StardustMath.HALF_PI); var x: Number = CAMERA_RADIUS * Math.cos (theta) * Math.cos (phi); Var y: Number = -CAMERA_RADIUS * tak i Math.sin (phi); //oppmerksom på at dette er negativt nå Var z: Number = CAMERA_RADIUS * tak i Math.sin (theta) * Math.cos (phi); camera.x = x; //vi oppdaterer hver av x, y, z egenskaper PV3D kamera separat camera.y = y; camera.z = z;}

Ok, vi har nå byttet fra Stardust innfødt 3D-motor til Papervision3D. La oss nå ta en titt på resultatet. Legg merke til pixelation virkning på partiklene. Det er fordi Papervision3D først trekker vektorobjekter inn bitmaps før du bruker dem som partikkel materialer
Demo se det på nettet

Du finner all kildekoden for dette i "02 - Papervision3D Particles".. Mappen
< hr>
Papervision3D sin DisplayObject3D Class

Så langt har vi jobbet med "2D billboards" - flate gjenstander, som papir. Det er mulig å lage "ekte" 3D partikkel objekter, som Papervision3D sin DisplayObject3D stedene. Vi er bare nødt til å bruke en annen initializer. Nå la oss komme ned til den siste delen av denne opplæringen. Vi vil skape røde og blå kube partikler

Vi kommer til å endre initializer om partikkel utseende for siste gang .

Før det, erklærer en LightObject3D variabel i emitter klassen. Vi kommer til å bruke FlatShadeMaterial for DisplayObject3D gjenstander, som krever en lyskilde. Også, erklærer følgende konstanter - vi vil bruke disse som parametere for FlastShadeMaterial, og for å bestemme kuber 'størrelser:
offentlig Var lys: LightObject3D; private static konst LIGHT_COLOR_1: uint = 0xCC3300; private static konst LIGHT_COLOR_2: uint = 0x006699; private static konst AMBIENT_COLOR_1: uint = 0x881100; private static konst AMBIENT_COLOR_2: uint = 0x002244; private static konst CUBE_SIZE: Number = 15;

Nå endrer følgende kode i emitter-klasse:
Var mat1: MovieParticleMaterial = new MovieParticleMaterial (ny stjerne ()); Var mat2: MovieParticleMaterial = new MovieParticleMaterial (ny sirkel ()); Var doc1: PV3DParticle = new PV3DParticle ([mat1]); Var doc2: PV3DParticle = new PV3DParticle ([mat2]);

til dette:
lys = new LightObject3D (); Var mat1: FlatShadeMaterial = new FlatShadeMaterial (lys, LIGHT_COLOR_1, AMBIENT_COLOR_1); Var mat2: FlatShadeMaterial = new FlatShadeMaterial (lys, LIGHT_COLOR_2, AMBIENT_COLOR_2); Var matList1: MaterialsList = new MaterialsList ({alt: mat1}); Var matList2: MaterialsList = new MaterialsList ({alt: mat2}); Var params1: Array = [matList1, CUBE_SIZE, CUBE_SIZE, CUBE_SIZE]; Var params2: Array = [matList2, CUBE_SIZE , CUBE_SIZE, CUBE_SIZE]; Var doc1: PV3DDisplayObject3DClass = new PV3DDisplayObject3DClass (Cube, params1); Var doc2: PV3DDisplayObject3DClass = new PV3DDisplayObject3DClass (Cube, params2);

Den nye partikkelen utseende vil bli initialisert som røde og blå 3D kuber. Den første konstruktør parameter for PV3DDisplayObject3DClass initializer er den klassen vi ønsker på å bruke for partiklene (så her er det Cube klasse) og den andre parameteren er en rekke konstruktørparametre for dette Cube klassen.

Tidligere fordi vi jobbet med "2D billboards", bare rotasjon om Z-aksen betydde noe. Nå som vi jobber med ekte 3D-objekter, trenger vi å passere tre Tilfeldige objekt referanser til de Rotation3D og Omega3D konstruktører, en for hver akse

Endre følgende kode i emitter klassen.
AddInitializer ( ny Rotation3D (null, null, ny UniformRandom (0, 180))); addInitializer (ny Omega3D (null, null, ny UniformRandom (OMEGA_AVG, OMEGA_VAR)));

til dette:
Var rotationRandom: UniformRandom = ny UniformRandom (0, 180); Var omegaRandom: UniformRandom = new UniformRandom (OMEGA_AVG, OMEGA_VAR); addInitializer (ny Rotation3D (rotationRandom, rotationRandom, rotationRandom)); addInitializer (ny Omega3D (omegaRandom, omegaRandom, omegaRandom));

Denne gangen, i stedet for å bruke en Partikler objekt som vår partikkel container, bruker vi en DisplayObject3D som beholderen. Deklarere en variabel for denne beholderen i dokumentet klassen:
private Var container: DisplayObject3D;

Dessuten trenger vi en annen type renderer for å skape partikler i den nye emballasjen. Endre renderer type fra PV3DParticleRenderer til PV3DDisplayObject3DRenderer. Koden i dokumentet klassens konstruktør skal nå se slik ut:
initPV3D (); klokke = new SteadyClock (PARTICLE_RATE); emitter = new StarEmitter (klokke); renderer = new PV3DDisplayObject3DRenderer (container); //dette har endret renderer.addEmitter (emitter); pause_btn.addEventListener (MouseEvent.CLICK, togglePause); addEventListener (Event.ENTER_FRAME, mainLoop);

I initPV3D () -funksjonen, har vi nå behov for å initial beholderen variabel og legge den til scenen. Legg disse to linjene til slutten av den funksjonen:
container = new DisplayObject3D (); scene.addChild (container);

I den updateCamera () -metoden, ønsker vi å gjøre det lett å følge kameraet, så vi har en illusjon om at lyset alltid "skyter" ut fra våre øyne. Endre følgende kode:
camera.x = x; camera.y = y; camera.z = z;

til dette:
emitter.light.x = camera.x = x; emitter.light .Y = camera.y = y; emitter.light.z = camera.z = z;

Nå lyskilden er alltid på samme punkt som kameraet

Jepp, vi er endelig ferdig med denne opplæringen. Ingen flere koding. La oss ta en titt på vår endelige resultatet, med fancy røde og blå 3D kuber
Demo se det på nettet!

Kildekoden for dette finner du i "Papervision3D DisplayObject3D" -mappen.

arbeidsflyt for å skape 3D-partikkel effekter med Stardust er Konklusjon
ganske mye den samme som for 2D-effekter. Du bare velger et annet sett med initializers, handlinger og renderers. Stardust støtter også andre 3D-motorer, inkludert ZedBox og ND3D. Bruken er nesten den samme. Du må bare bruke et annet sett med initializers og renderers. Du kan selv forlenge initializer, Handling, og Renderer klasser for å arbeide med hvilken 3D motorer du liker!

Nå har du det grunnleggende, hvorfor ikke gå tilbake til consts opprettet i trinn 6 og leke med dem å se effektene?

Jeg håper denne opplæringen hjelper deg å forstå Stardust mer og gjør deg mer kjent og komfortabel med Stardust arbeidsflyt. Takk for lesing!