Merge

--HG--
branch : trunk

1 files changed, 1864 insertions, 0 deletions

diff --git a/externals/g3dlite/G3D.lib/source/System.cpp b/externals/g3dlite/G3D.lib/source/System.cpp
new file mode 100644
index 00000000000..748e13257f1
--- /dev/null
+++ b/externals/g3dlite/G3D.lib/source/System.cpp
@@ -0,0 +1,1864 @@
+/** 
+  @file System.cpp
+ 
+  @maintainer Morgan McGuire, matrix@graphics3d.com
+
+  Note: every routine must call init() first.
+
+  There are two kinds of detection used in this file.  At compile
+  time, the _MSC_VER #define is used to determine whether x86 assembly
+  can be used at all.  At runtime, processor detection is used to
+  determine if we can safely call the routines that use that assembly.
+
+  @cite Rob Wyatt http://www.gamasutra.com/features/wyatts_world/19990709/processor_detection_01.htm
+  @cite Benjamin Jurke http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-ProcessorDetectionClass&forum=cotd&id=-1
+  @cite Michael Herf http://www.stereopsis.com/memcpy.html
+
+  @created 2003-01-25
+  @edited  2008-09-02
+ */
+
+#include "G3D/platform.h"
+#include "G3D/System.h"
+#include "G3D/debug.h"
+#include "G3D/fileutils.h"
+#include "G3D/TextOutput.h"
+#include "G3D/G3DGameUnits.h"
+#include "G3D/Crypto.h"
+#include "G3D/prompt.h"
+#include "G3D/Log.h"
+#include <time.h>
+
+#include <cstring>
+#include <cstdio>
+
+// Uncomment the following line to turn off G3D::System memory
+// allocation and use the operating system's malloc.
+//#define NO_BUFFERPOOL
+
+#if defined(__i386__) || defined(__x86_64__) || defined(G3D_WIN32)
+#    define G3D_NOT_OSX_PPC
+#endif
+
+#ifdef G3D_WIN32
+
+#   include <conio.h>
+#   include <sys/timeb.h>
+#   include "G3D/RegistryUtil.h"
+
+#elif defined(G3D_LINUX) 
+
+    #include <stdlib.h>
+    #include <stdio.h>
+    #include <errno.h>
+    #include <sys/types.h>
+    #include <sys/select.h>
+    #include <termios.h>
+    #include <unistd.h>
+    #include <sys/ioctl.h>
+    #include <sys/time.h>
+    #include <pthread.h>
+
+#elif defined(G3D_OSX)
+
+    #include <stdlib.h>
+    #include <stdio.h>
+    #include <errno.h>
+    #include <sys/types.h>
+	#include <sys/sysctl.h>
+    #include <sys/select.h>
+    #include <sys/time.h>
+    #include <termios.h>
+    #include <unistd.h>
+    #include <pthread.h>
+	#include <mach-o/arch.h>
+
+    #include <sstream>
+    #include <CoreServices/CoreServices.h>
+#endif
+
+#if defined(SSE)
+    #include <xmmintrin.h>
+#endif
+
+namespace G3D {
+
+struct CpuInfo
+{
+public:
+    int     m_cpuSpeed;
+    bool    m_hasCPUID;
+    bool    m_hasRDTSC;
+    bool    m_hasMMX;
+    bool    m_hasSSE;
+    bool    m_hasSSE2;
+    bool    m_hasSSE3;
+    bool    m_has3DNOW;
+    char    m_cpuVendorStr[1024];
+};
+
+// helper macro to call cpuid functions and return all values
+#ifdef _MSC_VER
+
+    // VC on Intel
+#   define CALL_CPUID(func, areg, breg, creg, dreg) \
+	   __asm mov	eax, func   \
+	   __asm cpuid             \
+       __asm mov	areg, eax   \
+       __asm mov	breg, ebx   \
+	   __asm mov	creg, ecx   \
+	   __asm mov	dreg, edx
+
+#elif defined(__GNUC__) && defined(G3D_OSX_INTEL)
+    // GCC on OS X intel
+#    define CALL_CPUID(func, areg, breg, creg, dreg) \
+       areg = 0;   \
+       breg = 0;   \
+       creg = 0;   \
+       dreg = 0;
+#else
+    // Any other compiler/platform, likely GCC
+#   define CALL_CPUID(func, areg, breg, creg, dreg) \
+       __asm__ (           \
+       "cpuid \n":         \
+       "=a" (areg),        \
+       "=b" (breg),        \
+       "=c" (creg),        \
+       "=d" (dreg):        \
+       "a" (func)          \
+       );
+#endif
+
+// this holds the data directory set by the application (currently GApp) for use by findDataFile
+static char                                     g_appDataDir[FILENAME_MAX] = "";
+
+static CpuInfo                                  g_cpuInfo = {
+    0, false, false, false, false, false, false, false, {'U', 'n', 'k', 'n', 'o', 'w', 'n', '\0'}};
+
+static G3DEndian                                _machineEndian      = G3D_LITTLE_ENDIAN;
+static char                                     _cpuArchCstr[1024];
+static char                                     _operatingSystemCstr[1024];
+
+#ifdef G3D_WIN32
+/** Used by getTick() for timing */
+static LARGE_INTEGER                            _start;
+static LARGE_INTEGER                            _counterFrequency;
+#else
+static struct timeval                           _start;
+#endif
+
+static char                                     versionCstr[1024];
+System::OutOfMemoryCallback                     System::outOfMemoryCallback = NULL;
+
+#ifdef G3D_OSX
+long											System::m_OSXCPUSpeed;
+double											System::m_secondsPerNS;
+#endif
+
+/** The Real-World time of System::getTick() time 0.  Set by initTime */
+static RealTime             realWorldGetTickTime0;
+
+
+static unsigned int      maxSupportedCPUIDLevel = 0;
+static unsigned int      maxSupportedExtendedLevel = 0;
+
+/** Checks if the CPUID command is available on the processor (called from init) */
+static void checkForCPUID();
+
+/** ReadRead the standard processor extensions.  Called from init(). */
+static void getStandardProcessorExtensions();
+
+/** Called from init */
+static void initTime();
+
+
+std::string System::findDataFile
+(const std::string&  full,
+ bool                errorIfNotFound) {
+
+    if (fileExists(full)) {
+        return full;
+    }
+
+    std::string initialAppDataDir(g_appDataDir);
+
+    std::string name = filenameBaseExt(full);
+    std::string originalPath = filenamePath(full);
+
+    // Search several paths
+    Array<std::string> pathBase;
+
+    int backlen = 4;
+
+    // add what should be the current working directory
+    pathBase.append("");
+
+    // add application specified data directory to be searched first
+    pathBase.append(initialAppDataDir);
+
+    // try walking back along the directory tree
+    std::string prev = "";
+    for (int i = 0; i < backlen; ++i) {
+        pathBase.append(originalPath + prev);
+        prev = prev + "../";        
+    }
+
+    prev = "../";
+    for (int i = 0; i < backlen; ++i) {
+        pathBase.append(prev);
+        prev = prev + "../";        
+    }
+
+    // Hard-code in likely install directories
+    int ver = G3D_VER;
+    std::string lname = format("G3D-%d.%02d", ver / 10000, (ver / 100) % 100);
+
+    if (G3D_VER % 100 != 0) {
+        lname = lname + format("-b%02d/", ver % 100);
+    } else {
+        lname = lname + "/";
+    }
+
+    // Look in some other likely places
+#   ifdef G3D_WIN32
+        std::string lpath = "libraries/G3D/";
+        pathBase.append(std::string("c:/") + lpath);
+        pathBase.append(std::string("d:/") + lpath);
+        pathBase.append(std::string("e:/") + lpath);
+        pathBase.append(std::string("f:/") + lpath);
+        pathBase.append(std::string("g:/") + lpath);
+        pathBase.append(std::string("x:/") + lpath);
+#   endif
+#   if defined(G3D_LINUX)
+        pathBase.append("/usr/local/");
+        pathBase.append("/course/cs224/");
+        pathBase.append("/map/gfx0/common/games/");
+#   endif
+#   if defined(G3D_FREEBSD)
+        pathBase.append("/usr/local/");
+        pathBase.append("/usr/local/371/");
+        pathBase.append("/usr/cs-local/371/");
+#   endif
+#   if defined(G3D_OSX)
+        pathBase.append("/usr/local/" + lname);
+        pathBase.append("/Volumes/McGuire/Projects/");
+#   endif
+
+    // Add the library name to all variations
+    int N = pathBase.size();
+    for (int i = 0; i < N; ++i) {
+        pathBase.append(pathBase[i] + lname);
+        pathBase.append(pathBase[i] + "G3D/");
+    }
+
+    Array<std::string> subDir;
+    subDir.append("", "font/", "sky/", "gui/");
+    subDir.append("image/", "quake2/", "quake2/players/");
+    subDir.append("quake3/", "SuperShader/", "ifs/", "3ds/");
+    subDir.append("quake2/speedway/");
+
+    Array<std::string> path;
+    for (int p = 0; p < pathBase.size(); ++p) {
+        for (int s = 0; s < subDir.size(); ++s) {
+            path.append(pathBase[p] + subDir[s]);
+            path.append(pathBase[p] + "data/" + subDir[s]);
+            path.append(pathBase[p] + "data-files/" + subDir[s]);
+        }
+    }
+
+    for (int i = 0; i < path.length(); ++i) {
+        std::string filename = path[i] + name;
+        if (fileExists(filename)) {
+            logPrintf("\nWARNING: Could not find '%s' so '%s' "
+                      "was substituted.\n", full.c_str(), 
+                      filename.c_str());
+            return filename;
+        }
+    }
+
+    if (errorIfNotFound) {
+        // Generate an error message
+        std::string locations;
+        for (int i = 0; i < path.size(); ++i) {
+            locations += path[i] + name + "\n";
+        }
+        alwaysAssertM(false, "Could not find '" + full + "' in:\n" + locations);
+    }
+    // Not found
+    return "";
+}
+
+
+void System::setAppDataDir(const std::string& path) {
+    // just copy the path, it needs to be valid
+    strncpy(g_appDataDir, path.c_str(), sizeof(g_appDataDir));
+}
+
+
+std::string demoFindData(bool errorIfNotFound) {
+    // Directories that might contain the data
+    Array<std::string> potential;
+
+    // Look back up the directory tree
+    std::string x = "../";
+    std::string f = "";
+    for (int i = 0; i < 6; ++i) {
+        potential.append(f);
+        f = f + x;
+    }
+    
+    // Hard-code in likely install directories
+    int ver = G3D_VER;
+    std::string lname = format("G3D-%d.%02d", ver / 10000, (ver / 100) % 100);
+
+    if (G3D_VER % 100 != 0) {
+        lname = lname + format("-b%02d/", ver % 100);
+    } else {
+        lname = lname + "/";
+    }
+
+    std::string lpath = "libraries/" + lname;
+    #ifdef G3D_WIN32
+        potential.append(std::string("c:/") + lpath);
+        potential.append(std::string("d:/") + lpath);
+        potential.append(std::string("e:/") + lpath);
+        potential.append(std::string("f:/") + lpath);
+        potential.append(std::string("g:/") + lpath);
+        potential.append(std::string("x:/") + lpath);
+    #elif defined(G3D_LINUX)
+        potential.append("/usr/local/" + lname);
+        potential.append("/course/cs224/");
+        potential.append("/map/gfx0/common/games/");
+    #elif defined(G3D_FREEBSD)
+        potential.append("/usr/local/" + lname);
+	potential.append("/usr/local/371/")
+	potential.append("/usr/cs-local/371/")
+    #elif defined(G3D_OSX)
+        potential.append("/usr/local/" + lname);
+        potential.append("/Volumes/McGuire/Projects/");
+        potential.append("/Volumes/McGuire/Projects/G3D/");
+    #endif
+
+    // Scan all potentials for the font directory
+    for (int p = 0; p < potential.size();  ++p) {
+        std::string path = potential[p];
+        //debugPrintf("Looking at: %sdata\n", path.c_str());
+        if (fileExists(path + "data") && fileExists(path + "data/font")) {
+            return path + "data/";
+        }
+        if (fileExists(path + "data-files") && fileExists(path + "data-files/font")) {
+            return path + "data-files/";
+        }
+    }
+
+    if (errorIfNotFound) {
+        const char* choice[] = {"Exit"};
+
+        prompt("Demo Error", "The demo could not locate the data directory.  "
+            "The data is required to run this demo.  If you have not downloaded "
+            "the data zipfile, get it from http://g3d-cpp.sf.net.  If you have "
+            "downloaded it, it needs to be no more than 4 directories above the "
+            "demo directory.", choice, 1, true);
+    }
+
+    return "";
+}
+
+bool System::hasCPUID() {
+    init();
+    return g_cpuInfo.m_hasCPUID;
+}
+
+bool System::hasRDTSC() {
+    init();
+    return g_cpuInfo.m_hasRDTSC;
+}
+
+
+bool System::hasSSE() {
+    init();
+    return g_cpuInfo.m_hasSSE;
+}
+
+
+bool System::hasSSE2() {
+    init();
+    return g_cpuInfo.m_hasSSE2;
+}
+
+bool System::hasSSE3() {
+	init();
+    return g_cpuInfo.m_hasSSE3;
+}
+
+bool System::hasMMX() {
+    init();
+    return g_cpuInfo.m_hasMMX;
+}
+
+
+bool System::has3DNow() {
+    init();
+    return g_cpuInfo.m_has3DNOW;
+}
+
+
+const std::string& System::cpuVendor() {
+    init();
+    static const std::string _cpuVendor = g_cpuInfo.m_cpuVendorStr;
+    return _cpuVendor;
+}
+
+
+G3DEndian System::machineEndian() {
+    init();
+    return _machineEndian;
+}
+
+const std::string& System::operatingSystem() {
+    init();
+    static const std::string _operatingSystem =_operatingSystemCstr;
+    return _operatingSystem;
+}
+        
+
+const std::string& System::cpuArchitecture() {
+    init();
+    static const std::string _cpuArch = _cpuArchCstr;
+    return _cpuArch;
+}
+
+const std::string& System::build() {
+    const static std::string b =
+#   ifdef _DEBUG
+        "Debug";
+#   else 
+        "Release";
+#   endif
+
+    return b;
+}
+
+const std::string& System::version() {
+    init();
+
+    static const std::string _version = versionCstr;
+    return _version;
+}
+
+
+void System::init() {
+    // Cannot use most G3D data structures or utility functions in here because
+    // they are not initialized.
+
+    static bool initialized = false;
+
+    if (initialized) {
+        return;
+    }
+
+    initialized = true;
+
+    if ((G3D_VER % 100) != 0) {
+        sprintf(versionCstr, "G3D %d.%02d beta %d",
+            G3D_VER / 10000,
+            (G3D_VER / 100) % 100,
+            G3D_VER % 100);
+    } else {
+        sprintf(versionCstr, "G3D %d.%02d",
+            G3D_VER / 10000,
+            (G3D_VER / 100) % 100);
+    }
+
+    // First of all we check if the CPUID command is available
+    checkForCPUID();
+
+    // Figure out if this machine is little or big endian.
+    {
+        int32 a = 1;
+        if (*(uint8*)&a == 1) {
+            _machineEndian = G3D_LITTLE_ENDIAN;
+        } else {
+            _machineEndian = G3D_BIG_ENDIAN;
+        }
+    }
+
+#   ifdef G3D_NOT_OSX_PPC
+    // Process the CPUID information
+    if (g_cpuInfo.m_hasCPUID) {
+        // We read the standard CPUID level 0x00000000 which should
+        // be available on every x86 processor.  This fills out
+        // a string with the processor vendor tag.
+        unsigned int eaxreg = 0, ebxreg = 0, ecxreg = 0, edxreg = 0;
+
+        CALL_CPUID(0x00, eaxreg, ebxreg, ecxreg, edxreg);
+
+        // Then we connect the single register values to the vendor string
+        *((unsigned int*) g_cpuInfo.m_cpuVendorStr)         = ebxreg;
+        *((unsigned int*) (g_cpuInfo.m_cpuVendorStr + 4))   = edxreg;
+        *((unsigned int*) (g_cpuInfo.m_cpuVendorStr + 8))   = ecxreg;
+        g_cpuInfo.m_cpuVendorStr[12] = '\0';
+
+        // We can also read the max. supported standard CPUID level
+        maxSupportedCPUIDLevel = eaxreg & 0xFFFF;
+
+        // Then we read the ext. CPUID level 0x80000000
+        CALL_CPUID(0x80000000, eaxreg, ebxreg, ecxreg, edxreg);
+
+        // ...to check the max. supported extended CPUID level
+        maxSupportedExtendedLevel = eaxreg;
+
+        // Then we switch to the specific processor vendors.
+        // Fill out _cpuArch based on this information.  It will
+        // be overwritten by the next block of code on Windows,
+        // but on Linux will stand.
+        switch (ebxreg) {
+        case 0x756E6547:        // GenuineIntel
+            strcpy(_cpuArchCstr, "Intel Processor");
+            break;
+            
+        case 0x68747541:        // AuthenticAMD
+            strcpy(_cpuArchCstr, "AMD Processor");
+            break;
+
+        case 0x69727943:        // CyrixInstead
+            strcpy(_cpuArchCstr, "Cyrix Processor");
+            break;
+
+        default:
+            strcpy(_cpuArchCstr, "Unknown Processor Vendor");
+            break;
+        }
+    }
+    #endif // G3D_NOT_OSX_PPC
+
+    #ifdef G3D_WIN32
+        bool success = RegistryUtil::readInt32
+            ("HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", "~MHz", g_cpuInfo.m_cpuSpeed);
+
+        SYSTEM_INFO systemInfo;
+        GetSystemInfo(&systemInfo);
+        char* arch;
+        switch (systemInfo.wProcessorArchitecture) {
+        case PROCESSOR_ARCHITECTURE_INTEL:
+            arch = "Intel";
+            break;
+    
+        case PROCESSOR_ARCHITECTURE_MIPS:
+            arch = "MIPS";
+            break;
+
+        case PROCESSOR_ARCHITECTURE_ALPHA:
+            arch = "Alpha";
+            break;
+
+        case PROCESSOR_ARCHITECTURE_PPC:
+            arch = "Power PC";
+            break;
+
+        default:
+            arch = "Unknown";
+        }
+
+        uint32 maxAddr = (uint32)systemInfo.lpMaximumApplicationAddress;
+        sprintf(_cpuArchCstr, "%d x %d-bit %s processor",
+                    systemInfo.dwNumberOfProcessors,
+                    (int)(::log((double)maxAddr) / ::log(2.0) + 2.0),
+                    arch);
+                   //                    _CPUSpeed / (1024.0 * 1024));
+
+        OSVERSIONINFO osVersionInfo;
+        osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+        success = GetVersionEx(&osVersionInfo) != 0;
+
+        if (success) {
+            sprintf(_operatingSystemCstr, "Windows %d.%d build %d Platform %d %s",
+                osVersionInfo.dwMajorVersion, 
+                osVersionInfo.dwMinorVersion,
+                osVersionInfo.dwBuildNumber,
+                osVersionInfo.dwPlatformId,
+                osVersionInfo.szCSDVersion);
+        } else {
+            strcpy(_operatingSystemCstr, "Windows");
+        }
+    
+    #elif defined(G3D_LINUX)
+
+        {
+            // Shell out to the 'uname' command
+            FILE* f = popen("uname -a", "r");
+
+            int len = 100;
+            char* r = (char*)::malloc(len * sizeof(char));
+            fgets(r, len, f);
+            // Remove trailing newline
+            if (r[strlen(r) - 1] == '\n') {
+                r[strlen(r) - 1] = '\0';
+            }
+            fclose(f);
+
+            strcpy(_operatingSystemCstr, r);
+            ::free(r);
+        }
+
+    #elif defined(G3D_OSX)
+
+        // Operating System:
+        SInt32 macVersion;
+        Gestalt(gestaltSystemVersion, &macVersion);
+
+        int major = (macVersion >> 8) & 0xFF;
+        int minor = (macVersion >> 4) & 0xF;
+        int revision = macVersion & 0xF;
+
+        sprintf(_operatingSystemCstr, "OS X %x.%x.%x", major, minor, revision); 
+                 
+        // Clock Cycle Timing Information:
+        Gestalt('pclk', &System::m_OSXCPUSpeed);
+        g_cpuInfo.m_cpuSpeed = iRound((double)m_OSXCPUSpeed / (1024 * 1024));
+        m_secondsPerNS = 1.0 / 1.0e9;
+        
+        // System Architecture:
+	const NXArchInfo* pInfo = NXGetLocalArchInfo();
+		
+	if (pInfo) {
+	    strcpy(_cpuArchCstr, pInfo->description);
+			
+	    switch (pInfo->cputype) {
+	    case CPU_TYPE_POWERPC:
+	        switch(pInfo->cpusubtype){
+		case CPU_SUBTYPE_POWERPC_750:
+		case CPU_SUBTYPE_POWERPC_7400:
+		case CPU_SUBTYPE_POWERPC_7450:
+		    strcpy(g_cpuInfo.m_cpuVendorStr, "Motorola");
+		    break;
+		case CPU_SUBTYPE_POWERPC_970:
+		    strcpy(g_cpuInfo.m_cpuVendorStr, "IBM");
+		    break;
+		}
+		break;
+	    
+	        case CPU_TYPE_I386:
+		    strcpy(g_cpuInfo.m_cpuVendorStr, "Intel");
+		    break;
+	    }
+	}
+    #endif
+
+    initTime();
+
+    getStandardProcessorExtensions();
+}
+
+static void checkForCPUID() {
+    unsigned int bitChanged = 0;
+
+    // We've to check if we can toggle the flag register bit 21.
+    // If we can't the processor does not support the CPUID command.
+    
+#if defined(_MSC_VER)
+    __asm {
+        push eax
+        push ebx
+        pushfd
+        pushfd
+        pop   eax
+        mov   ebx, eax
+        xor   eax, 0x00200000 
+        push  eax
+        popfd
+        pushfd
+        pop   eax
+        popfd
+        xor   eax, ebx 
+        mov   bitChanged, eax
+        pop ebx
+        pop eax
+    }
+#elif defined(__GNUC__) && defined(i386) && !defined(G3D_OSX_INTEL)
+    // 32-bit g++
+    __asm__ (
+        "pushfl                      # Get original EFLAGS             \n"
+        "pushfl                                                        \n"
+        "popl    %%eax                                                 \n"
+        "movl    %%eax, %%ecx                                          \n"
+        "xorl    $0x200000, %%eax    # Flip ID bit in EFLAGS           \n"
+        "pushl   %%eax               # Save new EFLAGS value on stack  \n"
+        "popfl                       # Replace current EFLAGS value    \n"
+        "pushfl                      # Get new EFLAGS                  \n"
+        "popl    %%eax               # Store new EFLAGS in EAX         \n"
+        "popfl                                                         \n"
+        "xorl    %%ecx, %%eax        # Can not toggle ID bit,          \n"
+        "movl    %%eax, %0           # We have CPUID support           \n"
+        : "=m" (bitChanged)
+        : // No inputs
+        : "%eax", "%ecx"
+    );
+#elif defined(__GNUC__) && defined(__x86_64__) && !defined(G3D_OSX_INTEL)
+    // x86_64 has SSE and CPUID
+
+    bitChanged = 1;
+#else 
+    // Unknown architecture
+    bitChanged = 0;
+#endif
+
+    g_cpuInfo.m_hasCPUID = ((bitChanged == 0) ? false : true);
+}
+
+void getStandardProcessorExtensions() {
+#if !defined(G3D_OSX) || defined(G3D_OSX_INTEL)
+    if (! g_cpuInfo.m_hasCPUID) {
+        return;
+    }
+
+    unsigned int eaxreg = 0, ebxreg = 0, ecxreg = 0;
+    unsigned int features = 0;
+
+    // http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/25481.pdf
+    // call cpuid with function 0x01 in EAX
+
+    // Invoking CPUID with '1' in EAX fills out edx with a bit string.
+    // The bits of this value indicate the presence or absence of 
+    // useful processor features.
+    CALL_CPUID(0x01, eaxreg, ebxreg, ecxreg, features);
+
+    #define checkBit(var, bit)   ((var & (1 << bit)) ? true : false)
+
+    g_cpuInfo.m_hasRDTSC    = checkBit(features, 16);
+    g_cpuInfo.m_hasMMX      = checkBit(features, 23);
+    g_cpuInfo.m_hasSSE      = checkBit(features, 25);
+    g_cpuInfo.m_hasSSE2     = checkBit(features, 26);
+    g_cpuInfo.m_hasSSE3     = checkBit(ecxreg, 0);
+
+    if (maxSupportedExtendedLevel >= 0x80000001) {
+        // function 0x80000001 changes bit 31 of edx to 3dnow support flag
+        CALL_CPUID(0x80000001, eaxreg, ebxreg, ecxreg, features);
+        g_cpuInfo.m_has3DNOW = checkBit(features, 31);
+    } else {
+        g_cpuInfo.m_has3DNOW = false;
+    }
+
+    #undef checkBit
+#endif
+}
+
+#if defined(SSE)
+
+// Copy in 128 bytes chunks, where each chunk contains 8*float32x4 = 8 * 4 * 4 bytes = 128 bytes
+//
+//
+void memcpySSE2(void* dst, const void* src, int nbytes) {
+    int remainingBytes = nbytes;
+
+    if (nbytes > 128) {
+
+        // Number of chunks
+        int N = nbytes / 128;
+
+        float* restrict d = (float*)dst;
+        const float* restrict s = (const float*)src;
+    
+        // Finish when the destination pointer has moved 8N elements 
+        float* stop = d + (N * 8 * 4);
+
+        while (d < stop) {
+            // Inner loop unrolled 8 times
+            const __m128 r0 = _mm_loadu_ps(s);
+            const __m128 r1 = _mm_loadu_ps(s + 4);
+            const __m128 r2 = _mm_loadu_ps(s + 8);
+            const __m128 r3 = _mm_loadu_ps(s + 12);
+            const __m128 r4 = _mm_loadu_ps(s + 16);
+            const __m128 r5 = _mm_loadu_ps(s + 20);
+            const __m128 r6 = _mm_loadu_ps(s + 24);
+            const __m128 r7 = _mm_loadu_ps(s + 28);
+
+            _mm_storeu_ps(d, r0);
+            _mm_storeu_ps(d + 4, r1);
+            _mm_storeu_ps(d + 8, r2);
+            _mm_storeu_ps(d + 12, r3);
+            _mm_storeu_ps(d + 16, r4);
+            _mm_storeu_ps(d + 20, r5);
+            _mm_storeu_ps(d + 24, r6);
+            _mm_storeu_ps(d + 28, r7);
+
+            s += 32;
+            d += 32;
+        }
+
+        remainingBytes -= N * 8 * 4 * 4; 
+    }
+
+    if (remainingBytes > 0) {
+        // Memcpy the rest
+        memcpy((uint8*)dst + (nbytes - remainingBytes), (const uint8*)src + (nbytes - remainingBytes), remainingBytes); 
+    }
+}
+#else
+
+    // Fall back to memcpy
+    void memcpySSE2(void *dst, const void *src, int nbytes) {
+        memcpy(dst, src, nbytes);
+    }
+
+#endif
+
+#if defined(G3D_WIN32) && defined(SSE)
+/** Michael Herf's fast memcpy */
+void memcpyMMX(void* dst, const void* src, int nbytes) {
+    int remainingBytes = nbytes;
+
+    if (nbytes > 64) {
+            _asm {
+                    mov esi, src 
+                    mov edi, dst 
+                    mov ecx, nbytes 
+                    shr ecx, 6 // 64 bytes per iteration 
+
+    loop1: 
+                    movq mm1,  0[ESI] // Read in source data 
+                    movq mm2,  8[ESI]
+                    movq mm3, 16[ESI]
+                    movq mm4, 24[ESI] 
+                    movq mm5, 32[ESI]
+                    movq mm6, 40[ESI]
+                    movq mm7, 48[ESI]
+                    movq mm0, 56[ESI]
+
+                    movntq  0[EDI], mm1 // Non-temporal stores 
+                    movntq  8[EDI], mm2 
+                    movntq 16[EDI], mm3 
+                    movntq 24[EDI], mm4 
+                    movntq 32[EDI], mm5 
+                    movntq 40[EDI], mm6 
+                    movntq 48[EDI], mm7 
+                    movntq 56[EDI], mm0 
+
+                    add esi, 64 
+                    add edi, 64 
+                    dec ecx 
+                    jnz loop1 
+
+                    emms
+            }
+            remainingBytes -= ((nbytes >> 6) << 6); 
+    }
+
+    if (remainingBytes > 0) {
+        // Memcpy the rest
+        memcpy((uint8*)dst + (nbytes - remainingBytes), (const uint8*)src + (nbytes - remainingBytes), remainingBytes); 
+    }
+}
+
+#else
+    // Fall back to memcpy
+    void memcpyMMX(void *dst, const void *src, int nbytes) {
+        memcpy(dst, src, nbytes);
+    }
+
+#endif
+
+
+void System::memcpy(void* dst, const void* src, size_t numBytes) {
+    if (System::hasSSE2() && System::hasMMX()) {
+        G3D::memcpyMMX(dst, src, numBytes);
+    } else if (System::hasSSE() && System::hasMMX()) {
+        G3D::memcpyMMX(dst, src, numBytes);
+    } else {
+        ::memcpy(dst, src, numBytes);
+    }
+}
+
+
+/** Michael Herf's fastest memset. n32 must be filled with the same
+    character repeated. */
+#if defined(G3D_WIN32) && defined(SSE)
+
+// On x86 processors, use MMX
+void memfill(void *dst, int n32, unsigned long i) {
+
+    int originalSize = i;
+    int bytesRemaining = i;
+
+    if (i > 16) {
+        
+        bytesRemaining = i % 16;
+        i -= bytesRemaining;
+                __asm {
+                        movq mm0, n32
+                        punpckldq mm0, mm0
+                        mov edi, dst
+
+                loopwrite:
+
+                        movntq 0[edi], mm0
+                        movntq 8[edi], mm0
+
+                        add edi, 16
+                        sub i, 16
+                        jg loopwrite
+
+                        emms
+                }
+    }
+
+    if (bytesRemaining > 0) {
+        ::memset((uint8*)dst + (originalSize - bytesRemaining), n32, bytesRemaining); 
+    }
+}
+
+#else
+
+// For non x86 processors, we fall back to the standard memset
+void memfill(void *dst, int n32, unsigned long i) {
+    ::memset(dst, n32, i);
+}
+
+#endif
+
+
+void System::memset(void* dst, uint8 value, size_t numBytes) {
+    if (System::hasSSE() && System::hasMMX()) {
+        uint32 v = value;
+        v = v + (v << 8) + (v << 16) + (v << 24); 
+        G3D::memfill(dst, v, numBytes);
+    } else {
+        ::memset(dst, value, numBytes);
+    }
+}
+
+
+std::string& System::appName() {
+    static std::string n = filenameBase(currentProgramFilename());
+    return n;
+}
+
+
+std::string System::currentProgramFilename() {
+    char filename[2048];
+
+    #ifdef G3D_WIN32
+    {
+        GetModuleFileNameA(NULL, filename, sizeof(filename));
+    } 
+    #else
+    {
+            int ret = readlink("/proc/self/exe", filename, sizeof(filename));
+            
+            // In case of an error, leave the handling up to the caller
+        if (ret == -1) {
+                    return "";
+        }
+            
+        debugAssert((int)sizeof(filename) > ret);
+            
+            // Ensure proper NULL termination
+            filename[ret] = 0;      
+    }
+    #endif
+
+    return filename;
+}
+
+
+void System::sleep(RealTime t) {
+
+    // Overhead of calling this function.
+    static const RealTime OVERHEAD = .000006;
+
+    RealTime now = time();
+    RealTime wakeupTime = now + t - OVERHEAD;
+
+    RealTime remainingTime = wakeupTime - now;
+    RealTime sleepTime = 0;
+
+    while (remainingTime > 0) {
+        
+
+        if (remainingTime > 0.001) {
+            // Safe to use Sleep with a time... sleep for half the remaining time
+            sleepTime = max(remainingTime * .5, 0.0005);
+        } else if (remainingTime > 0.0001) {
+            // Safe to use Sleep with a zero time;
+            // causes the program to yield only
+            // the current time slice, and then return.
+            sleepTime = 0;
+        } else {
+            // Not safe to use Sleep; busy wait
+            sleepTime = -1;
+        }
+
+        if (sleepTime >= 0) {
+            #ifdef G3D_WIN32
+                // Translate to milliseconds
+                Sleep((int)(sleepTime * 1e3));
+            #else
+                // Translate to microseconds
+                usleep((int)(sleepTime * 1e6));
+            #endif
+        }
+
+        now = time();
+        remainingTime = wakeupTime - now;
+    }
+}
+
+
+void System::consoleClearScreen() {
+    #ifdef G3D_WIN32
+        system("cls");
+    #else
+        system("clear");
+    #endif
+}
+
+
+bool System::consoleKeyPressed() {
+    #ifdef G3D_WIN32
+    
+        return _kbhit() != 0;
+
+    #else
+    
+        static const int STDIN = 0;
+        static bool initialized = false;
+
+        if (! initialized) {
+            // Use termios to turn off line buffering
+            termios term;
+            tcgetattr(STDIN, &term);
+            term.c_lflag &= ~ICANON;
+            tcsetattr(STDIN, TCSANOW, &term);
+            setbuf(stdin, NULL);
+            initialized = true;
+        }
+
+        #ifdef G3D_LINUX
+
+            int bytesWaiting;
+            ioctl(STDIN, FIONREAD, &bytesWaiting);
+            return bytesWaiting;
+
+        #else
+
+            timeval timeout;
+            fd_set rdset;
+
+            FD_ZERO(&rdset);
+            FD_SET(STDIN, &rdset);
+            timeout.tv_sec  = 0;
+            timeout.tv_usec = 0;
+
+            return select(STDIN + 1, &rdset, NULL, NULL, &timeout);
+        #endif
+    #endif
+}
+
+
+int System::consoleReadKey() {
+    #ifdef G3D_WIN32
+        return _getch();
+    #else
+        char c;
+        read(0, &c, 1);
+        return c;
+    #endif
+}
+
+
+void initTime() {
+    #ifdef G3D_WIN32
+        if (QueryPerformanceFrequency(&_counterFrequency)) {
+            QueryPerformanceCounter(&_start);
+        }
+
+        struct _timeb t;
+        _ftime(&t);
+
+        realWorldGetTickTime0 = (RealTime)t.time - t.timezone * G3D::MINUTE + (t.dstflag ? G3D::HOUR : 0);
+
+    #else
+        gettimeofday(&_start, NULL);
+        // "sse" = "seconds since epoch".  The time
+        // function returns the seconds since the epoch
+        // GMT (perhaps more correctly called UTC). 
+        time_t gmt = time(NULL);
+        
+        // No call to free or delete is needed, but subsequent
+        // calls to asctime, ctime, mktime, etc. might overwrite
+        // local_time_vals. 
+        tm* localTimeVals = localtime(&gmt);
+    
+        time_t local = gmt;
+        
+        if (localTimeVals) {
+            // tm_gmtoff is already corrected for daylight savings.
+            local = local + localTimeVals->tm_gmtoff;
+        }
+        
+        realWorldGetTickTime0 = local;
+    #endif
+}
+
+
+RealTime System::time() { 
+    init();
+    #ifdef G3D_WIN32
+        LARGE_INTEGER now;
+        QueryPerformanceCounter(&now);
+
+        return ((RealTime)(now.QuadPart - _start.QuadPart) /
+                _counterFrequency.QuadPart) + realWorldGetTickTime0;
+    #else
+        // Linux resolution defaults to 100Hz.
+        // There is no need to do a separate RDTSC call as gettimeofday
+        // actually uses RDTSC when on systems that support it, otherwise
+        // it uses the system clock.
+        struct timeval now;
+        gettimeofday(&now, NULL);
+
+        return (now.tv_sec  - _start.tv_sec) +
+               (now.tv_usec - _start.tv_usec) / 1e6
+			    + realWorldGetTickTime0;
+    #endif
+}
+
+
+////////////////////////////////////////////////////////////////
+
+#define REALPTR_TO_USERPTR(x)   ((uint8*)(x) + sizeof (void *))
+#define USERPTR_TO_REALPTR(x)   ((uint8*)(x) - sizeof (void *))
+#define REALBLOCK_SIZE(x)       ((x) + sizeof (void *))
+
+class BufferPool {
+public:
+
+    /** Only store buffers up to these sizes (in bytes) in each pool->
+        Different pools have different management strategies.
+
+        A large block is preallocated for tiny buffers; they are used with
+        tremendous frequency.  Other buffers are allocated as demanded.
+        Tiny buffers are 128 bytes long because that seems to align well with
+        cache sizes on many machines.
+      */
+    enum {tinyBufferSize = 128, smallBufferSize = 1024, medBufferSize = 4096};
+
+    /** 
+       Most buffers we're allowed to store.
+       128000 * 128  = 16 MB (preallocated)
+         2048 * 1024 =  2 MB (allocated on demand)
+         1024 * 4096 =  4 MB (allocated on demand)
+     */
+    enum {maxTinyBuffers = 128000, maxSmallBuffers = 2048, maxMedBuffers = 1024};
+
+private:
+
+    class MemBlock {
+    public:
+        void*           ptr;
+        size_t          bytes;
+
+        inline MemBlock() : ptr(NULL), bytes(0) {}
+        inline MemBlock(void* p, size_t b) : ptr(p), bytes(b) {}
+    };
+
+    MemBlock smallPool[maxSmallBuffers];
+    int smallPoolSize;
+
+    MemBlock medPool[maxMedBuffers];
+    int medPoolSize;
+
+    /** The tiny pool is a single block of storage into which all tiny
+        objects are allocated.  This provides better locality for
+        small objects and avoids the search time, since all tiny
+        blocks are exactly the same size. */
+    void* tinyPool[maxTinyBuffers];
+    int tinyPoolSize;
+
+    /** Pointer to the data in the tiny pool */
+    void* tinyHeap;
+
+#   ifdef G3D_WIN32
+    CRITICAL_SECTION    mutex;
+#   else
+    pthread_mutex_t     mutex;
+#   endif
+
+    /** Provide synchronization between threads */
+    void lock() {
+#       ifdef G3D_WIN32
+            EnterCriticalSection(&mutex);
+#       else
+            pthread_mutex_lock(&mutex);
+#       endif
+    }
+
+    void unlock() {
+#       ifdef G3D_WIN32
+            LeaveCriticalSection(&mutex);
+#       else
+            pthread_mutex_unlock(&mutex);
+#       endif
+    }
+
+    /** 
+     Malloc out of the tiny heap. Returns NULL if allocation failed.
+     */
+    inline void* tinyMalloc(size_t bytes) {
+        // Note that we ignore the actual byte size
+        // and create a constant size block.
+        (void)bytes;
+        assert(tinyBufferSize >= bytes);
+
+        void* ptr = NULL;
+
+        if (tinyPoolSize > 0) {
+            --tinyPoolSize;
+
+            // Return the old last pointer from the freelist
+            ptr = tinyPool[tinyPoolSize];
+
+#           ifdef G3D_DEBUG
+                if (tinyPoolSize > 0) {
+                    assert(tinyPool[tinyPoolSize - 1] != ptr); 
+                     //   "System::malloc heap corruption detected: "
+                     //   "the last two pointers on the freelist are identical (during tinyMalloc).");
+                }
+#           endif
+
+            // NULL out the entry to help detect corruption
+            tinyPool[tinyPoolSize] = NULL;
+        }
+
+        return ptr;
+    }
+
+    /** Returns true if this is a pointer into the tiny heap. */
+    bool inTinyHeap(void* ptr) {
+        return 
+            (ptr >= tinyHeap) && 
+            (ptr < (uint8*)tinyHeap + maxTinyBuffers * tinyBufferSize);
+    }
+
+    void tinyFree(void* ptr) {
+        assert(ptr);
+        assert(tinyPoolSize < maxTinyBuffers);
+ //           "Tried to free a tiny pool buffer when the tiny pool freelist is full.");
+
+#       ifdef G3D_DEBUG
+            if (tinyPoolSize > 0) {
+                void* prevOnHeap = tinyPool[tinyPoolSize - 1];
+                assert(prevOnHeap != ptr); 
+//                    "System::malloc heap corruption detected: "
+//                    "the last two pointers on the freelist are identical (during tinyFree).");
+            }
+#       endif
+
+        assert(tinyPool[tinyPoolSize] == NULL);
+
+        // Put the pointer back into the free list
+        tinyPool[tinyPoolSize] = ptr;
+        ++tinyPoolSize;
+
+    }
+
+    void flushPool(MemBlock* pool, int& poolSize) {
+        for (int i = 0; i < poolSize; ++i) {
+            ::free(pool[i].ptr);
+            pool[i].ptr = NULL;
+            pool[i].bytes = 0;
+        }
+        poolSize = 0;
+    }
+
+
+    /**  Allocate out of a specific pool->  Return NULL if no suitable 
+         memory was found. 
+    
+         */
+    void* malloc(MemBlock* pool, int& poolSize, size_t bytes) {
+
+        // OPT: find the smallest block that satisfies the request.
+
+        // See if there's something we can use in the buffer pool->
+        // Search backwards since usually we'll re-use the last one.
+        for (int i = (int)poolSize - 1; i >= 0; --i) {
+            if (pool[i].bytes >= bytes) {
+                // We found a suitable entry in the pool->
+
+                // No need to offset the pointer; it is already offset
+                void* ptr = pool[i].ptr;
+
+                // Remove this element from the pool
+                --poolSize;
+                pool[i] = pool[poolSize];
+
+                return ptr;
+            }
+        }
+
+        return NULL;
+    }
+
+public:
+
+    /** Count of memory allocations that have occurred. */
+    int totalMallocs;
+    int mallocsFromTinyPool;
+    int mallocsFromSmallPool;
+    int mallocsFromMedPool;
+
+    /** Amount of memory currently allocated (according to the application). 
+        This does not count the memory still remaining in the buffer pool,
+        but does count extra memory required for rounding off to the size
+        of a buffer.
+        Primarily useful for detecting leaks.*/
+    // TODO: make me an atomic int!
+    volatile int bytesAllocated;
+
+    BufferPool() {
+        totalMallocs         = 0;
+
+        mallocsFromTinyPool  = 0;
+        mallocsFromSmallPool = 0;
+        mallocsFromMedPool   = 0;
+
+        bytesAllocated       = true;
+
+        tinyPoolSize         = 0;
+        tinyHeap             = NULL;
+
+        smallPoolSize        = 0;
+
+        medPoolSize          = 0;
+
+
+        // Initialize the tiny heap as a bunch of pointers into one
+        // pre-allocated buffer.
+        tinyHeap = ::malloc(maxTinyBuffers * tinyBufferSize);
+        for (int i = 0; i < maxTinyBuffers; ++i) {
+            tinyPool[i] = (uint8*)tinyHeap + (tinyBufferSize * i);
+        }
+        tinyPoolSize = maxTinyBuffers;
+
+#       ifdef G3D_WIN32
+            InitializeCriticalSection(&mutex);
+#       else
+            pthread_mutex_init(&mutex, NULL);
+#       endif
+    }
+
+
+    ~BufferPool() {
+        ::free(tinyHeap);
+#       ifdef G3D_WIN32
+            DeleteCriticalSection(&mutex);
+#       else
+            // No destruction on pthreads
+#       endif
+    }
+
+    
+    void* realloc(void* ptr, size_t bytes) {
+        if (ptr == NULL) {
+            return malloc(bytes);
+        }
+
+        if (inTinyHeap(ptr)) {
+            if (bytes <= tinyBufferSize) {
+                // The old pointer actually had enough space.
+                return ptr;
+            } else {
+                // Free the old pointer and malloc
+                
+                void* newPtr = malloc(bytes);
+                System::memcpy(newPtr, ptr, tinyBufferSize);
+                tinyFree(ptr);
+                return newPtr;
+
+            }
+        } else {
+            // In one of our heaps.
+
+            // See how big the block really was
+            size_t realSize = *(uint32*)USERPTR_TO_REALPTR(ptr);
+            if (bytes <= realSize) {
+                // The old block was big enough.
+                return ptr;
+            }
+
+            // Need to reallocate
+            void* newPtr = malloc(bytes);
+            System::memcpy(newPtr, ptr, realSize);
+            free(ptr);
+            return newPtr;
+        }
+    }
+
+
+    void* malloc(size_t bytes) {
+        lock();
+        ++totalMallocs;
+
+        if (bytes <= tinyBufferSize) {
+
+            void* ptr = tinyMalloc(bytes);
+
+            if (ptr) {
+                ++mallocsFromTinyPool;
+                unlock();
+                return ptr;
+            }
+
+        } 
+        
+        // Failure to allocate a tiny buffer is allowed to flow
+        // through to a small buffer
+        if (bytes <= smallBufferSize) {
+            
+            void* ptr = malloc(smallPool, smallPoolSize, bytes);
+
+            if (ptr) {
+                ++mallocsFromSmallPool;
+                unlock();
+                return ptr;
+            }
+
+        } else if (bytes <= medBufferSize) {
+            // Note that a small allocation failure does *not* fall
+            // through into a medium allocation because that would
+            // waste the medium buffer's resources.
+
+            void* ptr = malloc(medPool, medPoolSize, bytes);
+
+            if (ptr) {
+                ++mallocsFromMedPool;
+                unlock();
+                debugAssertM(ptr != NULL, "BufferPool::malloc returned NULL");
+                return ptr;
+            }
+        }
+
+        bytesAllocated += REALBLOCK_SIZE(bytes);
+        unlock();
+
+        // Heap allocate
+
+        // Allocate 4 extra bytes for our size header (unfortunate,
+        // since malloc already added its own header).
+        void* ptr = ::malloc(REALBLOCK_SIZE(bytes));
+
+        if (ptr == NULL) {
+            // Flush memory pools to try and recover space
+            flushPool(smallPool, smallPoolSize);
+            flushPool(medPool, medPoolSize);
+            ptr = ::malloc(REALBLOCK_SIZE(bytes));
+        }
+
+        if (ptr == NULL) {
+            if ((System::outOfMemoryCallback != NULL) &&
+                (System::outOfMemoryCallback(REALBLOCK_SIZE(bytes), true) == true)) {
+                // Re-attempt the malloc
+                ptr = ::malloc(REALBLOCK_SIZE(bytes));
+            }
+        }
+
+        if (ptr == NULL) {
+            if (System::outOfMemoryCallback != NULL) {
+                // Notify the application
+                System::outOfMemoryCallback(REALBLOCK_SIZE(bytes), false);
+            }
+#           ifdef G3D_DEBUG
+                debugPrintf("::malloc(%d) returned NULL\n", REALBLOCK_SIZE(bytes));
+#           endif
+            debugAssertM(ptr != NULL, 
+                         "::malloc returned NULL. Either the "
+                         "operating system is out of memory or the "
+                         "heap is corrupt.");
+            return NULL;
+        }
+
+        *(uint32*)ptr = bytes;
+
+        return REALPTR_TO_USERPTR(ptr);
+    }
+
+
+    void free(void* ptr) {
+        if (ptr == NULL) {
+            // Free does nothing on null pointers
+            return;
+        }
+
+        assert(isValidPointer(ptr));
+
+        if (inTinyHeap(ptr)) {
+            lock();
+            tinyFree(ptr);
+            unlock();
+            return;
+        }
+
+        uint32 bytes = *(uint32*)USERPTR_TO_REALPTR(ptr);
+
+        lock();
+        if (bytes <= smallBufferSize) {
+            if (smallPoolSize < maxSmallBuffers) {
+                smallPool[smallPoolSize] = MemBlock(ptr, bytes);
+                ++smallPoolSize;
+                unlock();
+                return;
+            }
+        } else if (bytes <= medBufferSize) {
+            if (medPoolSize < maxMedBuffers) {
+                medPool[medPoolSize] = MemBlock(ptr, bytes);
+                ++medPoolSize;
+                unlock();
+                return;
+            }
+        }
+        bytesAllocated -= REALBLOCK_SIZE(bytes);
+        unlock();
+
+        // Free; the buffer pools are full or this is too big to store.
+        ::free(USERPTR_TO_REALPTR(ptr));
+    }
+
+    std::string performance() const {
+        if (totalMallocs > 0) {
+            int pooled = mallocsFromTinyPool +
+                         mallocsFromSmallPool + 
+                         mallocsFromMedPool;
+
+            int total = totalMallocs;
+
+            return format("malloc performance: %5.1f%% <= %db, %5.1f%% <= %db, "
+                          "%5.1f%% <= %db, %5.1f%% > %db",
+                          100.0 * mallocsFromTinyPool  / total,
+                          BufferPool::tinyBufferSize,
+                          100.0 * mallocsFromSmallPool / total,
+                          BufferPool::smallBufferSize,
+                          100.0 * mallocsFromMedPool   / total,
+                          BufferPool::medBufferSize,
+                          100.0 * (1.0 - (double)pooled / total),
+                          BufferPool::medBufferSize);
+        } else {
+            return "No System::malloc calls made yet.";
+        }
+    }
+
+    std::string status() const {
+        return format("preallocated shared buffers: %5d/%d x %db",
+            maxTinyBuffers - tinyPoolSize, maxTinyBuffers, tinyBufferSize);
+    }
+};
+
+// Dynamically allocated because we need to ensure that
+// the buffer pool is still around when the last global variable 
+// is deallocated.
+static BufferPool* bufferpool = NULL;
+
+std::string System::mallocPerformance() {    
+#ifndef NO_BUFFERPOOL
+    return bufferpool->performance();
+#else
+	return "NO_BUFFERPOOL";
+#endif
+}
+
+std::string System::mallocStatus() {    
+#ifndef NO_BUFFERPOOL
+    return bufferpool->status();
+#else
+	return "NO_BUFFERPOOL";
+#endif
+}
+
+
+void System::resetMallocPerformanceCounters() {
+#ifndef NO_BUFFERPOOL
+    bufferpool->totalMallocs         = 0;
+    bufferpool->mallocsFromMedPool   = 0;
+    bufferpool->mallocsFromSmallPool = 0;
+    bufferpool->mallocsFromTinyPool  = 0;
+#endif
+}
+
+
+#ifndef NO_BUFFERPOOL
+inline void initMem() {
+    // Putting the test here ensures that the system is always
+    // initialized, even when globals are being allocated.
+    static bool initialized = false;
+    if (! initialized) {
+        bufferpool = new BufferPool();
+        initialized = true;
+    }
+}
+#endif
+
+
+void* System::malloc(size_t bytes) {
+#ifndef NO_BUFFERPOOL
+    initMem();
+    return bufferpool->malloc(bytes);
+#else
+    return ::malloc(bytes);
+#endif
+}
+
+void* System::calloc(size_t n, size_t x) {
+#ifndef NO_BUFFERPOOL
+    void* b = System::malloc(n * x);
+    debugAssertM(b != NULL, "System::malloc returned NULL");
+    debugAssertM(isValidHeapPointer(b), "System::malloc returned an invalid pointer");
+    System::memset(b, 0, n * x);
+    return b;
+#else
+    return ::calloc(n, x);
+#endif
+}
+
+
+void* System::realloc(void* block, size_t bytes) {
+#ifndef NO_BUFFERPOOL
+    initMem();
+    return bufferpool->realloc(block, bytes);
+#else
+	return ::realloc(block, bytes);
+#endif
+}
+
+
+void System::free(void* p) {
+#ifndef NO_BUFFERPOOL
+    bufferpool->free(p);
+#else
+	return ::free(p);
+#endif
+}
+
+
+void* System::alignedMalloc(size_t bytes, size_t alignment) {
+
+    alwaysAssertM(isPow2(alignment), "alignment must be a power of 2");
+
+    // We must align to at least a word boundary.
+    alignment = iMax(alignment, sizeof(void *));
+
+    // Pad the allocation size with the alignment size and the
+    // size of the redirect pointer.
+    size_t totalBytes = bytes + alignment + sizeof(void*);
+
+    size_t truePtr = (size_t)System::malloc(totalBytes);
+
+    if (truePtr == 0) {
+        // malloc returned NULL
+        return NULL;
+    }
+
+    debugAssert(isValidHeapPointer((void*)truePtr));
+    #ifdef G3D_WIN32
+    // The blocks we return will not be valid Win32 debug heap
+    // pointers because they are offset 
+    //  debugAssert(_CrtIsValidPointer((void*)truePtr, totalBytes, TRUE) );
+    #endif
+
+    // The return pointer will be the next aligned location (we must at least
+    // leave space for the redirect pointer, however).
+    size_t  alignedPtr = truePtr + sizeof(void*);
+
+    // 2^n - 1 has the form 1111... in binary.
+    uint32 bitMask = (alignment - 1);
+
+    // Advance forward until we reach an aligned location.
+    while ((alignedPtr & bitMask) != 0) {
+        alignedPtr += sizeof(void*);
+    }
+
+    debugAssert(alignedPtr - truePtr + bytes <= totalBytes);
+
+    // Immediately before the aligned location, write the true array location
+    // so that we can free it correctly.
+    size_t* redirectPtr = (size_t *)(alignedPtr - sizeof(void *));
+    redirectPtr[0] = truePtr;
+
+    debugAssert(isValidHeapPointer((void*)truePtr));
+
+    #ifdef G3D_WIN32
+        debugAssert( _CrtIsValidPointer((void*)alignedPtr, bytes, TRUE) );
+    #endif
+    return (void *)alignedPtr;
+}
+
+
+void System::alignedFree(void* _ptr) {
+    if (_ptr == NULL) {
+        return;
+    }
+
+    size_t alignedPtr = (size_t)_ptr;
+
+    // Back up one word from the pointer the user passed in.
+    // We now have a pointer to a pointer to the true start
+    // of the memory block.
+    size_t* redirectPtr = (size_t*)(alignedPtr - sizeof(void *));
+
+    // Dereference that pointer so that ptr = true start
+    void* truePtr = (void*)redirectPtr[0];
+
+    debugAssert(isValidHeapPointer((void*)truePtr));
+    System::free(truePtr);
+}
+
+
+void System::setEnv(const std::string& name, const std::string& value) {
+    std::string cmd = name + "=" + value;
+#   ifdef G3D_WIN32
+        _putenv(cmd.c_str());
+#   else
+        // Many linux implementations of putenv expect char*
+        putenv(const_cast<char*>(cmd.c_str()));
+#   endif
+}
+
+const char* System::getEnv(const std::string& name) {
+    return getenv(name.c_str());
+}
+
+static void var(TextOutput& t, const std::string& name, const std::string& val) {
+    t.writeSymbols(name,"=");
+    t.writeString(val);
+    t.writeNewline();
+}
+
+
+static void var(TextOutput& t, const std::string& name, const bool val) {
+    t.writeSymbols(name, "=", val ? "Yes" : "No");
+    t.writeNewline();
+}
+
+
+static void var(TextOutput& t, const std::string& name, const int val) {
+    t.writeSymbols(name,"=");
+    t.writeNumber(val);
+    t.writeNewline();
+}
+
+void System::describeSystem(
+    std::string&        s) {
+
+    TextOutput t;
+    describeSystem(t);
+    t.commitString(s);
+}
+
+void System::describeSystem(
+    TextOutput& t) {
+
+    t.writeSymbols("App", "{");
+    t.writeNewline();
+    t.pushIndent();
+        var(t, "Name", System::currentProgramFilename());
+        char cwd[1024];
+        getcwd(cwd, 1024);
+        var(t, "cwd", std::string(cwd));
+    t.popIndent();
+    t.writeSymbols("}");
+    t.writeNewline();
+    t.writeNewline();
+
+    t.writeSymbols("OS", "{");
+    t.writeNewline();
+    t.pushIndent();
+        var(t, "Name", System::operatingSystem());
+    t.popIndent();
+    t.writeSymbols("}");
+    t.writeNewline();
+    t.writeNewline();
+
+    t.writeSymbols("CPU", "{");
+    t.writeNewline();
+    t.pushIndent();
+        var(t, "Vendor", System::cpuVendor());
+        var(t, "Architecture", System::cpuArchitecture());
+        var(t, "hasCPUID", System::hasCPUID());
+        var(t, "hasMMX", System::hasMMX());
+        var(t, "hasSSE", System::hasSSE());
+        var(t, "hasSSE2", System::hasSSE2());
+        var(t, "hasSSE3", System::hasSSE3());
+        var(t, "has3DNow", System::has3DNow());
+        var(t, "hasRDTSC", System::hasRDTSC());
+    t.popIndent();
+    t.writeSymbols("}");
+    t.writeNewline();
+    t.writeNewline();
+       
+    t.writeSymbols("G3D", "{");
+    t.writeNewline();
+    t.pushIndent();
+        var(t, "Link version", G3D_VER);
+        var(t, "Compile version", System::version());
+    t.popIndent();
+    t.writeSymbols("}");
+    t.writeNewline();
+    t.writeNewline();
+}
+
+
+int System::cpuSpeedMHz() {
+    return g_cpuInfo.m_cpuSpeed;
+}
+
+
+void System::setClipboardText(const std::string& s) {
+#   ifdef G3D_WIN32
+        if (OpenClipboard(NULL)) {
+            HGLOBAL hMem = GlobalAlloc(GHND | GMEM_DDESHARE, s.size() + 1);
+            if (hMem) {
+                char *pMem = (char*)GlobalLock(hMem);
+                strcpy(pMem, s.c_str());
+                GlobalUnlock(hMem);
+
+                EmptyClipboard();
+                SetClipboardData(CF_TEXT, hMem);
+            }
+
+            CloseClipboard();
+            GlobalFree(hMem);
+        }
+#   endif
+}
+
+
+std::string System::getClipboardText() {
+    std::string s;
+
+#   ifdef G3D_WIN32
+        if (OpenClipboard(NULL)) {
+            HANDLE h = GetClipboardData(CF_TEXT);
+
+            if (h) {
+                char* temp = (char*)GlobalLock(h);
+                if (temp) {
+    	            s = temp;
+                }
+                temp = NULL;
+                GlobalUnlock(h);
+            }
+            CloseClipboard();
+        }
+#   endif
+    return s;
+}
+
+
+std::string System::currentDateString() {
+    time_t t1;
+    ::time(&t1);
+    tm* t = localtime(&t1);
+    return format("%d-%02d-%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday); 
+}
+
+
+}  // namespace