Particle Labs
It's done...
Samstag, 15. August 2009 von PSY
Hiho,
nach monatelanger Pause (oder auch Faulheit) hab ich mich die Tage wieder mal ans Particle System gesetzt und solange gecoded bis es fertig war
Folgende Funktionen zum Designen der Particle kamen noch hinzu:
SetColor
Farbe festlegen, Variationen, Farbänderung über Zeit
SetLifeTime
Wie der Name schon sagt
SetBlendmode
Lichteffekte (Farbaddition)
SetHelix
Drehung festlegen (gut für Wirbelstürme u.ä. Effekte)
SetHorizontal
Particle "legt" sich auf den Boden (gut für Wasserringe, Blätter, Papier usw)
SetAngle
Inneren und äusseren Emissionswinkel festlegen
SetEmissionMode
Ring, Fläche, Punkt usw
SetOffsets
Partikel verschieben / Emissionsmodi konfigurieren
SetBounce
Bodenhöhe, Elastizität, Anzahl der Sprünge
SetTrail
Partikel hinterlassen Spuren (ebenfalls konfigurierbar)
CamFade
Ab welchem z-Abstand zur Cam soll der Partikel anfangen zu faden?
CloneParticleType
Anhand eines bestehenden Partikels einen neuen clonen. Gut für ähnliche Partikel
Dazu kamen noch einige Säuberungsfunktionen:
Einzelne oder alle Emitter stoppen
Partikel löschen
Partikelsystem killen
Trails löschen
Die Ausrichtung der Partikel anhand ihrer Flugbahn gefiel mir auch noch nicht, deswegen hab ich sie folgendermassen verändert:
Der 3D Punkt, wo der Partikel ursprünglich entstand, wird gespeichert.
Der letze Aufenthaltspunkt des Partikels vor der erneuten Positionsberechnung wird gespeichert.
Beide Raumvektoren werden voneinander subtrahiert und das Ergebnis halbiert.
An dem so errechneten Punkt wird der Partikel dann ausgerichtet (Y-Achse)
Tja, das wars eigentlich. Das Projekt wird allerdings nur für eigene Zwecke benutzt, mehr dazu im Showcase.
L8er,
PSY
nach monatelanger Pause (oder auch Faulheit) hab ich mich die Tage wieder mal ans Particle System gesetzt und solange gecoded bis es fertig war
Folgende Funktionen zum Designen der Particle kamen noch hinzu:
SetColor
Farbe festlegen, Variationen, Farbänderung über Zeit
SetLifeTime
Wie der Name schon sagt
SetBlendmode
Lichteffekte (Farbaddition)
SetHelix
Drehung festlegen (gut für Wirbelstürme u.ä. Effekte)
SetHorizontal
Particle "legt" sich auf den Boden (gut für Wasserringe, Blätter, Papier usw)
SetAngle
Inneren und äusseren Emissionswinkel festlegen
SetEmissionMode
Ring, Fläche, Punkt usw
SetOffsets
Partikel verschieben / Emissionsmodi konfigurieren
SetBounce
Bodenhöhe, Elastizität, Anzahl der Sprünge
SetTrail
Partikel hinterlassen Spuren (ebenfalls konfigurierbar)
CamFade
Ab welchem z-Abstand zur Cam soll der Partikel anfangen zu faden?
CloneParticleType
Anhand eines bestehenden Partikels einen neuen clonen. Gut für ähnliche Partikel
Dazu kamen noch einige Säuberungsfunktionen:
Einzelne oder alle Emitter stoppen
Partikel löschen
Partikelsystem killen
Trails löschen
Die Ausrichtung der Partikel anhand ihrer Flugbahn gefiel mir auch noch nicht, deswegen hab ich sie folgendermassen verändert:
Der 3D Punkt, wo der Partikel ursprünglich entstand, wird gespeichert.
Der letze Aufenthaltspunkt des Partikels vor der erneuten Positionsberechnung wird gespeichert.
Beide Raumvektoren werden voneinander subtrahiert und das Ergebnis halbiert.
An dem so errechneten Punkt wird der Partikel dann ausgerichtet (Y-Achse)
Tja, das wars eigentlich. Das Projekt wird allerdings nur für eigene Zwecke benutzt, mehr dazu im Showcase.
L8er,
PSY
Variationen sind das Spice des Particles
Donnerstag, 5. März 2009 von PSY
Hiho,
endlich hab ich mal wieder was geschafft, wenn auch wenig.
Die Abfrage, ob Particle sich im Sichtbereich der Cam befinden oder nicht und somit gerendert/nicht gerendert werden müssen, habe ich elegant und schnell durch die Pyramiden-Sichtkegelmethode gelöst.
Näheres dazu hier:
https://www.blitzforum.de/foru...hp?t=30927
Folgende Funktionen zum Designen der Particle hab ich hinzugefügt bzw. verbessert:
Setspeed
Ausgangsgeschwindigkeit +- Toleranz festlegen, Beschleunigung +- over time
SetChaoticSpeed
Geschwindigkeitsänderungen in x,y,z Richtung over time festlegen
SetSize
Ausgangsgrösse +- Toleranz festlegen, Wachstum/Schrumpfen over time, Maxgrösse festlegen
SetAlpha
Initialer Alphawert +- Toleranz festlegen, +- Alphawert ändern over time
SetWeight
Ausgangsgewicht +- Toleranz festlegen
SetMotion
Modus 1: Face Camera mit festem Drehwinkel
Modus 2: Face Camera mit Rotation °/sec
Modus 3: Ausrichten an Bewegungsrichtung
Modus 4: Crazymode. Particle dreht sich zufällig um x, y und z Achse. Nützlich für Funkensimulationen u.ä.
Das wars erstmal wieder,
weitere Funktionen zum Particledesign folgen.
L8er,
PSY
endlich hab ich mal wieder was geschafft, wenn auch wenig.
Die Abfrage, ob Particle sich im Sichtbereich der Cam befinden oder nicht und somit gerendert/nicht gerendert werden müssen, habe ich elegant und schnell durch die Pyramiden-Sichtkegelmethode gelöst.
Näheres dazu hier:
https://www.blitzforum.de/foru...hp?t=30927
Folgende Funktionen zum Designen der Particle hab ich hinzugefügt bzw. verbessert:
Setspeed
Ausgangsgeschwindigkeit +- Toleranz festlegen, Beschleunigung +- over time
SetChaoticSpeed
Geschwindigkeitsänderungen in x,y,z Richtung over time festlegen
SetSize
Ausgangsgrösse +- Toleranz festlegen, Wachstum/Schrumpfen over time, Maxgrösse festlegen
SetAlpha
Initialer Alphawert +- Toleranz festlegen, +- Alphawert ändern over time
SetWeight
Ausgangsgewicht +- Toleranz festlegen
SetMotion
Modus 1: Face Camera mit festem Drehwinkel
Modus 2: Face Camera mit Rotation °/sec
Modus 3: Ausrichten an Bewegungsrichtung
Modus 4: Crazymode. Particle dreht sich zufällig um x, y und z Achse. Nützlich für Funkensimulationen u.ä.
Das wars erstmal wieder,
weitere Funktionen zum Particledesign folgen.
L8er,
PSY
ES WERDE LICHT !
Montag, 23. Februar 2009 von PSY
Hiho,
ok die Phase der Faulheit ist erstmal vorbei...zumindest bis nach Erstellen dieses Posts
Die Nacht habe ich mich endlich an die fehlende Berechnung und Ausgabe der Partikel an sich (damit man auch mal was sieht *g*) rangemacht. Nachdem ich fertig war und nen Testlauf gestartet hab, sah ich erstmal NICHTS
Ok, also erstmal alle Variablennamen gecheckt, und alle Funktionsübergabevariablen auf Namen und Typ (Float, Integer...) überprüft. Ich konnte gar nicht glauben, was da alles falsch war
Naja das kommt halt davon, wenn man das ganze Gerüst coded, ohne Testläufe machen zu können...wie auch ^^
Nachdem ich das alles mal ausgebügelt hatte, nächster Testlauf....und wieder NIX
Nach ca. 10 Minuten hab ich rausgefunden, dass ich nen weiteren Schreibfehler in den UV-Koordinaten hatte...letztendlich war die Grösse jedes Partikels 0
Neuer Testlauf....MAN SIEHT WAS
Und zwar genau 1 grossen Particle, der dumm im Mesh rumsteht und sich nicht bewegt...naja immerhin *g*
Nach fast ner halben Stunde Fehlersuche hatte ich das Problem gefunden...ein Schreibfehler ausgerechnet in der Variable, die die Differenz in Millisekunden zwischen dem aktuellen und dem letzen Update des Particlesystems misst...anstatt pl_looptime hab ich pl_looptme geschrieben...welche somit immer 0 war.
Tja, da ich mit dieser Variable so ziemlich alle Veränderungen berechne (Bewegung, Alpha, Farben, Grösse....) war das natürlich dumm gelaufen....
Naja soviel zu der Vorgeschichte, jetzt gehts erstmal wieder ins Technische
Im letzten Worklog wurden ja bereits die Partikel vom Emitter erstellt und mit Werten gefüttert.
Folgendes ist nun hinzugekommen
Alle Particle werden geupdatet (erstmal nur auf Position)
Das passiert grob folgendermassen:
Erstmal Gesamtzahl Particle und die Anzahl der gerenderten Particle auf 0 setzen
Surface(s) löschen...evt kommen ja noch welche hinzu wegen verschiedener Blendmodes (ich muss jetzt erstmal ParticleTypes erschaffen, also zeichnen und mit Parametern füttern..endlich was das richtig Fun macht hehe)
Jeden Particle loopen, dabei:
ParticleCount um 1 erhöhen, Particletyp merken
Particle x,y,z Position updaten mithilfe oben erwähnter Variable, die die vergangene Zeit zum letzten Particleupdate misst ( z.B. Particle\x = Particle\x + pl_looptime * Particle\vx )
Maximalgrösse Particle abfangen
Muss Particle gelöscht werden (z.B. Lifetime überschritten, Alpha<=0, zu gross.....)
Muss nicht gelöscht werden??? Dann ran ans Rendern, und zwar so:
Überprüfung, ob Particle überhaupt im Cam Sichtbereich ist....
Wenn ja, Anzahl der gerenderten Particle um 1 erhöhen und ab in die Renderfunktion, dabei wird einfach der ganze Type übergeben
Die Renderfunktion sieht dann grob so aus:
Function PL_RENDER (Particle.TParticle)
Variablen erstmal zuweisen, z.b. x,y,z, uv Werte, Farben usw.... (z.B. x=Particle\x, size=Particle\size...)
Ein bei der Initialisierung erstelltes Ghost-Mesh auf die Grösse des Particles skalieren
Ghostmesh an x,y,z Position des Particles positionieren
Ghostmesh auf Cam ausrichten (Alle Particle schauen im Moment nur auf die Cam)
Die 4 Vertices des Ghostmeshes rausfinden und auf das ParticleLabs Hauptmesh übertragen
Vertices einfärben
2 Triangles mit den Vertices erstellen, die ein Quad bilden
...und schon sieht man auch was
Die Funktion, die überprüft ob ein Particle im Sichtbereich ist oder nicht, ist weniger spektakulär:
Function PL_OnScreen (x#, y#, z#)
Mit CameraProject rausfinden, ob x,y und z im aktuellen Auflösungsbereich liegen oder nicht
Wenn ja, Rendern = true, andernfalls Rendern = false ^^
Wobei ich mit dieser Funktion noch nicht zufrieden bin. Die Grösse des Particles wird im Moment noch nicht berücksichtigt. Deshalb können Particle verschwinden, bevor sie komplett aus dem Bildschirm gescrollt sind. Zur Veranschaulichung:
Stellt euch vor, ich fahr mit der Cam extrem nahe an ein Particle ran. Das Particle füllt den halben Bildschirm in x-Richtung aus, bei einer Auflösung von 800*600. Wenn der Mittelpunkt des Particels jetzt gerade den Bildschirm verlässt (was ich mit CameraProject feststellen kann), ist der halbe Particle immer noch auf dem Bildschirm...aber trotzdem wird der Particle nicht mehr gerendert.
Da nützt es auch nicht, die Grösse und Skalierung des Particles mit in die Berechnung einzubeziehen....
Ich müsste eigentlich den Abstand der Cam zum Particle bestimmen, damit und mit der Skalierung und Grösse des Particles UND MIT DER DREHUNG DES PARTICLES die 2D Grösse des Particles bestimmen...was aber viel zu aufwändig wäre...mal sehen welchen Kompromiss ich da finden kann.
Naja aber immerhin funktioniert das System jetzt, auch wenn es eigentlich noch nicht viel kann. Alle Particel drehn sich zur Kamera, Alpha und Farbe werden nicht geändert, es gibt nur Emitter, die Particle von einem Punkt ausspucken, es gibt nur einen Blendmodus, es gibt keine Zufälle und Variationen der Particle...aber das ist jetzt relativ einfach und schnell zu implementieren, ich muss grob gesagt nur ein paar Felder in den Types hinzufügen und ein paar Berechnungen mehr laufen lassen
Immerhin sind Gewicht und Gravitation schon mit eingebunden
Was ich auf jeden Fall noch einbauen will / überlege evt einzubauen:
Alphaänderung der Particle
Farbänderung der Particle
Geschwindigkeitsvariationen
Wachsen/Schrumpfen der Particle
Particlerotation
Verschiedene Arten des Emittierens, z.B. Ring, Zufallsarea, Kreuz, Linie, Tunnel, Trichter...
Absorber
Eventuell Particle, die Subparticle ausstossen...
Particle die nach x Sekunden explodieren
Particle, die bestimmten Bahnen folgen
Andere Ausrichtungen der Particle (immer nur auf Cam ausrichten sucked)
Offsets für die Emitter
Soundanbindung
Achja, zum Speed im Moment:
Knapp 11000 gerenderte Particle werden im Fenstermodus 800*600 mit knapp 86 FPS dargestellt. Wobei sie in Zufallsrichtungen ausgespuckt werden, und nur Gewicht, Gravitation und Y(Emitterspeed) berücksichtigt werden...
So das wars für heut,
hier ist Faasend und ich bin noch nüchtern, geht gar nicht... 8)
Alleh Hopp
PSY
ok die Phase der Faulheit ist erstmal vorbei...zumindest bis nach Erstellen dieses Posts
Die Nacht habe ich mich endlich an die fehlende Berechnung und Ausgabe der Partikel an sich (damit man auch mal was sieht *g*) rangemacht. Nachdem ich fertig war und nen Testlauf gestartet hab, sah ich erstmal NICHTS
Ok, also erstmal alle Variablennamen gecheckt, und alle Funktionsübergabevariablen auf Namen und Typ (Float, Integer...) überprüft. Ich konnte gar nicht glauben, was da alles falsch war
Naja das kommt halt davon, wenn man das ganze Gerüst coded, ohne Testläufe machen zu können...wie auch ^^
Nachdem ich das alles mal ausgebügelt hatte, nächster Testlauf....und wieder NIX
Nach ca. 10 Minuten hab ich rausgefunden, dass ich nen weiteren Schreibfehler in den UV-Koordinaten hatte...letztendlich war die Grösse jedes Partikels 0
Neuer Testlauf....MAN SIEHT WAS
Und zwar genau 1 grossen Particle, der dumm im Mesh rumsteht und sich nicht bewegt...naja immerhin *g*
Nach fast ner halben Stunde Fehlersuche hatte ich das Problem gefunden...ein Schreibfehler ausgerechnet in der Variable, die die Differenz in Millisekunden zwischen dem aktuellen und dem letzen Update des Particlesystems misst...anstatt pl_looptime hab ich pl_looptme geschrieben...welche somit immer 0 war.
Tja, da ich mit dieser Variable so ziemlich alle Veränderungen berechne (Bewegung, Alpha, Farben, Grösse....) war das natürlich dumm gelaufen....
Naja soviel zu der Vorgeschichte, jetzt gehts erstmal wieder ins Technische
Im letzten Worklog wurden ja bereits die Partikel vom Emitter erstellt und mit Werten gefüttert.
Folgendes ist nun hinzugekommen
Alle Particle werden geupdatet (erstmal nur auf Position)
Das passiert grob folgendermassen:
Erstmal Gesamtzahl Particle und die Anzahl der gerenderten Particle auf 0 setzen
Surface(s) löschen...evt kommen ja noch welche hinzu wegen verschiedener Blendmodes (ich muss jetzt erstmal ParticleTypes erschaffen, also zeichnen und mit Parametern füttern..endlich was das richtig Fun macht hehe)
Jeden Particle loopen, dabei:
ParticleCount um 1 erhöhen, Particletyp merken
Particle x,y,z Position updaten mithilfe oben erwähnter Variable, die die vergangene Zeit zum letzten Particleupdate misst ( z.B. Particle\x = Particle\x + pl_looptime * Particle\vx )
Maximalgrösse Particle abfangen
Muss Particle gelöscht werden (z.B. Lifetime überschritten, Alpha<=0, zu gross.....)
Muss nicht gelöscht werden??? Dann ran ans Rendern, und zwar so:
Überprüfung, ob Particle überhaupt im Cam Sichtbereich ist....
Wenn ja, Anzahl der gerenderten Particle um 1 erhöhen und ab in die Renderfunktion, dabei wird einfach der ganze Type übergeben
Die Renderfunktion sieht dann grob so aus:
Function PL_RENDER (Particle.TParticle)
Variablen erstmal zuweisen, z.b. x,y,z, uv Werte, Farben usw.... (z.B. x=Particle\x, size=Particle\size...)
Ein bei der Initialisierung erstelltes Ghost-Mesh auf die Grösse des Particles skalieren
Ghostmesh an x,y,z Position des Particles positionieren
Ghostmesh auf Cam ausrichten (Alle Particle schauen im Moment nur auf die Cam)
Die 4 Vertices des Ghostmeshes rausfinden und auf das ParticleLabs Hauptmesh übertragen
Vertices einfärben
2 Triangles mit den Vertices erstellen, die ein Quad bilden
...und schon sieht man auch was
Die Funktion, die überprüft ob ein Particle im Sichtbereich ist oder nicht, ist weniger spektakulär:
Function PL_OnScreen (x#, y#, z#)
Mit CameraProject rausfinden, ob x,y und z im aktuellen Auflösungsbereich liegen oder nicht
Wenn ja, Rendern = true, andernfalls Rendern = false ^^
Wobei ich mit dieser Funktion noch nicht zufrieden bin. Die Grösse des Particles wird im Moment noch nicht berücksichtigt. Deshalb können Particle verschwinden, bevor sie komplett aus dem Bildschirm gescrollt sind. Zur Veranschaulichung:
Stellt euch vor, ich fahr mit der Cam extrem nahe an ein Particle ran. Das Particle füllt den halben Bildschirm in x-Richtung aus, bei einer Auflösung von 800*600. Wenn der Mittelpunkt des Particels jetzt gerade den Bildschirm verlässt (was ich mit CameraProject feststellen kann), ist der halbe Particle immer noch auf dem Bildschirm...aber trotzdem wird der Particle nicht mehr gerendert.
Da nützt es auch nicht, die Grösse und Skalierung des Particles mit in die Berechnung einzubeziehen....
Ich müsste eigentlich den Abstand der Cam zum Particle bestimmen, damit und mit der Skalierung und Grösse des Particles UND MIT DER DREHUNG DES PARTICLES die 2D Grösse des Particles bestimmen...was aber viel zu aufwändig wäre...mal sehen welchen Kompromiss ich da finden kann.
Naja aber immerhin funktioniert das System jetzt, auch wenn es eigentlich noch nicht viel kann. Alle Particel drehn sich zur Kamera, Alpha und Farbe werden nicht geändert, es gibt nur Emitter, die Particle von einem Punkt ausspucken, es gibt nur einen Blendmodus, es gibt keine Zufälle und Variationen der Particle...aber das ist jetzt relativ einfach und schnell zu implementieren, ich muss grob gesagt nur ein paar Felder in den Types hinzufügen und ein paar Berechnungen mehr laufen lassen
Immerhin sind Gewicht und Gravitation schon mit eingebunden
Was ich auf jeden Fall noch einbauen will / überlege evt einzubauen:
Alphaänderung der Particle
Farbänderung der Particle
Geschwindigkeitsvariationen
Wachsen/Schrumpfen der Particle
Particlerotation
Verschiedene Arten des Emittierens, z.B. Ring, Zufallsarea, Kreuz, Linie, Tunnel, Trichter...
Absorber
Eventuell Particle, die Subparticle ausstossen...
Particle die nach x Sekunden explodieren
Particle, die bestimmten Bahnen folgen
Andere Ausrichtungen der Particle (immer nur auf Cam ausrichten sucked)
Offsets für die Emitter
Soundanbindung
Achja, zum Speed im Moment:
Knapp 11000 gerenderte Particle werden im Fenstermodus 800*600 mit knapp 86 FPS dargestellt. Wobei sie in Zufallsrichtungen ausgespuckt werden, und nur Gewicht, Gravitation und Y(Emitterspeed) berücksichtigt werden...
So das wars für heut,
hier ist Faasend und ich bin noch nüchtern, geht gar nicht... 8)
Alleh Hopp
PSY
Emitter - oder wie man Partikel spuckt
Mittwoch, 18. Februar 2009 von PSY
Hiho,
nachdem die Grundfunktionenen stehn, habe ich mich mal an die Emitter rangewagt.
Die beiden wichtigesten Funktionen sind:
Function CreateEmitter%() und
Function FeedEmitter%(HND%, ptID%, duration%, emissionrate%)
CreateEmitter() macht im Moment grob folgendes:
Neuen Emitter-Type erstellen
Cube erstellen und einfärben (wollte es zuerst mit Cones machen, da man sofort gesehen hätte, wo die Partikel ausgestossen werden, aber Cones sind im Vergleich zu Cubes viel langsamer, und es wird am jedem fps gespart )...
Handle des Cubes mit Nameentity identifizieren, falls ich später keine Lust habe durch alle Emitter zu loopen (werden noch Geschwindikeitstests folgen)
Handle zurückgeben
Feedemitter() ist dazu gedacht, die einzelnen Emitter mit 1 oder mehreren Partikelarten (Types) zu "laden". Grob:
Emitter identifizieren
# Particle Types des Emitters um 1 erhöhen
Handle des neuen ParticleType - Slots merken
Übergebene Dauer und Emissionsrate zuweisen
Neuen Particle Type auf "aktiv" setzen
Evt. Maximum Life Time des Emitters anpassen (ist neuer Particle Type am längsten aktiv?)
Handle zurückgeben, falls der Particle Type später deaktiviert / reaktiviert werden soll
Die Emitterupdatefunktion habe ich auch schon "fertig", leider kann ich im Moment noch überhaupt nichts testen, da ich die Particle-Update Funktion erst am Schluss einbetten kann, wenn der Rest fertig ist.
Funktionsweise Update Emitter:
Verstrichene Zeit zwischen jetzt und letztem Update ermitteln
Jeden Emitter loopen, dabei :
Schauen ob er überhaupt auf "aktiv" steht
Wenn ja, Position und Drehung merken
SUB-Loop durch alle Particle Types des Emitters, dabei:
Wird der aktuelle Particle Type überhaupt noch ausgespuckt? (Emission Time schon überschritten?)
Wenn ja, berechnen, wieviel Partikel in diesem Loop erzeugt werden müssen, um die Emissionrate pro Sekunde einzuhalten
Die Anzahl der errechneten Partikel erzeugen, dabei:
Partikeltyp und Emitterhandle merken
x,y,z Position des Partikels aus Emitterposition ableiten
Speedkomponenten des Partikels ausrechnen (hm da muss wohl Vektorrechnung her, die definierte Geschwindigkeit des Partikels bezieht sich ja auf die Y-Richtung (Emitterausstossrichtung), und ich muss ja dabei die Ausrichtung des Emitters berücksichtigen...mal sehn wie ich das mach
Farben, Starttime zuweisen
am Ende die ursrprüngliche Emitterposition wiederherstellen
Die Emitterposition merk ich mir, weil ich eventuell später verschiedene Ausstossformen einfügen werde, wie z.B. Ringe, Vierecke, Wellen, Flächen usw. und dabei den Emitter während des jeweiligen Partikelausstosses permanent verschieben/ausrichten muss....aber mal sehn...vielleicht gibts auch nur Punktausspucker
Naja das wars bis jetzt mal wieder, morgen oder die Tage wage ich mich dann mal an die Positionierung und Berechnung der einzelnen Vertices(Particle) auf der SingleSurface...brrrrrrr
So long,
PSY
nachdem die Grundfunktionenen stehn, habe ich mich mal an die Emitter rangewagt.
Die beiden wichtigesten Funktionen sind:
Function CreateEmitter%() und
Function FeedEmitter%(HND%, ptID%, duration%, emissionrate%)
CreateEmitter() macht im Moment grob folgendes:
Neuen Emitter-Type erstellen
Cube erstellen und einfärben (wollte es zuerst mit Cones machen, da man sofort gesehen hätte, wo die Partikel ausgestossen werden, aber Cones sind im Vergleich zu Cubes viel langsamer, und es wird am jedem fps gespart )...
Handle des Cubes mit Nameentity identifizieren, falls ich später keine Lust habe durch alle Emitter zu loopen (werden noch Geschwindikeitstests folgen)
Handle zurückgeben
Feedemitter() ist dazu gedacht, die einzelnen Emitter mit 1 oder mehreren Partikelarten (Types) zu "laden". Grob:
Emitter identifizieren
# Particle Types des Emitters um 1 erhöhen
Handle des neuen ParticleType - Slots merken
Übergebene Dauer und Emissionsrate zuweisen
Neuen Particle Type auf "aktiv" setzen
Evt. Maximum Life Time des Emitters anpassen (ist neuer Particle Type am längsten aktiv?)
Handle zurückgeben, falls der Particle Type später deaktiviert / reaktiviert werden soll
Die Emitterupdatefunktion habe ich auch schon "fertig", leider kann ich im Moment noch überhaupt nichts testen, da ich die Particle-Update Funktion erst am Schluss einbetten kann, wenn der Rest fertig ist.
Funktionsweise Update Emitter:
Verstrichene Zeit zwischen jetzt und letztem Update ermitteln
Jeden Emitter loopen, dabei :
Schauen ob er überhaupt auf "aktiv" steht
Wenn ja, Position und Drehung merken
SUB-Loop durch alle Particle Types des Emitters, dabei:
Wird der aktuelle Particle Type überhaupt noch ausgespuckt? (Emission Time schon überschritten?)
Wenn ja, berechnen, wieviel Partikel in diesem Loop erzeugt werden müssen, um die Emissionrate pro Sekunde einzuhalten
Die Anzahl der errechneten Partikel erzeugen, dabei:
Partikeltyp und Emitterhandle merken
x,y,z Position des Partikels aus Emitterposition ableiten
Speedkomponenten des Partikels ausrechnen (hm da muss wohl Vektorrechnung her, die definierte Geschwindigkeit des Partikels bezieht sich ja auf die Y-Richtung (Emitterausstossrichtung), und ich muss ja dabei die Ausrichtung des Emitters berücksichtigen...mal sehn wie ich das mach
Farben, Starttime zuweisen
am Ende die ursrprüngliche Emitterposition wiederherstellen
Die Emitterposition merk ich mir, weil ich eventuell später verschiedene Ausstossformen einfügen werde, wie z.B. Ringe, Vierecke, Wellen, Flächen usw. und dabei den Emitter während des jeweiligen Partikelausstosses permanent verschieben/ausrichten muss....aber mal sehn...vielleicht gibts auch nur Punktausspucker
Naja das wars bis jetzt mal wieder, morgen oder die Tage wage ich mich dann mal an die Positionierung und Berechnung der einzelnen Vertices(Particle) auf der SingleSurface...brrrrrrr
So long,
PSY
The Beginnings...
Sonntag, 15. Februar 2009 von PSY
So...
da ich dieses Jahr eventuell mehr Zeit als sonst haben werde , und zudem einen Sack voll Projektideen(Spiele) in der Schublade, von denen 90% sicher ein paar grafische Leckereien brauchen könnten, habe ich mich dazu entschlossen, eine Particleengine auf die Beine zu stellen, namens
PARTICLE LABS
Die Anforderungen
Die Engine soll natürlich -mehr oder weniger- universell einsetzbar sein...zumindest in meinen Projekten Dazu muss sie folgendes können:
Single Surface
Verschiedene Texturen für die einzelnen Particle handeln
Einfach zu verwaltende Emitter
Einfach zu erstellende Particle(Types)
Zeitabhängige Partikel
Eventuell verschiedene Blend Modi (bin noch nicht sicher ob ich das so hinbekomm wie ich will)
SAUSCHNELL
Nachdem ich mir mal ein paar Grundgedanken gemacht hab, hab ich mal angefangen zu coden und mir erstmal überlegt, welche Parameter die Emitter und Particle mindestens besitzen müssen, und welche Grundfunktionen ich brauche. Folgendes ist dabei rausgekommen:
Es gibt natürlich 3 grosse Types.
EMITTER
PARTICLETYPES
DIE EINZELNEN PARTICLE AN SICH
Eventuell kommt noch ein Absorber hinzu, aber das hat noch Zeit...
EMITTER
Field handle%
Field starttime%
Field active%
Field ptype%
Field ptlife%
Field ptrate%
PARTICLETYPE
Field lifetime%
Field alpha#
Field speed#
Field size#
Field weight#
Field u#,v#
Field r%,g%,b%
PARTICLE
Field emitterhandle%
Field x#, y#, z#
Field scale#
Field size#
Field alpha#
Field r#,g#,b#
Folgende Grundfunktionen muss die Engine beherrschen:
Texturen, Cam und Kram initialisieren
Emitter mit Particlen füttern
Emitter starten und stoppen
Particlesystem freigeben
Particle Type erstellen (incl. Textur zuweisen)
Grösse, Geschwindigkeit, Alpha, Gravitation, Farbe, Lebenszeit für Particle(Type) ändern/zuweisen
Hauptfunktion: Alle Emitter/Particle(Types) updaten
Die Types Grundfunktionen hab ich schonmal gecoded...was ja auch nicht sonderlich schwer war
Das Updaten der Particle wird natürlich die restlichen 90% der Arbeit ausmachen... Oo
Der Grundcode ist jetzt (natürlich übersichtlich und auskommentiert) schon 340 Zeilen gross...und ich hab eigentlich noch nichts erreicht Oo
Naja der Grundstein ist gelegt, mal sehn was sich daraus machen lässt
Jetzt ist erstmal Schluss, Age of Conan wartet hrhr...
L8er,
PSY
da ich dieses Jahr eventuell mehr Zeit als sonst haben werde
, und zudem einen Sack voll Projektideen(Spiele) in der Schublade, von denen 90% sicher ein paar grafische Leckereien brauchen könnten, habe ich mich dazu entschlossen, eine Particleengine auf die Beine zu stellen, namens
PARTICLE LABS
Die Anforderungen
Die Engine soll natürlich -mehr oder weniger- universell einsetzbar sein...zumindest in meinen Projekten
Dazu muss sie folgendes können:
Single Surface
Verschiedene Texturen für die einzelnen Particle handeln
Einfach zu verwaltende Emitter
Einfach zu erstellende Particle(Types)
Zeitabhängige Partikel
Eventuell verschiedene Blend Modi (bin noch nicht sicher ob ich das so hinbekomm wie ich will)
SAUSCHNELL
Nachdem ich mir mal ein paar Grundgedanken gemacht hab, hab ich mal angefangen zu coden und mir erstmal überlegt, welche Parameter die Emitter und Particle mindestens besitzen müssen, und welche Grundfunktionen ich brauche. Folgendes ist dabei rausgekommen:
Es gibt natürlich 3 grosse Types.
EMITTER
PARTICLETYPES
DIE EINZELNEN PARTICLE AN SICH
Eventuell kommt noch ein Absorber hinzu, aber das hat noch Zeit...
EMITTER
Field handle%
Field starttime%
Field active%
Field ptype%
Field ptlife%
Field ptrate%
PARTICLETYPE
Field lifetime%
Field alpha#
Field speed#
Field size#
Field weight#
Field u#,v#
Field r%,g%,b%
PARTICLE
Field emitterhandle%
Field x#, y#, z#
Field scale#
Field size#
Field alpha#
Field r#,g#,b#
Folgende Grundfunktionen muss die Engine beherrschen:
Texturen, Cam und Kram initialisieren
Emitter mit Particlen füttern
Emitter starten und stoppen
Particlesystem freigeben
Particle Type erstellen (incl. Textur zuweisen)
Grösse, Geschwindigkeit, Alpha, Gravitation, Farbe, Lebenszeit für Particle(Type) ändern/zuweisen
Hauptfunktion: Alle Emitter/Particle(Types) updaten
Die Types Grundfunktionen hab ich schonmal gecoded...was ja auch nicht sonderlich schwer war
Das Updaten der Particle wird natürlich die restlichen 90% der Arbeit ausmachen... Oo
Der Grundcode ist jetzt (natürlich übersichtlich und auskommentiert) schon 340 Zeilen gross...und ich hab eigentlich noch nichts erreicht Oo
Naja der Grundstein ist gelegt, mal sehn was sich daraus machen lässt
Jetzt ist erstmal Schluss, Age of Conan wartet hrhr...
L8er,
PSY