IParticleRangeValue: Unterschied zwischen den Versionen

Aus AquaSoft Wiki
Zur Navigation springenZur Suche springen
(Die Seite wurde neu angelegt: „IParticleRangeValue ist eine Ableitung von IRangeValue. Die ''Bereichswerte'' (engl. RangeValue) geben die Möglichkeit, dass Objekte nicht einen fixen Wer…“)
 
 
(16 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
−
IParticleRangeValue ist eine Ableitung von [[IRangeValue]]. Die ''Bereichswerte'' (engl. RangeValue) geben die Möglichkeit, dass Objekte nicht einen fixen Wert zugewiesen bekommen, sondern Werte innerhalb eines bestimmten Bereiches annehmen. Genaueres [[IRangeValue|hier]].
+
'''IParticleRangeValue''' ist eine Ableitung von [[IRangeValue]]. Die ''Bereichswerte'' (engl. RangeValue) geben die Möglichkeit, dass Objekte nicht einen fixen Wert zugewiesen bekommen, sondern Werte innerhalb eines bestimmten Bereiches annehmen. Genaueres [[IRangeValue|hier]].
  
 
Es wird unterschieden zwischen "einfachen" RangeValues ('''IParticleRangeValue''') und dreidimensionalen RangeValues ('''IParticleVectorRangeValue'''). Die dreidimensionalen RangeValues können also Werte in allen Richtungen des Raumes annehmen und verfügen daher über mehr Getter und Setter.
 
Es wird unterschieden zwischen "einfachen" RangeValues ('''IParticleRangeValue''') und dreidimensionalen RangeValues ('''IParticleVectorRangeValue'''). Die dreidimensionalen RangeValues können also Werte in allen Richtungen des Raumes annehmen und verfügen daher über mehr Getter und Setter.
  
−
Einige 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. 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.
+
<code>
 +
  IParticleRangeValue''' inherits from''' [[IRangeValue]]
 +
    function GetValue (const Time: Double): Double;
 +
    procedure SetValue (const ItemIndex: Integer; const Time: Double; const Value: Single);
 +
    procedure Clear;
 +
    procedure Assign(const Other: IParticleRangeValue);
 +
    property MaxTime: Double read GetMaxTime write SetMaxTime;
 +
    property TimeMode: [[TTimeMode]] read GetTimeMode write SetTimeMode;
 +
  end;
  
−
= Beispiel =
+
  IParticleRangeValue '''inherits from''' [[IRangeValue]]
 +
    function GetValueX (const Time: Double): Double;
 +
    procedure SetValueX (const ItemIndex: Integer; const Time: Double; const Value: Single);
 +
    function GetValueY (const Time: Double): Double;
 +
    procedure SetValueY (const ItemIndex: Integer; const Time: Double; const Value: Single);
 +
    function GetValueZ (const Time: Double): Double;
 +
    procedure SetValueZ (const ItemIndex: Integer; const Time: Double; const Value: Single);
 +
    procedure SetValueXYZ (const ItemIndex: Integer; const Time: Double; const Value: Single);
 +
    procedure Clear;
 +
    procedure Assign(const Other: IParticleVectorRangeValue);
 +
    property MaxTime: Double read GetMaxTime write SetMaxTime;
 +
    property TimeMode: [[TTimeMode]] read GetTimeMode write SetTimeMode;
 +
  end;
 +
</code>
  
−
Einem Partikelsystem werden folgende Werte gegeben:
+
= Methoden =
−
* 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.
+
* Werte setzen: SetValue bzw. SetValueX, SetValueY, SetValueZ und SetValueXYZ. Für die Parameter siehe [[IRangeValue|hier]]. SetValueXYZ gibt allen Dimensionen den gleichen Wert.
−
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.
+
<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>
  
−
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.
 
  
 +
* Alle Werte löschen
 
<code>
 
<code>
−
   IParticle '''inherits from''' [[ISlideShowObject]]
+
   procedure Clear;
−
    function InitialSpeed: [[IParticleRangeValue]] 
+
</code>
−
    function Speed: [[IParticleRangeValue]]
 
−
    function InitialDirection: [[IParticleVectorRangeValue]]
 
−
    function Direction: [[IParticleVectorRangeValue]]
 
−
    function InitialSize: [[IParticleRangeValue]]
 
−
    function Size: [[IParticleRangeValue]]
 
−
    function InitialRotation: [[IParticleVectorRangeValue]]
 
−
    function Rotation: [[IParticleVectorRangeValue]]
 
−
    function InitialRotationFrequency: [[IParticleVectorRangeValue]]
 
−
    function RotationFrequency: [[IParticleVectorRangeValue]]
 
  
−
    property Move: [[TParticleMove]]
 
−
    function InitialMoveStrength: [[IParticleVectorRangeValue]]
 
−
    function MoveStrength: [[IParticleVectorRangeValue]]
 
−
    function InitialMoveSineFrequency: [[IParticleRangeValue]]
 
−
    function MoveSineFrequency: [[IParticleRangeValue]]
 
  
−
    function MaxAge: [[IParticleRangeValue]]
+
* Maximaler Zeitpunkt, der einen Wert bekommen hat
−
    function ParticlesPerSecond: [[IParticleRangeValue]]
+
<code>
−
    function EmitterSpread: [[IParticleRangeValue]]
+
  property MaxTime: Double;
 +
</code>
  
−
    property SpriteAnimation: [[TParticleSpriteAnimation]]
 
−
    function SpriteAnimationFrequency: [[IParticleRangeValue]]
 
  
−
    property Filename: [[IFilename]]  
+
* Zeitmodus ausgeben: Eingebene Werte werden entweder als absolute Zeitpunkt in Millisekunden interpretiertoder als relative Werte in Prozent bzgl. MaxTime.
−
    property Clipping: Boolean
+
<code>
−
    property PreWarmTime: Integer
+
  property TimeMode: [[TTimeMode]];
 +
</code>
  
−
    property Emitter: [[TParticleEmitter]]
 
−
    property Options: [[TParticleOptions]]
 
−
    property Environment: [[TParticleEnvironment]]
 
  
−
    property Seed: Int64 
+
* Werte von anderem IParticleRangeValue übernehmen:
−
   end;
+
<code>
 +
   procedure Assign(const Other: IParticleVectorRangeValue);
 
</code>
 
</code>
  
 
[[Kategorie:Scripting-API]]
 
[[Kategorie:Scripting-API]]
 +
[[Kategorie:Partikelsystem]]
 +
[[Kategorie:Language]]

Aktuelle Version vom 23. Juni 2014, 16:42 Uhr

IParticleRangeValue ist eine Ableitung von IRangeValue. Die Bereichswerte (engl. RangeValue) geben die Möglichkeit, dass Objekte nicht einen fixen Wert zugewiesen bekommen, sondern Werte innerhalb eines bestimmten Bereiches annehmen. Genaueres hier.

Es wird unterschieden zwischen "einfachen" RangeValues (IParticleRangeValue) und dreidimensionalen RangeValues (IParticleVectorRangeValue). Die dreidimensionalen RangeValues können also Werte in allen Richtungen des Raumes annehmen und verfügen daher über mehr Getter und Setter. 

 IParticleRangeValue inherits from IRangeValue
   function GetValue (const Time: Double): Double;
   procedure SetValue (const ItemIndex: Integer; const Time: Double; const Value: Single);
   procedure Clear;
   procedure Assign(const Other: IParticleRangeValue);
   property MaxTime: Double read GetMaxTime write SetMaxTime;
   property TimeMode: TTimeMode read GetTimeMode write SetTimeMode;
 end;

 IParticleRangeValue inherits from IRangeValue
   function GetValueX (const Time: Double): Double;
   procedure SetValueX (const ItemIndex: Integer; const Time: Double; const Value: Single);
   function GetValueY (const Time: Double): Double;
   procedure SetValueY (const ItemIndex: Integer; const Time: Double; const Value: Single);
   function GetValueZ (const Time: Double): Double;
   procedure SetValueZ (const ItemIndex: Integer; const Time: Double; const Value: Single);
   procedure SetValueXYZ (const ItemIndex: Integer; const Time: Double; const Value: Single);
   procedure Clear;
   procedure Assign(const Other: IParticleVectorRangeValue);
   property MaxTime: Double read GetMaxTime write SetMaxTime;
   property TimeMode: TTimeMode read GetTimeMode write SetTimeMode;
 end;

Methoden

  • Werte setzen: SetValue bzw. SetValueX, SetValueY, SetValueZ und SetValueXYZ. Für die Parameter siehe hier. SetValueXYZ gibt allen Dimensionen den gleichen Wert.

 procedure SetValue (const ItemIndex: Integer; const Time: Double; const Value: Single);

  • Wert zum Zeitpunkt Time ausgeben, analog zum Setter.

 function GetValue (const Time: Double): Double;


  • Alle Werte löschen

 procedure Clear;


  • Maximaler Zeitpunkt, der einen Wert bekommen hat

 property MaxTime: Double;


  • Zeitmodus ausgeben: Eingebene Werte werden entweder als absolute Zeitpunkt in Millisekunden interpretiertoder als relative Werte in Prozent bzgl. MaxTime.

 property TimeMode: TTimeMode;


  • Werte von anderem IParticleRangeValue übernehmen:

 procedure Assign(const Other: IParticleVectorRangeValue);

Abgerufen von „https://wiki.aquasoft.de/wiki/index.php?title=IParticleRangeValue&oldid=1158“