Particle Labs

Kommentare anzeigen Worklog abonnieren

Worklogs 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 Wink

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:
Arrow Der 3D Punkt, wo der Partikel ursprünglich entstand, wird gespeichert.
Arrow Der letze Aufenthaltspunkt des Partikels vor der erneuten Positionsberechnung wird gespeichert.
Arrow Beide Raumvektoren werden voneinander subtrahiert und das Ergebnis halbiert.
Arrow 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

ES WERDE LICHT !

Montag, 23. Februar 2009 von PSY
Hiho,

ok die Phase der Faulheit ist erstmal vorbei...zumindest bis nach Erstellen dieses Posts Wink

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 Confused

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 Embarassed 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 Rolling Eyes
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 Embarassed

Neuer Testlauf....MAN SIEHT WAS Shocked 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.... Rolling Eyes


Naja soviel zu der Vorgeschichte, jetzt gehts erstmal wieder ins Technische Wink

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:

Exclamation Erstmal Gesamtzahl Particle und die Anzahl der gerenderten Particle auf 0 setzen
Exclamation 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)
Exclamation Jeden Particle loopen, dabei:
Exclamation ParticleCount um 1 erhöhen, Particletyp merken
Exclamation 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 )
Exclamation Maximalgrösse Particle abfangen
Exclamation Muss Particle gelöscht werden (z.B. Lifetime überschritten, Alpha<=0, zu gross.....)
Exclamation Muss nicht gelöscht werden??? Dann ran ans Rendern, und zwar so:
Exclamation Überprüfung, ob Particle überhaupt im Cam Sichtbereich ist....
Exclamation 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)
Exclamation Variablen erstmal zuweisen, z.b. x,y,z, uv Werte, Farben usw.... (z.B. x=Particle\x, size=Particle\size...)
Exclamation Ein bei der Initialisierung erstelltes Ghost-Mesh auf die Grösse des Particles skalieren
Exclamation Ghostmesh an x,y,z Position des Particles positionieren
Exclamation Ghostmesh auf Cam ausrichten (Alle Particle schauen im Moment nur auf die Cam)
Exclamation Die 4 Vertices des Ghostmeshes rausfinden und auf das ParticleLabs Hauptmesh übertragen
Exclamation Vertices einfärben
Exclamation 2 Triangles mit den Vertices erstellen, die ein Quad bilden

...und schon sieht man auch was Wink

Die Funktion, die überprüft ob ein Particle im Sichtbereich ist oder nicht, ist weniger spektakulär:
Function PL_OnScreen (x#, y#, z#)

Exclamation Mit CameraProject rausfinden, ob x,y und z im aktuellen Auflösungsbereich liegen oder nicht
Exclamation 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 Wink
Immerhin sind Gewicht und Gravitation schon mit eingebunden

Was ich auf jeden Fall noch einbauen will / überlege evt einzubauen:
Exclamation Alphaänderung der Particle
Exclamation Farbänderung der Particle
Exclamation Geschwindigkeitsvariationen
Exclamation Wachsen/Schrumpfen der Particle
Exclamation Particlerotation
Exclamation Verschiedene Arten des Emittierens, z.B. Ring, Zufallsarea, Kreuz, Linie, Tunnel, Trichter...
Exclamation Absorber
Exclamation Eventuell Particle, die Subparticle ausstossen...
Exclamation Particle die nach x Sekunden explodieren
Exclamation Particle, die bestimmten Bahnen folgen
Exclamation Andere Ausrichtungen der Particle (immer nur auf Cam ausrichten sucked)
Exclamation Offsets für die Emitter
Exclamation 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:

Arrow Function CreateEmitter%() und
Arrow Function FeedEmitter%(HND%, ptID%, duration%, emissionrate%)


CreateEmitter() macht im Moment grob folgendes:
Exclamation Neuen Emitter-Type erstellen
Exclamation 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 Wink)...
Exclamation Handle des Cubes mit Nameentity identifizieren, falls ich später keine Lust habe durch alle Emitter zu loopen (werden noch Geschwindikeitstests folgen)
Exclamation Handle zurückgeben


Feedemitter() ist dazu gedacht, die einzelnen Emitter mit 1 oder mehreren Partikelarten (Types) zu "laden". Grob:
Exclamation Emitter identifizieren
Exclamation # Particle Types des Emitters um 1 erhöhen
Exclamation Handle des neuen ParticleType - Slots merken
Exclamation Übergebene Dauer und Emissionsrate zuweisen
Exclamation Neuen Particle Type auf "aktiv" setzen
Exclamation Evt. Maximum Life Time des Emitters anpassen (ist neuer Particle Type am längsten aktiv?)
Exclamation 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:
Exclamation Verstrichene Zeit zwischen jetzt und letztem Update ermitteln
Exclamation Jeden Emitter loopen, dabei :
Exclamation Schauen ob er überhaupt auf "aktiv" steht
Exclamation Wenn ja, Position und Drehung merken
Exclamation SUB-Loop durch alle Particle Types des Emitters, dabei:
Exclamation Wird der aktuelle Particle Type überhaupt noch ausgespuckt? (Emission Time schon überschritten?)
Exclamation Wenn ja, berechnen, wieviel Partikel in diesem Loop erzeugt werden müssen, um die Emissionrate pro Sekunde einzuhalten
Exclamation Die Anzahl der errechneten Partikel erzeugen, dabei:
Exclamation Partikeltyp und Emitterhandle merken
Exclamation x,y,z Position des Partikels aus Emitterposition ableiten
Exclamation 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 Rolling Eyes
Exclamation Farben, Starttime zuweisen
Exclamation 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 Wink


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 Wink

The Beginnings...

Sonntag, 15. Februar 2009 von PSY
So...

da ich dieses Jahr eventuell mehr Zeit als sonst haben werde Wink , 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

Arrow PARTICLE LABS


Exclamation Die Anforderungen
Die Engine soll natürlich -mehr oder weniger- universell einsetzbar sein...zumindest in meinen Projekten Wink Dazu muss sie folgendes können:

Idea Single Surface
Idea Verschiedene Texturen für die einzelnen Particle handeln
Idea Einfach zu verwaltende Emitter
Idea Einfach zu erstellende Particle(Types)
Idea Zeitabhängige Partikel
Idea Eventuell verschiedene Blend Modi (bin noch nicht sicher ob ich das so hinbekomm wie ich will)
Idea SAUSCHNELL Wink


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.
Arrow EMITTER
Arrow PARTICLETYPES
Arrow 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 Very Happy
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
Wink

Jetzt ist erstmal Schluss, Age of Conan wartet hrhr...

L8er,
PSY