'''IRangeValue''' ist ein Datentyp, der es ermöglicht, einen Wertebereich anzugeben, anstelle eines konkreten Wertes. Dieser Wertebereich wird über zwei begrenzende Kurven definiert. Die Kurven geben Werte zu einem bestimmten Zeitpunkt an. Ist nur eine Kurve definiert, gibt der RangeValue die Werte dieser Kurve zu einem bestimmten Zeitpunkt aus. Sind zwei Kurven definiert, gibt der RangeValue einen zufälligen Wert zwischen den Werten der beiden Kurven zum gegebenen Zeitpunkt aus. Siehe [[#Beispiele|Beispiele]]. Möglich ist auch, dass anstelle eines Zufallswertes eine Wichtung genommen wird, siehe [[IParticleRangeValue]].

<code>
IRangeValue
function GetValue (const Time: Double): Double;
procedure SetValue (const ItemIndex: Integer; const Time: Double; const Value: Single);
procedure Clear;
procedure Assign(const Other: IScripting_IRangeValue);
end;
</code>

= Methoden =

* Werte setzen: SetValue bzw. SetValueX, SetValueY, SetValueZ und SetValueXYZ. Für die Parameter siehe [[IRangeValue|hier]]. SetValueXYZ gibt allen Dimensionen den gleichen Wert.
<code>
procedure SetValue (const ItemIndex: Integer; const Time: Double; const Value: Single);
</code>
* Wert zum Zeitpunkt Time ausgeben, analog zum Setter.
<code>
function GetValue (const Time: Double): Double;
</code>

* Alle Werte löschen
<code>
procedure Clear;
</code>

* Werte von anderem IParticleRangeValue übernehmen:
<code>
procedure Assign(const Other: IParticleVectorRangeValue);
</code>

= Beispiele =

'''Beispiel 1''':
Ein RangeValue soll eine konstante Funktion werden. Dann wird ausschließlich nur die erste Kurve mit Werten gefüllt:
<code>
RangeValue.SetValue(0, 0, 10); //Parameter: KurvenIndex, Zeitpunkt, Wert
</code>
Dieser Code sagt, dass die beschränkende Kurve 0 zum Zeitpunkt 0 den Wert 10 erhält. Aufgrund der Interpolation hat die Kurve zu jedem anderen Zeitpunkt ebenfalls den Wert 10.

'''Beispiel 2''':
Dem RangeValue werden zwei Werte zugewiesen
<code>
RangeValue.SetValue(0, 0, 10);
RangeValue.SetValue(0, 1000, 20);
</code>
Der RangeValue hat weiterhin nur eine beschränkende Kurve. Doch sie ist keine Konstante mehr: Zum Zeitpunkt 0 liefert sie den Wert 0, zum Zeitpunkt 1000 und höher den Wert 20. Die Werte zwischen 0 und 1000 werden interpoliert. Zum Zeitpunkt 500 könnte der RangeValue also 15 liefern. So lassen sich beliebige Kurven konstruieren.

Der RangeValue kann aber eben auch Bereichsangaben haben. Gibt man jetzt Werte für zwei beschränkende Kurven an, erhält man einen Bereich. Der RangeValue liefert nun einen zufälligen Wert zwischen den Werten der beiden Schranken (andere Fälle: siehe Wichtung bei [[IParticleRangeValue]]).

'''Beispiel 3''':
RangeValue mit Bereichsangeben:
<code>
RangeValue.SetValue(0, 0, 10);
RangeValue.SetValue(1, 0, 100);
</code>
Der RangeValue erhält hier zwei beschränkende Kurven. Beide Kurven sind Konstanten, in dem Fall mit den Werten 10 und 100. Der RangeValue wird also als Wert zu jedem beliebigen Zeitpunkt einen zufälligen Wert zwischen 10 und 100 ausgeben.

'''Beispiel 4''':
Nichtkonstante Schranken:
<code>
RangeValue.SetValue(0, 0, 10);
RangeValue.SetValue(1, 0, 100);
RangeValue.SetValue(0, 1000, 20);
RangeValue.SetValue(1, 500, 50);
</code>
Der RangeValue hat nun zwei nichtkonstante Kurven als Schranken erhalten. Er wird beim Zeitpunkt 500 also beide Kurvenwerte interpolieren. Die Kurve 0 hat zum Zeitpunkt 500 den Wert 15. Die Kurve 1 hat zum Zeitpunkt 500 den Wert 50. Demnach liefert der RangeValue zum Zeitpunkt 500 einen zufälligen Wert zwischen 15 und 50.

[[Kategorie:Scripting-API]]
[[Kategorie:Language]]

2014-06-23T14:42:21Z

Mark.lorenz: Die Seite wurde neu angelegt: „Die Flexicollage ist vom Typ '''ITransformation''' und leitet von '''ISlideShowObject''' ab. Es fungiert als visueller Container für andere [[ISlideShowOb…“

ITransformation

2014-06-23T14:42:17Z

Mark.lorenz: Weiterleitung nach Flexicollage erstellt

#REDIRECT [[Flexicollage]]

[[Kategorie:Scripting-API]]
[[Kategorie:Language]]

TFillbackgroundMode

2014-06-23T14:41:18Z

Mark.lorenz: Die Seite wurde neu angelegt: „Aufzählungstyp für Methode ''FillBackground'' der Flexicollage. FillBackground gibt an, ob der Hintergrund der Flexicollage gefüllt werden soll oder nic…“

Aufzählungstyp für Methode ''FillBackground'' der [[Flexicollage]]. FillBackground gibt an, ob der Hintergrund der Flexicollage gefüllt werden soll oder nicht.

= Werte =
* '''fbOff''': Keine Füllung
* '''fbOn''': Hintergrund füllen
* '''fbAuto''': Automatische Entscheidung ob Füllung oder nicht.

[[Kategorie:Scripting-API]]

ITransformation

2014-06-23T14:39:21Z

TParticleEmitter

2014-06-23T14:33:26Z

Mark.lorenz:

Aufzählungstyp für Methode ''Emitter'' des [[Partikelobjekt|Partikelobjekts]]. Emitter gibt den Emittertypen des Partikelobjekts an.

= Werte =
* '''pemRectEdge''': Partikel werden zufällig an den Kanten des Boundsrect des Partikelsystems emittiert.
* '''pemRectArea''': Partikel werden zufällig innerhalb des Boundsrect des Partikelsystems emittiert.
* '''pemPoint''': Partikel werden im Mittelpunkt des Boundsrect des Partikelsystems emittiert.
* '''pemPath''': Dem Partikelsystem wird ein Bewegungspfad gegeben. Die Partikel werden dann auf dem Pfad emittiert. Dadurch kann sich der Emitter aber nicht bewegen, da der Bewegungspfad für das Emittieren zuständig ist. Abhilfe schafft hier, indem man das Partikelsystem in eine Flexicollage ([[ITransformation]]) legt und diese mit einem Bewegungspfad versieht.

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

TParticleEmitter

2014-06-23T14:32:54Z

Mark.lorenz:

Aufzählungstyp für Methode ''Emitter'' des [[Partikelobjekt|Partikelobjekts]]. Emitter gibt den Emittertypen des Partikelobjekts an.

= Werte =
* '''pemRectEdge''': Partikel werden zufällig an den Kanten des Boundsrect des Partikelsystems emittiert.
* '''pemRectArea''': Partikel werden zufällig innerhalb des Boundsrect des Partikelsystems emittiert.
* '''pemPoint''': Partikel werden im Mittelpunkt des Boundsrect des Partikelsystems emittiert.
* '''pemPath''': Dem Partikelsystem wird ein Bewegungspfad gegeben. Die Partikel werden dann auf dem Pfad emittiert. Dadurch kann sich der Emitter aber nicht bewegen, da der Bewegungspfad für das Emittieren zuständig ist. Abhilfe schafft hier, indem man das Partikelsystem in eine Flexicollage ([[ITransformableContainer]]) legt und diese mit einem Bewegungspfad versieht.

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

TParticleEmitter

2014-06-23T14:32:41Z

Mark.lorenz: Die Seite wurde neu angelegt: „Aufzählungstyp für Methode ''Emitter'' des Partikelobjekts. Emitter gibt den Emittertypen des Partikelobjekts an. = Werte = * '''pemRectE…“

Aufzählungstyp für Methode ''Emitter'' des [[Partikelobjekt|Partikelobjekts]]. Emitter gibt den Emittertypen des Partikelobjekts an.

= Werte =
* '''pemRectEdge''': Partikel werden zufällig an den Kanten des Boundsrect des Partikelsystems emittiert.
* '''pemRectArea''': Partikel werden zufällig innerhalb des Boundsrect des Partikelsystems emittiert.
* '''pemPoint''': Partikel werden im Mittelpunkt des Boundsrect des Partikelsystems emittiert.
* '''pemPath''': Dem Partikelsystem wird ein Bewegungspfad gegeben. Die Partikel werden dann auf dem Pfad emittiert. Dadurch kann sich der Emitter aber nicht bewegen, da der Bewegungspfad für das Emittieren zuständig ist. Abhilfe schafft hier, indem man das Partikelsystem in eine Flexicollage ([[ITransformable]]) legt und diese mit einem Bewegungspfad versieht.

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

Partikelobjekt

2014-06-23T14:24:49Z

Mark.lorenz:

Das Partikelobjekt ist vom Typ '''IParticle''' und leitet von '''[[ISlideShowObject]]''' ab. Mit diesem Objekt kann man Partikeleffekte erstellen.

Das Partikelobjekt enthält unter anderem Eigenschaften des Typs [[IParticleRangeValue]] bzw. [[IParticleRangeValue|IParticleVectorRangeValue]]. Einige dieser Eigenschaften verfügen über Initialwerte (wie ''Size'' und ''InitialSize''). Die Initialwerte geben den Ausgangszustand des Wertes an, die Nicht-Initialwerte geben eine Änderung an. Die Initialwerte bekommen einen Wertebereich. Beim Emittieren eines Partikels wird dem neuen Partikel ein zufälliger Werte innerhalb dieses Bereichs zugewiesen. Initialwerte können sich über die Dauer des Partikelsystems ändern. Die Änderungswerte erhalten ebenfalls einen Bereich. Der Unterschied ist, dass bei ihnen vorher eine Wichtung ermittelt wird. Diese wird benutzt um die Änderungen über die Lebenszeit des Partikels immer gleich gewichtet zu haben (siehe [[#Beispiel|Beispiel]]).

<code>
IParticle '''inherits from''' [[ISlideShowObject]]
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialSpeed: [[IParticleRangeValue]]
function Speed: [[IParticleRangeValue]]
function InitialSize: [[IParticleRangeValue]]
function Size: [[IParticleRangeValue]]
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialOpacity: [[IParticleRangeValue|IParticleRangeValue]]
function Opacity: [[IParticleRangeValue|IParticleRangeValue]]

property Move: [[TParticleMove]]
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialMoveSineFrequency: [[IParticleRangeValue]]
function MoveSineFrequency: [[IParticleRangeValue]]

function MaxAge: [[IParticleRangeValue]]
function ParticlesPerSecond: [[IParticleRangeValue]]

property SpriteAnimation: [[TParticleSpriteAnimation]]
function InitialSpriteAnimationFrequency: [[IParticleRangeValue|IParticleRangeValue]]
function SpriteAnimationFrequency: [[IParticleRangeValue]]

property Filename: [[IFilename]]
property Clipping: Boolean
property PreWarmTime: Integer

property Emitter: [[TParticleEmitter]]
function EmitterSpread: [[IParticleRangeValue]]
procedure AddEmitterClipRect(const X, Y, Width, Height, AngleZ: Single; const Invert: Boolean);

property Options: [[TParticleOptions]]
property Environment: [[TParticleEnvironment]]

property Seed: Int64
end;
</code>

= Methoden =

== Partikel ==

* Bewegungsrichtung
<code>
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Richtungsänderung über die Zeit: Addition von Winkeln (zB. bei Initialrichtung von 10 und einer Richtung von 10 bekommt das Partikel die Richtung 20).
<code>
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelgeschwindigkeit in Bewegungsrichtung
<code>
function InitialSpeed: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function Speed: [[IParticleRangeValue]];
</code>

* Partikelgröße. Skaliert das Partikel ohne Verzerrung so, dass die größte Richtung die Partikelgröße wird ("einpassen"):
<code>
function InitialSize: [[IParticleRangeValue]];
</code>
* Größenänderung über die Zeit: Prozent der Initialgröße.
<code>
function Size: [[IParticleRangeValue]];
</code>

* Partikeltransparenz
<code>
function InitialOpacity: [[IParticleRangeValue]];
</code>
* Transparenzänderung über die Zeit: Prozent der Initialtransparenz.
<code>
function Opacity: [[IParticleRangeValue]];
</code>

* Partikeldrehung: Man unterscheidet zwischen der statischen Lage des Partikels und einer beständigen Drehung. Beispielsweise sollen die Partikel beim Emittieren immer zwischen 10 und 20 Grad gedreht sein, die Lage aber behalten. Dafür kommt die Eigenschaft '''Rotation''' in Frage (bei einer Rotationsgeschwindigkeit von 0). Ist jedoch eine permanente Drehung gewünscht, nimmt man die '''Rotationfrequency''' (Rotationsgeschwindigkeit). Lage und Rotationsgeschwindigkeitschließen sich nicht aus. Positive Werte drehen im Uhrzeigersinn, negative entgegengesetzt.
* Lage des Partikels
<code>
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Lageänderung über die Zeit. Additiv (zB. 10° bei 0ms und 20° bei 1000ms ergibt in der ersten Sekunde eine Drehung um 10°, danach keine weitere).
<code>
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Rotationsgeschwindigkeit: Gibt die Anzahl der Drehungen in einer Sekunde an.
<code>
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Geschwindigkeitsänderung die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelbewegung: Partikel können neben ihrer eigentlichen Bewegungsrichtung auch von ihrer Bewegung abweichen, zum Beispiel schwingen.
<code>
property Move: [[TParticleMove]];
</code>
* Stärke der Abweichgungsbewegung:
<code>
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Stärkenänderung über die Zeit: Prozent der Initialstärke:
<code>
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Abweichungsfrequenz: Gibt an, wie viele Schwingungen oder Kreisbewegungen in einer Sekunde vollführt werden
<code>
function InitialMoveFrequency: [[IParticleRangeValue]];
</code>
* Frequenzänderung über die Zeit: Prozent der Initialfrequenz:
<code>
function MoveFrequency: [[IParticleRangeValue]];
</code>

* Lebensdauer des Partikels in Millisekunden. 0 heißt, dass das Partikel nie "stirbt".
<code>
function MaxAge: [[IParticleRangeValue]];
</code>

* Emittierrate. Gibt an, wie viele Partikel in einer Sekunde emittiert werden.
<code>
function ParticlesPerSecond: [[IParticleRangeValue]];
</code>

* Partikelanimation. Sind im Partikelsystem mehrere Bilddateien angegeben, können die Partikel ihr Bild während ihrer Lebenszeit ändern.
<code>
property SpriteAnimation: [[TParticleSpriteAnimation]]
</code>
* Animationsgeschwindigkeit: Gibt an, wie oft die Liste der Bilder in einem Partikel in einer Sekunde angezeigt wird (zB. es sind 5 Bilder angegeben, die Animationsgeschwindigkeit ist 1, dann wird das Bild des Partikels alle 1/5 Sekunden geändert, also in der einen Sekunde durch die ganze Liste iteriert)
<code>
function InitialSpriteAnimationFrequency: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function SpriteAnimationFrequency: [[IParticleRangeValue]];
</code>

* Dateinamen der Partikelbilder
<code>
property Filename: [[IFilename]];
</code>

* Partikelsystem auf seine Bounds zuschneiden oder alle Partikel, die hinausragen anzeigen:
<code>
property Clipping: Boolean;
</code>

* Partikelsystem vorsimulieren. Es ist möglich, dass simuliert wird, dass das Partikelsystem bereits eine gewisse Zeit (in Millisekunden) gelaufen war, bevor es wirklich angezeigt wird.
<code>
property PreWarmTime: Integer;
</code>

== Emitter ==

* Emitter-Typ:
<code>
property Emitter: [[TParticleEmitter]]
</code>

* Rand am Emitter: Wenn der Emitter vom Typ ''pePoint'' oder ''pePath'' ist, kann er einen Abstand erhalten: Beim Punkt-Emitter werden die Partikel in einem Kreis mit angebenen Abstand emittiert, beim Pfad-Emitter werden die Partikel sowohl oberhalb als auch unterhalb davon abgebildet.
<code>
function EmitterSpread: [[IParticleRangeValue]]
</code>

* Flächen, an denen nicht emittiert werden soll: Der Emitter hält eine Liste von gedrehten Rechtecken, an denen nicht emittiert werden darf.
<code>
procedure AddEmitterClipRect(const X, Y, Width, Height, AngleZ: Single; const Invert: Boolean);
</code>

== Optionen ==

* Partikel-Umgebung: Gibt an, ob die Bounds vom Partikelsystem nur als Positionierung der Partikel beim Emittieren dienen ('''peGlobal'''), oder ob das Partikelsystem Einfluss auf die Partikel hat, die Partikel also mitskalieren und sich mitdrehen, etc. ('''peLocal''')
<code>
property Environment: [[TParticleEnvironment]]
</code>

* Partikeloptionen geben beispielsweise an, wie sich die Partikel bei Drehung des Partikelsystems verhalten oder ob die Animationen abrupt oder durch Alphablending ablaufen:
<code>
property Options: [[TParticleOptions]]
</code>

= Beispiel =

Einem Partikelsystem werden folgende [[IParticleRangeValue|RangeValues]] gegeben:
* InitialSize zwischen 10 und 20.
* Size zwischen 50 und 100 ab 0ms und 0 und 50 ab 1000ms

Partikel 1 bekommt zufällig eine Größe zwischen 10 und 20, zB. 15. Der Size-Wert modifiziert diesen Initialwert, in dem Fall prozentual. Das heißt das Partikel ist zwischen 50% * 15 und 100% * 15 groß ab Sekunde 0 seiner Lebenszeit. Der genaue Wert wird durch die zufällig gewählte Wichtung ermittelt, sagen wir 50%. Die Wichtung legt also die Mitte des Bereichs fest. Demnach ist die Wichtung 75%, also die Mitte zwischen 50 und 100. Daher hat der Partikel zum Zeitpunkt 0ms (also dem Zeitpunkt seines Emittierens) die Größe 75% * 15 = 11,25.
Der Size-Wert ändert sich über die Zeit. Allerdings bleibt die Wichtung pro Partikel gleich. Der Size-Wert sagt, dass die Partikel bei Sekunde 1 nur noch zwischen 0 und 50% des Initialwertes groß sind. Durch die Wichtung von 50% ergibt sich ein Size-Wert von 25%, also der Mitte zwischen 0 und 50%. Daher hat das Partikel zum Zeitpunkt 1000ms die Größe 25% * 15 = 3,75.

Für Partikel 2 wird eine neue Initialgröße vergeben (deren Bereich sich über die Zeit natürlich auch verändern kann). Ebenso wird eine neue Wichtung ermittelt, zB. Initialgröße von 12 und einer Wichtung von 100%. Demnach ist das Partikel 2 zum Zeitpunkt 0ms 12 Einheiten groß und nach einer Sekunde nur noch 6.

<code>
var Particle := SlideShowObject as IParticle;
Particle.InitialSize.SetValue(0, 0, 10);
Particle.InitialSize.SetValue(1, 0, 20);
Particle.Size.SetValue(0, 0, 50);
Particle.Size.SetValue(1, 0, 100);
Particle.Size.SetValue(0, 1000, 0);
Particle.Size.SetValue(1, 1000, 50);
</code>

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

TParticleSpriteAnimation

2014-06-23T14:22:57Z

Mark.lorenz: Die Seite wurde neu angelegt: „Aufzählungstyp für Methode ''SpriteAnimation'' des Partikelobjekts. SpriteAnimation gibt an, wie eine Liste von Bildern des Partikelsystem…“

TParticleMove

2014-06-23T14:17:35Z

Mark.lorenz: Die Seite wurde neu angelegt: „Aufzählungstyp für Methode ''Move'' des Partikelobjekts. Move gibt die Bewegungsart an, die Partikel zusätzlich zur eigentlichen Bewegung…“

Aufzählungstyp für Methode ''Move'' des [[Partikelobjekt|Partikelobjekts]]. Move gibt die Bewegungsart an, die Partikel zusätzlich zur eigentlichen Bewegungsrichtung des Partikels ausführen.

= Werte =
* '''pmNone''': Keine zusätzliche Bewegung
* '''pmSinus''': Sinusbewegung senkrecht zur XY-Richtung
* '''pmCircle''': Kreisbewegungen in XY-Richtung
* '''pmRandomX''': Zufällige Bewegung senkrecht zur XY-Richtung
* '''pmRandomXY''': Zufällige Bewegung in XY-Richtung
* '''pmRandomXYZ''': Zufällige Bewegung in alle Richtungen
* '''pmGravity''': Zufällige Bewegung in XY-Richtung ausgelöst durch Gravitation

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

Partikelobjekt

2014-06-23T14:11:32Z

Mark.lorenz: /* Optionen */

Das Partikelobjekt ist vom Typ '''IParticle''' und leitet von '''[[ISlideShowObject]]''' ab. Mit diesem Objekt kann man Partikeleffekte erstellen.

Das Partikelobjekt enthält unter anderem Eigenschaften des Typs [[IParticleRangeValue]] bzw. [[IParticleRangeValue|IParticleVectorRangeValue]]. Einige dieser Eigenschaften verfügen über Initialwerte (wie ''Size'' und ''InitialSize''). Die Initialwerte geben den Ausgangszustand des Wertes an, die Nicht-Initialwerte geben eine Änderung an. Die Initialwerte bekommen einen Wertebereich. Beim Emittieren eines Partikels wird dem neuen Partikel ein zufälliger Werte innerhalb dieses Bereichs zugewiesen. Initialwerte können sich über die Dauer des Partikelsystems ändern. Die Änderungswerte erhalten ebenfalls einen Bereich. Der Unterschied ist, dass bei ihnen vorher eine Wichtung ermittelt wird. Diese wird benutzt um die Änderungen über die Lebenszeit des Partikels immer gleich gewichtet zu haben (siehe [[#Beispiel|Beispiel]]).

<code>
IParticle '''inherits from''' [[ISlideShowObject]]
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialSpeed: [[IParticleRangeValue]]
function Speed: [[IParticleRangeValue]]
function InitialSize: [[IParticleRangeValue]]
function Size: [[IParticleRangeValue]]
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]

property Move: [[TParticleMove]]
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialMoveSineFrequency: [[IParticleRangeValue]]
function MoveSineFrequency: [[IParticleRangeValue]]

function MaxAge: [[IParticleRangeValue]]
function ParticlesPerSecond: [[IParticleRangeValue]]

property SpriteAnimation: [[TParticleSpriteAnimation]]
function InitialSpriteAnimationFrequency: [[IParticleRangeValue|IParticleRangeValue]]
function SpriteAnimationFrequency: [[IParticleRangeValue]]

property Filename: [[IFilename]]
property Clipping: Boolean
property PreWarmTime: Integer

property Emitter: [[TParticleEmitter]]
function EmitterSpread: [[IParticleRangeValue]]
procedure AddEmitterClipRect(const X, Y, Width, Height, AngleZ: Single; const Invert: Boolean);

property Options: [[TParticleOptions]]
property Environment: [[TParticleEnvironment]]

property Seed: Int64
end;
</code>

= Methoden =

== Partikel ==

* Bewegungsrichtung
<code>
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Richtungsänderung über die Zeit: Addition von Winkeln (zB. bei Initialrichtung von 10 und einer Richtung von 10 bekommt das Partikel die Richtung 20).
<code>
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelgeschwindigkeit in Bewegungsrichtung
<code>
function InitialSpeed: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function Speed: [[IParticleRangeValue]];
</code>

* Partikelgröße. Skaliert das Partikel ohne Verzerrung so, dass die größte Richtung die Partikelgröße wird ("einpassen"):
<code>
function InitialSize: [[IParticleRangeValue]];
</code>
* Größenänderung über die Zeit: Prozent der Initialgröße.
<code>
function Size: [[IParticleRangeValue]];
</code>

* Partikeldrehung: Man unterscheidet zwischen der statischen Lage des Partikels und einer beständigen Drehung. Beispielsweise sollen die Partikel beim Emittieren immer zwischen 10 und 20 Grad gedreht sein, die Lage aber behalten. Dafür kommt die Eigenschaft '''Rotation''' in Frage (bei einer Rotationsgeschwindigkeit von 0). Ist jedoch eine permanente Drehung gewünscht, nimmt man die '''Rotationfrequency''' (Rotationsgeschwindigkeit). Lage und Rotationsgeschwindigkeitschließen sich nicht aus. Positive Werte drehen im Uhrzeigersinn, negative entgegengesetzt.
* Lage des Partikels
<code>
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Lageänderung über die Zeit. Additiv (zB. 10° bei 0ms und 20° bei 1000ms ergibt in der ersten Sekunde eine Drehung um 10°, danach keine weitere).
<code>
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Rotationsgeschwindigkeit: Gibt die Anzahl der Drehungen in einer Sekunde an.
<code>
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Geschwindigkeitsänderung die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelbewegung: Partikel können neben ihrer eigentlichen Bewegungsrichtung auch von ihrer Bewegung abweichen, zum Beispiel schwingen.
<code>
property Move: [[TParticleMove]];
</code>
* Stärke der Abweichgungsbewegung:
<code>
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Stärkenänderung über die Zeit: Prozent der Initialstärke:
<code>
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Abweichungsfrequenz: Gibt an, wie viele Schwingungen oder Kreisbewegungen in einer Sekunde vollführt werden
<code>
function InitialMoveFrequency: [[IParticleRangeValue]];
</code>
* Frequenzänderung über die Zeit: Prozent der Initialfrequenz:
<code>
function MoveFrequency: [[IParticleRangeValue]];
</code>

* Lebensdauer des Partikels in Millisekunden. 0 heißt, dass das Partikel nie "stirbt".
<code>
function MaxAge: [[IParticleRangeValue]];
</code>

* Emittierrate. Gibt an, wie viele Partikel in einer Sekunde emittiert werden.
<code>
function ParticlesPerSecond: [[IParticleRangeValue]];
</code>

* Partikelanimation. Sind im Partikelsystem mehrere Bilddateien angegeben, können die Partikel ihr Bild während ihrer Lebenszeit ändern.
<code>
property SpriteAnimation: [[TParticleSpriteAnimation]]
</code>
* Animationsgeschwindigkeit: Gibt an, wie oft die Liste der Bilder in einem Partikel in einer Sekunde angezeigt wird (zB. es sind 5 Bilder angegeben, die Animationsgeschwindigkeit ist 1, dann wird das Bild des Partikels alle 1/5 Sekunden geändert, also in der einen Sekunde durch die ganze Liste iteriert)
<code>
function InitialSpriteAnimationFrequency: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function SpriteAnimationFrequency: [[IParticleRangeValue]];
</code>

* Dateinamen der Partikelbilder
<code>
property Filename: [[IFilename]];
</code>

* Partikelsystem auf seine Bounds zuschneiden oder alle Partikel, die hinausragen anzeigen:
<code>
property Clipping: Boolean;
</code>

* Partikelsystem vorsimulieren. Es ist möglich, dass simuliert wird, dass das Partikelsystem bereits eine gewisse Zeit (in Millisekunden) gelaufen war, bevor es wirklich angezeigt wird.
<code>
property PreWarmTime: Integer;
</code>

== Emitter ==

* Emitter-Typ:
<code>
property Emitter: [[TParticleEmitter]]
</code>

* Rand am Emitter: Wenn der Emitter vom Typ ''pePoint'' oder ''pePath'' ist, kann er einen Abstand erhalten: Beim Punkt-Emitter werden die Partikel in einem Kreis mit angebenen Abstand emittiert, beim Pfad-Emitter werden die Partikel sowohl oberhalb als auch unterhalb davon abgebildet.
<code>
function EmitterSpread: [[IParticleRangeValue]]
</code>

* Flächen, an denen nicht emittiert werden soll: Der Emitter hält eine Liste von gedrehten Rechtecken, an denen nicht emittiert werden darf.
<code>
procedure AddEmitterClipRect(const X, Y, Width, Height, AngleZ: Single; const Invert: Boolean);
</code>

== Optionen ==

* Partikel-Umgebung: Gibt an, ob die Bounds vom Partikelsystem nur als Positionierung der Partikel beim Emittieren dienen ('''peGlobal'''), oder ob das Partikelsystem Einfluss auf die Partikel hat, die Partikel also mitskalieren und sich mitdrehen, etc. ('''peLocal''')
<code>
property Environment: [[TParticleEnvironment]]
</code>

* Partikeloptionen geben beispielsweise an, wie sich die Partikel bei Drehung des Partikelsystems verhalten oder ob die Animationen abrupt oder durch Alphablending ablaufen:
<code>
property Options: [[TParticleOptions]]
</code>

= Beispiel =

Einem Partikelsystem werden folgende [[IParticleRangeValue|RangeValues]] gegeben:
* InitialSize zwischen 10 und 20.
* Size zwischen 50 und 100 ab 0ms und 0 und 50 ab 1000ms

Partikel 1 bekommt zufällig eine Größe zwischen 10 und 20, zB. 15. Der Size-Wert modifiziert diesen Initialwert, in dem Fall prozentual. Das heißt das Partikel ist zwischen 50% * 15 und 100% * 15 groß ab Sekunde 0 seiner Lebenszeit. Der genaue Wert wird durch die zufällig gewählte Wichtung ermittelt, sagen wir 50%. Die Wichtung legt also die Mitte des Bereichs fest. Demnach ist die Wichtung 75%, also die Mitte zwischen 50 und 100. Daher hat der Partikel zum Zeitpunkt 0ms (also dem Zeitpunkt seines Emittierens) die Größe 75% * 15 = 11,25.
Der Size-Wert ändert sich über die Zeit. Allerdings bleibt die Wichtung pro Partikel gleich. Der Size-Wert sagt, dass die Partikel bei Sekunde 1 nur noch zwischen 0 und 50% des Initialwertes groß sind. Durch die Wichtung von 50% ergibt sich ein Size-Wert von 25%, also der Mitte zwischen 0 und 50%. Daher hat das Partikel zum Zeitpunkt 1000ms die Größe 25% * 15 = 3,75.

Für Partikel 2 wird eine neue Initialgröße vergeben (deren Bereich sich über die Zeit natürlich auch verändern kann). Ebenso wird eine neue Wichtung ermittelt, zB. Initialgröße von 12 und einer Wichtung von 100%. Demnach ist das Partikel 2 zum Zeitpunkt 0ms 12 Einheiten groß und nach einer Sekunde nur noch 6.

<code>
var Particle := SlideShowObject as IParticle;
Particle.InitialSize.SetValue(0, 0, 10);
Particle.InitialSize.SetValue(1, 0, 20);
Particle.Size.SetValue(0, 0, 50);
Particle.Size.SetValue(1, 0, 100);
Particle.Size.SetValue(0, 1000, 0);
Particle.Size.SetValue(1, 1000, 50);
</code>

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

Partikelobjekt

2014-06-23T14:09:52Z

Mark.lorenz:

Das Partikelobjekt ist vom Typ '''IParticle''' und leitet von '''[[ISlideShowObject]]''' ab. Mit diesem Objekt kann man Partikeleffekte erstellen.

Das Partikelobjekt enthält unter anderem Eigenschaften des Typs [[IParticleRangeValue]] bzw. [[IParticleRangeValue|IParticleVectorRangeValue]]. Einige dieser Eigenschaften verfügen über Initialwerte (wie ''Size'' und ''InitialSize''). Die Initialwerte geben den Ausgangszustand des Wertes an, die Nicht-Initialwerte geben eine Änderung an. Die Initialwerte bekommen einen Wertebereich. Beim Emittieren eines Partikels wird dem neuen Partikel ein zufälliger Werte innerhalb dieses Bereichs zugewiesen. Initialwerte können sich über die Dauer des Partikelsystems ändern. Die Änderungswerte erhalten ebenfalls einen Bereich. Der Unterschied ist, dass bei ihnen vorher eine Wichtung ermittelt wird. Diese wird benutzt um die Änderungen über die Lebenszeit des Partikels immer gleich gewichtet zu haben (siehe [[#Beispiel|Beispiel]]).

<code>
IParticle '''inherits from''' [[ISlideShowObject]]
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialSpeed: [[IParticleRangeValue]]
function Speed: [[IParticleRangeValue]]
function InitialSize: [[IParticleRangeValue]]
function Size: [[IParticleRangeValue]]
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]

property Move: [[TParticleMove]]
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialMoveSineFrequency: [[IParticleRangeValue]]
function MoveSineFrequency: [[IParticleRangeValue]]

function MaxAge: [[IParticleRangeValue]]
function ParticlesPerSecond: [[IParticleRangeValue]]

property SpriteAnimation: [[TParticleSpriteAnimation]]
function InitialSpriteAnimationFrequency: [[IParticleRangeValue|IParticleRangeValue]]
function SpriteAnimationFrequency: [[IParticleRangeValue]]

property Filename: [[IFilename]]
property Clipping: Boolean
property PreWarmTime: Integer

property Emitter: [[TParticleEmitter]]
function EmitterSpread: [[IParticleRangeValue]]
procedure AddEmitterClipRect(const X, Y, Width, Height, AngleZ: Single; const Invert: Boolean);

property Options: [[TParticleOptions]]
property Environment: [[TParticleEnvironment]]

property Seed: Int64
end;
</code>

= Methoden =

== Partikel ==

* Bewegungsrichtung
<code>
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Richtungsänderung über die Zeit: Addition von Winkeln (zB. bei Initialrichtung von 10 und einer Richtung von 10 bekommt das Partikel die Richtung 20).
<code>
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelgeschwindigkeit in Bewegungsrichtung
<code>
function InitialSpeed: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function Speed: [[IParticleRangeValue]];
</code>

* Partikelgröße. Skaliert das Partikel ohne Verzerrung so, dass die größte Richtung die Partikelgröße wird ("einpassen"):
<code>
function InitialSize: [[IParticleRangeValue]];
</code>
* Größenänderung über die Zeit: Prozent der Initialgröße.
<code>
function Size: [[IParticleRangeValue]];
</code>

* Partikeldrehung: Man unterscheidet zwischen der statischen Lage des Partikels und einer beständigen Drehung. Beispielsweise sollen die Partikel beim Emittieren immer zwischen 10 und 20 Grad gedreht sein, die Lage aber behalten. Dafür kommt die Eigenschaft '''Rotation''' in Frage (bei einer Rotationsgeschwindigkeit von 0). Ist jedoch eine permanente Drehung gewünscht, nimmt man die '''Rotationfrequency''' (Rotationsgeschwindigkeit). Lage und Rotationsgeschwindigkeitschließen sich nicht aus. Positive Werte drehen im Uhrzeigersinn, negative entgegengesetzt.
* Lage des Partikels
<code>
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Lageänderung über die Zeit. Additiv (zB. 10° bei 0ms und 20° bei 1000ms ergibt in der ersten Sekunde eine Drehung um 10°, danach keine weitere).
<code>
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Rotationsgeschwindigkeit: Gibt die Anzahl der Drehungen in einer Sekunde an.
<code>
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Geschwindigkeitsänderung die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelbewegung: Partikel können neben ihrer eigentlichen Bewegungsrichtung auch von ihrer Bewegung abweichen, zum Beispiel schwingen.
<code>
property Move: [[TParticleMove]];
</code>
* Stärke der Abweichgungsbewegung:
<code>
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Stärkenänderung über die Zeit: Prozent der Initialstärke:
<code>
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Abweichungsfrequenz: Gibt an, wie viele Schwingungen oder Kreisbewegungen in einer Sekunde vollführt werden
<code>
function InitialMoveFrequency: [[IParticleRangeValue]];
</code>
* Frequenzänderung über die Zeit: Prozent der Initialfrequenz:
<code>
function MoveFrequency: [[IParticleRangeValue]];
</code>

* Lebensdauer des Partikels in Millisekunden. 0 heißt, dass das Partikel nie "stirbt".
<code>
function MaxAge: [[IParticleRangeValue]];
</code>

* Emittierrate. Gibt an, wie viele Partikel in einer Sekunde emittiert werden.
<code>
function ParticlesPerSecond: [[IParticleRangeValue]];
</code>

* Partikelanimation. Sind im Partikelsystem mehrere Bilddateien angegeben, können die Partikel ihr Bild während ihrer Lebenszeit ändern.
<code>
property SpriteAnimation: [[TParticleSpriteAnimation]]
</code>
* Animationsgeschwindigkeit: Gibt an, wie oft die Liste der Bilder in einem Partikel in einer Sekunde angezeigt wird (zB. es sind 5 Bilder angegeben, die Animationsgeschwindigkeit ist 1, dann wird das Bild des Partikels alle 1/5 Sekunden geändert, also in der einen Sekunde durch die ganze Liste iteriert)
<code>
function InitialSpriteAnimationFrequency: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function SpriteAnimationFrequency: [[IParticleRangeValue]];
</code>

* Dateinamen der Partikelbilder
<code>
property Filename: [[IFilename]];
</code>

* Partikelsystem auf seine Bounds zuschneiden oder alle Partikel, die hinausragen anzeigen:
<code>
property Clipping: Boolean;
</code>

* Partikelsystem vorsimulieren. Es ist möglich, dass simuliert wird, dass das Partikelsystem bereits eine gewisse Zeit (in Millisekunden) gelaufen war, bevor es wirklich angezeigt wird.
<code>
property PreWarmTime: Integer;
</code>

== Emitter ==

* Emitter-Typ:
<code>
property Emitter: [[TParticleEmitter]]
</code>

* Rand am Emitter: Wenn der Emitter vom Typ ''pePoint'' oder ''pePath'' ist, kann er einen Abstand erhalten: Beim Punkt-Emitter werden die Partikel in einem Kreis mit angebenen Abstand emittiert, beim Pfad-Emitter werden die Partikel sowohl oberhalb als auch unterhalb davon abgebildet.
<code>
function EmitterSpread: [[IParticleRangeValue]]
</code>

* Flächen, an denen nicht emittiert werden soll: Der Emitter hält eine Liste von gedrehten Rechtecken, an denen nicht emittiert werden darf.
<code>
procedure AddEmitterClipRect(const X, Y, Width, Height, AngleZ: Single; const Invert: Boolean);
</code>

== Optionen ==

* Partikel-Umgebung: Gibt an, ob die Bounds vom Partikelsystem nur als Positionierung der Partikel beim Emittieren dienen ('''peGlobal'''), oder ob das Partikelsystem Einfluss auf die Partikel hat, die Partikel also mitskalieren und sich mitdrehen, etc. ('''peLocal''')
<code>
property Environment: [[TParticleEnvironment]]
</code>

* Partikeloptionen:
<code>
property Options: [[TParticleOptions]]
</code>

= Beispiel =

Einem Partikelsystem werden folgende [[IParticleRangeValue|RangeValues]] gegeben:
* InitialSize zwischen 10 und 20.
* Size zwischen 50 und 100 ab 0ms und 0 und 50 ab 1000ms

Partikel 1 bekommt zufällig eine Größe zwischen 10 und 20, zB. 15. Der Size-Wert modifiziert diesen Initialwert, in dem Fall prozentual. Das heißt das Partikel ist zwischen 50% * 15 und 100% * 15 groß ab Sekunde 0 seiner Lebenszeit. Der genaue Wert wird durch die zufällig gewählte Wichtung ermittelt, sagen wir 50%. Die Wichtung legt also die Mitte des Bereichs fest. Demnach ist die Wichtung 75%, also die Mitte zwischen 50 und 100. Daher hat der Partikel zum Zeitpunkt 0ms (also dem Zeitpunkt seines Emittierens) die Größe 75% * 15 = 11,25.
Der Size-Wert ändert sich über die Zeit. Allerdings bleibt die Wichtung pro Partikel gleich. Der Size-Wert sagt, dass die Partikel bei Sekunde 1 nur noch zwischen 0 und 50% des Initialwertes groß sind. Durch die Wichtung von 50% ergibt sich ein Size-Wert von 25%, also der Mitte zwischen 0 und 50%. Daher hat das Partikel zum Zeitpunkt 1000ms die Größe 25% * 15 = 3,75.

Für Partikel 2 wird eine neue Initialgröße vergeben (deren Bereich sich über die Zeit natürlich auch verändern kann). Ebenso wird eine neue Wichtung ermittelt, zB. Initialgröße von 12 und einer Wichtung von 100%. Demnach ist das Partikel 2 zum Zeitpunkt 0ms 12 Einheiten groß und nach einer Sekunde nur noch 6.

<code>
var Particle := SlideShowObject as IParticle;
Particle.InitialSize.SetValue(0, 0, 10);
Particle.InitialSize.SetValue(1, 0, 20);
Particle.Size.SetValue(0, 0, 50);
Particle.Size.SetValue(1, 0, 100);
Particle.Size.SetValue(0, 1000, 0);
Particle.Size.SetValue(1, 1000, 50);
</code>

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

Partikelobjekt

2014-06-23T12:44:22Z

Mark.lorenz:

Das Partikelobjekt ist vom Typ '''IParticle''' und leitet von '''[[ISlideShowObject]]''' ab. Mit diesem Objekt kann man Partikeleffekte erstellen.

Das Partikelobjekt enthält unter anderem Eigenschaften des Typs [[IParticleRangeValue]] bzw. [[IParticleRangeValue|IParticleVectorRangeValue]]. Einige dieser Eigenschaften verfügen über Initialwerte (wie ''Size'' und ''InitialSize''). Die Initialwerte geben den Ausgangszustand des Wertes an, die Nicht-Initialwerte geben eine Änderung an. Die Initialwerte bekommen einen Wertebereich. Beim Emittieren eines Partikels wird dem neuen Partikel ein zufälliger Werte innerhalb dieses Bereichs zugewiesen. Initialwerte können sich über die Dauer des Partikelsystems ändern. Die Änderungswerte erhalten ebenfalls einen Bereich. Der Unterschied ist, dass bei ihnen vorher eine Wichtung ermittelt wird. Diese wird benutzt um die Änderungen über die Lebenszeit des Partikels immer gleich gewichtet zu haben (siehe [[#Beispiel|Beispiel]]).

<code>
IParticle '''inherits from''' [[ISlideShowObject]]
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialSpeed: [[IParticleRangeValue]]
function Speed: [[IParticleRangeValue]]
function InitialSize: [[IParticleRangeValue]]
function Size: [[IParticleRangeValue]]
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]]

property Move: [[TParticleMove]]
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]]
function InitialMoveSineFrequency: [[IParticleRangeValue]]
function MoveSineFrequency: [[IParticleRangeValue]]

function MaxAge: [[IParticleRangeValue]]
function ParticlesPerSecond: [[IParticleRangeValue]]

property SpriteAnimation: [[TParticleSpriteAnimation]]
function InitialSpriteAnimationFrequency: [[IParticleRangeValue|IParticleRangeValue]]
function SpriteAnimationFrequency: [[IParticleRangeValue]]

property Filename: [[IFilename]]
property Clipping: Boolean
property PreWarmTime: Integer

property Emitter: [[TParticleEmitter]]
function EmitterSpread: [[IParticleRangeValue]]
property Options: [[TParticleOptions]]
property Environment: [[TParticleEnvironment]]

property Seed: Int64
end;
</code>

= Methoden =

* Bewegungsrichtung
<code>
function InitialDirection: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Richtungsänderung über die Zeit: Addition von Winkeln (zB. bei Initialrichtung von 10 und einer Richtung von 10 bekommt das Partikel die Richtung 20).
<code>
function Direction: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelgeschwindigkeit in Bewegungsrichtung
<code>
function InitialSpeed: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function Speed: [[IParticleRangeValue]];
</code>

* Partikelgröße. Skaliert das Partikel ohne Verzerrung so, dass die größte Richtung die Partikelgröße wird ("einpassen"):
<code>
function InitialSize: [[IParticleRangeValue]];
</code>
* Größenänderung über die Zeit: Prozent der Initialgröße.
<code>
function Size: [[IParticleRangeValue]];
</code>

* Partikeldrehung: Man unterscheidet zwischen der statischen Lage des Partikels und einer beständigen Drehung. Beispielsweise sollen die Partikel beim Emittieren immer zwischen 10 und 20 Grad gedreht sein, die Lage aber behalten. Dafür kommt die Eigenschaft '''Rotation''' in Frage (bei einer Rotationsgeschwindigkeit von 0). Ist jedoch eine permanente Drehung gewünscht, nimmt man die '''Rotationfrequency''' (Rotationsgeschwindigkeit). Lage und Rotationsgeschwindigkeitschließen sich nicht aus. Positive Werte drehen im Uhrzeigersinn, negative entgegengesetzt.
* Lage des Partikels
<code>
function InitialRotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Lageänderung über die Zeit. Additiv (zB. 10° bei 0ms und 20° bei 1000ms ergibt in der ersten Sekunde eine Drehung um 10°, danach keine weitere).
<code>
function Rotation: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Rotationsgeschwindigkeit: Gibt die Anzahl der Drehungen in einer Sekunde an.
<code>
function InitialRotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Geschwindigkeitsänderung die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function RotationFrequency: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>

* Partikelbewegung: Partikel können neben ihrer eigentlichen Bewegungsrichtung auch von ihrer Bewegung abweichen, zum Beispiel schwingen.
<code>
property Move: [[TParticleMove]];
</code>
* Stärke der Abweichgungsbewegung:
<code>
function InitialMoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Stärkenänderung über die Zeit: Prozent der Initialstärke:
<code>
function MoveStrength: [[IParticleRangeValue|IParticleVectorRangeValue]];
</code>
* Abweichungsfrequenz: Gibt an, wie viele Schwingungen oder Kreisbewegungen in einer Sekunde vollführt werden
<code>
function InitialMoveFrequency: [[IParticleRangeValue]];
</code>
* Frequenzänderung über die Zeit: Prozent der Initialfrequenz:
<code>
function MoveFrequency: [[IParticleRangeValue]];
</code>

* Lebensdauer des Partikels in Millisekunden. 0 heißt, dass das Partikel nie "stirbt".
<code>
function MaxAge: [[IParticleRangeValue]];
</code>

* Emittierrate. Gibt an, wie viele Partikel in einer Sekunde emittiert werden.
<code>
function ParticlesPerSecond: [[IParticleRangeValue]];
</code>

* Partikelanimation. Sind im Partikelsystem mehrere Bilddateien angegeben, können die Partikel ihr Bild während ihrer Lebenszeit ändern.
<code>
property SpriteAnimation: [[TParticleSpriteAnimation]]
</code>
* Animationsgeschwindigkeit: Gibt an, wie oft die Liste der Bilder in einem Partikel in einer Sekunde angezeigt wird (zB. es sind 5 Bilder angegeben, die Animationsgeschwindigkeit ist 1, dann wird das Bild des Partikels alle 1/5 Sekunden geändert, also in der einen Sekunde durch die ganze Liste iteriert)
<code>
function InitialSpriteAnimationFrequency: [[IParticleRangeValue]];
</code>
* Geschwindigkeitsänderung über die Zeit: Prozent der Initialgeschwindigkeit.
<code>
function SpriteAnimationFrequency: [[IParticleRangeValue]];
</code>

* Dateinamen der Partikelbilder
<code>
property Filename: [[IFilename]];
</code>

* Partikelsystem auf seine Bounds zuschneiden oder alle Partikel, die hinausragen anzeigen:
<code>
property Clipping: Boolean;
</code>

* Partikelsystem vorsimulieren. Es ist möglich, dass simuliert wird, dass das Partikelsystem bereits eine gewisse Zeit (in Millisekunden) gelaufen war, bevor es wirklich angezeigt wird.
<code>
property PreWarmTime: Integer;
</code>

= Beispiel =

Einem Partikelsystem werden folgende [[IParticleRangeValue|RangeValues]] gegeben:
* InitialSize zwischen 10 und 20.
* Size zwischen 50 und 100 ab 0ms und 0 und 50 ab 1000ms

Partikel 1 bekommt zufällig eine Größe zwischen 10 und 20, zB. 15. Der Size-Wert modifiziert diesen Initialwert, in dem Fall prozentual. Das heißt das Partikel ist zwischen 50% * 15 und 100% * 15 groß ab Sekunde 0 seiner Lebenszeit. Der genaue Wert wird durch die zufällig gewählte Wichtung ermittelt, sagen wir 50%. Die Wichtung legt also die Mitte des Bereichs fest. Demnach ist die Wichtung 75%, also die Mitte zwischen 50 und 100. Daher hat der Partikel zum Zeitpunkt 0ms (also dem Zeitpunkt seines Emittierens) die Größe 75% * 15 = 11,25.
Der Size-Wert ändert sich über die Zeit. Allerdings bleibt die Wichtung pro Partikel gleich. Der Size-Wert sagt, dass die Partikel bei Sekunde 1 nur noch zwischen 0 und 50% des Initialwertes groß sind. Durch die Wichtung von 50% ergibt sich ein Size-Wert von 25%, also der Mitte zwischen 0 und 50%. Daher hat das Partikel zum Zeitpunkt 1000ms die Größe 25% * 15 = 3,75.

Für Partikel 2 wird eine neue Initialgröße vergeben (deren Bereich sich über die Zeit natürlich auch verändern kann). Ebenso wird eine neue Wichtung ermittelt, zB. Initialgröße von 12 und einer Wichtung von 100%. Demnach ist das Partikel 2 zum Zeitpunkt 0ms 12 Einheiten groß und nach einer Sekunde nur noch 6.

<code>
var Particle := SlideShowObject as IParticle;
Particle.InitialSize.SetValue(0, 0, 10);
Particle.InitialSize.SetValue(1, 0, 20);
Particle.Size.SetValue(0, 0, 50);
Particle.Size.SetValue(1, 0, 100);
Particle.Size.SetValue(0, 1000, 0);
Particle.Size.SetValue(1, 1000, 50);
</code>

[[Kategorie:Scripting-API]]
[[Kategorie:Partikelsystem]]

IParticleRangeValue

2014-06-23T12:44:10Z

Mark.lorenz: /* Methoden */