Hallöchen,

so, jetzt wirds kompliziert. Ich habe hunderste Partikelemitter die ich am Anfang beim emittieren zu einem Buffer zusammenfasse. Diese werden dann via Transformfeedback weiter berechnet. Damit ich später beim Rendern der Partikel noch weiß, aus welchem Emitter das Partikel kam, (das brauch ich aus mehreren Gründen..) schleife ich einen weiteren EmitterID-Buffer durch die Pipeline.

So nun brauch ich pro Emitter, die BoundingBox der Partikel die von ihm erzeugt wurden. Wie könnte man dies nun am einfachsten realisieren?

Grüße,
Thomas

ADD: Es geht hier meist um bis zu 1000 Emitter und insg. 2-3mio Partikel...

Am besten keine Bounding-Box sondern Bounding-Sphere verwenden.
Eine Bounding-Box benötigt zu viel dynamic branching, während ne Bounding-Sphere mit einem Check verarbeitet ist und auch einem Partikel viel besser repräsentieren kann.
Im Fall einer Bounding-Sphere ist die Position die gleiche wie das transformierte Partikel selber und der Radius entspricht der Größe des Partikels, welches ja auch irgendwo definiert wurde(z.B. t=time, GL_PointSize oder ähnliches).
Der Test selber wäre dann sehr trivial.
float dist=abs(particleA-particleB)-(radiusA+radiusB);

*dist==0 -> 1 Kontaktpunkt
*dist<0 -> überschneiden sich
*dist>0 -> keine kollision

In einem shader könnte man dann z.B. folgendes machen.
color_out=float3(step(dist,0),0.0,0.0);// zeichne alle kollidierenden Partikel rot, sonnst weiß

In einigen Fällen kommt man natürlich nicht um ein dynamic branching, da sollte man dann davon aus gehen, dass der true case der übliche Fall ist.
Also im fall einer Flüssigkeits Simulation wäre es alle Partikel kollidieren.
if (dist<=0.0)
do foo
else
do bla

Im Fall von eines Feuers, Asteroiden, Special FX wäre es keine kollision.
if (dist>0.0)
do foo
else
do bla

Da die CPU und GPU bei branching eine schätzung machen, welcher Fall ein tritt, geht die verarbeitung weiter und wenn dann einige cycles später die Antwort rein kommt, wird geguckt ob alles verworfen werden muss und der else tree durch geht oder einfach weiter machen kann, ohne Zeit verloren zu haben.

Dynamic Branching ist nur sehr teuer, wenn man den seltenden Fall im if und den häufigen im else packt.
Aber auf GPU würde ich das vollständig meiden und mathematische wege suchen, die ein dynamic branching verhindern.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004

nein du hast mich leider falsch verstanden.. Ich brauch keine BoundingSphere für das Partikel selbst, sondern für ALLE Partikel EINES Emitters... ich muss um diese Partikel eine Box zeichnen worauf etwas projeziert wird..

lässt sich die Position deiner Partikel durch eine Funktion f(t) abbilden?

_________________
Meine Homepage

Also on-thy-fly eine BoundingBox zu berechnen ist nicht leicht, zumindest wenn es effizient sein soll. Wenn möglich solltest du versuchen die Box auf Basis der Parameter des Emitters zu berechnen. Wenn die Parameter konstant sind sollte das ziemlich gut funktionieren, insbesondere da du das nur einmal machen musst.

Es wäre wahrscheinlich hilfreich zu wissen was du da auf die Box projizieren willst. Kannst du das vielleicht direkt auf die Partikel projizieren statt auf die Box?

Wenn du tatsächlich eine BoundingBox brauchst...hm....ich würde irgendwie versuchen mit einem Vertexshader jeweils immer eine BoundingBox für N Partikel zu berechnen (z.B. mit N = 100). Die BoundingBox schreibt der Shader via TransformFeedback Min und Max in einen VBO. Auf den neuen VBO (mit jetzt nur noch 2/N sovielen Partikeln) wendest du den gleichen Shader (leicht angepasst, weil der keine Partikel bekommt) dann wieder an...solange bis nur noch eine einzelne BoundingBox übrig bleibt.

So würde das jedenfalls funktionieren wenn man alle Partikel in EINER Box haben will. Da du nun aber pro Emitter eine Box hast wird es kompliziert. Möglicherweise lässt du den Geometryshader jeweils BoundingBoxen für ca. 10-20 Emitter berechnen. Also du speicherst Min, Max und EmitterID als ein "Vertex" im Buffer. Diese BoundingBoxen fasst du dann in einem weiteren Pass weiter zusammen, solange bis du für jeden Emitter eine Box hast.

Pseudocode:

_________________
Yeah!

