From Unreal Wiki, The Unreal Engine Documentation Site
Jump to navigation Jump to search
UT :: Object (UT) >> Bitmap >> Texture (UT) >> FractalTexture >> FireTexture (Package: Fire)
UT2003 :: Object >> Material >> RenderedMaterial >> BitmapMaterial >> Texture >> FractalTexture >> FireTexture (Package: Fire)

Can render fire, lightning and other effects.



All FX_ parameters are applied only to new sparks when drawing them in the editor. All other parameters take effect instantly. The FX parameters have different effects based on the type of spark selected. See ESpark enum below.

bool bRising 
Whether "flames" should move upwards.
DMode DrawMode 
byte FX_Area 
byte FX_AuxSize 
An additional size parameter for the effect.
byte FX_Frequency 
byte FX_Heat 
Brightness of the individual spark.
byte FX_HorizSpeed 
Horizontal speed of the effect. (128 = no horizontal movement)
byte FX_Phase 
byte FX_Size 
The size of the effect.
byte FX_VertSpeed 
Vertical speed of the effect. (128 = no vertical movement)
byte RenderHeat 
The overall intensity.
int SparksLimit 
The maximum number of sparks allowed to be displayed. Both the permanent (drawn in the editor) and the transient (created when animating the texture) sparks are counted here. Lowering this number can improve performance, while a higher number allows more complex effects.
ESpark SparkType 
The type of spark to draw in the editor.

UnrealScript-Only Properties

int NumSparks 
byte OldRenderHeat (transient) 
byte PenDownX (transient) 
byte PenDownY (transient) 
byte RenderTable[1028] (transient) 
array<Spark> Sparks (transient) 
byte StarStatus (transient) 



Simple, nonmoving sparks of random intensity. Looks best with bRising set to True.
Sparks with random positional jitter over an area of horizontal size FX_Size, vertical size FX_AuxSize, with intensity FX_Heat.
Great for pulse-trains, FX_Frequency sets the time frequency, and FX_Phase is the spatial frequency: 0=pulsed fire, use higher values for moving trains of sparks.
The shieldbelt effect uses this kind of spark.
Like SPARK_Burn, but this has several options to customize the graininess, brightness and intensity distribution to any desired output, providing a versatile base fire effect.
FX_Frequency sets the average pattern frequency, FX_Heat determines the ratio of bright patches to dark ones, i.e. a medium setting increases the contrast of the overall effect.
Emits sparks in all directions.
Simple up-moving, fading-out sparks.
Like SPARK_Blaze, but with gravity acting on the sparks. A nice sparse effect to put at the center of complex ramped lighting bolt scenes, for example.
Simple eruptions to the right and left, falling down.
Sparks moving in horizontal, 'cylindrical' orbits, with angular velocity FX_HorizSpeed. FX_Heat determines the minimum intensity, which always varies along a spark's orbit - this means that a low FX_Heat setting gives a collection of sparks a 3d-appearance, as if the 'backfacing' sparks are removed. FX_Size sets the amplitude of the orbits.
DrawMode influences the FX_Size dynamically; when set to any of the 'Lathe' options, as long as you keep the mouse button pressed while drawing, all sparks will be aligned around an invisible vertical axis so it's as if you're using a lathe. Lathe_2, _3 and _4 draw multiple sparks at regular spacings around the cylinder, instead of just one.
The way the initial position of sparks wind around the cylinder as you draw is influenced by FX_Frequency.
Like SPARK_Cylinder, but this type makes all the 'backfaced' sparks disappear completely.
FX_Size determines the amplitude of the orbits, at FX_Frequency.
FX_HorizSpeed and FX_VertSpeed determine the horizontal and vertical frequencies independently. Like SPARK_Cylinder, individual spark intensity depends on the phase of the horizontal movement and this is always offset by FX_Heat.
FX_Size sets the amplitude of these, moving on a simple vertical sine wave pattern at FX_Frequency. As with SPARK_Cylinder, the 'back-facing' effect depends on the FX_Heat setting.
Moving in the directions set by FX_HorizSpeed and FX_VertSpeed, these glow out as they progress over straight trajectories of determined by both FX_Size and the initial heat FX_Heat.
With the speeds set to extremes (0, 128, 255) the trajectories become clean straight lines.
Like SPARK_Emit, but the sparks have gravity acting on them. A great effect for stuff like streaming lava, steam or water. Setting initial speeds to zero (128, 128) makes the sparks oozing down.
A random moving flock of sparks drawn at FX_Heat, jittering in circular orbits of size FX_Area, with FX_Size being the lifetime of individual sparks.
Random cloud of straight moving sparks drawn at FX_Heat with lifetime FX_Size.
Fast moving sparks going upward at V-shaped angles.
Wandering Organic sparks.
A wandering cloud of double-speed upward moving sparks.
Completely customizable clouds using FX_HorizSpeed and FX_VertSpeed. While moving, sparks glow up to the maximum brightness and then disappear. FX_Area determines the spark's lifetime by setting their initial brightness. A high FX_Area value makes sparks start at a lower heat so they take longer to reach full heat. Set the speeds at or around zero (128, 128) to create a nice sparkly effect.
Like SPARK_CustomCloud, but the spawning points of these are random within an FX_Area sized square, the upper left corner of which is the mouse position where you draw the effect.
Unlike any other sparks, this one doesn't get washed out by the fire algorithm, but consists of single pixels of brightness FX_Heat, which get obscured by any fire passing across it, unless the flames have a very low intensity.
Click, stretch out the lightning to the desired end location, and release it. A low setting of FX_Frequency gives continuous lightning bolts, while a high setting makes it flash more intermittently. Most lightning looks coolest when it's kind of sparse, achieve this by either adjusting the RenderHeat or setting a higher FX_Frequency.
Like SPARK_LineLightning, but with intensity diminishing towards the endpoint of the bolt.
Spherically symmetrical lightning, with diameter FX_Size. Sparse by default, to get more coverage put a few of them on top of each other.
Sparks move outward in circular orbits the size of which is determined by FX_Area, over a path of length FX_Size. They are emitted at an initial angle FX_Phase, FX_Frequency sets the rotation speed.
Random cloud of straight moving sparks drawn at FX_Heat with lifetime FX_Size.
Spawns upward wavy streams, FX_Frequency determines the speed at which the initial angle changes. FX_Phase controls the relative phase. On a low FX_Heat setting, a few of these can be combined together or with other effects to design smoky whirls.





Information about a single spark. (Used internally.)

<uscript> struct Spark {

   var ESpark Type;   // Spark type.
   var byte   Heat;   // Spark heat.
   var byte   X;      // Spark X location (0 - Xdimension-1).
   var byte   Y;      // Spark Y location (0 - Ydimension-1).
   var byte   ByteA;  // X-speed.
   var byte   ByteB;  // Y-speed.
   var byte   ByteC;  // Age, Emitter freq.
   var byte   ByteD;  // Exp.Time.

}; </uscript>


Draconx: I'd love to see a description on how the Lathe modes work, I've seen images of cool looking fire textures supposedly done using the lathe modes, yet no actual explanation to their use.