Show in Contents

Add to Favorites

Home: Flint
 
 Simple Mathematical Functions

Function Reference

Rounding Functions
 
                
               
             
             
            
            Random Number Functions
          
       
       
       
       
      Use the following functions
         to create curves based on random values.
      
      rand
         
         Returns
            a random value between -1 and 1, based on the value used as an argument,
            called the seed. Using the same seed in
            the rand function for multiple channels produces the exact same
            results. To create completely random results, use the true rand function.
         
            
               
                  
                  
                  
                     | Syntax: | rand(Seed) | 
                  
                     | Arguments: | 
                           Seed is the value used to generate the
                              random return value. This is usually set to a changing value such
                              as the current frame number.
                            | 
                  
                     | Examples: | 
                           rand(frame % 10) * 50 + 50 returns a
                              set of random values between0 and 100 that repeats every 10 frames.
                            rand(frame) * 100 returns a random value
                              between -100 and 100for every frame in the animation. The following
                              curve shows the result of this function: 
                            | 
               
            
          
      truerand
         
         Returns
            a truly random value between two given numbers. The sequence of
            returned values will constantly change, never reproducing past results.
         
            
               
                  
                  
                  
                     | Syntax: | truerand(Low, High) | 
                  
                     | Arguments: | 
                           Low and High are the upper and lower bounds,
                              respectively, of the random number to generate.
                            | 
                  
                     | Example: | 
                           truerand(-5.5,10.8) returns a truly random value
                              between -5.5and 10.8.
                            | 
               
            
          
      noise
         
         Returns
            a random value between -1 and 1, based on a given vector. If the
            parameter varies smoothly, this function will return a continuously
            changing value that also varies smoothly.
         
            
               
                  
                  
                  
                     | Syntax: | noise(Position) | 
                  
                     | Arguments: | 
                           Position is a vector used as a seed for
                              the returned random value.
                            | 
                  
                     | Examples: | 
                           noise(frame) * 5 returns a continuous
                              random value between-5 and 5.
                           (noise(axis1.position) + 1) / 2 * 100
                              returns a continuous random value between 0 and 100.
                           noise(axis1.position) * 100 yields the
                              following curve:
                            | 
               
            
          
      noise3
         
         Returns
            a random vector for all elements in a vector between -1 and 1. If
            the parameter varies smoothly, this function will return a vector
            of continuously changing values that also vary smoothly.
         
            
               
                  
                  
                  
                     | Syntax: | noise3(Position) | 
                  
                     | Arguments: | 
                           Position is a vector used as a seed for
                              the returned random vector.
                            | 
                  
                     | Examples: | 
                           noise3(frame) * 5 returns a vector of continuous
                              random values between -5 and 5.
                           (noise3(axis1.position) + 1) / 2 * 100
                              returns a vector of continuous random values between 0 and 100.
                           noise3(axis1.position) * 100 returns
                              the following three curves:
                            | 
               
            
          
      fnoise
         
         Returns
            a random value between -1 and 1, based on a given vector. If the
            parameter varies smoothly, this function will return a continuously
            changing value that also varies smoothly to a fractal pattern. This
            function is similar to the noise function, but it applies a fractal
            pattern to the result.
         
            
               
                  
                  
                  
                     | Syntax: | fnoise(Position) | 
                  
                     | Arguments: | 
                           Position is a vector used as a seed for
                              the returned random value.
                            | 
                  
                     | Examples: | 
                           fnoise(frame) * 5 returns a continuous random
                              value between-5 and 5.
                           (fnoise(axis1.position) + 1) / 2 * 100
                              returns a continuous random value between 0 and 100.
                           fnoise(axis1.position) * 100 yields the
                              following curve:
                            | 
               
            
          
      turbulence
         
         Returns
            a random value between -1 and 1, based on a given vector and with
            the ability to control the level of smoothness for the resulting
            curve.
         
            
               
                  
                  
                  
                     | Syntax: | turbulence(Position, Level) | 
                  
                     | Arguments: | 
                           Position is a vector used as a seed for
                              the returned random value.
                           Level is a positive integer where the
                              greater the value, the greater the jitter applied to the resulting
                              curve. If this argument is set to a value less than 1, the level
                              will be treated as if 1 were used. If it is set to a number with
                              a fractional component, the number will be rounded down to the nearest
                              integer. 
                            | 
                  
                     | Examples: | 
                           turbulence(axis1.position, 1) * 100 yields
                              the following curve:
                            
                           turbulence(axis1.position, 8) * 100 yields
                              the following curve:
                            | 
               
            
          
      turbulence3
         
         Returns
            a random vector for all elements in a vector between -1 and 1, along
            with the ability to control the smoothness of the resulting curve.
            If the position parameter varies smoothly, this function will return
            a vector of continuously changing values that also vary smoothly.
         
            
               
                  
                  
                  
                     | Syntax: | turbulence3(Position, Level) | 
                  
                     | Arguments: | 
                           Position is a vector used as a seed for
                              the returned random vector.
                           Level is a positive integer used to control
                              the level of jitter of the resulting curve. If this argument is
                              set to a value less than 1, the level will be treated as if 1 were
                              used. If it is set to a number with a fractional component, the
                              number will be rounded down to the nearest integer. 
                            | 
                  
                     | Examples: | 
                           turbulence3(axis1.position, 1) * 100
                              returns the following three curves:
                            
                           turbulence3(axis1.position, 8) * 100
                              returns the following three curves:
                            |