From 20d28e80a5c861a9d5f449ea911ab75b4f37ad0d Mon Sep 17 00:00:00 2001
From: Jef <jef@targetspot.com>
Date: Tue, 24 Sep 2024 14:54:57 +0200
Subject: Initial community commit

---
 Src/Plugins/Visualization/vis_milk2/state.cpp | 1961 +++++++++++++++++++++++++
 1 file changed, 1961 insertions(+)
 create mode 100644 Src/Plugins/Visualization/vis_milk2/state.cpp

(limited to 'Src/Plugins/Visualization/vis_milk2/state.cpp')

diff --git a/Src/Plugins/Visualization/vis_milk2/state.cpp b/Src/Plugins/Visualization/vis_milk2/state.cpp
new file mode 100644
index 00000000..68b060f3
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_milk2/state.cpp
@@ -0,0 +1,1961 @@
+/*
+  LICENSE
+  -------
+Copyright 2005-2013 Nullsoft, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer. 
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution. 
+
+  * Neither the name of Nullsoft nor the names of its contributors may be used to 
+    endorse or promote products derived from this software without specific prior written permission. 
+ 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "api__vis_milk2.h"
+#include "state.h"
+#include "support.h"
+#include "ns-eel2/ns-eel.h"
+#include "plugin.h"
+#include "utility.h"
+#include <windows.h>
+#include <locale.h>
+#include "resource.h"
+#include <vector>
+#include <assert.h>
+
+extern CPlugin g_plugin;		// declared in main.cpp
+
+#define FRAND ((rand() % 7381)/7380.0f)
+
+
+
+// These are intended to replace GetPrivateProfileInt/FloatString, which are very slow
+//  for large files (they always start from the top).  (really slow - some preset loads 
+//  were taking 90 ms because of these!)
+// The trick here is that we assume the file will be ordered correctly.  If not - if 
+//  the next line doesn't have the expected token - we rescan from the top.  If the line
+//  is never found, we use the default value, and leave MyGetPos untouched.
+
+#include "gstring.h"
+
+typedef std::vector<GStringA> VarNameList;
+typedef std::vector<int    > IntList;
+
+
+FILE* fLastFilePtr = NULL;
+void GetFast_CLEAR() { fLastFilePtr = NULL; }
+bool _GetLineByName(FILE* f, const char* szVarName, char* szRet, int nMaxRetChars)
+{
+    // lines in the file look like this:  szVarName=szRet
+    //                               OR:  szVarName szRet
+    // the part of the line after the '=' sign (or space) goes into szRet.  
+    // szVarName can't have any spaces in it.
+
+    static int MyLineNum = 0;
+    static VarNameList line_varName;
+    static IntList     line_value_bytepos;
+
+    if (f != fLastFilePtr) 
+    { 
+        fLastFilePtr = f; 
+        MyLineNum = 0; 
+        line_varName.clear();
+        line_value_bytepos.clear();
+        
+        // start from beginning of file
+        fseek(f, 0, SEEK_SET);
+
+        // scan each line in the file for "szVarName=value" pairs, and store info about them.
+        #define MAX_VARNAME_LEN 128
+        char szThisLineVarName[MAX_VARNAME_LEN];
+        while (1) 
+        {
+            char ch;
+            int pos = 0;
+            do 
+            {
+                ch = fgetc(f);
+                if (pos < MAX_VARNAME_LEN-3)
+                    szThisLineVarName[pos++] = ch;
+            } 
+            while ( ch != '\r' && 
+                    ch != '\n' && 
+                    ch != ' '  && 
+                    ch != '='  && 
+                    ch != EOF );
+            if (ch == EOF)
+                break;
+            
+            if (ch == '=' || ch == ' ') 
+            {
+                szThisLineVarName[pos-1] = 0;  // replace '=' with a null char.
+                int bytepos = ftell(f);
+
+                //add an entry
+                line_varName.push_back(szThisLineVarName);
+                line_value_bytepos.push_back( bytepos );
+
+                // eat chars up to linefeed or EOF
+                /*
+                do 
+                {
+                    ch = fgetc(f);
+                }
+                while (ch != '\r' && ch != '\n' && ch != EOF);
+                */
+                fgets(szRet, nMaxRetChars-3, f);  // reads chars up til the next linefeed.
+            }
+            if (ch == EOF)
+                break;
+                        
+            // eat any extra linefeed chars. 
+            do 
+            {
+                ch = fgetc(f);
+            } 
+            while ((ch == '\r' || ch == '\n') && ch != EOF);
+            if (ch == EOF)
+                break;
+
+            // back up one char
+            fseek(f, -1, SEEK_CUR);
+
+            // on to next line...
+        }
+    }
+
+    // if current line isn't the one, check all the others...
+    if (MyLineNum < 0 || (size_t)MyLineNum >= line_varName.size() || strcmp(line_varName[MyLineNum].c_str(), szVarName) != 0)
+    {
+        int N = line_varName.size();
+		int i = 0;
+		for (i=0; i<N; i++)
+            if (strcmp(line_varName[i].c_str(), szVarName) == 0)
+            {
+                MyLineNum = i;
+                break;
+            }
+        
+        // otherwise, szVarName not found in the file!
+        if (i==N)
+            return false;
+    }
+
+    fseek(f, line_value_bytepos[MyLineNum], SEEK_SET);
+
+    // now we know that we found and ate the '=' sign; return rest of the line.
+    int nChars = 0;
+    int pos = 0;
+    while (pos < nMaxRetChars-3)
+    {
+        char ch = fgetc(f);
+        if (ch == '\r' || ch == '\n' || ch==EOF)
+            break;
+        szRet[pos++] = ch;
+    };
+    szRet[pos] = 0;
+    //fgets(szRet, nMaxRetChars-3, f);  // reads chars up til the next linefeed.  NAH - it also copies in the linefeed char...
+
+    // move to next line
+    MyLineNum++;
+    //fseek(f, line_value_bytepos[MyLineNum], SEEK_SET);
+
+    return true;
+}
+
+int GetFastInt   (const char* szVarName, int   def, FILE* f)
+{
+    char buf[256];
+    if (!_GetLineByName(f, szVarName, buf, 255))
+        return def;
+    int ret;
+    if (sscanf(buf, "%d", &ret)==1)
+        return ret;
+    return def;
+}
+
+float GetFastFloat (const char* szVarName, float def, FILE* f)
+{
+    char buf[256];
+    if (!_GetLineByName(f, szVarName, buf, 255))
+        return def;
+    float ret;
+    if (_sscanf_l(buf, "%f", g_use_C_locale, &ret)==1)
+	{
+        return ret;
+	}
+	return def;
+}
+
+void GetFastString(const char* szVarName, const char* szDef, char* szRetLine, int nMaxChars, FILE* f)
+{
+    if (_GetLineByName(f, szVarName, szRetLine, nMaxChars-1))
+        return;
+    // otherwise, copy the default string, being careful not to overflow dest buf.  
+    // (avoid strncpy because it pads with zeroes all the way out to the max size.)
+    int x = 0;
+    while (szDef[x] && x < nMaxChars)
+    {
+        szRetLine[x] = szDef[x];
+        x++;
+    }
+    szRetLine[x] = 0;
+}
+
+CState::CState()
+{
+	//Default();
+
+	// this is the list of variables that can be used for a PER-FRAME calculation;
+	// it is a SUBSET of the per-vertex calculation variable list.
+	m_pf_codehandle = NULL;
+	m_pp_codehandle = NULL;
+	m_pf_eel = NSEEL_VM_alloc();
+	m_pv_eel = NSEEL_VM_alloc();
+	int i = 0;
+	for (i=0; i<MAX_CUSTOM_WAVES; i++)
+    {
+        m_wave[i].m_pf_codehandle = NULL;
+        m_wave[i].m_pp_codehandle = NULL;
+				m_wave[i].m_pf_eel=NSEEL_VM_alloc();
+				m_wave[i].m_pp_eel=NSEEL_VM_alloc();
+    }
+    for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+    {
+        m_shape[i].m_pf_codehandle = NULL;
+				m_shape[i].m_pf_eel=NSEEL_VM_alloc();
+        //m_shape[i].m_pp_codehandle = NULL;
+    }
+	//RegisterBuiltInVariables();
+}
+
+CState::~CState()
+{
+	FreeVarsAndCode();
+	NSEEL_VM_free(m_pf_eel);
+	NSEEL_VM_free(m_pv_eel);
+	int i = 0;
+	for (i=0; i<MAX_CUSTOM_WAVES; i++)
+	{
+		NSEEL_VM_free(m_wave[i].m_pf_eel);
+		NSEEL_VM_free(m_wave[i].m_pp_eel);
+	}
+	for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+	{
+		NSEEL_VM_free(m_shape[i].m_pf_eel);
+	}
+}
+
+//--------------------------------------------------------------------------------
+
+void CState::RegisterBuiltInVariables(int flags)
+{
+    if (flags & RECOMPILE_PRESET_CODE)
+    {
+	    NSEEL_VM_resetvars(m_pf_eel);
+        var_pf_zoom		= NSEEL_VM_regvar(m_pf_eel, "zoom");		// i/o
+	    var_pf_zoomexp  = NSEEL_VM_regvar(m_pf_eel, "zoomexp");	// i/o
+	    var_pf_rot		= NSEEL_VM_regvar(m_pf_eel, "rot");		// i/o
+	    var_pf_warp		= NSEEL_VM_regvar(m_pf_eel, "warp");		// i/o
+	    var_pf_cx		= NSEEL_VM_regvar(m_pf_eel, "cx");		// i/o
+	    var_pf_cy		= NSEEL_VM_regvar(m_pf_eel, "cy");		// i/o
+	    var_pf_dx		= NSEEL_VM_regvar(m_pf_eel, "dx");		// i/o
+	    var_pf_dy		= NSEEL_VM_regvar(m_pf_eel, "dy");		// i/o
+	    var_pf_sx		= NSEEL_VM_regvar(m_pf_eel, "sx");		// i/o
+	    var_pf_sy		= NSEEL_VM_regvar(m_pf_eel, "sy");		// i/o
+	    var_pf_time		= NSEEL_VM_regvar(m_pf_eel, "time");		// i
+	    var_pf_fps      = NSEEL_VM_regvar(m_pf_eel, "fps");       // i
+	    var_pf_bass		= NSEEL_VM_regvar(m_pf_eel, "bass");		// i
+	    var_pf_mid		= NSEEL_VM_regvar(m_pf_eel, "mid");		// i
+	    var_pf_treb		= NSEEL_VM_regvar(m_pf_eel, "treb");		// i
+	    var_pf_bass_att	= NSEEL_VM_regvar(m_pf_eel, "bass_att");	// i
+	    var_pf_mid_att	= NSEEL_VM_regvar(m_pf_eel, "mid_att");	// i
+	    var_pf_treb_att	= NSEEL_VM_regvar(m_pf_eel, "treb_att");	// i
+	    var_pf_frame    = NSEEL_VM_regvar(m_pf_eel, "frame");
+	    var_pf_decay	= NSEEL_VM_regvar(m_pf_eel, "decay");
+	    var_pf_wave_a	= NSEEL_VM_regvar(m_pf_eel, "wave_a");
+	    var_pf_wave_r	= NSEEL_VM_regvar(m_pf_eel, "wave_r");
+	    var_pf_wave_g	= NSEEL_VM_regvar(m_pf_eel, "wave_g");
+	    var_pf_wave_b	= NSEEL_VM_regvar(m_pf_eel, "wave_b");
+	    var_pf_wave_x	= NSEEL_VM_regvar(m_pf_eel, "wave_x");
+	    var_pf_wave_y	= NSEEL_VM_regvar(m_pf_eel, "wave_y");
+	    var_pf_wave_mystery = NSEEL_VM_regvar(m_pf_eel, "wave_mystery");
+	    var_pf_wave_mode = NSEEL_VM_regvar(m_pf_eel, "wave_mode");
+		int vi = 0;
+		for (vi=0; vi<NUM_Q_VAR; vi++)
+        {
+            char buf[16];
+            sprintf(buf, "q%d", vi+1);
+            var_pf_q[vi] = NSEEL_VM_regvar(m_pf_eel, buf);
+        }
+	    var_pf_progress = NSEEL_VM_regvar(m_pf_eel, "progress");
+	    var_pf_ob_size	= NSEEL_VM_regvar(m_pf_eel, "ob_size");
+	    var_pf_ob_r		= NSEEL_VM_regvar(m_pf_eel, "ob_r");
+	    var_pf_ob_g		= NSEEL_VM_regvar(m_pf_eel, "ob_g");
+	    var_pf_ob_b		= NSEEL_VM_regvar(m_pf_eel, "ob_b");
+	    var_pf_ob_a		= NSEEL_VM_regvar(m_pf_eel, "ob_a");
+	    var_pf_ib_size	= NSEEL_VM_regvar(m_pf_eel, "ib_size");
+	    var_pf_ib_r		= NSEEL_VM_regvar(m_pf_eel, "ib_r");
+	    var_pf_ib_g		= NSEEL_VM_regvar(m_pf_eel, "ib_g");
+	    var_pf_ib_b		= NSEEL_VM_regvar(m_pf_eel, "ib_b");
+	    var_pf_ib_a		= NSEEL_VM_regvar(m_pf_eel, "ib_a");
+	    var_pf_mv_x		= NSEEL_VM_regvar(m_pf_eel, "mv_x");
+	    var_pf_mv_y		= NSEEL_VM_regvar(m_pf_eel, "mv_y");
+	    var_pf_mv_dx	= NSEEL_VM_regvar(m_pf_eel, "mv_dx");
+	    var_pf_mv_dy	= NSEEL_VM_regvar(m_pf_eel, "mv_dy");
+	    var_pf_mv_l		= NSEEL_VM_regvar(m_pf_eel, "mv_l");
+	    var_pf_mv_r		= NSEEL_VM_regvar(m_pf_eel, "mv_r");
+	    var_pf_mv_g		= NSEEL_VM_regvar(m_pf_eel, "mv_g");
+	    var_pf_mv_b		= NSEEL_VM_regvar(m_pf_eel, "mv_b");
+	    var_pf_mv_a		= NSEEL_VM_regvar(m_pf_eel, "mv_a");
+	    var_pf_monitor  = NSEEL_VM_regvar(m_pf_eel, "monitor");
+	    var_pf_echo_zoom   = NSEEL_VM_regvar(m_pf_eel, "echo_zoom");
+	    var_pf_echo_alpha  = NSEEL_VM_regvar(m_pf_eel, "echo_alpha");
+	    var_pf_echo_orient = NSEEL_VM_regvar(m_pf_eel, "echo_orient");
+        var_pf_wave_usedots  = NSEEL_VM_regvar(m_pf_eel, "wave_usedots");
+        var_pf_wave_thick    = NSEEL_VM_regvar(m_pf_eel, "wave_thick");
+        var_pf_wave_additive = NSEEL_VM_regvar(m_pf_eel, "wave_additive");
+        var_pf_wave_brighten = NSEEL_VM_regvar(m_pf_eel, "wave_brighten");
+        var_pf_darken_center = NSEEL_VM_regvar(m_pf_eel, "darken_center");
+        var_pf_gamma         = NSEEL_VM_regvar(m_pf_eel, "gamma");
+        var_pf_wrap          = NSEEL_VM_regvar(m_pf_eel, "wrap");
+        var_pf_invert        = NSEEL_VM_regvar(m_pf_eel, "invert");
+        var_pf_brighten      = NSEEL_VM_regvar(m_pf_eel, "brighten");
+        var_pf_darken        = NSEEL_VM_regvar(m_pf_eel, "darken");
+        var_pf_solarize      = NSEEL_VM_regvar(m_pf_eel, "solarize");
+        var_pf_meshx         = NSEEL_VM_regvar(m_pf_eel, "meshx");
+        var_pf_meshy         = NSEEL_VM_regvar(m_pf_eel, "meshy");
+        var_pf_pixelsx       = NSEEL_VM_regvar(m_pf_eel, "pixelsx");
+        var_pf_pixelsy       = NSEEL_VM_regvar(m_pf_eel, "pixelsy");
+        var_pf_aspectx       = NSEEL_VM_regvar(m_pf_eel, "aspectx");
+        var_pf_aspecty       = NSEEL_VM_regvar(m_pf_eel, "aspecty");
+        var_pf_blur1min      = NSEEL_VM_regvar(m_pf_eel, "blur1_min");
+        var_pf_blur2min      = NSEEL_VM_regvar(m_pf_eel, "blur2_min");
+        var_pf_blur3min      = NSEEL_VM_regvar(m_pf_eel, "blur3_min");
+        var_pf_blur1max      = NSEEL_VM_regvar(m_pf_eel, "blur1_max");
+        var_pf_blur2max      = NSEEL_VM_regvar(m_pf_eel, "blur2_max");
+        var_pf_blur3max      = NSEEL_VM_regvar(m_pf_eel, "blur3_max");
+        var_pf_blur1_edge_darken = NSEEL_VM_regvar(m_pf_eel, "blur1_edge_darken");
+
+	    // this is the list of variables that can be used for a PER-VERTEX calculation:
+	    // ('vertex' meaning a vertex on the mesh) (as opposed to a once-per-frame calculation)
+
+        NSEEL_VM_resetvars(m_pv_eel);
+
+        var_pv_zoom		= NSEEL_VM_regvar(m_pv_eel, "zoom");		// i/o
+	    var_pv_zoomexp  = NSEEL_VM_regvar(m_pv_eel, "zoomexp");	// i/o
+	    var_pv_rot		= NSEEL_VM_regvar(m_pv_eel, "rot");		// i/o
+	    var_pv_warp		= NSEEL_VM_regvar(m_pv_eel, "warp");		// i/o
+	    var_pv_cx		= NSEEL_VM_regvar(m_pv_eel, "cx");		// i/o
+	    var_pv_cy		= NSEEL_VM_regvar(m_pv_eel, "cy");		// i/o
+	    var_pv_dx		= NSEEL_VM_regvar(m_pv_eel, "dx");		// i/o
+	    var_pv_dy		= NSEEL_VM_regvar(m_pv_eel, "dy");		// i/o
+	    var_pv_sx		= NSEEL_VM_regvar(m_pv_eel, "sx");		// i/o
+	    var_pv_sy		= NSEEL_VM_regvar(m_pv_eel, "sy");		// i/o
+	    var_pv_time		= NSEEL_VM_regvar(m_pv_eel, "time");		// i
+	    var_pv_fps 		= NSEEL_VM_regvar(m_pv_eel, "fps");		// i
+	    var_pv_bass		= NSEEL_VM_regvar(m_pv_eel, "bass");		// i
+	    var_pv_mid		= NSEEL_VM_regvar(m_pv_eel, "mid");		// i
+	    var_pv_treb		= NSEEL_VM_regvar(m_pv_eel, "treb");		// i
+	    var_pv_bass_att	= NSEEL_VM_regvar(m_pv_eel, "bass_att");	// i
+	    var_pv_mid_att	= NSEEL_VM_regvar(m_pv_eel, "mid_att");	// i
+	    var_pv_treb_att	= NSEEL_VM_regvar(m_pv_eel, "treb_att");	// i
+	    var_pv_frame    = NSEEL_VM_regvar(m_pv_eel, "frame");
+	    var_pv_x		= NSEEL_VM_regvar(m_pv_eel, "x");			// i
+	    var_pv_y		= NSEEL_VM_regvar(m_pv_eel, "y");			// i
+	    var_pv_rad		= NSEEL_VM_regvar(m_pv_eel, "rad");		// i
+	    var_pv_ang		= NSEEL_VM_regvar(m_pv_eel, "ang");		// i
+        for (vi=0; vi<NUM_Q_VAR; vi++)
+        {
+            char buf[16];
+            sprintf(buf, "q%d", vi+1);
+            var_pv_q[vi] = NSEEL_VM_regvar(m_pv_eel, buf);
+        }
+	    var_pv_progress = NSEEL_VM_regvar(m_pv_eel, "progress");
+        var_pv_meshx    = NSEEL_VM_regvar(m_pv_eel, "meshx");
+        var_pv_meshy    = NSEEL_VM_regvar(m_pv_eel, "meshy");
+        var_pv_pixelsx  = NSEEL_VM_regvar(m_pv_eel, "pixelsx");
+        var_pv_pixelsy  = NSEEL_VM_regvar(m_pv_eel, "pixelsy");
+        var_pv_aspectx  = NSEEL_VM_regvar(m_pv_eel, "aspectx");
+        var_pv_aspecty  = NSEEL_VM_regvar(m_pv_eel, "aspecty");
+    }
+
+    if (flags & RECOMPILE_WAVE_CODE)
+    {
+        for (int i=0; i<MAX_CUSTOM_WAVES; i++)
+        {
+	        NSEEL_VM_resetvars(m_wave[i].m_pf_eel);
+	        m_wave[i].var_pf_time		= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "time");		// i
+	        m_wave[i].var_pf_fps 		= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "fps");		// i
+	        m_wave[i].var_pf_frame      = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "frame");     // i
+	        m_wave[i].var_pf_progress   = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "progress");  // i
+			int vi = 0;
+			for (vi=0; vi<NUM_Q_VAR; vi++)
+            {
+                char buf[16];
+                sprintf(buf, "q%d", vi+1);
+                m_wave[i].var_pf_q[vi] = NSEEL_VM_regvar(m_wave[i].m_pf_eel, buf);
+            }
+            for (vi=0; vi<NUM_T_VAR; vi++)
+            {
+                char buf[16];
+                sprintf(buf, "t%d", vi+1);
+                m_wave[i].var_pf_t[vi] = NSEEL_VM_regvar(m_wave[i].m_pf_eel, buf);
+            }
+	        m_wave[i].var_pf_bass		= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "bass");		// i
+	        m_wave[i].var_pf_mid		= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "mid");		// i
+	        m_wave[i].var_pf_treb		= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "treb");		// i
+	        m_wave[i].var_pf_bass_att	= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "bass_att");	// i
+	        m_wave[i].var_pf_mid_att	= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "mid_att");	// i
+	        m_wave[i].var_pf_treb_att	= NSEEL_VM_regvar(m_wave[i].m_pf_eel, "treb_att");	// i
+	        m_wave[i].var_pf_r          = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "r");         // i/o
+	        m_wave[i].var_pf_g          = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "g");         // i/o
+	        m_wave[i].var_pf_b          = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "b");         // i/o
+	        m_wave[i].var_pf_a          = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "a");         // i/o
+            m_wave[i].var_pf_samples    = NSEEL_VM_regvar(m_wave[i].m_pf_eel, "samples");   // i/o
+
+	        NSEEL_VM_resetvars(m_wave[i].m_pp_eel);
+	        m_wave[i].var_pp_time		= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "time");		// i
+	        m_wave[i].var_pp_fps 		= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "fps");		// i
+	        m_wave[i].var_pp_frame      = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "frame");     // i
+	        m_wave[i].var_pp_progress   = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "progress");  // i
+            for (vi=0; vi<NUM_Q_VAR; vi++)
+            {
+                char buf[16];
+                sprintf(buf, "q%d", vi+1);
+                m_wave[i].var_pp_q[vi] = NSEEL_VM_regvar(m_wave[i].m_pp_eel, buf);
+            }
+            for (vi=0; vi<NUM_T_VAR; vi++)
+            {
+                char buf[16];
+                sprintf(buf, "t%d", vi+1);
+                m_wave[i].var_pp_t[vi] = NSEEL_VM_regvar(m_wave[i].m_pp_eel, buf);
+            }
+	        m_wave[i].var_pp_bass		= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "bass");		// i
+	        m_wave[i].var_pp_mid		= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "mid");		// i
+	        m_wave[i].var_pp_treb		= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "treb");		// i
+	        m_wave[i].var_pp_bass_att	= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "bass_att");	// i
+	        m_wave[i].var_pp_mid_att	= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "mid_att");	// i
+	        m_wave[i].var_pp_treb_att	= NSEEL_VM_regvar(m_wave[i].m_pp_eel, "treb_att");	// i
+            m_wave[i].var_pp_sample     = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "sample");    // i
+            m_wave[i].var_pp_value1     = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "value1");    // i
+            m_wave[i].var_pp_value2     = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "value2");    // i
+	        m_wave[i].var_pp_x          = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "x");         // i/o
+	        m_wave[i].var_pp_y          = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "y");         // i/o
+	        m_wave[i].var_pp_r          = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "r");         // i/o
+	        m_wave[i].var_pp_g          = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "g");         // i/o
+	        m_wave[i].var_pp_b          = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "b");         // i/o
+	        m_wave[i].var_pp_a          = NSEEL_VM_regvar(m_wave[i].m_pp_eel, "a");         // i/o
+        }
+    }
+
+    if (flags & RECOMPILE_SHAPE_CODE)
+    {
+        for (int i=0; i<MAX_CUSTOM_SHAPES; i++)
+        {
+	        NSEEL_VM_resetvars(m_shape[i].m_pf_eel);
+	        m_shape[i].var_pf_time		= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "time");		// i
+	        m_shape[i].var_pf_fps 		= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "fps");		// i
+	        m_shape[i].var_pf_frame      = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "frame");     // i
+	        m_shape[i].var_pf_progress   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "progress");  // i
+			int vi = 0;
+			for (vi=0; vi<NUM_Q_VAR; vi++)
+            {
+                char buf[16];
+                sprintf(buf, "q%d", vi+1);
+                m_shape[i].var_pf_q[vi] = NSEEL_VM_regvar(m_shape[i].m_pf_eel, buf);
+            }
+            for (vi=0; vi<NUM_T_VAR; vi++)
+            {
+                char buf[16];
+                sprintf(buf, "t%d", vi+1);
+                m_shape[i].var_pf_t[vi] = NSEEL_VM_regvar(m_shape[i].m_pf_eel, buf);
+            }
+	        m_shape[i].var_pf_bass		= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "bass");		// i
+	        m_shape[i].var_pf_mid		= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "mid");		// i
+	        m_shape[i].var_pf_treb		= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "treb");		// i
+	        m_shape[i].var_pf_bass_att	= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "bass_att");	// i
+	        m_shape[i].var_pf_mid_att	= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "mid_att");	// i
+	        m_shape[i].var_pf_treb_att	= NSEEL_VM_regvar(m_shape[i].m_pf_eel, "treb_att");	// i
+	        m_shape[i].var_pf_x          = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "x");         // i/o
+	        m_shape[i].var_pf_y          = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "y");         // i/o
+	        m_shape[i].var_pf_rad        = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "rad");         // i/o
+	        m_shape[i].var_pf_ang        = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "ang");         // i/o
+	        m_shape[i].var_pf_tex_ang    = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "tex_ang");         // i/o
+	        m_shape[i].var_pf_tex_zoom   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "tex_zoom");         // i/o
+	        m_shape[i].var_pf_sides      = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "sides");         // i/o
+	        m_shape[i].var_pf_textured   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "textured");         // i/o
+	        m_shape[i].var_pf_instance   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "instance");         // i/o
+	        m_shape[i].var_pf_instances  = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "num_inst");         // i/o
+	        m_shape[i].var_pf_additive   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "additive");         // i/o
+	        m_shape[i].var_pf_thick      = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "thick");         // i/o
+	        m_shape[i].var_pf_r          = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "r");         // i/o
+	        m_shape[i].var_pf_g          = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "g");         // i/o
+	        m_shape[i].var_pf_b          = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "b");         // i/o
+	        m_shape[i].var_pf_a          = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "a");         // i/o
+	        m_shape[i].var_pf_r2         = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "r2");         // i/o
+	        m_shape[i].var_pf_g2         = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "g2");         // i/o
+	        m_shape[i].var_pf_b2         = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "b2");         // i/o
+	        m_shape[i].var_pf_a2         = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "a2");         // i/o
+	        m_shape[i].var_pf_border_r   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "border_r");         // i/o
+	        m_shape[i].var_pf_border_g   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "border_g");         // i/o
+	        m_shape[i].var_pf_border_b   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "border_b");         // i/o
+	        m_shape[i].var_pf_border_a   = NSEEL_VM_regvar(m_shape[i].m_pf_eel, "border_a");         // i/o
+        }
+    }
+}
+void CState::Default(DWORD ApplyFlags)
+{
+	// DON'T FORGET TO ADD NEW VARIABLES TO BLEND FUNCTION, IMPORT, and EXPORT AS WELL!!!!!!!!
+
+    if ( (ApplyFlags & STATE_GENERAL) &&    // check for these 3 @ same time,
+         (ApplyFlags & STATE_MOTION) &&     // so a preset switch w/ warp/comp lock
+         (ApplyFlags & STATE_WAVE)        // updates the name, but mash-ups don't.
+        )
+    {
+        lstrcpyW(m_szDesc, INVALID_PRESET_DESC);
+	    //lstrcpy(m_szSection, "n/a");
+
+        m_fPresetStartTime = -1;
+    }
+
+    m_nMinPSVersion   = 0;     
+    m_nMaxPSVersion   = 0;     
+
+    m_bBlending				= false;
+
+    // general:
+    if (ApplyFlags & STATE_GENERAL)
+    {
+        m_fRating				= 3.0f;
+	    m_fDecay				= 0.98f;	// 1.0 = none, 0.95 = heavy decay
+	    m_fGammaAdj				= 2.0f;		// 1.0 = reg; +2.0 = double, +3.0 = triple...
+	    m_fVideoEchoZoom		= 2.0f;
+	    m_fVideoEchoAlpha		= 0.0f;
+	    m_nVideoEchoOrientation	= 0;		// 0-3
+	    m_bRedBlueStereo		= false;
+	    m_bBrighten				= false;
+	    m_bDarken				= false;
+	    m_bTexWrap				= true;
+	    m_bDarkenCenter			= false;
+	    m_bSolarize				= false;
+	    m_bInvert				= false;
+	    m_fShader				= 0.0f;
+	    m_fBlur1Min             = 0.0f;
+	    m_fBlur2Min             = 0.0f;
+	    m_fBlur3Min             = 0.0f;
+	    m_fBlur1Max             = 1.0f;
+	    m_fBlur2Max             = 1.0f;
+	    m_fBlur3Max             = 1.0f;
+	    m_fBlur1EdgeDarken      = 0.25f;
+    }
+
+ 
+    // wave:
+    if (ApplyFlags & STATE_WAVE)
+    {
+	    m_nWaveMode				= 0;
+	     m_nOldWaveMode			= -1;
+	    m_bAdditiveWaves		= false;
+	    m_bWaveDots				= false;
+	    m_bWaveThick            = false;
+        m_fWaveAlpha			= 0.8f;
+	    m_fWaveScale			= 1.0f;
+	    m_fWaveSmoothing		= 0.75f;	// 0 = no smoothing, 0.9 = HEAVY smoothing
+	    m_fWaveParam			= 0.0f;
+	    m_bModWaveAlphaByVolume = false;
+	    m_fModWaveAlphaStart	= 0.75f;		// when relative volume hits this level, alpha -> 0
+	    m_fModWaveAlphaEnd		= 0.95f;		// when relative volume hits this level, alpha -> 1
+	    m_fWaveR		= 1.0f;
+	    m_fWaveG		= 1.0f;
+	    m_fWaveB		= 1.0f;
+	    m_fWaveX		= 0.5f;
+	    m_fWaveY		= 0.5f;
+	    m_bMaximizeWaveColor	= true;
+	    m_fMvX				  	= 12.0f;
+	    m_fMvY					= 9.0f;
+	    m_fMvDX                 = 0.0f;
+	    m_fMvDY                 = 0.0f;
+	    m_fMvL				  	= 0.9f;
+	    m_fMvR                  = 1.0f;
+	    m_fMvG                  = 1.0f;
+	    m_fMvB                  = 1.0f;
+	    m_fMvA                  = 1.0f;
+
+		int i = 0;
+        for (i=0; i<MAX_CUSTOM_WAVES; i++)
+        {
+            m_wave[i].enabled = 0;
+            m_wave[i].samples = 512;
+            m_wave[i].sep = 0;
+            m_wave[i].scaling = 1.0f;
+            m_wave[i].smoothing = 0.5f;
+            m_wave[i].r = 1.0f;
+            m_wave[i].g = 1.0f;
+            m_wave[i].b = 1.0f;
+            m_wave[i].a = 1.0f;
+            m_wave[i].bSpectrum = 0;
+            m_wave[i].bUseDots = 0;
+            m_wave[i].bDrawThick = 0;
+            m_wave[i].bAdditive = 0;
+        }
+        for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+        {
+            m_shape[i].enabled = 0;
+            m_shape[i].sides   = 4;
+            m_shape[i].additive = 0;
+            m_shape[i].thickOutline = 0;
+            m_shape[i].textured = 0;
+            m_shape[i].instances = 1;
+            m_shape[i].tex_zoom = 1.0f;
+            m_shape[i].tex_ang  = 0.0f;
+            m_shape[i].x = 0.5f;
+            m_shape[i].y = 0.5f;
+            m_shape[i].rad = 0.1f;
+            m_shape[i].ang = 0.0f;
+            m_shape[i].r = 1.0f;
+            m_shape[i].g = 0.0f;
+            m_shape[i].b = 0.0f;
+            m_shape[i].a = 1.0f;
+            m_shape[i].r2 = 0.0f;
+            m_shape[i].g2 = 1.0f;
+            m_shape[i].b2 = 0.0f;
+            m_shape[i].a2 = 0.0f;
+            m_shape[i].border_r = 1.0f;
+            m_shape[i].border_g = 1.0f;
+            m_shape[i].border_b = 1.0f;
+            m_shape[i].border_a = 0.1f;
+        }
+        for (i=0; i<MAX_CUSTOM_WAVES; i++)
+        {
+            m_wave[i].m_szInit[0] = 0;
+            m_wave[i].m_szPerFrame[0] = 0;
+            m_wave[i].m_szPerPoint[0] = 0;
+        }
+        for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+        {
+            m_shape[i].m_szInit[0] = 0;
+            m_shape[i].m_szPerFrame[0] = 0;
+            //m_shape[i].m_szPerPoint[0] = 0;
+        }
+    }
+
+    // motion:
+    if (ApplyFlags & STATE_MOTION)
+    {
+        m_fWarpAnimSpeed		= 1.0f;		// additional timescaling for warp animation
+	    m_fWarpScale			= 1.0f;
+	    m_fZoomExponent			= 1.0f;
+	    m_fZoom			= 1.0f;
+	    m_fRot 			= 0.0f;
+	    m_fRotCX		= 0.5f;
+	    m_fRotCY		= 0.5f;
+	    m_fXPush		= 0.0f;
+	    m_fYPush		= 0.0f;
+	    m_fWarpAmount	= 1.0f;
+	    m_fStretchX     = 1.0f;
+	    m_fStretchY     = 1.0f;
+	    m_fOuterBorderSize = 0.01f;
+	    m_fOuterBorderR	= 0.0f;
+	    m_fOuterBorderG	= 0.0f;
+	    m_fOuterBorderB	= 0.0f;
+	    m_fOuterBorderA	= 0.0f;
+	    m_fInnerBorderSize = 0.01f;
+	    m_fInnerBorderR	= 0.25f;
+	    m_fInnerBorderG	= 0.25f;
+	    m_fInnerBorderB	= 0.25f;
+	    m_fInnerBorderA	= 0.0f;
+
+        // clear all code strings:
+        m_szPerFrameInit[0] = 0;
+        m_szPerFrameExpr[0] = 0;
+        m_szPerPixelExpr[0] = 0;
+    }
+
+	// DON'T FORGET TO ADD NEW VARIABLES TO BLEND FUNCTION, IMPORT, and EXPORT AS WELL!!!!!!!!
+	// ALSO BE SURE TO REGISTER THEM ON THE MAIN MENU (SEE MILKDROP.CPP)
+
+    // warp shader
+    if (ApplyFlags & STATE_WARP)
+    {
+        m_szWarpShadersText[0] = 0;
+        m_nWarpPSVersion   = 0;     
+    }
+    
+    // comp shader
+    if (ApplyFlags & STATE_COMP)
+    {
+        m_szCompShadersText[0] = 0;
+        m_nCompPSVersion   = 0;     
+    }
+
+    RandomizePresetVars();
+
+	FreeVarsAndCode();
+}
+
+void CState::StartBlendFrom(CState *s_from, float fAnimTime, float fTimespan)
+{
+	CState *s_to = this;
+
+	// bools, ints, and strings instantly change
+
+	s_to->m_fVideoEchoAlphaOld		 = s_from->m_fVideoEchoAlpha.eval(-1);
+	s_to->m_nVideoEchoOrientationOld = s_from->m_nVideoEchoOrientation;
+	s_to->m_nOldWaveMode			 = s_from->m_nWaveMode;
+
+	/*
+	s_to->m_fVideoEchoAlphaOld		 = s_from->m_fVideoEchoAlpha.eval(-1);
+	s_to->m_nVideoEchoOrientationOld = s_from->m_nVideoEchoOrientation;
+
+	s_to->m_nOldWaveMode			= s_from->m_nWaveMode;
+	s_to->m_nWaveMode				= s_from->m_nWaveMode;
+	s_to->m_bAdditiveWaves			= s_from->m_bAdditiveWaves;
+	s_to->m_nVideoEchoOrientation	= s_from->m_nVideoEchoOrientation;
+	s_to->m_fWarpAnimSpeed			= s_from->m_fWarpAnimSpeed;	// would req. 10 phase-matches to blend this one!!!
+	s_to->m_bWaveDots				= s_from->m_bWaveDots;
+	s_to->m_bWaveThick				= s_from->m_bWaveThick;
+	s_to->m_bModWaveAlphaByVolume	= s_from->m_bModWaveAlphaByVolume;
+	s_to->m_bMaximizeWaveColor		= s_from->m_bMaximizeWaveColor;
+	s_to->m_bTexWrap				= s_from->m_bTexWrap;			
+	s_to->m_bDarkenCenter			= s_from->m_bDarkenCenter;
+	s_to->m_bRedBlueStereo			= s_from->m_bRedBlueStereo;
+	s_to->m_bBrighten				= s_from->m_bBrighten;
+	s_to->m_bDarken					= s_from->m_bDarken;
+	s_to->m_bSolarize				= s_from->m_bSolarize;
+	s_to->m_bInvert					= s_from->m_bInvert;
+	s_to->m_fRating					= s_from->m_fRating;
+	*/
+
+	// expr. eval. also copies over immediately (replaces prev.)
+	m_bBlending = true;
+	m_fBlendStartTime = fAnimTime;
+	m_fBlendDuration = fTimespan;
+	
+	/*
+	//for (int e=0; e<MAX_EVALS; e++)
+	{
+		char szTemp[MAX_BIGSTRING_LEN];
+
+		lstrcpy(szTemp, m_szPerFrameExpr);
+		lstrcpy(m_szPerFrameExpr, s_to->m_szPerFrameExpr);
+		lstrcpy(s_to->m_szPerFrameExpr, szTemp);
+
+		lstrcpy(szTemp, m_szPerPixelExpr);
+		lstrcpy(m_szPerPixelExpr, s_to->m_szPerPixelExpr);
+		lstrcpy(s_to->m_szPerPixelExpr, szTemp);
+
+		lstrcpy(szTemp, m_szPerFrameInit);
+		lstrcpy(m_szPerFrameInit, s_to->m_szPerFrameInit);
+		lstrcpy(s_to->m_szPerFrameInit, szTemp);
+	}
+	RecompileExpressions();
+	s_to->RecompileExpressions();
+
+	lstrcpy(m_szDesc,    s_to->m_szDesc);
+	//lstrcpy(m_szSection, s_to->m_szSection);
+	*/
+	
+	// CBlendableFloats & SuperValues blend over time 
+	m_fGammaAdj      .StartBlendFrom(&s_from->m_fGammaAdj      , fAnimTime, fTimespan);
+	m_fVideoEchoZoom .StartBlendFrom(&s_from->m_fVideoEchoZoom , fAnimTime, fTimespan);
+	m_fVideoEchoAlpha.StartBlendFrom(&s_from->m_fVideoEchoAlpha, fAnimTime, fTimespan);
+	m_fDecay         .StartBlendFrom(&s_from->m_fDecay         , fAnimTime, fTimespan);
+	m_fWaveAlpha     .StartBlendFrom(&s_from->m_fWaveAlpha     , fAnimTime, fTimespan);
+	m_fWaveScale     .StartBlendFrom(&s_from->m_fWaveScale     , fAnimTime, fTimespan);
+	m_fWaveSmoothing .StartBlendFrom(&s_from->m_fWaveSmoothing , fAnimTime, fTimespan);
+	m_fWaveParam     .StartBlendFrom(&s_from->m_fWaveParam     , fAnimTime, fTimespan);
+	m_fWarpScale     .StartBlendFrom(&s_from->m_fWarpScale     , fAnimTime, fTimespan);
+	m_fZoomExponent  .StartBlendFrom(&s_from->m_fZoomExponent  , fAnimTime, fTimespan);
+	m_fShader        .StartBlendFrom(&s_from->m_fShader        , fAnimTime, fTimespan);
+	m_fModWaveAlphaStart.StartBlendFrom(&s_from->m_fModWaveAlphaStart, fAnimTime, fTimespan);
+	m_fModWaveAlphaEnd  .StartBlendFrom(&s_from->m_fModWaveAlphaEnd, fAnimTime, fTimespan);
+
+	m_fZoom		.StartBlendFrom(&s_from->m_fZoom		, fAnimTime, fTimespan);
+	m_fRot 		.StartBlendFrom(&s_from->m_fRot 		, fAnimTime, fTimespan);
+	m_fRotCX	.StartBlendFrom(&s_from->m_fRotCX		, fAnimTime, fTimespan);
+	m_fRotCY	.StartBlendFrom(&s_from->m_fRotCY		, fAnimTime, fTimespan);
+	m_fXPush	.StartBlendFrom(&s_from->m_fXPush		, fAnimTime, fTimespan);
+	m_fYPush	.StartBlendFrom(&s_from->m_fYPush		, fAnimTime, fTimespan);
+	m_fWarpAmount.StartBlendFrom(&s_from->m_fWarpAmount,fAnimTime, fTimespan);
+	m_fStretchX .StartBlendFrom(&s_from->m_fStretchX	, fAnimTime, fTimespan);
+	m_fStretchY .StartBlendFrom(&s_from->m_fStretchY	, fAnimTime, fTimespan);
+	m_fWaveR	.StartBlendFrom(&s_from->m_fWaveR		, fAnimTime, fTimespan);
+	m_fWaveG	.StartBlendFrom(&s_from->m_fWaveG		, fAnimTime, fTimespan);
+	m_fWaveB	.StartBlendFrom(&s_from->m_fWaveB		, fAnimTime, fTimespan);
+	m_fWaveX	.StartBlendFrom(&s_from->m_fWaveX		, fAnimTime, fTimespan);
+	m_fWaveY	.StartBlendFrom(&s_from->m_fWaveY		, fAnimTime, fTimespan);
+	m_fOuterBorderSize	.StartBlendFrom(&s_from->m_fOuterBorderSize	, fAnimTime, fTimespan);
+	m_fOuterBorderR		.StartBlendFrom(&s_from->m_fOuterBorderR	, fAnimTime, fTimespan);
+	m_fOuterBorderG		.StartBlendFrom(&s_from->m_fOuterBorderG	, fAnimTime, fTimespan);
+	m_fOuterBorderB		.StartBlendFrom(&s_from->m_fOuterBorderB	, fAnimTime, fTimespan);
+	m_fOuterBorderA		.StartBlendFrom(&s_from->m_fOuterBorderA	, fAnimTime, fTimespan);
+	m_fInnerBorderSize	.StartBlendFrom(&s_from->m_fInnerBorderSize	, fAnimTime, fTimespan);
+	m_fInnerBorderR		.StartBlendFrom(&s_from->m_fInnerBorderR	, fAnimTime, fTimespan);
+	m_fInnerBorderG		.StartBlendFrom(&s_from->m_fInnerBorderG	, fAnimTime, fTimespan);
+	m_fInnerBorderB		.StartBlendFrom(&s_from->m_fInnerBorderB	, fAnimTime, fTimespan);
+	m_fInnerBorderA		.StartBlendFrom(&s_from->m_fInnerBorderA	, fAnimTime, fTimespan);
+	m_fMvX				.StartBlendFrom(&s_from->m_fMvX				, fAnimTime, fTimespan);
+	m_fMvY				.StartBlendFrom(&s_from->m_fMvY				, fAnimTime, fTimespan);
+	m_fMvDX				.StartBlendFrom(&s_from->m_fMvDX			, fAnimTime, fTimespan);
+	m_fMvDY				.StartBlendFrom(&s_from->m_fMvDY			, fAnimTime, fTimespan);
+	m_fMvL				.StartBlendFrom(&s_from->m_fMvL				, fAnimTime, fTimespan);
+	m_fMvR				.StartBlendFrom(&s_from->m_fMvR				, fAnimTime, fTimespan);
+	m_fMvG				.StartBlendFrom(&s_from->m_fMvG				, fAnimTime, fTimespan);
+	m_fMvB				.StartBlendFrom(&s_from->m_fMvB				, fAnimTime, fTimespan);
+	m_fMvA				.StartBlendFrom(&s_from->m_fMvA				, fAnimTime, fTimespan);
+    m_fBlur1Min         .StartBlendFrom(&s_from->m_fBlur1Min        , fAnimTime, fTimespan);
+    m_fBlur2Min         .StartBlendFrom(&s_from->m_fBlur2Min        , fAnimTime, fTimespan);
+    m_fBlur3Min         .StartBlendFrom(&s_from->m_fBlur3Min        , fAnimTime, fTimespan);
+    m_fBlur1Max         .StartBlendFrom(&s_from->m_fBlur1Max        , fAnimTime, fTimespan);
+    m_fBlur2Max         .StartBlendFrom(&s_from->m_fBlur2Max        , fAnimTime, fTimespan);
+    m_fBlur3Max         .StartBlendFrom(&s_from->m_fBlur3Max        , fAnimTime, fTimespan);
+    m_fBlur1EdgeDarken  .StartBlendFrom(&s_from->m_fBlur1EdgeDarken , fAnimTime, fTimespan);
+
+	// if motion vectors were transparent before, don't morph the # in X and Y - just
+	// start in the right place, and fade them in.
+	bool bOldStateTransparent = (s_from->m_fMvA.eval(-1) < 0.001f);
+	bool bNewStateTransparent = (s_to->m_fMvA.eval(-1) < 0.001f);
+	if (!bOldStateTransparent && bNewStateTransparent)
+	{
+		s_from->m_fMvX = s_to->m_fMvX.eval(fAnimTime);
+		s_from->m_fMvY = s_to->m_fMvY.eval(fAnimTime);
+		s_from->m_fMvDX = s_to->m_fMvDX.eval(fAnimTime);
+		s_from->m_fMvDY = s_to->m_fMvDY.eval(fAnimTime);
+		s_from->m_fMvL = s_to->m_fMvL.eval(fAnimTime);
+		s_from->m_fMvR = s_to->m_fMvR.eval(fAnimTime);
+		s_from->m_fMvG = s_to->m_fMvG.eval(fAnimTime);
+		s_from->m_fMvB = s_to->m_fMvB.eval(fAnimTime);
+	}
+	if (bNewStateTransparent && !bOldStateTransparent)
+	{
+		s_to->m_fMvX = s_from->m_fMvX.eval(fAnimTime);
+		s_to->m_fMvY = s_from->m_fMvY.eval(fAnimTime);
+		s_to->m_fMvDX = s_from->m_fMvDX.eval(fAnimTime);
+		s_to->m_fMvDY = s_from->m_fMvDY.eval(fAnimTime);
+		s_to->m_fMvL = s_from->m_fMvL.eval(fAnimTime);
+		s_to->m_fMvR = s_from->m_fMvR.eval(fAnimTime);
+		s_to->m_fMvG = s_from->m_fMvG.eval(fAnimTime);
+		s_to->m_fMvB = s_from->m_fMvB.eval(fAnimTime);
+	}
+
+}
+
+void WriteCode(FILE* fOut, int i, char* pStr, char* prefix, bool bPrependApostrophe = false)
+{
+	char szLineName[32];
+	int line = 1;
+	int start_pos = 0;
+	int char_pos = 0;
+
+	while (pStr[start_pos] != 0)
+	{
+		while (	pStr[char_pos] != 0 &&
+				pStr[char_pos] != LINEFEED_CONTROL_CHAR)
+			char_pos++;
+
+		sprintf(szLineName, "%s%d", prefix, line);
+
+		char ch = pStr[char_pos];
+		pStr[char_pos] = 0;
+		//if (!WritePrivateProfileString(szSectionName,szLineName,&pStr[start_pos],szIniFile)) return false;
+        fprintf(fOut, "%s=%s%s\n", szLineName, bPrependApostrophe ? "`" : "", &pStr[start_pos]);
+		pStr[char_pos] = ch;
+
+		if (pStr[char_pos] != 0) char_pos++;
+		start_pos = char_pos;
+		line++;
+	}
+}
+
+bool CState::Export(const wchar_t *szIniFile)
+{
+	FILE *fOut = _wfopen(szIniFile, L"w");
+	if (!fOut) return false;
+
+    // IMPORTANT: THESE MUST BE THE FIRST TWO LINES.  Otherwise it is assumed to be a MilkDrop 1-era preset.
+    if (m_nMaxPSVersion > 0)
+    {
+        fprintf(fOut, "MILKDROP_PRESET_VERSION=%d\n", CUR_MILKDROP_PRESET_VERSION);
+        fprintf(fOut, "PSVERSION=%d\n"     ,m_nMaxPSVersion);  // the max
+        fprintf(fOut, "PSVERSION_WARP=%d\n",m_nWarpPSVersion);
+        fprintf(fOut, "PSVERSION_COMP=%d\n",m_nCompPSVersion);
+    }
+    
+    // just for backwards compatibility; MilkDrop 1 can read MilkDrop 2 presets, minus the new features.
+    // (...this section name allows the GetPrivateProfile*() functions to still work on milkdrop 1)
+	fprintf(fOut, "[preset00]\n");    
+
+	fprintf(fOut, "%s=%.3f\n", "fRating",                m_fRating);         
+	fprintf(fOut, "%s=%.3f\n", "fGammaAdj",              m_fGammaAdj.eval(-1));         
+	fprintf(fOut, "%s=%.3f\n", "fDecay",                 m_fDecay.eval(-1));            
+	fprintf(fOut, "%s=%.3f\n", "fVideoEchoZoom",         m_fVideoEchoZoom.eval(-1));    
+	fprintf(fOut, "%s=%.3f\n", "fVideoEchoAlpha",        m_fVideoEchoAlpha.eval(-1));   
+	fprintf(fOut, "%s=%d\n", "nVideoEchoOrientation",  m_nVideoEchoOrientation);      
+
+	fprintf(fOut, "%s=%d\n", "nWaveMode",              m_nWaveMode);                  
+	fprintf(fOut, "%s=%d\n", "bAdditiveWaves",         m_bAdditiveWaves);             
+	fprintf(fOut, "%s=%d\n", "bWaveDots",              m_bWaveDots);                  
+	fprintf(fOut, "%s=%d\n", "bWaveThick",             m_bWaveThick);                  
+	fprintf(fOut, "%s=%d\n", "bModWaveAlphaByVolume",  m_bModWaveAlphaByVolume);      
+	fprintf(fOut, "%s=%d\n", "bMaximizeWaveColor",     m_bMaximizeWaveColor);         
+	fprintf(fOut, "%s=%d\n", "bTexWrap",               m_bTexWrap			);         
+	fprintf(fOut, "%s=%d\n", "bDarkenCenter",          m_bDarkenCenter		);         
+	fprintf(fOut, "%s=%d\n", "bRedBlueStereo",         m_bRedBlueStereo     );
+	fprintf(fOut, "%s=%d\n", "bBrighten",              m_bBrighten			);         
+	fprintf(fOut, "%s=%d\n", "bDarken",                m_bDarken			);         
+	fprintf(fOut, "%s=%d\n", "bSolarize",              m_bSolarize			);         
+	fprintf(fOut, "%s=%d\n", "bInvert",                m_bInvert			);         
+
+	fprintf(fOut, "%s=%.3f\n", "fWaveAlpha",             m_fWaveAlpha.eval(-1)); 		  
+	fprintf(fOut, "%s=%.3f\n", "fWaveScale",             m_fWaveScale.eval(-1));        
+	fprintf(fOut, "%s=%.3f\n", "fWaveSmoothing",         m_fWaveSmoothing.eval(-1));    
+	fprintf(fOut, "%s=%.3f\n", "fWaveParam",             m_fWaveParam.eval(-1));        
+	fprintf(fOut, "%s=%.3f\n", "fModWaveAlphaStart",     m_fModWaveAlphaStart.eval(-1));
+	fprintf(fOut, "%s=%.3f\n", "fModWaveAlphaEnd",       m_fModWaveAlphaEnd.eval(-1));  
+	fprintf(fOut, "%s=%.3f\n", "fWarpAnimSpeed",         m_fWarpAnimSpeed);             
+	fprintf(fOut, "%s=%.3f\n", "fWarpScale",             m_fWarpScale.eval(-1));        
+	fprintf(fOut, "%s=%.5f\n", "fZoomExponent",          m_fZoomExponent.eval(-1));     
+	fprintf(fOut, "%s=%.3f\n", "fShader",                m_fShader.eval(-1));           
+
+	fprintf(fOut, "%s=%.5f\n", "zoom",                   m_fZoom      .eval(-1));       
+	fprintf(fOut, "%s=%.5f\n", "rot",                    m_fRot       .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "cx",                     m_fRotCX     .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "cy",                     m_fRotCY     .eval(-1));       
+	fprintf(fOut, "%s=%.5f\n", "dx",                     m_fXPush     .eval(-1));       
+	fprintf(fOut, "%s=%.5f\n", "dy",                     m_fYPush     .eval(-1));       
+	fprintf(fOut, "%s=%.5f\n", "warp",                   m_fWarpAmount.eval(-1));       
+	fprintf(fOut, "%s=%.5f\n", "sx",                     m_fStretchX  .eval(-1));       
+	fprintf(fOut, "%s=%.5f\n", "sy",                     m_fStretchY  .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "wave_r",                 m_fWaveR     .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "wave_g",                 m_fWaveG     .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "wave_b",                 m_fWaveB     .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "wave_x",                 m_fWaveX     .eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "wave_y",                 m_fWaveY     .eval(-1));       
+
+	fprintf(fOut, "%s=%.3f\n", "ob_size",             m_fOuterBorderSize.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ob_r",                m_fOuterBorderR.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ob_g",                m_fOuterBorderG.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ob_b",                m_fOuterBorderB.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ob_a",                m_fOuterBorderA.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ib_size",             m_fInnerBorderSize.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ib_r",                m_fInnerBorderR.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ib_g",                m_fInnerBorderG.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ib_b",                m_fInnerBorderB.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "ib_a",                m_fInnerBorderA.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "nMotionVectorsX",     m_fMvX.eval(-1));         
+	fprintf(fOut, "%s=%.3f\n", "nMotionVectorsY",     m_fMvY.eval(-1));         
+	fprintf(fOut, "%s=%.3f\n", "mv_dx",               m_fMvDX.eval(-1));         
+	fprintf(fOut, "%s=%.3f\n", "mv_dy",               m_fMvDY.eval(-1));         
+	fprintf(fOut, "%s=%.3f\n", "mv_l",                m_fMvL.eval(-1));         
+	fprintf(fOut, "%s=%.3f\n", "mv_r",                m_fMvR.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "mv_g",                m_fMvG.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "mv_b",                m_fMvB.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "mv_a",                m_fMvA.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b1n",                 m_fBlur1Min.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b2n",                 m_fBlur2Min.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b3n",                 m_fBlur3Min.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b1x",                 m_fBlur1Max.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b2x",                 m_fBlur2Max.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b3x",                 m_fBlur3Max.eval(-1));       
+	fprintf(fOut, "%s=%.3f\n", "b1ed",                m_fBlur1EdgeDarken.eval(-1));       
+
+	int i = 0;
+    for (i=0; i<MAX_CUSTOM_WAVES; i++)
+        m_wave[i].Export(fOut, L"dummy_filename", i);
+
+    for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+        m_shape[i].Export(fOut, L"dummy_filename", i);
+
+	// write out arbitrary expressions, one line at a time
+    WriteCode(fOut, i, m_szPerFrameInit, "per_frame_init_");
+    WriteCode(fOut, i, m_szPerFrameExpr, "per_frame_"); 
+    WriteCode(fOut, i, m_szPerPixelExpr, "per_pixel_"); 
+    if (m_nWarpPSVersion >= MD2_PS_2_0)
+        WriteCode(fOut, i, m_szWarpShadersText, "warp_", true);
+    if (m_nCompPSVersion >= MD2_PS_2_0)
+        WriteCode(fOut, i, m_szCompShadersText, "comp_", true);
+
+	fclose(fOut);
+
+	return true;
+}
+
+int  CWave::Export(FILE* fOut, const wchar_t *szFile, int i)
+{
+    FILE* f2 = fOut;
+    if (!fOut)
+    {
+	    f2 = _wfopen(szFile, L"w");
+        if (!f2) return 0;
+    }
+
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "enabled",    enabled);
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "samples",    samples);
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "sep",        sep    );
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "bSpectrum",  bSpectrum);
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "bUseDots",   bUseDots);
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "bDrawThick", bDrawThick);
+	fprintf(f2, "wavecode_%d_%s=%d\n", i, "bAdditive",  bAdditive);
+	fprintf(f2, "wavecode_%d_%s=%.5f\n", i, "scaling",    scaling);
+	fprintf(f2, "wavecode_%d_%s=%.5f\n", i, "smoothing",  smoothing);
+	fprintf(f2, "wavecode_%d_%s=%.3f\n", i, "r",          r);
+	fprintf(f2, "wavecode_%d_%s=%.3f\n", i, "g",          g);
+	fprintf(f2, "wavecode_%d_%s=%.3f\n", i, "b",          b);
+	fprintf(f2, "wavecode_%d_%s=%.3f\n", i, "a",          a);
+
+    // READ THE CODE IN
+    char prefix[64];
+    sprintf(prefix, "wave_%d_init",      i); WriteCode(f2, i, m_szInit,     prefix);
+    sprintf(prefix, "wave_%d_per_frame", i); WriteCode(f2, i, m_szPerFrame, prefix);
+    sprintf(prefix, "wave_%d_per_point", i); WriteCode(f2, i, m_szPerPoint, prefix);
+
+    if (!fOut)
+	    fclose(f2); // [sic]
+
+    return 1;
+}
+
+int  CShape::Export(FILE* fOut, const wchar_t *szFile, int i)
+{
+    FILE* f2 = fOut;
+    if (!fOut)
+    {
+	    f2 = _wfopen(szFile, L"w");
+        if (!f2) return 0;
+	    //fprintf(f2, "[%s]\n", szSection);
+    }
+
+	fprintf(f2, "shapecode_%d_%s=%d\n", i, "enabled",    enabled);
+	fprintf(f2, "shapecode_%d_%s=%d\n", i, "sides",      sides);
+	fprintf(f2, "shapecode_%d_%s=%d\n", i, "additive",   additive);
+	fprintf(f2, "shapecode_%d_%s=%d\n", i, "thickOutline",thickOutline);
+	fprintf(f2, "shapecode_%d_%s=%d\n", i, "textured",   textured);
+	fprintf(f2, "shapecode_%d_%s=%d\n", i, "num_inst",   instances);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "x",          x);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "y",          y);
+	fprintf(f2, "shapecode_%d_%s=%.5f\n", i, "rad",        rad);
+	fprintf(f2, "shapecode_%d_%s=%.5f\n", i, "ang",        ang);
+	fprintf(f2, "shapecode_%d_%s=%.5f\n", i, "tex_ang",    tex_ang);
+	fprintf(f2, "shapecode_%d_%s=%.5f\n", i, "tex_zoom",   tex_zoom);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "r",          r);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "g",          g);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "b",          b);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "a",          a);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "r2",         r2);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "g2",         g2);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "b2",         b2);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "a2",         a2);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "border_r",   border_r);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "border_g",   border_g);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "border_b",   border_b);
+	fprintf(f2, "shapecode_%d_%s=%.3f\n", i, "border_a",   border_a);
+
+    char prefix[64];
+    sprintf(prefix, "shape_%d_init",      i); WriteCode(f2, i, m_szInit,     prefix);
+    sprintf(prefix, "shape_%d_per_frame", i); WriteCode(f2, i, m_szPerFrame, prefix);
+    //sprintf(prefix, "shape_%d_per_point", i); WriteCode(f2, i, m_szPerPoint, prefix);
+
+    if (!fOut)
+	    fclose(f2); // [sic]
+
+    return 1;
+}
+
+void ReadCode(FILE* f, char* pStr, char* prefix)
+{
+    if (!pStr) 
+        return;
+    pStr[0] = 0;
+
+	// read in & compile arbitrary expressions
+	char szLineName[32];
+	char szLine[MAX_BIGSTRING_LEN];
+	int len;
+
+	int line = 1;
+	int char_pos = 0;
+	bool bDone = false;
+
+	while (!bDone)
+	{
+		sprintf(szLineName, "%s%d", prefix, line); 
+
+		GetFastString(szLineName, "~!@#$", szLine, MAX_BIGSTRING_LEN, f);	// fixme
+		len = strlen(szLine);
+
+		if ((strcmp(szLine, "~!@#$")==0) ||		// if the key was missing,
+			(len >= MAX_BIGSTRING_LEN-1-char_pos-1))			// or if we're out of space
+		{
+			bDone = true;
+		}
+		else 
+		{
+            sprintf(&pStr[char_pos], "%s%c", (szLine[0]=='`') ? &szLine[1] : szLine, LINEFEED_CONTROL_CHAR);
+            if (szLine[0] == '`')
+                len--;
+		}
+	
+		char_pos += len + 1;
+		line++;
+	}
+	pStr[char_pos++] = 0;	// null-terminate
+
+	// read in & compile arbitrary expressions
+    /*
+    int n2 = 3 + MAX_CUSTOM_WAVES*3 + MAX_CUSTOM_SHAPES*2;
+	for (int n=0; n<n2; n++)
+	{
+		char *pStr;
+        char prefix[64];
+		char szLineName[32];
+		char szLine[MAX_BIGSTRING_LEN];
+		int len;
+
+		int line = 1;
+		int char_pos = 0;
+		bool bDone = false;
+
+		switch(n)
+		{
+		case 0: pStr = m_szPerFrameExpr; strcpy(prefix, "per_frame_"); break;
+		case 1: pStr = m_szPerPixelExpr; strcpy(prefix, "per_pixel_"); break;
+		case 2: pStr = m_szPerFrameInit; strcpy(prefix, "per_frame_init_"); break;
+        default:
+            if (n < 3 + 3*MAX_CUSTOM_WAVES)
+            {
+                int i = (n-3) / 3;
+                int j = (n-3) % 3;
+                switch(j)
+                {
+                case 0: pStr = m_wave[i].m_szInit;     sprintf(prefix, "wave_%d_init",      i); break;
+                case 1: pStr = m_wave[i].m_szPerFrame; sprintf(prefix, "wave_%d_per_frame", i); break;
+                case 2: pStr = m_wave[i].m_szPerPoint; sprintf(prefix, "wave_%d_per_point", i); break;
+                }
+            }
+            else
+            {
+                int i = (n-3-3*MAX_CUSTOM_WAVES) / 2;
+                int j = (n-3-3*MAX_CUSTOM_WAVES) % 2;
+                switch(j)
+                {
+                case 0: pStr = m_shape[i].m_szInit;     sprintf(prefix, "shape_%d_init",      i); break;
+                case 1: pStr = m_shape[i].m_szPerFrame; sprintf(prefix, "shape_%d_per_frame", i); break;
+                }
+            }
+		}
+		
+		while (!bDone)
+		{
+			sprintf(szLineName, "%s%d", prefix, line); 
+
+			GetPrivateProfileString(szSectionName, szLineName, "~!@#$", szLine, MAX_BIGSTRING_LEN, szIniFile);	// fixme
+			len = strlen(szLine);
+
+			if ((strcmp(szLine, "~!@#$")==0) ||		// if the key was missing,
+				(len >= MAX_BIGSTRING_LEN-1-char_pos-1))			// or if we're out of space
+			{
+				bDone = true;
+			}
+			else 
+			{
+				sprintf(&pStr[char_pos], "%s%c", szLine, LINEFEED_CONTROL_CHAR);
+			}
+		
+			char_pos += len + 1;
+			line++;
+		}
+		pStr[char_pos++] = 0;	// null-terminate
+	}
+    */
+}
+
+int CWave::Import(FILE* f, const wchar_t* szFile, int i)
+{
+    FILE* f2 = f;
+    if (!f)
+    {
+	    f2 = _wfopen(szFile, L"rb");
+        if (!f2) return 0;
+        GetFast_CLEAR();
+    }
+
+    char buf[64];
+    sprintf(buf, "wavecode_%d_%s", i, "enabled"   ); enabled    = GetFastInt  (buf, enabled   , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "samples"   ); samples    = GetFastInt  (buf, samples   , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "sep"       ); sep        = GetFastInt  (buf, sep       , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "bSpectrum" ); bSpectrum  = GetFastInt  (buf, bSpectrum , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "bUseDots"  ); bUseDots   = GetFastInt  (buf, bUseDots  , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "bDrawThick"); bDrawThick = GetFastInt  (buf, bDrawThick, f2);
+    sprintf(buf, "wavecode_%d_%s", i, "bAdditive" ); bAdditive  = GetFastInt  (buf, bAdditive , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "scaling"   ); scaling    = GetFastFloat(buf, scaling   , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "smoothing" ); smoothing  = GetFastFloat(buf, smoothing , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "r"         ); r          = GetFastFloat(buf, r         , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "g"         ); g          = GetFastFloat(buf, g         , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "b"         ); b          = GetFastFloat(buf, b         , f2);
+    sprintf(buf, "wavecode_%d_%s", i, "a"         ); a          = GetFastFloat(buf, a         , f2);
+
+    // READ THE CODE IN
+    char prefix[64];
+    sprintf(prefix, "wave_%d_init",      i); ReadCode(f2, m_szInit,     prefix);
+    sprintf(prefix, "wave_%d_per_frame", i); ReadCode(f2, m_szPerFrame, prefix);
+    sprintf(prefix, "wave_%d_per_point", i); ReadCode(f2, m_szPerPoint, prefix);
+
+    if (!f)
+	    fclose(f2); // [sic]
+
+    return 1;
+}
+
+int  CShape::Import(FILE* f, const wchar_t* szFile, int i)
+{
+    FILE* f2 = f;
+    if (!f)
+    {
+	    f2 = _wfopen(szFile, L"rb");
+        if (!f2) return 0;
+        GetFast_CLEAR();
+    }
+
+    char buf[64];
+	sprintf(buf, "shapecode_%d_%s", i, "enabled"     ); enabled      = GetFastInt  (buf, enabled     , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "sides"       ); sides        = GetFastInt  (buf, sides       , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "additive"    ); additive     = GetFastInt  (buf, additive    , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "thickOutline"); thickOutline = GetFastInt  (buf, thickOutline, f2);
+	sprintf(buf, "shapecode_%d_%s", i, "textured"    ); textured     = GetFastInt  (buf, textured    , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "num_inst"   ); instances    = GetFastInt  (buf, instances   , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "x"           ); x            = GetFastFloat(buf, x           , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "y"           ); y            = GetFastFloat(buf, y           , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "rad"         ); rad          = GetFastFloat(buf, rad         , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "ang"         ); ang          = GetFastFloat(buf, ang         , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "tex_ang"     ); tex_ang      = GetFastFloat(buf, tex_ang     , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "tex_zoom"    ); tex_zoom     = GetFastFloat(buf, tex_zoom    , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "r"           ); r            = GetFastFloat(buf, r           , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "g"           ); g            = GetFastFloat(buf, g           , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "b"           ); b            = GetFastFloat(buf, b           , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "a"           ); a            = GetFastFloat(buf, a           , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "r2"          ); r2           = GetFastFloat(buf, r2          , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "g2"          ); g2           = GetFastFloat(buf, g2          , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "b2"          ); b2           = GetFastFloat(buf, b2          , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "a2"          ); a2           = GetFastFloat(buf, a2          , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "border_r"    ); border_r     = GetFastFloat(buf, border_r    , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "border_g"    ); border_g     = GetFastFloat(buf, border_g    , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "border_b"    ); border_b     = GetFastFloat(buf, border_b    , f2);
+	sprintf(buf, "shapecode_%d_%s", i, "border_a"    ); border_a     = GetFastFloat(buf, border_a    , f2);
+
+    // READ THE CODE IN
+    char prefix[64];
+    sprintf(prefix, "shape_%d_init",      i); ReadCode(f2, m_szInit,     prefix);
+    sprintf(prefix, "shape_%d_per_frame", i); ReadCode(f2, m_szPerFrame, prefix);
+
+    if (!f)
+	    fclose(f2); // [sic]
+
+    return 1;
+}
+
+bool CState::Import(const wchar_t *szIniFile, float fTime, CState* pOldState, DWORD ApplyFlags)
+{
+    // if any ApplyFlags are missing, the settings will be copied from pOldState.  =)
+
+    if (!pOldState) 
+        ApplyFlags = STATE_ALL;
+    
+    if (ApplyFlags!=STATE_ALL && this != pOldState)
+    {
+        assert(pOldState);
+        // in order to copy the old state, we have to byte copy it.
+        memcpy(this, pOldState, sizeof(CState));
+        // clear all the copied code pointers, WITHOUT actually freeing it (since ptrs were copied)
+        // so that the Default() call below won't release pOldState's copied pointers.
+        // [all expressions will be recompiled @ end of this fn, whether we updated them or not]
+        FreeVarsAndCode(false);  
+    }
+
+    // apply defaults for the stuff we will overwrite.
+    Default(ApplyFlags);//RandomizePresetVars();
+
+    GetFast_CLEAR();
+
+    if ( (ApplyFlags & STATE_GENERAL) &&    // check for these 3 @ same time,
+         (ApplyFlags & STATE_MOTION) &&     // so a preset switch w/ warp/comp lock
+         (ApplyFlags & STATE_WAVE)        // updates the name, but mash-ups don't.
+        )
+    {
+        m_fPresetStartTime = fTime;
+
+	    // extract a description of the preset from the filename
+	    {
+		    // copy get the filename (without the path)
+		    const wchar_t *p = wcsrchr(szIniFile, '\\');
+		    if (p==NULL) p = szIniFile;
+		    lstrcpyW(m_szDesc, p+1);		
+
+		    // next remove the extension
+		    RemoveExtension(m_szDesc);
+	    }
+    }
+    
+    FILE* f = _wfopen(szIniFile, L"rb");
+    if (!f)
+        return false;
+
+    int nMilkdropPresetVersion = GetFastInt("MILKDROP_PRESET_VERSION",100,f);
+    //if (ApplyFlags != STATE_ALL)
+    //    nMilkdropPresetVersion = CUR_MILKDROP_PRESET_VERSION;  //if we're mashing up, force it up to now
+    
+
+    int nWarpPSVersionInFile;
+    int nCompPSVersionInFile;
+    if (nMilkdropPresetVersion < 200) {
+        nWarpPSVersionInFile = 0;
+        nCompPSVersionInFile = 0;
+    }
+    else if (nMilkdropPresetVersion == 200) {
+        nWarpPSVersionInFile = GetFastInt("PSVERSION", 2, f);
+        nCompPSVersionInFile = nWarpPSVersionInFile;
+    }
+    else {
+        nWarpPSVersionInFile = GetFastInt("PSVERSION_WARP", 2, f);
+        nCompPSVersionInFile = GetFastInt("PSVERSION_COMP", 2, f);
+    }
+
+    // general:
+    if (ApplyFlags & STATE_GENERAL)
+    {
+        m_fRating				= GetFastFloat("fRating",m_fRating,f);
+	    m_fDecay                = GetFastFloat("fDecay",m_fDecay.eval(-1),f);
+	    m_fGammaAdj             = GetFastFloat("fGammaAdj" ,m_fGammaAdj.eval(-1),f);
+	    m_fVideoEchoZoom        = GetFastFloat("fVideoEchoZoom",m_fVideoEchoZoom.eval(-1),f);
+	    m_fVideoEchoAlpha       = GetFastFloat("fVideoEchoAlpha",m_fVideoEchoAlpha.eval(-1),f);
+	    m_nVideoEchoOrientation = GetFastInt  ("nVideoEchoOrientation",m_nVideoEchoOrientation,f);
+        m_bRedBlueStereo        = (GetFastInt ("bRedBlueStereo", m_bRedBlueStereo,f) != 0);
+	    m_bBrighten				= (GetFastInt ("bBrighten",m_bBrighten	,f) != 0);
+	    m_bDarken				= (GetFastInt ("bDarken"  ,m_bDarken	,f) != 0);
+	    m_bSolarize				= (GetFastInt ("bSolarize",m_bSolarize	,f) != 0);
+	    m_bInvert				= (GetFastInt ("bInvert"  ,m_bInvert	,f) != 0);
+	    m_fShader               = GetFastFloat("fShader",m_fShader.eval(-1),f);
+        m_fBlur1Min			= GetFastFloat("b1n",    m_fBlur1Min.eval(-1),f);       
+        m_fBlur2Min			= GetFastFloat("b2n",    m_fBlur2Min.eval(-1),f);       
+        m_fBlur3Min			= GetFastFloat("b3n",    m_fBlur3Min.eval(-1),f);       
+        m_fBlur1Max			= GetFastFloat("b1x",    m_fBlur1Max.eval(-1),f);       
+        m_fBlur2Max			= GetFastFloat("b2x",    m_fBlur2Max.eval(-1),f);       
+        m_fBlur3Max			= GetFastFloat("b3x",    m_fBlur3Max.eval(-1),f);       
+        m_fBlur1EdgeDarken  = GetFastFloat("b1ed",   m_fBlur1EdgeDarken.eval(-1),f); 
+    }
+
+    // wave:
+    if (ApplyFlags & STATE_WAVE)
+    {
+	    m_nWaveMode             = GetFastInt  ("nWaveMode",m_nWaveMode,f);
+	    m_bAdditiveWaves		= (GetFastInt ("bAdditiveWaves",m_bAdditiveWaves,f) != 0);
+	    m_bWaveDots		        = (GetFastInt ("bWaveDots",m_bWaveDots,f) != 0);
+	    m_bWaveThick            = (GetFastInt ("bWaveThick",m_bWaveThick,f) != 0);
+	    m_bModWaveAlphaByVolume	= (GetFastInt ("bModWaveAlphaByVolume",m_bModWaveAlphaByVolume,f) != 0);
+	    m_bMaximizeWaveColor    = (GetFastInt ("bMaximizeWaveColor" ,m_bMaximizeWaveColor,f) != 0);
+	    m_fWaveAlpha            = GetFastFloat("fWaveAlpha",m_fWaveAlpha.eval(-1),f);
+	    m_fWaveScale            = GetFastFloat("fWaveScale",m_fWaveScale.eval(-1),f);
+	    m_fWaveSmoothing        = GetFastFloat("fWaveSmoothing",m_fWaveSmoothing.eval(-1),f);
+	    m_fWaveParam            = GetFastFloat("fWaveParam",m_fWaveParam.eval(-1),f);
+	    m_fModWaveAlphaStart    = GetFastFloat("fModWaveAlphaStart",m_fModWaveAlphaStart.eval(-1),f);
+	    m_fModWaveAlphaEnd      = GetFastFloat("fModWaveAlphaEnd",m_fModWaveAlphaEnd.eval(-1),f);
+	    m_fWaveR				= GetFastFloat("wave_r",m_fRot.eval(-1),f);	
+	    m_fWaveG				= GetFastFloat("wave_g",m_fRot.eval(-1),f);	
+	    m_fWaveB				= GetFastFloat("wave_b",m_fRot.eval(-1),f);	
+	    m_fWaveX				= GetFastFloat("wave_x",m_fRot.eval(-1),f);	
+	    m_fWaveY				= GetFastFloat("wave_y",m_fRot.eval(-1),f);	
+	    m_fMvX				= GetFastFloat("nMotionVectorsX",  m_fMvX.eval(-1),f);
+	    m_fMvY           	= GetFastFloat("nMotionVectorsY",  m_fMvY.eval(-1),f);
+	    m_fMvDX				= GetFastFloat("mv_dx",  m_fMvDX.eval(-1),f);
+	    m_fMvDY				= GetFastFloat("mv_dy",  m_fMvDY.eval(-1),f);
+	    m_fMvL				= GetFastFloat("mv_l",   m_fMvL.eval(-1),f);
+	    m_fMvR				= GetFastFloat("mv_r",   m_fMvR.eval(-1),f);	
+	    m_fMvG				= GetFastFloat("mv_g",   m_fMvG.eval(-1),f);	
+	    m_fMvB				= GetFastFloat("mv_b",   m_fMvB.eval(-1),f);	
+	    m_fMvA				= (GetFastInt ("bMotionVectorsOn",false,f) == 0) ? 0.0f : 1.0f; // for backwards compatibility
+	    m_fMvA				= GetFastFloat("mv_a",   m_fMvA.eval(-1),f);	
+		
+		int i = 0;
+		for (i=0; i<MAX_CUSTOM_WAVES; i++)
+        {
+            m_wave[i].Import(f, L"dummy_filename", i);
+        }
+        for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+        {
+            m_shape[i].Import(f, L"dummy_filename", i);
+        }
+    }
+
+    // motion:
+    if (ApplyFlags & STATE_MOTION)
+    {
+	    m_fZoom					= GetFastFloat("zoom",m_fZoom.eval(-1),f);	
+	    m_fRot					= GetFastFloat("rot",m_fRot.eval(-1),f);	
+	    m_fRotCX				= GetFastFloat("cx",m_fRotCX.eval(-1),f);	
+	    m_fRotCY				= GetFastFloat("cy",m_fRotCY.eval(-1),f);	
+	    m_fXPush				= GetFastFloat("dx",m_fXPush.eval(-1),f);	
+	    m_fYPush				= GetFastFloat("dy",m_fYPush.eval(-1),f);	
+	    m_fWarpAmount			= GetFastFloat("warp",m_fWarpAmount.eval(-1),f);	
+	    m_fStretchX				= GetFastFloat("sx",m_fStretchX.eval(-1),f);	
+	    m_fStretchY				= GetFastFloat("sy",m_fStretchY.eval(-1),f);	
+        m_bTexWrap			    = (GetFastInt ("bTexWrap", m_bTexWrap,f) != 0);
+	    m_bDarkenCenter			= (GetFastInt ("bDarkenCenter", m_bDarkenCenter,f) != 0);
+	    m_fWarpAnimSpeed        = GetFastFloat("fWarpAnimSpeed",m_fWarpAnimSpeed,f);
+	    m_fWarpScale            = GetFastFloat("fWarpScale",m_fWarpScale.eval(-1),f);
+	    m_fZoomExponent         = GetFastFloat("fZoomExponent",m_fZoomExponent.eval(-1),f);
+	    m_fOuterBorderSize	= GetFastFloat("ob_size",m_fOuterBorderSize.eval(-1),f);	
+	    m_fOuterBorderR		= GetFastFloat("ob_r",   m_fOuterBorderR.eval(-1),f);	
+	    m_fOuterBorderG		= GetFastFloat("ob_g",   m_fOuterBorderG.eval(-1),f);	
+	    m_fOuterBorderB		= GetFastFloat("ob_b",   m_fOuterBorderB.eval(-1),f);	
+	    m_fOuterBorderA		= GetFastFloat("ob_a",   m_fOuterBorderA.eval(-1),f);	
+	    m_fInnerBorderSize	= GetFastFloat("ib_size",m_fInnerBorderSize.eval(-1),f);	
+	    m_fInnerBorderR		= GetFastFloat("ib_r",   m_fInnerBorderR.eval(-1),f);	
+	    m_fInnerBorderG		= GetFastFloat("ib_g",   m_fInnerBorderG.eval(-1),f);	
+	    m_fInnerBorderB		= GetFastFloat("ib_b",   m_fInnerBorderB.eval(-1),f);	
+	    m_fInnerBorderA		= GetFastFloat("ib_a",   m_fInnerBorderA.eval(-1),f);	
+        //m_szPerFrameInit[0] = 0;
+        //m_szPerFrameExpr[0] = 0;
+        //m_szPerPixelExpr[0] = 0;
+        ReadCode(f, m_szPerFrameInit, "per_frame_init_");
+        ReadCode(f, m_szPerFrameExpr, "per_frame_");
+        ReadCode(f, m_szPerPixelExpr, "per_pixel_");
+    }
+    
+    // warp shader
+    if (ApplyFlags & STATE_WARP)
+    {
+        //m_szWarpShadersText[0] = 0;
+        ReadCode(f, m_szWarpShadersText, "warp_");
+        if (!m_szWarpShadersText[0]) 
+            g_plugin.GenWarpPShaderText(m_szWarpShadersText, m_fDecay.eval(-1), m_bTexWrap);
+        m_nWarpPSVersion = nWarpPSVersionInFile;
+    }
+    
+    // comp shader
+    if (ApplyFlags & STATE_COMP) 
+    {
+        //m_szCompShadersText[0] = 0;
+        ReadCode(f, m_szCompShadersText, "comp_");
+        if (!m_szCompShadersText[0])
+            g_plugin.GenCompPShaderText(m_szCompShadersText, m_fGammaAdj.eval(-1), m_fVideoEchoAlpha.eval(-1), m_fVideoEchoZoom.eval(-1), m_nVideoEchoOrientation, m_fShader.eval(-1), m_bBrighten, m_bDarken, m_bSolarize, m_bInvert);
+        m_nCompPSVersion = nCompPSVersionInFile;
+    }
+
+    m_nMaxPSVersion = max(m_nWarpPSVersion, m_nCompPSVersion);
+    m_nMinPSVersion = min(m_nWarpPSVersion, m_nCompPSVersion);
+	
+
+	RecompileExpressions();
+
+    fclose(f);
+
+    return true;
+}
+
+void CState::GenDefaultWarpShader()
+{
+    if (m_nWarpPSVersion>0)
+        g_plugin.GenWarpPShaderText(m_szWarpShadersText, m_fDecay.eval(-1), m_bTexWrap);
+}
+void CState::GenDefaultCompShader()
+{
+    if (m_nCompPSVersion>0)
+        g_plugin.GenCompPShaderText(m_szCompShadersText, m_fGammaAdj.eval(-1), m_fVideoEchoAlpha.eval(-1), m_fVideoEchoZoom.eval(-1), m_nVideoEchoOrientation, m_fShader.eval(-1), m_bBrighten, m_bDarken, m_bSolarize, m_bInvert);
+}
+
+void CState::FreeVarsAndCode(bool bFree)
+{
+	// free the compiled expressions
+	if (m_pf_codehandle)
+	{
+        if (bFree)
+		    NSEEL_code_free(m_pf_codehandle);
+		m_pf_codehandle = NULL;
+	}
+	if (m_pp_codehandle)
+	{
+        if (bFree)
+    		NSEEL_code_free(m_pp_codehandle);
+		m_pp_codehandle = NULL;
+	}
+
+	int i = 0;
+    for (i=0; i<MAX_CUSTOM_WAVES; i++)
+    {
+	    if (m_wave[i].m_pf_codehandle)
+        {
+            if (bFree)
+                NSEEL_code_free(m_wave[i].m_pf_codehandle);
+            m_wave[i].m_pf_codehandle = NULL;
+        }
+	    if (m_wave[i].m_pp_codehandle)
+        {
+            if (bFree)
+                NSEEL_code_free(m_wave[i].m_pp_codehandle);
+            m_wave[i].m_pp_codehandle = NULL;
+        }
+    }
+
+    for (i=0; i<MAX_CUSTOM_SHAPES; i++)
+    {
+	    if (m_shape[i].m_pf_codehandle)
+        {
+            if (bFree)
+                NSEEL_code_free(m_shape[i].m_pf_codehandle);
+            m_shape[i].m_pf_codehandle = NULL;
+        }
+	    /*if (m_shape[i].m_pp_codehandle)
+        {
+            freeCode(m_shape[i].m_pp_codehandle);
+            m_shape[i].m_pp_codehandle = NULL;
+        }*/
+    }
+
+	// free our text version of the expressions? - no!
+	//m_szPerFrameExpr[0] = 0;
+	//m_szPerPixelExpr[0] = 0;
+
+	// free the old variable names & reregister the built-in variables (since they got nuked too)
+	RegisterBuiltInVariables(0xFFFFFFFF);
+}
+
+void CState::StripLinefeedCharsAndComments(char *src, char *dest)
+{
+	// replaces all LINEFEED_CONTROL_CHAR characters in src with a space in dest;
+	// also strips out all comments (beginning with '//' and going til end of line).
+	// Restriction: sizeof(dest) must be >= sizeof(src).
+
+	int i2 = 0;
+	int len = strlen(src);
+	int bComment = false;
+	for (int i=0; i<len; i++)		
+	{
+		if (bComment)
+		{
+			if (src[i] == LINEFEED_CONTROL_CHAR)	
+				bComment = false;
+		}
+		else
+		{
+			if ((src[i] =='\\' && src[i+1] =='\\') || (src[i] =='/' && src[i+1] =='/'))
+				bComment = true;
+			else if (src[i] != LINEFEED_CONTROL_CHAR)
+				dest[i2++] = src[i];
+		}
+	}
+	dest[i2] = 0;
+}
+
+void CState::RecompileExpressions(int flags, int bReInit)
+{
+    // before we get started, if we redo the init code for the preset, we have to redo
+    // other things too, because q1-q8 could change.
+    if ((flags & RECOMPILE_PRESET_CODE) && bReInit)
+    {
+        flags |= RECOMPILE_WAVE_CODE;
+        flags |= RECOMPILE_SHAPE_CODE;
+    }
+
+    // free old code handles
+    if (flags & RECOMPILE_PRESET_CODE)
+    {
+	    if (m_pf_codehandle)
+	    {
+		    NSEEL_code_free(m_pf_codehandle);
+		    m_pf_codehandle = NULL;
+	    }
+	    if (m_pp_codehandle)
+	    {
+		    NSEEL_code_free(m_pp_codehandle);
+		    m_pp_codehandle = NULL;
+	    }
+    }
+    if (flags & RECOMPILE_WAVE_CODE)
+    {
+        for (int i=0; i<MAX_CUSTOM_WAVES; i++)
+        {
+		    if (m_wave[i].m_pf_codehandle)
+		    {
+			    NSEEL_code_free(m_wave[i].m_pf_codehandle);
+			    m_wave[i].m_pf_codehandle = NULL;
+		    }
+		    if (m_wave[i].m_pp_codehandle)
+		    {
+			    NSEEL_code_free(m_wave[i].m_pp_codehandle);
+			    m_wave[i].m_pp_codehandle = NULL;
+		    }
+        }
+    }
+    if (flags & RECOMPILE_SHAPE_CODE)
+    {
+        for (int i=0; i<MAX_CUSTOM_SHAPES; i++)
+        {
+		    if (m_shape[i].m_pf_codehandle)
+		    {
+			    NSEEL_code_free(m_shape[i].m_pf_codehandle);
+			    m_shape[i].m_pf_codehandle = NULL;
+		    }
+		    /*if (m_shape[i].m_pp_codehandle)
+		    {
+			    freeCode(m_shape[i].m_pp_codehandle);
+			    m_shape[i].m_pp_codehandle = NULL;
+		    }*/
+        }
+    }
+
+    // if we're recompiling init code, clear vars to zero, and re-register built-in variables.
+	if (bReInit)
+	{
+		RegisterBuiltInVariables(flags);
+	}
+
+	// QUICK FIX: if the code strings ONLY have spaces and linefeeds, erase them, 
+	// because for some strange reason this causes errors in compileCode().
+    int n2 = 3 + MAX_CUSTOM_WAVES*3 + MAX_CUSTOM_SHAPES*2; 
+	for (int n=0; n<n2; n++)
+	{
+		char *pOrig;
+		switch(n)
+		{
+		case 0: pOrig = m_szPerFrameExpr; break;
+		case 1: pOrig = m_szPerPixelExpr; break;
+		case 2: pOrig = m_szPerFrameInit; break;
+        default:
+            if (n < 3 + 3*MAX_CUSTOM_WAVES)
+            {
+                int i = (n-3) / 3;
+                int j = (n-3) % 3;
+                switch(j)
+                {
+                case 0: pOrig = m_wave[i].m_szInit;     break;
+                case 1: pOrig = m_wave[i].m_szPerFrame; break;
+                case 2: pOrig = m_wave[i].m_szPerPoint; break;
+                }
+            }
+            else
+            {
+                int i = (n-3-3*MAX_CUSTOM_WAVES) / 2;
+                int j = (n-3-3*MAX_CUSTOM_WAVES) % 2;
+                switch(j)
+                {
+                case 0: pOrig = m_shape[i].m_szInit;     break;
+                case 1: pOrig = m_shape[i].m_szPerFrame; break;
+                }
+            }
+		}
+		char *p = pOrig;
+		while (*p==' ' || *p==LINEFEED_CONTROL_CHAR) p++;
+		if (*p == 0) pOrig[0] = 0;
+	}
+
+    // COMPILE NEW CODE.
+	#ifndef _NO_EXPR_   
+    {
+    	// clear any old error msg.:
+    	//g_plugin.m_fShowUserMessageUntilThisTime = g_plugin.GetTime();	
+
+	    char buf[MAX_BIGSTRING_LEN*3];
+
+        if (flags & RECOMPILE_PRESET_CODE)
+        {
+            // 1. compile AND EXECUTE preset init code
+		    StripLinefeedCharsAndComments(m_szPerFrameInit, buf);
+	        if (buf[0] && bReInit)
+	        {
+		        NSEEL_CODEHANDLE	pf_codehandle_init;	
+
+			    if ( ! (pf_codehandle_init = NSEEL_code_compile(m_pf_eel, buf)))
+			    {
+                    wchar_t buf[1024];
+				    swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_PRESET_INIT_CODE), m_szDesc);
+                    g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+
+                    for (int vi=0; vi<NUM_Q_VAR; vi++)
+				        q_values_after_init_code[vi] = 0;
+                    monitor_after_init_code = 0;
+			    }
+			    else
+			    {
+				    // now execute the code, save the values of q1..q32, and clean up the code!
+
+                    g_plugin.LoadPerFrameEvallibVars(g_plugin.m_pState);
+
+				    NSEEL_code_execute(pf_codehandle_init);
+
+                    for (int vi=0; vi<NUM_Q_VAR; vi++)
+				        q_values_after_init_code[vi] = *var_pf_q[vi];
+                    monitor_after_init_code = *var_pf_monitor;
+
+				    NSEEL_code_free(pf_codehandle_init);
+				    pf_codehandle_init = NULL;
+			    }
+	        }
+
+            // 2. compile preset per-frame code
+            StripLinefeedCharsAndComments(m_szPerFrameExpr, buf);
+	        if (buf[0])
+	        {
+			    if ( ! (m_pf_codehandle = NSEEL_code_compile(m_pf_eel, buf)))
+			    {
+                    wchar_t buf[1024];
+				    swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_PER_FRAME_CODE), m_szDesc);
+                    g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+			    }
+	        }
+
+            // 3. compile preset per-pixel code
+		    StripLinefeedCharsAndComments(m_szPerPixelExpr, buf);
+	        if (buf[0])
+	        {
+			    if ( ! (m_pp_codehandle = NSEEL_code_compile(m_pv_eel, buf)))
+			    {
+                    wchar_t buf[1024];
+				    swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_PER_VERTEX_CODE), m_szDesc);
+                    g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+			    }
+	        }
+	        
+            //resetVars(NULL);
+        }
+
+        if (flags & RECOMPILE_WAVE_CODE)
+        {
+            for (int i=0; i<MAX_CUSTOM_WAVES; i++)
+            {
+                // 1. compile AND EXECUTE custom waveform init code
+		        StripLinefeedCharsAndComments(m_wave[i].m_szInit, buf);
+	            if (buf[0] && bReInit)
+                {
+		            #ifndef _NO_EXPR_
+		            {
+		                NSEEL_CODEHANDLE	codehandle_temp;	
+			            if ( ! (codehandle_temp = NSEEL_code_compile(m_wave[i].m_pf_eel, buf)))
+			            {
+                            wchar_t buf[1024];
+				            swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_WAVE_X_INIT_CODE), m_szDesc, i);
+                            g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+
+							int vi = 0;
+                            for (vi=0; vi<NUM_Q_VAR; vi++)
+                                *m_wave[i].var_pf_q[vi] = q_values_after_init_code[vi];
+                            for (vi=0; vi<NUM_T_VAR; vi++)
+				                m_wave[i].t_values_after_init_code[vi] = 0;
+			            }
+			            else
+			            {
+				            // now execute the code, save the values of t1..t8, and clean up the code!
+                    
+                            g_plugin.LoadCustomWavePerFrameEvallibVars(g_plugin.m_pState, i);
+                                // note: q values at this point will actually be same as 
+                                //       q_values_after_init_code[], since no per-frame code
+                                //       has actually been executed yet!
+
+				            NSEEL_code_execute(codehandle_temp);
+
+                            for (int vi=0; vi<NUM_T_VAR; vi++)
+				                m_wave[i].t_values_after_init_code[vi] = *m_wave[i].var_pf_t[vi];
+
+				            NSEEL_code_free(codehandle_temp);
+				            codehandle_temp = NULL;
+			            }
+		            }
+                    #endif
+                }
+
+                // 2. compile custom waveform per-frame code
+		        StripLinefeedCharsAndComments(m_wave[i].m_szPerFrame, buf);
+	            if (buf[0])
+                {
+		            #ifndef _NO_EXPR_
+			            if ( ! (m_wave[i].m_pf_codehandle = NSEEL_code_compile(m_wave[i].m_pf_eel, buf)))
+			            {
+                            wchar_t buf[1024];
+				            swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_WAVE_X_PER_FRAME_CODE), m_szDesc, i);
+                            g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+			            }
+                    #endif
+                }
+
+                // 3. compile custom waveform per-point code
+		        StripLinefeedCharsAndComments(m_wave[i].m_szPerPoint, buf);
+	            if (buf[0])
+                {
+			        if ( ! (m_wave[i].m_pp_codehandle = NSEEL_code_compile(m_wave[i].m_pp_eel, buf)))
+			        {
+                        wchar_t buf[1024];
+				        swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_WAVE_X_PER_POINT_CODE), m_szDesc, i);
+                        g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+			        }
+                }
+            }
+        }
+
+        if (flags & RECOMPILE_SHAPE_CODE)
+        {
+            for (int i=0; i<MAX_CUSTOM_SHAPES; i++)
+            {
+                // 1. compile AND EXECUTE custom shape init code
+		        StripLinefeedCharsAndComments(m_shape[i].m_szInit, buf);
+	            if (buf[0] && bReInit)
+                {
+		            #ifndef _NO_EXPR_
+		            {
+		                NSEEL_CODEHANDLE	codehandle_temp;	
+			            if ( ! (codehandle_temp = NSEEL_code_compile(m_shape[i].m_pf_eel, buf)))
+			            {
+                            wchar_t buf[1024];
+				            swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_SHAPE_X_INIT_CODE), m_szDesc, i);
+                            g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+
+							int vi = 0;
+                            for (vi=0; vi<NUM_Q_VAR; vi++)
+                                *m_shape[i].var_pf_q[vi] = q_values_after_init_code[vi];
+                            for (vi=0; vi<NUM_T_VAR; vi++)
+				                m_shape[i].t_values_after_init_code[vi] = 0;
+			            }
+			            else
+			            {
+				            // now execute the code, save the values of q1..q8, and clean up the code!
+                    
+                            g_plugin.LoadCustomShapePerFrameEvallibVars(g_plugin.m_pState, i, 0);
+                                // note: q values at this point will actually be same as 
+                                //       q_values_after_init_code[], since no per-frame code
+                                //       has actually been executed yet!
+
+				            NSEEL_code_execute(codehandle_temp);
+
+                            for (int vi=0; vi<NUM_T_VAR; vi++)
+                                m_shape[i].t_values_after_init_code[vi] = *m_shape[i].var_pf_t[vi];
+
+				            NSEEL_code_free(codehandle_temp);
+				            codehandle_temp = NULL;
+			            }
+		            }
+		            #endif
+                }
+
+                // 2. compile custom shape per-frame code
+		        StripLinefeedCharsAndComments(m_shape[i].m_szPerFrame, buf);
+	            if (buf[0])
+                {
+		            #ifndef _NO_EXPR_
+			            if ( ! (m_shape[i].m_pf_codehandle = NSEEL_code_compile(m_shape[i].m_pf_eel, buf)))
+			            {
+                            wchar_t buf[1024];
+				            swprintf(buf, WASABI_API_LNGSTRINGW(IDS_WARNING_PRESET_X_ERROR_IN_SHAPE_X_PER_FRAME_CODE), m_szDesc, i);
+                            g_plugin.AddError(buf, 6.0f, ERR_PRESET, true);
+			            }
+		            #endif
+                }
+
+                /*
+                // 3. compile custom shape per-point code
+		        StripLinefeedCharsAndComments(m_shape[i].m_szPerPoint, buf);
+	            if (buf[0])
+                {
+                    resetVars(m_shape[i].m_pp_vars);
+		            #ifndef _NO_EXPR_
+			            if ( ! (m_shape[i].m_pp_codehandle = compileCode(buf)))
+			            {
+				            sprintf(g_plugin.m_szUserMessage, "warning: preset \"%s\": error in shape %d per-point code", m_szDesc, i);
+				            g_plugin.m_fShowUserMessageUntilThisTime = g_plugin.GetTime() + 6.0f;
+                            g_plugin.m_bUserMessageIsError = true;
+			            }
+		            #endif
+                    resetVars(NULL);
+                }
+                */
+            }
+        }
+    }
+    #endif
+}
+
+void CState::RandomizePresetVars()
+{
+    m_rand_preset = D3DXVECTOR4(FRAND, FRAND, FRAND, FRAND);
+
+    int k = 0;
+    do
+    {
+        for (int i=0; i<4; i++) 
+        {
+            float xlate_mult = 1;//(j==0) ? 1 : 0;
+            float rot_mult = 0.9f*powf(k/8.0f, 3.2f);
+            m_xlate[k].x = (FRAND*2-1)*xlate_mult;
+            m_xlate[k].y = (FRAND*2-1)*xlate_mult;
+            m_xlate[k].z = (FRAND*2-1)*xlate_mult;
+            m_rot_base[k].x = FRAND*6.28f;
+            m_rot_base[k].y = FRAND*6.28f;
+            m_rot_base[k].z = FRAND*6.28f;
+            m_rot_speed[k].x = (FRAND*2-1)*rot_mult;
+            m_rot_speed[k].y = (FRAND*2-1)*rot_mult;
+            m_rot_speed[k].z = (FRAND*2-1)*rot_mult;
+            k++;
+        }
+    }
+    while (k < sizeof(m_xlate)/sizeof(m_xlate[0]));
+}
+
+CBlendableFloat::CBlendableFloat()
+{
+	m_bBlending  = false;
+}
+
+CBlendableFloat::~CBlendableFloat()
+{
+}
+
+//--------------------------------------------------------------------------------
+
+float CBlendableFloat::eval(float fTime)
+{
+	if (fTime < 0)
+	{
+		return val;
+	}
+
+	if (m_bBlending && (fTime > m_fBlendStartTime + m_fBlendDuration) || (fTime < m_fBlendStartTime))
+	{
+		m_bBlending = false;
+	}
+
+	if (!m_bBlending)
+	{
+		return val;
+	}
+	else
+	{
+		float mix = (fTime - m_fBlendStartTime) / m_fBlendDuration;
+		return (m_fBlendFrom*(1.0f - mix) + val*mix);
+	}
+}
+
+//--------------------------------------------------------------------------------
+
+void CBlendableFloat::StartBlendFrom(CBlendableFloat *f_from, float fAnimTime, float fDuration)
+{
+	if (fDuration < 0.001f)
+		return;
+
+	m_fBlendFrom		= f_from->eval(fAnimTime);
+	m_bBlending			= true;
+	m_fBlendStartTime	= fAnimTime;
+	m_fBlendDuration	= fDuration;
+}
\ No newline at end of file
-- 
cgit