Willst du raytracing betreiben, oder wozu brauchst du eine box ?
Soll die boundingbox perfekt sein, also dynamisch anpassen ?
Wenn ja kommst du wohl kaum um eine funktion f(t) drum rum, wenn du nicht gerade lust auf bruteforce hast.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004

der Ansatz von Coolcat sieht schon gut aus. Noch paar infos. Die BoundingBox muss keineswegs perfekt sein, wichtig ist alle Partikel eines emitters einschließt und den Partikeln rel. nahe ist. Es geht um die Realisierung von Waterscreens. D.h. kleine Fontänendüsen wo mit Laser oder Videoprojektoren drauf projeziert wird. Es würde also auch genügen die boundingBox von ca. 3-10 Emittern zu berechnen, denn mehr Waterscreens kommen in einer Szene selten vor. Es würde theoretisch auch genügen, wenn sich die BoundingBox nur an Anfang aufbaut. Da die projezierte BoundingBox am Ende mit den Partikeln multipliziert wird, sieht man nur da was wo auch Wasser ist.

An direkter Projektion auf Partikel hab ich schon lange rumprobiert. Aber da es immer sehr viele Lichtquellen sind und die Partikel ohne Tiefentest gerendert werden wirds hier schwierig..

Bei der alten CPU Berechnung war es einfach, da hab ich einfach beim Partikel Update mit dem jeweiligen Min/Max-Wert verglichen..

Achso du willst zwei Volumen schneiden.... Dafür brauchst du keine Boundingbox sondern musst Raytracing fälschen. Das geht relativ einfach wenn du
einfach subtrahieren kannst (z.b. Shadowmapping) ansonsten musst du evtl. n bissl tricksen. In deinen Falle dürfte Tiefenpuffer (Partikel) - Tiefenpuffer (Laser) reichen,
wenn du es nicht projezieren willst.... Evtl musst du halt ein Start- und Endbyte definieren und für alles dazwischen den ganzen kram machen....

_________________
Meine Homepage

Anderer Ansatz:

Ich weiß ja pro Nozzle, mit welcher Power, Richtung + Sprühwinkel die Partikel emittiert werden. Wenn ich nun rausbekommen könnte welche Maximalhöhe ein Partikel des Nozzles erreichen kann, dann kann ich damit + den Sprühwinkel eine statische Box bauen.

So ein Partikel Update sieht so aus:



dir.y enthält am Anfang die Power mit welcher das Partikel emittiert wird. In jedem Frame wird hier dann die gravitation abgezogen. Eine möglichkeit wäre nun folgende. Ich schieße ein "virutelles" partikel ab und gucke wie hoch es kommt:



Allerdings finde ich das bisschen unprofessionell. Gibts da nicht irgendeine Formel womit man dies in einem Rutsch ausrechnen kann?

posY(t) = posYStart + (dirYStart - gravitation * t) * t;
posY'(t) = 0
t = dirYStart/(2 * gravitation)

posY(dirYStart/(2 * gravitation)) = posYStart + dirYStart^2 / (4*gravitation)

ist extempunkt von posY

über den ansatz lässt sich das eig lösen

mfg Frenk

mhhh so ganz verstehen tu ich deine formel nicht..

posY(t) = posYStart + (dirYStart - gravitation * t) * t;

posY gibt schlicht die position die ein Partikel von position posYStart mit dirYStart(richtung*stärke) emittiert nach t an.

posY ist an der stelle maximal/ minimal an der die ableitung = 0 ist sprich :
posY'(t) = 0

löst man diese gleichung bekommt man heraus, dass es ein extremata an der stelle t = dirYStart/(2 * gravitation) gibt.

nun setzt man t wieder in posY ein
posY(dirYStart/(2 * gravitation)) = posYStart + dirYStart^2 / (4*gravitation)

somit ist die maximale Y wert im standart fall
posYStart + dirYStart^2 / (4*gravitation)

Er hat aus deinem iterativen Ansatz eine geschlossene Formel gemacht

Für t = 1 ist das eben genau 1 Iterationsschritt, für t = 2 sind es 2 usw.
Das Ding hat er abgeleitet und die Nullstelle berechnet. Da die Ableitung linear ist gibt es nur die eine Nullstelle und die liegt eben bei

Dieses t setzt du dann wieder in die Formel ein und erhältst den Extremwert für Y. Normalerweise sollte dies das Maximum sein (nur wenn deine Gravitation nach unten geht ). Beachte das du auch ein negatives t erhalten kannst, etwa wenn die Düse unten gerichtet ist. Also du musst das Ergebnis auf den zulässigen Bereich 0...MaxLifetime beschränken.

Aus diesem berechneten Punkt und den Punkten t=0 und t=MaxLifetime baust du dann deine BoundingBox.


Edit: FrenK war schneller.

_________________
Yeah!