Customizing G-Force

You can customize G-Force in many ways by editing the settings and flags stored its preferences file, and the following list describes each parameter found in it. Note that each version of G-Force writes its own separate set of preferences (ex, the Winamp version writes "G-Force Prefs (Winamp)" while the standalone version writes "G-Force Prefs (Standalone)"). Since G-Force writes/updates its preferences file only when it exits, you'll have to run and exit G-Force at least once before you'll find a G-Force prefs file to edit. Further, G-Force shouldn't be running while you're editing its prefs file or else it will save over your changes when it exits. Do a search for "G-Force Prefs" on your system to see where G-Force has written its prefs file. Finally, if you find G-Force acting strangely after you edit its prefs file, just delete the prefs file and G-Force will make a new "factory" set of prefs.

SSvr (Screen Saver)
This parameter is used to make GF a screen saver, and tells GF the number of minutes to wait before switching to full screen once your computer has been left idle. You can disable this action by setting it to 0 or -1 (it's disabled by default).
MaxX, MaxY - (Max Dimensions/Letterbox Size)
These set a limit on the pixel dimensions of GF. For example, 640x480 may be too slow for your computer, but setting MaxY to 300 will increase framerate and you'll still have most of your screen filled up.
FWin - (Floating Window)
If this is 1, GF will try to "float" the G-Force window above other windows. This may not apply or be possible depending on your audio player and/or OS. Turn of floating window by setting it to 0.
FS_X, FS_Y - (Fullscreen Dimensions)
This tells GF what fullscreen resolution you prefer. When you tell it to go fullscreen, it will use the dimensions specified here. Be sure you only put sizes you know your screen can support, and if bad things start to happen, just stay with 640x480. Remember, these dimensions specify a device resolution, so you can't just put any values you like here (use MaxX and MaxY to tell GF to live in a smaller rect).
FS_D - (Fullscreen Depth)
This is the depth GF will choose when it goes fullscreen (choose only 8, 16, or 32). 8 and 32 bit will produce the same color-quality frames, but 32 will be slower because more data is moving around (ie, 1 byte per pixel vs. 4 bytes per pixel). 16 will be slightly faster than 32 but will show a small decrease in color quality. The only time you don't want to use 8 for FS_D is if your system is having problems using 8. The frame rate key shows you the current frame rate and can help you discover which depth is fastest for your system. Note that because GF tries to maintain a specified frame rate (see the 'FPS' pref), to do a frame rate comparison you must set the 'FPS' pref to a value GF won't be able to achieve (ex 100). If you don't do this and FPS happens to be set at 20, GF will task accordingly to achieve 20 fps, not making fps benchmarks possible.
FS_F - (Fullscreen Refresh Frequency)
(MacOS only) When this is 0, the system default refresh rate is used for whatever resolution is specified by FS_X, FS_Y, FS_D, and FS_#. Most of the time, this is fine since the system will choose the highest refresh frequency possible, but some systems have A/V output that needs to be a specific frequency (ex, set FS_F="60").
Cach - (Cache Configs Initially)
If this is set to 1, every config file will be loaded when GF starts up. The advantage of this is that you won't suffer possibly long jitters or lags if your disk is slow or goes to sleep. This disadvantage is that GF will take longer to startup (as it loads all the configs). By default, 'Cach' is set to 1, so set it to 0 if you don't wish to initially cache all the files for some reason.
CLP - (Cache Large Particles)
If this is 1, GF will pre-load all image and movie files in the sprites folders when it starts up (vs. not a sprite until it's needed). If you have RAM to spare and want to prevent pauses caused by an image or movie being loaded, leave this pref on.
FPS - (Desired Frame Rate)
GF will attempt to maintain a frame rate that matches the number in this parameter. For example, if you have a very fast system and want to prevent GF from going mach 3, you'd set FPS to 30 or 40. On the other hand, if you want your system to have more CPU for other tasks, you could set FPS to 10 or 15. Note: if GF stabilizes at a frame rate below what you have set in FPS, GF is doing everything it can to increase frame rate (and still failing). At this point, it'd be up to you to get your OS (or audio player) to provide more CPU to GF. Also note that it takes several seconds for GF to zero-in on the desired frame rate whenever you change something that affects how much G-Force needs the CPU (ex, window size, lots of text). This effect appears as GF running usually slow or fast for several seconds following a window resize.
FPS* - (Background Desired Frame Rate)
This is exactly the same as the FPS parameter except FPS* is the frame rate GF will try to maintain when its not in the foreground. For example, if you run GF regularly in the background while you work in another application, you'd set this to the frame rate you desire. Note that FPS* is currently implemented in the standalone for Windows and MacOS versions and no others because in the others it's not possible for GF to detect if it's in the foreground or not.
CLin - (Console Line Duration)
This is how many seconds a line will remain visible in the text console until it's erased.
TFnt - (Default Text Font)
This is the text font used when drawing track text and particle text. Note that TFnt can be overriden in a text particle by defining a TFnt string in the text particle.
TSze - (Default Text Size)
This is the text size used when drawing track text and particle text. Note that TSze can be overriden in a text particle by defining a TSze value in the text particle.
NoBo - (No Window Border)
If 1, GF will try to make its window borderless. This depends on what audio player and/or OS GF is running on.
KMap - (Key Map)
This is how GF knows what to do when you press a certain key (ie, certain keys are "mapped" to certain actions). The Nth character in the KMap parameter executes the Nth fuction, where all the functions/actions are listed below (ex, if 'Y' is the 4th character in KMap, then pressing 'Y' will trigger the 4th command/action (listed below). If GF sees you press a key that's not in KMap, then it will pass that keystroke to your audio player. For example, suppose '.' did something important in your audio player but was also used in G-Force (by default). You would replace the '.' in KMap with a different character, causing a new keypress to take the place of the '.' key.
Pos Default Description
01 T Track Title
02 L List the names of the currently loaded config(s)
03 R Show frame rate
04 Y Start New Particle
05 ` Fullscreen ON/OFF
06 O Show config names ON/OFF
07 K DeltaField transitions ON/OFF
08 G All slideshows ON
09 F All slideshows OFF
10-12 ASD Prev/Next/StartShow DeltaField
13-15 QWE Prev/Next/StartShow ColorMap
16-18 ,./ Prev/Next/StartShow WaveShape
19-20 [ ] -/+ sample amplitude
21-22 { } -/+ number of sub-samples per sample
23 P Particles ON/OFF
24 H Show Help
25 \ Console text ON/OFF
26 U Uncache/Purge all files, Reload current configs
Flow - (DeltaField Flow Scale)
Firstly, "flow scale" refers to the scaling of each pixel's flow vector in a DeltaField (recall that a DeltaField defines a 2D vector for every pixel in a frame). The 'Flow' pref scales the size of every pixel's flow vector (where Flow=100 means a scale of 1.00). Consider a deltafield that rotates all pixels about the origin: srcR="r",srcT="theta - .06". Flow=50 would make it seem like time is going twice as slow or that the field you're seeing is really srcR="r",srcT="theta - .03". In addition to 'Flow', G-Force applies its own flow scale based on the current/measured frame rate. GF does this to counteract the affects of the current frame rate--for example, deltafields at 50 fps would appear to flow twice as fast as the same deltafields at 25 fps. In other words, the Flow pref scales the flow for all deltafields while GF applies its own flow scale in a way to make flow independent of the current frame rate. Because GF is always adjusting the flow scale to achieve constant flow, you won't normally need to change the Flow parameter. However, it may be useful to change it significantly to help demonstrate the concepts involved (ex, 25 and 400).
T? - (Track Info)
Each frame, GF evaluates what you have expressed in T?: If it's greater than 0 and wasn't greater than 0 the previous frame, GF will look for a config named "Track Info" and run it. In other words, 'T?' acts as a trigger that makes GF run a specific config. As a trigger, 'T?' must "reset" by getting less than or equal to 0 before "Track Info" will be launched again. You could use 'T?' for anything, but it used by default to run a config that displays track info when a new track starts. 'T?' has access to 't' and 'LAST_SONG_START' (both in seconds). Here's some examples:
"1 + LAST_SONG_START - t"  // "Track Info" is run whenever a new song starts
"-1"                       // "Track Info" is never launched
"1 - t % 200"              // Starts "Track Info" every 200 seconds
// Starts "Track Info" when a new song starts and/or starts it every 200 seconds
"sqwv( t - LAST_SONG_START ) + pos( 1 - t % 200 )"
// Starts "Track Info" when a new song starts and every 10 minutes into the song
"sqwv( ( t - LAST_SONG_START ) % 600 )"
WInt - (Waveshape Interval)
Number of seconds GF uses a waveshape before switching to a new waveshape. For example, if you want to see a new waveshape every 15 seconds, set this to 15. In another example, you can force GF to always be morphing between waveshapes by setting this to 0. (ex, "15", "10 + rnd( 10 )", "0")
CInt - (ColorMap Interval)
Number of seconds GF uses a colormap before switching to a new colormap. This pref is similar to WInt and DInt.
DInt - (DeltaField Interval)
Number of seconds GF uses a deltafield before switching to a new deltafield. It takes a significant amount of CPU power to ready a deltafield for use, and GF chips away at this task each frame (this is why you get a spinning cursor when you resize GF's window). If you set DInt too low, GF will be unable to switch deltafields every DInt number of seconds because you're not giving GF enough time. If this happens, GF will simply run normally until it's finished readying in oncoming deltafield.
WMor - (WaveShape Morph Duration)
When GF switches waveshapes, it has to know how long to make the transition from one waveshape to the next waveshape. For example, setting WMor to "5 + rnd(6)" means each transition will be 5 to 11 seconds.
CMor - (ColorMap Morph Duration)
Same as WMor parameter but for ColorMap transitions instead.
DMor - (DeltaField Morph Duration)
Same as WMor parameter but for DeltaField transitions instead. Note that field transitions/morphs have to be enabled (see FldT) before DMor is used.
PPrb - (Particle Probability)
Once per second, GF picks a random number from 0 to 1 and evaluates the PPrb expression. If the random number is less than PPrb, a new particle is spawned/started. The variable NUM_PARTICLES is how many particles are currently running and is usually used in the 'PPrb' function. The PPrb should somehow use NUM_PARTICLES to decrease in value or else GF will just keep spawning new particles indefinitely! (Note how the default expression for PPrb has this property)
PDur - (Particle Duration)
When GF spawns a new particle, it assigns it a lifetime/duration. When that lifetime is up, the particle fades out. GF uses PDur whenever a particle is spawned and uses the value returned as the lifetime (in seconds). A particle is allowed to override PDur by defining its own PDur parameter (and G-Force uses that instead). See "Spinners".
FldT - (Field Transitions On)
If this is 1, GF will transition/morph between each DeltaField when GF is in DeltaField slideshow mode. If it's 0, when GF is in DeltaField slideshow mode, GF will switch to the oncoming field in one frame. Field transitions are a very cool effect, but it's recommended they're turned off your processor below 300-450MHz. See the command list to see what command toggles 'FldT'.
SNum - (Sample Size)
How many sub-samples are in each sample. Terminology: a "sample" is a sequence of sub-samples (ie, integers) that form a short clip of audio. So what is meant by "sample" really doesn't exist--it's just used to describe a sequence of integers that correspond to the current audio that G-Force is given for each frame. So SNum is the resolution or size of each sample, and the number of values in mag(0..1) is SNum. In a config, you can access 'SNum' by using NUM_SAMPLE_BINS. Press the '?' key to see what keys will change SNum in real time (ie, commands 21 and 22).
SScl - (Sample Scale)
Scales the amplitude of the input (ie, every sub-sample is multiplied by this number). If the music you play is soft, try increasing this to 1.5 or higher (1000 means 1.0 and 1500 means 1.5, etc). Press the 'H' key to see what keys will change SScl in real time (ie, commands 19 and 20).
SSmo - (Sample Gauss Smooth Factor)
The higher number this is, the more the a sample will be smoothed out (ie, peaks and valleys will be less jagged). To give you an idea, approximately doubling/halving this number will double/half the amount of smoothing. In other words, SSmo affects the amount of smoothing of mag(0..1).
FNum - (Frequency Sample Size)
How many sub-samples are in each frequency sample and like SNum, FNum is a resolution: there are FNum number of values in fft(0..1). The higher 'FNum' is, the more "bins" the frequency spectrum will be divided up into (note: "bin" is interchangeable with "sub-sample from a frequency sample" and "freq sample" is interchangeable with "freq spectrum"). See the background section for extra info. In a config, you can access 'FNum' by using NUM_FFT_BINS. If you're totally confused at this point, don't get upset--there's a lot to digest here--just see the documentation in the example configs, especially the documentation of the Stps parameter in "Rotating Corridor".
FSmo - (Frequency Sample Smooth Factor)
This is the same as 'SSmo' except that fft(0..1) is what's smoothed.
FRge - (Frequency Range Per Bin)
This is how "wide" of a frequency band a value from fft() is. The larger FRge is, the wider frequency band fft(0..1) will span. For example, if FRge is large then fft(0) may be the magnitude of the frequencies from 100 to 500 Hz, while if FRge is smaller then fft(0) may be the magnitude of the frequencies from 100 to 200 Hz. You may want to read the background section for more information on frequency spectrums.
FSrt - (Frequency Sample Start)
This controls or "anchors" what frequency fft(0) is. 'FSrt' controls the starting frequency of the freq spectrum and is independent of FRge and FNum. The proportionality constant depends only on what build of WhiteCap or G-Force you're using (ex, Standalone, Winamp, SoundJam, etc). In other words, the frequency bin returned by fft(x) is: const * ( FSrt + FRge * FNum * x ) Hz.
FFTT - (Frequency Sample Transform Fcn)
This parameter transforms input or "raw" freq values into the actual values accessed via fft(). For example, to increase the scale of fft(), just put a bigger scaling factor in front of the function (that's why there's no 'FScl' parameter). Each build of WhiteCap/G-Force has a different default FFFT function because each audio player's fft data is massaged differently to make it look nice. The variable W is the frequency, X is the raw fft value for that W, and the whole expression will be the new value of X. As a whole, I've chosen functions that suppress large fft values and amplify medium-level fft values.
SCmd - (Startup Command List)
A list of keystrokes or config names separated by semicolons that's executed when G-Force starts up. For example, if you desire to have G-Force go fullscreen whenever it starts up, insert the corresponding keystroke to SCmd. The format SCmd should take is identical to the format of a command line in any script. For example, also suppose after going fullscreen you wanted to run a script (perhaps containing various sprites/images you wanted displayed). SCmd would read, "`;Andy's Script".