diff --git a/3d-viewer/3d_cache/3d_cache.cpp b/3d-viewer/3d_cache/3d_cache.cpp
new file mode 100644
index 0000000000..96cd8c39d2
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_cache.cpp
@@ -0,0 +1,622 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <string>
+#include <utility>
+
+#include <wx/filename.h>
+#include <wx/utils.h>
+#include <wx/stdpaths.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include "md5.h"
+#include "3d_cache.h"
+#include "3d_info.h"
+#include "sg/scenegraph.h"
+#include "3d_filename_resolver.h"
+#include "3d_plugin_manager.h"
+#include "sg/ifsg_api.h"
+
+
+#define CACHE_CONFIG_NAME wxT( "cache.cfg" )
+
+
+
+static const wxString md5ToWXString( const unsigned char* aMD5Sum )
+{
+    unsigned char uc;
+    unsigned char tmp;
+    char          md5[33];
+    int           j = 0;
+
+    for( int i = 0; i < 16; ++i )
+    {
+        uc = aMD5Sum[i];
+        tmp = uc / 16;
+
+        if( tmp > 9 )
+            tmp += 87;
+        else
+            tmp += 48;
+
+        md5[j++] = tmp;
+        tmp = uc % 16;
+
+        if( tmp > 9 )
+            tmp += 87;
+        else
+            tmp += 48;
+
+        md5[j++] = tmp;
+    }
+
+    md5[j] = 0;
+
+    return wxString::FromUTF8Unchecked( md5 );
+}
+
+
+static bool md5matches( const unsigned char* md5a, const unsigned char* md5b )
+{
+    for( int i = 0; i < 16; ++i )
+    {
+        if( md5a[i] != md5b[i] )
+            return false;
+    }
+
+    return true;
+}
+
+
+static bool isMD5null( const unsigned char* aMD5Sum )
+{
+    if( NULL == aMD5Sum )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL passed for aMD5Sum\n";
+        return false;
+    }
+
+    for( int i = 0; i < 16; ++i )
+    {
+        if( 0 != aMD5Sum[i] )
+            return false;
+    }
+
+    return true;
+}
+
+
+class S3D_CACHE_ENTRY
+{
+private:
+    // prohibit assignment and default copy constructor
+    S3D_CACHE_ENTRY( const S3D_CACHE_ENTRY& source );
+    S3D_CACHE_ENTRY& operator=( const S3D_CACHE_ENTRY& source );
+
+    wxString m_CacheBaseName;  // base name of cache file (an MD5 sum)
+
+public:
+    S3D_CACHE_ENTRY();
+    ~S3D_CACHE_ENTRY();
+
+    void SetMD5( const unsigned char* aMD5Sum );
+    const wxString GetCacheBaseName( void );
+
+    unsigned char md5sum[16];
+    SCENEGRAPH* sceneData;
+};
+
+
+S3D_CACHE_ENTRY::S3D_CACHE_ENTRY()
+{
+    sceneData = NULL;
+    memset( md5sum, 0, 16 );
+}
+
+
+S3D_CACHE_ENTRY::~S3D_CACHE_ENTRY()
+{
+    if( NULL != sceneData )
+        delete sceneData;
+}
+
+
+void S3D_CACHE_ENTRY::SetMD5( const unsigned char* aMD5Sum )
+{
+    if( NULL == aMD5Sum )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL passed for aMD5Sum\n";
+        return;
+    }
+
+    memcpy( md5sum, aMD5Sum, 16 );
+    return;
+}
+
+
+const wxString S3D_CACHE_ENTRY::GetCacheBaseName( void )
+{
+    if( m_CacheBaseName.empty() )
+        m_CacheBaseName = md5ToWXString( md5sum );
+
+    return m_CacheBaseName;
+}
+
+
+S3D_CACHE::S3D_CACHE()
+{
+    m_DirtyCache = false;
+    m_FNResolver = new S3D_FILENAME_RESOLVER;
+    m_Plugins = new S3D_PLUGIN_MANAGER;
+
+    return;
+}
+
+S3D_CACHE::~S3D_CACHE()
+{
+    FlushCache();
+
+    if( m_FNResolver )
+        delete m_FNResolver;
+
+    if( m_Plugins )
+        delete m_Plugins;
+
+    return;
+}
+
+
+SCENEGRAPH* S3D_CACHE::Load( const wxString& aModelFile )
+{
+    wxString full3Dpath = m_FNResolver->ResolvePath( aModelFile );
+
+    if( full3Dpath.empty() )
+    {
+        // the model cannot be found; we cannot proceed
+        std::cout << " * [3D model] could not find model '";
+        std::cout << aModelFile.ToUTF8() << "'\n";
+        return NULL;
+    }
+
+    // check cache if file is already loaded
+    std::map< wxString, S3D_CACHE_ENTRY*, S3D::rsort_wxString >::iterator mi;
+    mi = m_CacheMap.find( full3Dpath );
+
+    if( mi != m_CacheMap.end() )
+        return mi->second->sceneData;
+
+    // a cache item does not exist; search the Filename->Cachename map
+    return checkCache( full3Dpath );
+}
+
+
+SCENEGRAPH* S3D_CACHE::checkCache( const wxString& aFileName )
+{
+    unsigned char md5sum[16];
+
+    if( !getMD5( aFileName, md5sum ) || m_CacheDir.empty() )
+    {
+        // just in case we can't get an MD5 sum (for example, on access issues)
+        // or we do not have a configured cache file directory, we create an
+        // entry to prevent further attempts at loading the file
+        S3D_CACHE_ENTRY* ep = new S3D_CACHE_ENTRY;
+        m_CacheList.push_back( ep );
+
+        if( m_CacheMap.insert( std::pair< wxString, S3D_CACHE_ENTRY* >
+            ( aFileName, ep ) ).second == false )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] duplicate entry in map file; key = ";
+            std::cerr << aFileName.ToUTF8() << "\n";
+            m_CacheList.pop_back();
+            delete ep;
+        }
+        else
+        {
+            std::cerr << " * [3D Model] [0] added cached name '" << aFileName.ToUTF8() << "'\n";
+        }
+
+        return NULL;
+    }
+
+    S3D_CACHE_ENTRY* ep = new S3D_CACHE_ENTRY;
+    m_CacheList.push_back( ep );
+
+    if( m_CacheMap.insert( std::pair< wxString, S3D_CACHE_ENTRY* >
+                               ( aFileName, ep ) ).second == false )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] duplicate entry in map file; key = ";
+        std::cerr << aFileName.ToUTF8() << "\n";
+        m_CacheList.pop_back();
+        delete ep;
+        return NULL;
+    }
+    else
+    {
+        std::cerr << " * [3D Model] [1] added cached name '" << aFileName.ToUTF8() << "'\n";
+    }
+
+    ep->SetMD5( md5sum );
+
+    wxString bname = ep->GetCacheBaseName();
+    wxString cachename = m_CacheDir + bname + wxT( ".3dc" );
+
+    if( wxFileName::FileExists( cachename ) )
+    {
+        loadCacheData( ep );
+        return ep->sceneData;
+    }
+
+    ep->sceneData = m_Plugins->Load3DModel( aFileName );
+
+    return ep->sceneData;
+}
+
+
+bool S3D_CACHE::getMD5( const wxString& aFileName, unsigned char* aMD5Sum )
+{
+    if( aFileName.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] empty filename\n";
+        return false;
+    }
+
+    if( NULL == aMD5Sum )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aMD5Sum\n";
+        return false;
+    }
+
+    FILE* fp = fopen( aFileName.ToUTF8(), "rb" );
+
+    if( !fp )
+    {
+        std::cerr << " * [3dmodel] could not open file '" << aFileName.ToUTF8() << "'\n";
+        return false;
+    }
+
+    struct md5_ctx msum;
+    md5_init_ctx( &msum );
+    int res = md5_stream( fp, aMD5Sum );
+    fclose( fp );
+
+    if( 0 != res )
+    {
+        std::cerr << " * [3dmodel] md5 calculation failed on file '" << aFileName.ToUTF8() << "'\n";
+        return false;
+    }
+
+    return true;
+}
+
+
+bool S3D_CACHE::loadCacheData( S3D_CACHE_ENTRY* aCacheItem )
+{
+    wxString bname = aCacheItem->GetCacheBaseName();
+
+    if( bname.empty() )
+    {
+        std::cerr << " * [3D model] cannot load cached model; no md5 hash available\n";
+        return false;
+    }
+
+    if( m_CacheDir.empty() )
+    {
+        std::cerr << " * [3D model] cannot load cached model; config directory unknown\n";
+        return false;
+    }
+
+    wxString fname = m_CacheDir + bname + wxT( ".3dc" );
+
+    // determine if the file exists and is a regular file
+    struct stat info;
+
+    if( stat( fname.ToUTF8(), &info ) )
+        return false;
+
+    if( !S_ISREG( info.st_mode ) )
+    {
+        std::cerr << " * [3D model] path exists but is not a regular file: '";
+        std::cerr << fname.ToUTF8() << "'\n";
+        return false;
+    }
+
+#warning NOT IMPLEMENTED
+    // XXX - proceed with loading the cache data
+    return false;
+}
+
+
+bool S3D_CACHE::saveCacheData( S3D_CACHE_ENTRY* aCacheItem )
+{
+    if( NULL == aCacheItem )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * NULL passed for aCacheItem\n";
+        return false;
+    }
+
+    if( NULL == aCacheItem->sceneData )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * aCacheItem has no valid scene data\n";
+        return false;
+    }
+
+    wxString bname = aCacheItem->GetCacheBaseName();
+
+    if( bname.empty() )
+    {
+        std::cerr << " * [3D model] cannot load cached model; no md5 hash available\n";
+        return false;
+    }
+
+    if( m_CacheDir.empty() )
+    {
+        std::cerr << " * [3D model] cannot load cached model; config directory unknown\n";
+        return false;
+    }
+
+    wxString fname = m_CacheDir + bname + wxT( ".3dc" );
+
+    if( wxFileName::Exists( fname ) )
+    {
+        // determine if the file is a regular file
+        struct stat info;
+
+        if( stat( fname.ToUTF8(), &info ) )
+            return false;
+
+        if( !S_ISREG( info.st_mode ) )
+        {
+            std::cerr << " * [3D model] path exists but is not a regular file: '";
+            std::cerr << fname.ToUTF8() << "'\n";
+            return false;
+        }
+
+        // the file already exists on disk; just exit
+        return true;
+    }
+
+#warning NOT IMPLEMENTED
+    // XXX - proceed with saving the cache data
+    return false;
+
+}
+
+
+bool S3D_CACHE::Set3DConfigDir( const wxString& aConfigDir )
+{
+    if( !m_ConfigDir.empty() )
+        return false;
+
+    wxFileName cfgdir( aConfigDir, "" );
+    cfgdir.Normalize();
+
+    if( cfgdir.DirExists() )
+    {
+        m_ConfigDir = cfgdir.GetPath();
+
+        // inform the file resolver of the config directory
+        if( !m_FNResolver->Set3DConfigDir( m_ConfigDir ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * could not set 3D Config Directory on filename resolver\n";
+            std::cerr << " * config directory: '" << m_ConfigDir.ToUTF8() << "'\n";
+        }
+
+        cfgdir.AppendDir( wxT( "cache" ) );
+
+        if( !cfgdir.DirExists() )
+        {
+            cfgdir.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
+
+            if( !cfgdir.DirExists() )
+            {
+                std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+                std::cerr << " * failed to create 3D cache directory\n";
+                std::cerr << " * cache directory: '";
+                std::cerr << cfgdir.GetPath().ToUTF8() << "'\n";
+                return false;
+            }
+        }
+
+        m_CacheDir = cfgdir.GetPathWithSep();
+        return true;
+    }
+
+    return false;
+}
+
+
+wxString S3D_CACHE::Get3DConfigDir( bool createDefault )
+{
+    if( !m_ConfigDir.empty() || !createDefault )
+        return m_ConfigDir;
+
+    // note: duplicated from common/common.cpp GetKicadConfigPath() to avoid
+    // code coupling; ideally the instantiating code should call
+    // Set3DConfigDir() to set the directory rather than relying on this
+    // directory remaining the same in future KiCad releases.
+    wxFileName cfgpath;
+
+    // From the wxWidgets wxStandardPaths::GetUserConfigDir() help:
+    //      Unix: ~ (the home directory)
+    //      Windows: "C:\Documents and Settings\username\Application Data"
+    //      Mac: ~/Library/Preferences
+    cfgpath.AssignDir( wxStandardPaths::Get().GetUserConfigDir() );
+
+#if !defined( __WINDOWS__ ) && !defined( __WXMAC__ )
+    wxString envstr;
+
+    if( !wxGetEnv( wxT( "XDG_CONFIG_HOME" ), &envstr ) || envstr.IsEmpty() )
+    {
+        // XDG_CONFIG_HOME is not set, so use the fallback
+        cfgpath.AppendDir( wxT( ".config" ) );
+    }
+    else
+    {
+        // Override the assignment above with XDG_CONFIG_HOME
+        cfgpath.AssignDir( envstr );
+    }
+#endif
+
+    cfgpath.AppendDir( wxT( "kicad" ) );
+    cfgpath.AppendDir( wxT( "3d" ) );
+
+    if( !cfgpath.DirExists() )
+    {
+        cfgpath.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
+    }
+
+    if( !cfgpath.DirExists() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * failed to create 3D configuration directory\n";
+        return wxT( "" );
+    }
+
+    if( Set3DConfigDir( cfgpath.GetPath() ) )
+        return m_ConfigDir;
+
+    return wxEmptyString;
+}
+
+
+bool S3D_CACHE::SetProjectDir( const wxString& aProjDir )
+{
+    bool hasChanged = false;
+
+    if( m_FNResolver->SetProjectDir( aProjDir, &hasChanged ) && hasChanged )
+    {
+        m_CacheMap.clear();
+
+        std::list< S3D_CACHE_ENTRY* >::iterator sL = m_CacheList.begin();
+        std::list< S3D_CACHE_ENTRY* >::iterator eL = m_CacheList.end();
+
+        while( sL != eL )
+        {
+            delete *sL;
+            ++sL;
+        }
+
+        m_CacheList.clear();
+
+        return true;
+    }
+
+    return false;
+}
+
+
+wxString S3D_CACHE::GetProjectDir( void )
+{
+    return m_FNResolver->GetProjectDir();
+}
+
+
+S3D_FILENAME_RESOLVER* S3D_CACHE::GetResolver( void )
+{
+    return m_FNResolver;
+}
+
+
+std::list< wxString > const* S3D_CACHE::GetFileFilters( void ) const
+{
+    return m_Plugins->GetFileFilters();
+}
+
+
+void S3D_CACHE::FlushCache( void )
+{
+    std::list< S3D_CACHE_ENTRY* >::iterator sCL = m_CacheList.begin();
+    std::list< S3D_CACHE_ENTRY* >::iterator eCL = m_CacheList.end();
+
+    while( sCL != eCL )
+    {
+        delete *sCL;
+        ++sCL;
+    }
+
+    m_CacheList.clear();
+    ClosePlugins();
+
+    return;
+}
+
+
+void S3D_CACHE::ClosePlugins( void )
+{
+    if( NULL != m_Plugins )
+        m_Plugins->ClosePlugins();
+
+    return;
+}
+
+// notes:
+// 1. aModelEntry:
+//    + rotation: degrees, model space X, Y, Z; rotations are specified in sequence
+//
+S3DMODEL* S3D_CACHE::Prepare( S3D_INFO const* aModelEntry,
+    const SGPOINT& aRotation, const SGPOINT& aOffset )
+{
+    SCENEGRAPH* sp = Load( aModelEntry->filename );
+
+    if( !sp )
+        return NULL;
+
+    // create a single transform entity to apply to the models
+    glm::dmat4 t0 = glm::translate( glm::dvec3( 25.4 * aModelEntry->offset.x, 25.4 * aModelEntry->offset.y,
+        25.4 * aModelEntry->offset.z ) );
+
+    glm::dmat4 rX = glm::rotate( aModelEntry->rotation.x, glm::dvec3( 1.0, 0.0, 0.0 ) );
+    glm::dmat4 rY = glm::rotate( -aModelEntry->rotation.y, glm::dvec3( 0.0, 1.0, 0.0 ) );
+    glm::dmat4 rZ = glm::rotate( aModelEntry->rotation.z, glm::dvec3( 0.0, 0.0, 1.0 ) );
+
+    glm::dmat4 s0 = glm::scale( glm::dvec3( aModelEntry->scale.x, aModelEntry->scale.y,
+        aModelEntry->scale.z ) );
+
+    glm::dmat4 m0 = rZ * rY * rX * s0 * t0;
+
+    rX = glm::rotate( aRotation.x, glm::dvec3( 1.0, 0.0, 0.0 ) );
+    rY = glm::rotate( aRotation.y, glm::dvec3( 0.0, 1.0, 0.0 ) );
+    rZ = glm::rotate( aRotation.z, glm::dvec3( 0.0, 0.0, 1.0 ) );
+
+    glm::dmat4 t1 = glm::translate( glm::dvec3( aOffset.x, aOffset.y, aOffset.z ) );
+
+    glm::dmat4 m1 = t1 * rZ * rY * rX * m0;
+
+    return S3D::Prepare( sp, &m1 );
+}
diff --git a/3d-viewer/3d_cache/3d_cache.h b/3d-viewer/3d_cache/3d_cache.h
new file mode 100644
index 0000000000..1961a4e16c
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_cache.h
@@ -0,0 +1,214 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_cache.h
+ * defines the display data cache manager for 3D models
+ */
+
+#ifndef CACHE_3D_H
+#define CACHE_3D_H
+
+#include <list>
+#include <map>
+#include <wx/string.h>
+#include "str_rsort.h"
+#include "3d_filename_resolver.h"
+#include "3d_info.h"
+#include <3d_rendering/c3dmodel.h>
+
+
+class  S3D_CACHE;
+class  S3D_CACHE_ENTRY;
+class  SCENEGRAPH;
+class  S3D_FILENAME_RESOLVER;
+class  S3D_PLUGIN_MANAGER;
+struct S3D_INFO;
+
+
+class S3D_CACHE
+{
+private:
+    /// cache entries
+    std::list< S3D_CACHE_ENTRY* > m_CacheList;
+
+    /// mapping of file names to cache names and data
+    std::map< wxString, S3D_CACHE_ENTRY*, S3D::rsort_wxString > m_CacheMap;
+
+    /// object to resolve file names
+    S3D_FILENAME_RESOLVER* m_FNResolver;
+
+    /// plugin manager
+    S3D_PLUGIN_MANAGER* m_Plugins;
+
+    /// set true if the cache needs to be updated
+    bool m_DirtyCache;
+
+    /// 3D cache directory
+    wxString m_CacheDir;
+
+    /// base configuration path for 3D items
+    wxString m_ConfigDir;
+
+    /// current KiCad project dir
+    wxString m_ProjDir;
+
+    /**
+     * Function checkCache
+     * searches the cache list for the given filename and retrieves
+     * the cache data; a cache entry is created if one does not
+     * already exist
+     *
+     * @param aFileName [in] is a partial or full file path; a partial path is accepted
+     * so that a cached model may be used in cases where the user has moved or deleted
+     * the original model file.
+     * @param aModelEntry [in, out] is the model entry for which we are retrieving
+     * scene data.
+     * @param aMD5Sum [in] is an optional MD5 sum; if this parameter is supplied and its value
+     * differs from the cached file then the function will fail and the flag aMD5Mismatch
+     * will be set to true. If the parameter is not supplied then the cache model is used
+     * if available and with no regard to the MD5 sum.
+     * @param aMD5Mismatch [out] if the function succeeds then this flag is set to false;
+     * the flag is set true if aMD5Sum is specified and differs from the cached object's
+     * md5sum.
+     * @return on success a pointer to a SCENEGRAPH, otherwise NULL
+     */
+    SCENEGRAPH* checkCache( const wxString& aFileName );
+
+    /**
+     * Function getMD5
+     * calculates the MD5 hash of the given file
+     *
+     * @param aFileName [in] is a fully qualified path to the model file
+     * @param aMD5Sum [out] is a 16-byte character array to hold the MD5 hash
+     * @return true if the md5 hash was calculated; otherwise false
+     */
+    bool getMD5( const wxString& aFileName, unsigned char* aMD5Sum );
+
+    // load scene data from a cache file
+    bool loadCacheData( S3D_CACHE_ENTRY* aCacheItem );
+
+    // save scene data to a cache file
+    bool saveCacheData( S3D_CACHE_ENTRY* aCacheItem );
+
+public:
+    S3D_CACHE();
+    virtual ~S3D_CACHE();
+
+    /**
+     * Function Set3DConfigDir
+     * Sets the configuration directory to be used by the
+     * model manager for storing 3D model manager configuration
+     * data and the model cache. The config directory may only be
+     * set once in the lifetime of the object.
+     *
+     * @param aConfigDir is the configuration directory to use
+     * for 3D model manager data
+     * @return true on success
+     */
+    bool Set3DConfigDir( const wxString& aConfigDir );
+
+    /**
+     * Function Get3DConfigDir
+     * returns the current 3D configuration directory on
+     * success, otherwise it returns wxEmptyString. If the
+     * directory was not previously set via Set3DConfigDir()
+     * then a default is used which is based on kicad's
+     * configuration directory code as of September 2015.
+     */
+    wxString Get3DConfigDir( bool createDefault = false );
+
+    /**
+     * Function SetProjectDir
+     * sets the current project's working directory; this
+     * affects the model search path
+     */
+    bool SetProjectDir( const wxString& aProjDir );
+
+    /**
+     * Function GetProjectDir
+     * returns the current project's working directory
+     */
+    wxString GetProjectDir( void );
+
+    /**
+     * Function Load
+     * attempts to load the scene data for a model; it will consult the
+     * internal cache list and load from cache if possible before invoking
+     * the load() function of the available plugins.
+     *
+     * @param aModelFile [in] is the partial or full path to the model to be loaded
+     * @return true if the model was successfully loaded, otherwise false.
+     * The model may fail to load if, for example, the plugin does not
+     * support rendering of the 3D model.
+     */
+    SCENEGRAPH* Load( const wxString& aModelFile );
+
+    S3D_FILENAME_RESOLVER* GetResolver( void );
+
+    /**
+     * Function GetFileFilters
+     * returns the list of file filters retrieved from the plugins;
+     * this will contain at least the default "All Files (*.*)|*.*"
+     *
+     * @return a pointer to the filter list
+     */
+    std::list< wxString > const* GetFileFilters( void ) const;
+
+    /**
+     * Function FlushCache
+     * frees all data in the cache and closes all plugins
+     */
+    void FlushCache( void );
+
+    /**
+     * Function ClosePlugins
+     * unloads plugins to free memory
+     */
+    void ClosePlugins( void );
+
+/**
+ * Function Prepare
+ * attempts to load the scene data for a model and to translate it
+ * into an S3D_MODEL structure for display by a renderer
+ *
+ * @param aModelEntry is the structure containing the model name,
+ * scale, offset, and rotation. Note that by kicad convention the
+ * operations are Offset-Scale-Rotation, the Y value of the offset
+ * is negative (Left-hand coordinate system), and the units of the
+ * offset is inches. Application of the Offset, Scale. Rotation
+ * within the aModelEntry structure places the model into a nominal
+ * (0, 0, 0) position and orientation. Final positioning of the
+ * model instance is determined by the aOffset, aAxis, and aAngle
+ * parameters.
+ * @ aRotation is a X, Y, Z rotation to calculate the final orientation
+ * of the model instance
+ * @param aOffset is an offset to apply to obtain the final position
+ * of the model instance; this offset is applied after the aAxis/aAngle
+ * orientation in the common Rotation-Scale-Translation order of transforms.
+ */
+    S3DMODEL* Prepare( S3D_INFO const* aModelEntry,
+        const SGPOINT& aRotation, const SGPOINT& aOffset );
+};
+
+#endif  // CACHE_3D_H
diff --git a/3d-viewer/3d_cache/3d_cache_wrapper.cpp b/3d-viewer/3d_cache/3d_cache_wrapper.cpp
new file mode 100644
index 0000000000..80769d9a5f
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_cache_wrapper.cpp
@@ -0,0 +1,66 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <common.h>
+#include "3d_cache_wrapper.h"
+
+
+CACHE_WRAPPER::CACHE_WRAPPER()
+{
+    return;
+}
+
+
+CACHE_WRAPPER::~CACHE_WRAPPER()
+{
+    return;
+}
+
+
+S3D_CACHE* PROJECT::Get3DCacheManager( bool updateProjDir )
+{
+    CACHE_WRAPPER* cw = (CACHE_WRAPPER*) GetElem( ELEM_3DCACHE );
+    S3D_CACHE* cache = dynamic_cast<S3D_CACHE*>( cw );
+
+    // check that we get the expected type of object or NULL
+    wxASSERT( !cw || cache );
+
+    if( !cw )
+    {
+        cw = new CACHE_WRAPPER;
+        cache = dynamic_cast<S3D_CACHE*>( cw );
+
+        wxFileName cfgpath;
+        cfgpath.AssignDir( GetKicadConfigPath() );
+        cfgpath.AppendDir( wxT( "3d" ) );
+        cache->Set3DConfigDir( cfgpath.GetFullPath() );
+        SetElem( ELEM_3DCACHE, cw );
+        updateProjDir = true;
+    }
+
+    if( updateProjDir )
+        cache->SetProjectDir( GetProjectPath() );
+
+    return cache;
+}
diff --git a/3d-viewer/3d_cache/3d_cache_wrapper.h b/3d-viewer/3d_cache/3d_cache_wrapper.h
new file mode 100644
index 0000000000..60051d21af
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_cache_wrapper.h
@@ -0,0 +1,37 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#ifndef CACHE_WRAPPER_3D_H
+#define CACHE_WRAPPER_3D_H
+
+#include <project.h>
+#include "3d_cache.h"
+
+class CACHE_WRAPPER : public S3D_CACHE, public PROJECT::_ELEM
+{
+public:
+    CACHE_WRAPPER();
+    virtual ~CACHE_WRAPPER();
+};
+
+#endif  // CACHE_WRAPPER_3D_H
diff --git a/3d-viewer/3d_cache/3d_filename_resolver.cpp b/3d-viewer/3d_cache/3d_filename_resolver.cpp
new file mode 100644
index 0000000000..c8ca971e45
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_filename_resolver.cpp
@@ -0,0 +1,457 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <wx/filename.h>
+#include <wx/utils.h>
+
+#include "3d_filename_resolver.h"
+
+#define S3D_RESOLVER_CONFIG wxT( "3Dresolver.cfg" )
+
+
+bool S3D_FILENAME_RESOLVER::Set3DConfigDir( const wxString& aConfigDir )
+{
+    if( aConfigDir.empty() )
+        return false;
+
+    wxFileName cfgdir( aConfigDir, "" );
+    cfgdir.Normalize();
+
+    if( false == cfgdir.DirExists() )
+        return false;
+
+    m_ConfigDir = cfgdir.GetPath();
+    createPathList();
+
+    return true;
+}
+
+
+bool S3D_FILENAME_RESOLVER::SetProjectDir( const wxString& aProjDir, bool* flgChanged )
+{
+    if( aProjDir.empty() )
+        return false;
+
+    wxFileName projdir( aProjDir, "" );
+    projdir.Normalize();
+
+    if( false == projdir.DirExists() )
+        return false;
+
+    wxString path = projdir.GetPath();
+
+    if( flgChanged )
+        *flgChanged = false;
+
+    if( m_Paths.empty() )
+    {
+        m_Paths.push_back( path );
+
+        if( flgChanged )
+            *flgChanged = true;
+
+    }
+    else
+    {
+        if( m_Paths.front().Cmp( path ) )
+        {
+            m_Paths.pop_front();
+            m_Paths.push_front( path );
+            m_NameMap.clear();
+
+            if( flgChanged )
+                *flgChanged = true;
+
+        }
+        else
+        {
+            return true;
+        }
+    }
+
+#ifdef DEBUG
+    std::cout << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cout << " * [INFO] changed project dir to " << m_Paths.front().ToUTF8() << "\n";
+#endif
+
+    return true;
+}
+
+
+wxString S3D_FILENAME_RESOLVER::GetProjectDir( void )
+{
+    if( m_Paths.empty() )
+        return wxEmptyString;
+
+    return m_Paths.front();
+}
+
+
+bool S3D_FILENAME_RESOLVER::createPathList( void )
+{
+    if( !m_Paths.empty() )
+        return true;
+
+    wxString kmod;
+
+    // add the current working directory as the first entry by
+    // default; since CWD is not necessarily what we really want,
+    // the user may change this later with a call to SetProjectDir()
+
+    if( !addPath( wxFileName::GetCwd() ) )
+        m_Paths.push_back( wxEmptyString );
+
+    if( wxGetEnv( wxT( "KISYS3DMOD" ), &kmod ) )
+        addPath( kmod );
+
+    if( !m_ConfigDir.empty() )
+        readPathList();
+
+    if( m_Paths.empty() )
+        return false;
+
+#ifdef DEBUG
+    std::cout << " * [3D model] search paths:\n";
+    std::list< wxString >::const_iterator sPL = m_Paths.begin();
+    std::list< wxString >::const_iterator ePL = m_Paths.end();
+
+    while( sPL != ePL )
+    {
+        std::cout << "   + '" << (*sPL).ToUTF8() << "'\n";
+        ++sPL;
+    }
+#endif
+
+    return true;
+}
+
+
+bool S3D_FILENAME_RESOLVER::UpdatePathList( std::vector< wxString >& aPathList )
+{
+    while( m_Paths.size() > 1 )
+        m_Paths.pop_back();
+
+    size_t nI = aPathList.size();
+
+    for( size_t i = 0; i < nI; ++i )
+        addPath( aPathList[i] );
+
+#ifdef DEBUG
+    std::cerr << "* S3D_FILENAME_RESOLVER::UpdatePathList()\n";
+    std::cerr << "NItems: " << aPathList.size() << "\n";
+
+    for( size_t i = 0; i < aPathList.size(); ++i )
+        std::cerr << "Item #" << i << ": " << aPathList[i].ToUTF8() << "\n";
+#endif
+
+    return writePathList();
+}
+
+
+wxString S3D_FILENAME_RESOLVER::ResolvePath( const wxString& aFileName )
+{
+    if( aFileName.empty() )
+        return wxEmptyString;
+
+    if( m_Paths.empty() )
+        createPathList();
+
+    // first attempt to use the name as specified:
+    wxString aResolvedName;
+    wxString fname = aFileName;
+
+#ifdef _WIN32
+    // translate from KiCad's internal UNIX-like path to MSWin paths
+    fname.Replace( wxT( "/" ), wxT( "\\" ) );
+#endif
+
+    if( checkRealPath( fname, aResolvedName ) )
+        return aResolvedName;
+
+    // look up the filename in the internal filename map
+    std::map< wxString, wxString, S3D::rsort_wxString >::iterator mi;
+    mi = m_NameMap.find( fname );
+
+    if( mi != m_NameMap.end() )
+        return mi->second;
+
+    std::list< wxString >::const_iterator sPL = m_Paths.begin();
+    std::list< wxString >::const_iterator ePL = m_Paths.end();
+
+    while( sPL != ePL )
+    {
+        wxFileName fpath( wxFileName::DirName( *sPL ) );
+        wxFileName filename( fname );
+
+        // we can only attempt a search if the filename is incomplete
+        if( filename.IsRelative() )
+        {
+            wxString fullPath = fpath.GetPathWithSep() + fname;
+
+            if( checkRealPath( fullPath, aResolvedName ) )
+                return aResolvedName;
+        }
+
+        ++sPL;
+    }
+
+    std::cerr << " * [3D Model] filename could not be resolved: '";
+    std::cerr << aFileName.ToUTF8() << "'\n";
+
+    return wxEmptyString;
+}
+
+
+bool S3D_FILENAME_RESOLVER::checkRealPath( const wxString& aFileName,
+    wxString& aResolvedName )
+{
+    aResolvedName.clear();
+    wxFileName fname( aFileName );
+    fname.Normalize();
+
+    if( !fname.FileExists() )
+        return false;
+
+    aResolvedName = fname.GetFullPath();
+    m_NameMap.insert( std::pair< wxString, wxString > ( aFileName, aResolvedName ) );
+
+    return true;
+}
+
+
+bool S3D_FILENAME_RESOLVER::addPath( const wxString& aPath )
+{
+    if( aPath.empty() )
+        return false;
+
+    wxFileName path( aPath, "" );
+    path.Normalize();
+
+    if( !path.DirExists() )
+    {
+        std::cerr << " * [3D Model] invalid path: '" << path.GetPath().ToUTF8() << "'\n";
+        return false;
+    }
+
+    wxString pname = path.GetPath();
+    std::list< wxString >::const_iterator sPL = m_Paths.begin();
+    std::list< wxString >::const_iterator ePL = m_Paths.end();
+
+    while( sPL != ePL )
+    {
+        if( !pname.Cmp( *sPL ) )
+            return true;
+
+        ++sPL;
+    }
+
+    m_Paths.push_back( pname );
+    return true;
+}
+
+
+bool S3D_FILENAME_RESOLVER::readPathList( void )
+{
+    if( m_ConfigDir.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * 3D configuration directory is unknown\n";
+        return false;
+    }
+
+    wxFileName cfgpath( m_ConfigDir, S3D_RESOLVER_CONFIG );
+    cfgpath.Normalize();
+    wxString cfgname = cfgpath.GetFullPath();
+
+    size_t nitems = m_Paths.size();
+
+    std::ifstream cfgFile;
+    std::string   cfgLine;
+
+    if( !wxFileName::Exists( cfgname ) )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * no 3D configuration file: '";
+        std::cerr << cfgname.ToUTF8() << "'\n";
+        return false;
+    }
+
+    cfgFile.open( cfgname.ToUTF8() );
+
+    if( !cfgFile.is_open() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * could not open configuration file '" << cfgname.ToUTF8() << "'\n";
+        return false;
+    }
+
+    int lineno = 0;
+    bool mod = false;   // set to true if there are non-existent paths in the file
+
+    while( cfgFile.good() )
+    {
+        cfgLine.clear();
+        std::getline( cfgFile, cfgLine );
+        ++lineno;
+
+        if( cfgLine.empty() )
+        {
+            if( cfgFile.eof() )
+                break;
+
+            continue;
+        }
+
+        std::string::size_type spos = cfgLine.find_first_of( '"', 0 );
+
+        if( std::string::npos == spos )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * bad config entry in config file '" << cfgname.ToUTF8() << "'\n";
+            std::cerr << "   line " << lineno << " [missing opening quote mark]\n";
+        }
+
+        cfgLine.erase( 0, spos + 1 );
+
+        spos = cfgLine.find_last_of( '"' );
+
+        if( std::string::npos == spos )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * bad config entry in config file '" << cfgname.ToUTF8() << "'\n";
+            std::cerr << "   line " << lineno << " [missing closing quote mark]\n";
+        }
+
+        cfgLine.erase( spos );
+
+        if( !addPath( cfgLine ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * bad config entry in config file '" << cfgname.ToUTF8() << "'\n";
+            std::cerr << "   line " << lineno << " [not a valid path]: '";
+            std::cerr << cfgLine << "'\n";
+            mod = true;
+        }
+    }
+
+    cfgFile.close();
+
+    if( mod )
+        writePathList();
+
+    if( m_Paths.size() != nitems )
+        return true;
+
+    return false;
+}
+
+
+bool S3D_FILENAME_RESOLVER::writePathList( void )
+{
+    if( m_ConfigDir.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * 3D configuration directory is unknown\n";
+        return false;
+    }
+
+    if( m_Paths.empty() || 1 == m_Paths.size() )
+        return false;
+
+    wxString cfgname = m_ConfigDir + S3D_RESOLVER_CONFIG;
+    std::ofstream cfgFile;
+
+    cfgFile.open( cfgname.ToUTF8(), std::ios_base::trunc );
+
+    if( !cfgFile.is_open() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * could not open configuration file '" << cfgname.ToUTF8() << "'\n";
+        return false;
+    }
+
+    std::list< wxString >::const_iterator sPL = m_Paths.begin();
+    std::list< wxString >::const_iterator ePL = m_Paths.end();
+
+    // the first entry is the current project dir; we never add a project dir
+    // to the path list in the configuration file
+    ++sPL;
+
+    while( sPL != ePL )
+    {
+        cfgFile << "\"" << (*sPL).ToUTF8() << "\"\n";
+        ++sPL;
+    }
+
+    bool bad = cfgFile.bad();
+    cfgFile.close();
+
+    if( bad )
+        return false;
+
+    return true;
+}
+
+
+wxString S3D_FILENAME_RESOLVER::ShortenPath( const wxString& aFullPathName )
+{
+    wxString fname = aFullPathName;
+
+    if( m_Paths.empty() )
+        createPathList();
+
+    std::list< wxString >::const_iterator sL = m_Paths.begin();
+    std::list< wxString >::const_iterator eL = m_Paths.end();
+
+    while( sL != eL )
+    {
+        wxFileName fpath( *sL, "" );
+        wxString fps = fpath.GetPathWithSep();
+
+        if( std::string::npos != fname.find( fps ) )
+        {
+            fname = fname.substr( fps.size() );
+
+#ifdef _WIN32
+            fname.Replace( wxT( "\\" ), wxT( "/" ) );
+#endif
+
+            return fname;
+        }
+
+        ++sL;
+    }
+
+    return fname;
+}
+
+
+
+const std::list< wxString >* S3D_FILENAME_RESOLVER::GetPaths( void )
+{
+    return &m_Paths;
+}
diff --git a/3d-viewer/3d_cache/3d_filename_resolver.h b/3d-viewer/3d_cache/3d_filename_resolver.h
new file mode 100644
index 0000000000..d88bc7c760
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_filename_resolver.h
@@ -0,0 +1,165 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_filename_resolver.h
+ * provides an extensible class to resolve 3D model paths. Initially
+ * the legacy behavior will be implemented and an incomplete path
+ * would be checked against the project directory or the KISYS3DMOD
+ * environment variable. In the future a configurable set of search
+ * paths may be specified.
+ */
+
+#ifndef FILENAME_RESOLVER_3D_H
+#define FILENAME_RESOLVER_3D_H
+
+#include <list>
+#include <map>
+#include <vector>
+#include <wx/string.h>
+#include "str_rsort.h"
+
+
+class S3D_FILENAME_RESOLVER
+{
+private:
+    wxString m_ConfigDir;           // 3D configuration directory
+    std::list< wxString > m_Paths;  // list of base paths to search from
+    // mapping of (short) file names to resolved names
+    std::map< wxString, wxString, S3D::rsort_wxString > m_NameMap;
+
+    /**
+     * Function checkRealPath
+     * checks if a file exists, is a regular file, and retrieves
+     * the canonical name and extension.
+     *
+     * @param aFileName [in] is the file name and path to be checked
+     * @param aResolvedName [out] is the canonical resolved filename
+     * @param aFileExtension [out] is the file's extension string
+     * @return true if the file was found and is a regular file
+     */
+    bool checkRealPath( const wxString& aFileName, wxString& aResolvedName );
+
+    /**
+     * Function createPathList
+     * builds the path list using available information such as
+     * KISYS3DMOD and the 3d_path_list configuration file. Invalid
+     * paths are silently discarded and removed from the configuration
+     * file.
+     *
+     * @return true if at least one valid path was found
+     */
+    bool createPathList( void );
+
+    /**
+     * Function addPath
+     * checks that a path is valid and adds it to the search list
+     *
+     * @param aPath is the path to be checked and added
+     * @return true if aPath is valid
+     */
+    bool addPath( const wxString& aPath );
+
+    /**
+     * Function readPathList
+     * reads a list of path names from a configuration file
+     *
+     * @return true if a file was found and contained at least
+     * one valid path
+     */
+    bool readPathList( void );
+
+    /**
+     * Function writePathList
+     * writes the current path list to a configuration file
+     *
+     * @return true if the path list was not empty and was
+     * successfully written to the configuration file
+     */
+    bool writePathList( void );
+
+public:
+    /**
+     * Function Set3DConfigDir
+     * sets the user's configuration directory
+     * for 3D models.
+     *
+     * @param aConfigDir
+     * @return true if the call succeeds (directory exists)
+     */
+    bool Set3DConfigDir( const wxString& aConfigDir );
+
+    /**
+     * Function SetProjectDir
+     * sets the current KiCad project directory as the first
+     * entry in the model path list
+     *
+     * @param aProjDir is the current project directory
+     * @param flgChanged, if specified, is set to true if the directory actually changed
+     * @return true if the call succeeds
+     */
+    bool SetProjectDir( const wxString& aProjDir, bool* flgChanged = NULL );
+    wxString GetProjectDir( void );
+
+
+    /**
+     * Function UpdatePathList
+     * clears the current path list and substitutes the given path
+     * list, updating the path configuration file on success.
+     */
+    bool UpdatePathList( std::vector< wxString >& aPathList );
+
+    /**
+     * Function ResolvePath
+     * determines the full path of the given file name. In the future
+     * remote files may be supported, in which case it is best to
+     * require a full URI in which case ResolvePath should check that
+     * the URI conforms to RFC-2396 and related documents and copies
+     * aFileName into aResolvedName if the URI is valid.
+     */
+    wxString ResolvePath( const wxString& aFileName );
+
+    /**
+     * Function ShortenPath
+     * produces a relative path based on the existing
+     * search directories or returns the same path if
+     * the path is not a superset of an existing search path.
+     *
+     * @param aFullPathName is an absolute path to shorten
+     * @return the shortened path or aFullPathName
+     */
+    wxString ShortenPath( const wxString& aFullPathName );
+
+    /**
+     * Function GetPaths
+     * returns a pointer to the internal path list; the items in:load
+     *
+     * the list can be used to set up the list of search paths
+     * available to a 3D file browser.
+     *
+     * @return pointer to the internal path list
+     */
+    const std::list< wxString >* GetPaths( void );
+};
+
+#endif  // FILENAME_RESOLVER_3D_H
diff --git a/3d-viewer/3d_cache/3d_info.h b/3d-viewer/3d_cache/3d_info.h
new file mode 100644
index 0000000000..ad901be95b
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_info.h
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 2011 Wayne Stambaugh <stambaughw@verizon.net>
+ * Copyright (C) 2004 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_info.h
+ * defines the basic data associated with a single 3D model.
+ */
+
+#ifndef INFO_3D_H
+#define INFO_3D_H
+
+#include <wx/string.h>
+#include <3d_cache/sg/sg_base.h>
+
+
+struct S3D_INFO
+{
+    SGPOINT scale;     ///< scaling factors for the 3D footprint shape
+    SGPOINT rotation;  ///< an X,Y,Z rotation (unit = degrees) for the 3D shape
+    SGPOINT offset;    ///< an offset (unit = inch) for the 3D shape
+    // note: the models are treated in a peculiar fashion since it is the
+    // SCALE which is applied first, followed by the ROTATION and finally
+    // the TRANSLATION/Offset (S-R-T). The usual order of operations is T-R-S.
+
+    wxString filename;  ///< The 3D shape filename in 3D library
+};
+
+#endif // INFO_3D_H
diff --git a/3d-viewer/3d_cache/3d_plugin_manager.cpp b/3d-viewer/3d_cache/3d_plugin_manager.cpp
new file mode 100644
index 0000000000..b90f9e1258
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_plugin_manager.cpp
@@ -0,0 +1,602 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <utility>
+#include <iostream>
+#include <unistd.h>
+#include <sys/types.h>
+#include <string>
+
+#include <wx/string.h>
+#include <wx/dir.h>
+#include <wx/config.h>
+#include <wx/stdpaths.h>
+#include <wx/filename.h>
+
+#ifdef _WIN32
+    #include <windows.h>
+#else
+    #include <dlfcn.h>
+    #include <pwd.h>
+#endif
+
+#include <3d_plugin_manager.h>
+#include <plugins/3d/3d_plugin.h>
+#include <3d_cache/sg/scenegraph.h>
+
+class S3D_PLUGIN_ITEM
+{
+private:
+#ifdef _WIN32
+    HMODULE m_dlHandle;
+#else
+    void* m_dlHandle;       // handle to the opened plugin
+#endif
+
+    S3D_PLUGIN* m_plugin;   // pointer to an instance
+    wxString m_pluginName;  // plugin name
+
+public:
+    S3D_PLUGIN_ITEM( const wxString& aPluginPath );
+    ~S3D_PLUGIN_ITEM();
+    bool Open( void );
+    void Close( void );
+    S3D_PLUGIN* GetPlugin( void );
+    const wxString GetPluginName( void );
+};
+
+
+S3D_PLUGIN_ITEM::S3D_PLUGIN_ITEM( const wxString& aPluginPath )
+{
+    m_pluginName = aPluginPath;
+    m_dlHandle = NULL;
+    m_plugin = NULL;
+
+    return;
+}
+
+S3D_PLUGIN_ITEM::~S3D_PLUGIN_ITEM()
+{
+    Close();
+}
+
+bool S3D_PLUGIN_ITEM::Open( void )
+{
+    if( NULL != m_dlHandle )
+        return true;
+
+    if( m_pluginName.IsEmpty() )
+        return false;
+
+    m_plugin = NULL;
+
+#ifdef _WIN32
+    // NOTE: MSWin uses UTF-16 encoding
+    #if defined( UNICODE ) || defined( _UNICODE )
+        m_dlHandle = LoadLibrary( m_pluginName.wc_str() );
+    #else
+        m_dlHandle = LoadLibrary( m_pluginName.ToUTF8() );
+    #endif
+#else
+    m_dlHandle = dlopen( m_pluginName.ToUTF8(), RTLD_LAZY | RTLD_LOCAL );
+#endif
+
+    if( NULL == m_dlHandle )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * could not open file: '" << m_pluginName.ToUTF8() << "'\n";
+        return false;
+    }
+    else
+    {
+
+#ifdef _WIN32
+        typedef S3D_PLUGIN* (*pPLUGIN)( void );
+        pPLUGIN Get3DPlugin = (pPLUGIN) GetProcAddress( m_dlHandle, "Get3DPlugin" );
+#else
+        S3D_PLUGIN* (*Get3DPlugin)( void );
+        *(void **) (&Get3DPlugin) = dlsym( m_dlHandle, "Get3DPlugin" );
+#endif
+
+        if( NULL == Get3DPlugin )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+
+#ifdef _WIN32
+            std::cerr << " * [INFO] could not find symbol\n";
+#else
+            char* err = dlerror();
+            std::cerr << " * [INFO] could not find symbol: '" << err << "'\n";
+#endif
+
+        }
+        else
+        {
+            // set the 3D Model Plugin object
+            m_plugin = (*Get3DPlugin)();
+            return true;
+        }
+    }
+
+#ifdef _WIN32
+    FreeLibrary( m_dlHandle );
+#else
+    dlclose( m_dlHandle );
+#endif
+
+    m_dlHandle = NULL;
+    return false;
+}
+
+void S3D_PLUGIN_ITEM::Close( void )
+{
+    m_plugin = NULL;
+
+    if( m_dlHandle )
+    {
+
+#ifdef _WIN32
+        FreeLibrary( m_dlHandle );
+#else
+        dlclose( m_dlHandle );
+#endif
+
+        m_dlHandle = NULL;
+    }
+
+    return;
+}
+
+
+S3D_PLUGIN* S3D_PLUGIN_ITEM::GetPlugin( void )
+{
+    if( NULL == m_plugin && !Open() )
+        return NULL;
+
+    return m_plugin;
+}
+
+
+const wxString S3D_PLUGIN_ITEM::GetPluginName( void )
+{
+    return m_pluginName;
+}
+
+
+S3D_PLUGIN_MANAGER::S3D_PLUGIN_MANAGER()
+{
+    // create the initial file filter list entry
+    m_FileFilters.push_back( _( "All Files (*.*)|*.*" ) );
+
+    // discover and load plugins
+    loadPlugins();
+
+#ifdef DEBUG
+    if( !m_ExtMap.empty() )
+    {
+        std::multimap< const wxString, S3D_PLUGIN_ITEM* >::const_iterator sM = m_ExtMap.begin();
+        std::multimap< const wxString, S3D_PLUGIN_ITEM* >::const_iterator eM = m_ExtMap.end();
+        std::cout << "* Extension [plugin name]:\n";
+
+        while( sM != eM )
+        {
+            std::cout << "  + '" << sM->first.ToUTF8() << "' [";
+            std::cout << sM->second->GetPluginName().ToUTF8() << "]\n";
+            ++sM;
+        }
+
+    }
+    else
+    {
+        std::cout << "* No plugins available\n";
+    }
+
+
+    if( !m_FileFilters.empty() )
+    {
+        /// list of file filters
+        std::list< wxString >::const_iterator sFF = m_FileFilters.begin();
+        std::list< wxString >::const_iterator eFF = m_FileFilters.end();
+        std::cout << "* File filters:\n";
+        int i = 0;
+
+        while( sFF != eFF )
+        {
+            std::cout << " + '" << *sFF << "'\n";
+            ++sFF;
+        }
+    }
+    else
+    {
+        std::cout << "* No file filters available\n";
+    }
+#endif  // DEBUG
+
+    return;
+}
+
+
+S3D_PLUGIN_MANAGER::~S3D_PLUGIN_MANAGER()
+{
+    std::list< S3D_PLUGIN_ITEM* >::iterator sP = m_Plugins.begin();
+    std::list< S3D_PLUGIN_ITEM* >::iterator eP = m_Plugins.end();
+
+    while( sP != eP )
+    {
+        (*sP)->Close();
+        delete *sP;
+        ++sP;
+    }
+
+    m_Plugins.clear();
+    return;
+}
+
+
+void S3D_PLUGIN_MANAGER::loadPlugins( void )
+{
+    std::list< std::string > pathlist;
+    std::list< wxString > searchpaths;
+    std::list< wxString > pluginlist;
+    wxFileName fn;
+
+#ifdef DEBUG
+    // set up to work from the build directory
+    fn.Assign( wxStandardPaths::Get().GetExecutablePath() );
+    fn.AppendDir( wxT("..") );
+    fn.AppendDir( wxT("plugins") );
+    fn.AppendDir( wxT("3d") );
+
+    std::string testpath = std::string( fn.GetPathWithSep().ToUTF8() );
+    checkPluginPath( testpath, searchpaths );
+#endif
+    fn.Assign( wxStandardPaths::Get().GetPluginsDir() );
+    fn.AppendDir( wxT( "kicad" ) );
+    fn.AppendDir( wxT( "plugins" ) );
+    fn.AppendDir( wxT( "3d" ) );
+    checkPluginPath( std::string( fn.GetPathWithSep().ToUTF8() ), searchpaths );
+
+    checkPluginPath( wxT( "/usr/lib/kicad/plugins/3d" ), searchpaths );
+    checkPluginPath( wxT( "/usr/local/lib/kicad/plugins/3d" ), searchpaths );
+    checkPluginPath( wxT( "/opt/kicad/lib/kicad/plugins/3d" ), searchpaths );
+
+#ifdef __APPLE__
+    // XXX - we want to use GetOSX... so add support for that somehow in order to avoid hard coding
+    // "/Library/Application Support/kicad/plugins/3d"
+    checkPluginPath( wxT( "/Library/Application Support/kicad/plugins/3d" ), searchpaths );
+
+    // /Library/Application Support/kicad/plugins
+    //fn.Assign( GetOSXKicadMachineDataDir() );
+    //fn.AppendDir( wxT( "plugins" ) );
+    //fn.AppendDir( wxT( "3d" ) );
+    //checkPluginPath( fn.GetPathWithSep(), searchpaths );
+#endif
+
+    // note: GetUserDataDir() gives '.pcbnew' rather than '.kicad' since it uses the exe name;
+    fn.Assign( wxStandardPaths::Get().GetUserDataDir() );
+    fn.AppendDir( wxT( ".kicad" ) );
+    fn.AppendDir( wxT( "plugins" ) );
+    fn.AppendDir( wxT( "3d" ) );
+    checkPluginPath( fn.GetPathWithSep(), searchpaths );
+
+    std::list< wxString >::iterator sPL = searchpaths.begin();
+    std::list< wxString >::iterator ePL = searchpaths.end();
+
+    while( sPL != ePL )
+    {
+#ifdef DEBUG
+        std::cout << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << ":\n";
+        std::cout << "* [DEBUG] searching path: '" << (*sPL).ToUTF8() << "'\n";
+#endif
+        listPlugins( *sPL, pluginlist );
+        ++sPL;
+    }
+
+    if( pluginlist.empty() )
+        return;
+
+    sPL = pluginlist.begin();
+    ePL = pluginlist.end();
+
+    while( sPL != ePL )
+    {
+        S3D_PLUGIN_ITEM* pp = new S3D_PLUGIN_ITEM( *sPL );
+
+        if( pp )
+        {
+            if( pp->Open() )
+            {
+#ifdef DEBUG
+                std::cout << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << ":\n";
+                std::cout << "* [DEBUG] adding plugin\n";
+#endif
+                m_Plugins.push_back( pp );
+
+                S3D_PLUGIN* lpp = pp->GetPlugin();
+
+                if( lpp )
+                {
+                    int nf = lpp->GetNFilters();
+
+                    for( int i = 0; i < nf; ++i )
+                        addFilterString( lpp->GetFileFilter( i ) );
+
+                }
+
+                addExtensionMap( pp );
+
+                // close the loaded library
+                pp->Close();
+            }
+            else
+            {
+#ifdef DEBUG
+                std::cout << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << ":\n";
+                std::cout << "* [DEBUG] deleting plugin\n";
+#endif
+                delete pp;
+            }
+        }
+
+        ++sPL;
+    }
+
+#ifdef DEBUG
+    std::cout << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << ":\n";
+    std::cout << "* [DEBUG] plugins loaded\n";
+#endif
+
+    return;
+}
+
+
+void S3D_PLUGIN_MANAGER::listPlugins( const wxString& aPath,
+    std::list< wxString >& aPluginList )
+{
+    // list potential plugins given a search paths
+    // note on typical plugin names:
+    // Linux: *.so, *.so.* (note: *.so.* will not be supported)
+    // MSWin: *.dll
+    // OSX: *.dylib, *.bundle
+
+    std::list< wxString > nameFilter;   // filter to apply to files
+    wxString lName;                     // stores name of enumerated files
+    wxString fName;                     // full name of file
+
+#ifdef __linux
+
+    nameFilter.push_back( wxString::FromUTF8Unchecked( "*.so" ) );
+
+#elif defined _WIN32
+
+    nameFilter.push_back( wxString::FromUTF8Unchecked( "*.dll" ) );
+
+#elif defined __APPLE__
+
+    nameFilter.push_back( wxString::FromUTF8Unchecked( "*.dylib" ) );
+    nameFilter.push_back( wxString::FromUTF8Unchecked( "*.bundle" ) );
+
+#else
+
+    // note: we need to positively identify a supported OS here
+    // and add suffixes which may be used for 3D model plugins
+    // on the specific OS
+    #warning NOT IMPLEMENTED
+
+#endif
+
+    wxDir wd;
+    wd.Open( aPath );
+
+    if( !wd.IsOpened() )
+        return;
+
+    wxString lp = wd.GetNameWithSep();
+    std::list< wxString >::iterator sExt = nameFilter.begin();
+    std::list< wxString >::iterator eExt = nameFilter.end();
+
+    while( sExt != eExt )
+    {
+        if( wd.GetFirst( &lName, *sExt, wxDIR_FILES ) )
+        {
+            fName = lp + lName;
+            checkPluginName( fName, aPluginList );
+
+            while( wd.GetNext( &lName ) )
+            {
+                fName = lp + lName;
+                checkPluginName( fName, aPluginList );
+            }
+        }
+
+        ++sExt;
+    }
+
+    wd.Close();
+
+    return;
+}
+
+
+void S3D_PLUGIN_MANAGER::checkPluginName( const wxString& aPath,
+    std::list< wxString >& aPluginList )
+{
+    // check the existence of a plugin name and add it to the list
+
+    if( aPath.empty() || !wxFileName::FileExists( aPath ) )
+        return;
+
+    wxFileName path( aPath );
+    path.Normalize();
+
+    // determine if the path is already in the list
+    wxString wxpath = path.GetFullPath();
+    std::list< wxString >::iterator bl = aPluginList.begin();
+    std::list< wxString >::iterator el = aPluginList.end();
+
+    while( bl != el )
+    {
+        if( 0 == (*bl).Cmp( wxpath ) )
+            return;
+
+        ++bl;
+    }
+
+    aPluginList.push_back( wxpath );
+
+    return;
+}
+
+
+void S3D_PLUGIN_MANAGER::checkPluginPath( const wxString& aPath,
+    std::list< wxString >& aSearchList )
+{
+    // check the existence of a path and add it to the path search list
+    if( aPath.empty() )
+        return;
+
+    wxFileName path( wxFileName::DirName( aPath ) );
+    path.Normalize();
+
+    if( !wxFileName::DirExists( path.GetFullPath() ) )
+        return;
+
+    // determine if the directory is already in the list
+    wxString wxpath = path.GetFullPath();
+    std::list< wxString >::iterator bl = aSearchList.begin();
+    std::list< wxString >::iterator el = aSearchList.end();
+
+    while( bl != el )
+    {
+        if( 0 == (*bl).Cmp( wxpath ) )
+            return;
+
+        ++bl;
+    }
+
+    aSearchList.push_back( wxpath );
+
+    return;
+}
+
+
+void S3D_PLUGIN_MANAGER::addFilterString( const wxString& aFilterString )
+{
+    // add an entry to the file filter list
+    if( aFilterString.empty() )
+        return;
+
+    std::list< wxString >::iterator sFF = m_FileFilters.begin();
+    std::list< wxString >::iterator eFF = m_FileFilters.end();
+
+    while( sFF != eFF )
+    {
+        if( 0 == (*sFF).Cmp( aFilterString ) )
+            return;
+
+        ++sFF;
+    }
+
+    m_FileFilters.push_back( aFilterString );
+    return;
+}
+
+
+void S3D_PLUGIN_MANAGER::addExtensionMap( S3D_PLUGIN_ITEM* aPlugin )
+{
+    // add entries to the extension map
+    if( NULL == aPlugin )
+        return;
+
+    S3D_PLUGIN* pp = aPlugin->GetPlugin();
+
+    if( NULL == pp )
+        return;
+
+    int nExt = pp->GetNExtensions();
+
+    for( int i = 0; i < nExt; ++i )
+    {
+        wxString ws = pp->GetModelExtension( i );
+
+        if( !ws.empty() )
+        {
+            m_ExtMap.insert( std::pair< const wxString, S3D_PLUGIN_ITEM* >( ws, aPlugin ) );
+        }
+
+    }
+
+    return;
+}
+
+
+std::list< wxString > const* S3D_PLUGIN_MANAGER::GetFileFilters( void ) const
+{
+    return &m_FileFilters;
+}
+
+
+SCENEGRAPH* S3D_PLUGIN_MANAGER::Load3DModel( const wxString& aFileName )
+{
+    wxFileName raw( aFileName );
+    wxString ext = raw.GetExt();
+
+    std::pair < std::multimap< const wxString, S3D_PLUGIN_ITEM* >::iterator,
+        std::multimap< const wxString, S3D_PLUGIN_ITEM* >::iterator > items;
+
+    items = m_ExtMap.equal_range( ext );
+    std::multimap< const wxString, S3D_PLUGIN_ITEM* >::iterator sL = items.first;
+
+    while( sL != items.second )
+    {
+        S3D_PLUGIN* pplug = sL->second->GetPlugin();
+
+        if( NULL != pplug && pplug->CanRender() )
+        {
+            SCENEGRAPH* sp = pplug->Load( aFileName );
+
+            if( NULL != sp )
+                return sp;
+        }
+
+        ++sL;
+    }
+
+    return NULL;
+}
+
+
+void S3D_PLUGIN_MANAGER::ClosePlugins( void )
+{
+    std::list< S3D_PLUGIN_ITEM* >::iterator sP = m_Plugins.begin();
+    std::list< S3D_PLUGIN_ITEM* >::iterator eP = m_Plugins.end();
+
+    while( sP != eP )
+    {
+        (*sP)->Close();
+        ++sP;
+    }
+
+    return;
+}
diff --git a/3d-viewer/3d_cache/3d_plugin_manager.h b/3d-viewer/3d_cache/3d_plugin_manager.h
new file mode 100644
index 0000000000..af03e18375
--- /dev/null
+++ b/3d-viewer/3d_cache/3d_plugin_manager.h
@@ -0,0 +1,96 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_plugin_manager.h
+ * manages 3D model plugins
+ */
+
+#ifndef PLUGIN_MANAGER_3D_H
+#define PLUGIN_MANAGER_3D_H
+
+#include <map>
+#include <list>
+#include <wx/string.h>
+
+class wxWindow;
+class S3D_PLUGIN_ITEM;
+struct S3D_INFO;
+class SCENEGRAPH;
+
+class S3D_PLUGIN_MANAGER
+{
+private:
+    /// list of discovered plugins
+    std::list< S3D_PLUGIN_ITEM* > m_Plugins;
+
+    /// mapping of extensions to available plugins
+    std::multimap< const wxString, S3D_PLUGIN_ITEM* > m_ExtMap;
+
+    /// list of file filters
+    std::list< wxString > m_FileFilters;
+
+    /// load plugins
+    void loadPlugins( void );
+
+    /// list potential plugins
+    void listPlugins( const wxString& aPath, std::list< wxString >& aPluginList );
+
+    /// check the existence of a plugin name and add it to the list
+    void checkPluginName( const wxString& aPath, std::list< wxString >& aPluginList );
+
+    /// check the existence of a path and add it to the path search list
+    void checkPluginPath( const wxString& aPath, std::list< wxString >& aSearchList );
+
+    /// add an entry to the file filter list
+    void addFilterString( const wxString& aFilterString );
+
+    /// add entries to the extension map
+    void addExtensionMap( S3D_PLUGIN_ITEM* aPlugin );
+
+public:
+    S3D_PLUGIN_MANAGER();
+    virtual ~S3D_PLUGIN_MANAGER();
+
+    /**
+     * Function GetFileFilters
+     * returns the list of file filters; this will contain at least
+     * the default "All Files (*.*)|*.*" and the file filters supported
+     * by any available plugins
+     *
+     * @return a pointer to the internal filter list
+     */
+    std::list< wxString > const* GetFileFilters( void ) const;
+
+    SCENEGRAPH* Load3DModel( const wxString& aFileName );
+
+    /**
+     * Function ClosePlugins
+     * iterates through all discovered plugins and closes them to
+     * reclaim memory. The individual plugins will be automatically
+     * reloaded as calls are made to load specific models.
+     */
+    void ClosePlugins( void );
+};
+
+#endif  // PLUGIN_MANAGER_3D_H
diff --git a/3d-viewer/3d_cache/CMakeLists.txt b/3d-viewer/3d_cache/CMakeLists.txt
new file mode 100644
index 0000000000..82ed6dec69
--- /dev/null
+++ b/3d-viewer/3d_cache/CMakeLists.txt
@@ -0,0 +1,3 @@
+# unset CMAKE_CXX_FLAGS because it's contaminated with too many options
+set( CMAKE_CXX_FLAGS "" )
+add_subdirectory( sg )
diff --git a/3d-viewer/3d_cache/README b/3d-viewer/3d_cache/README
new file mode 100644
index 0000000000..3b2602aaf3
--- /dev/null
+++ b/3d-viewer/3d_cache/README
@@ -0,0 +1,132 @@
+This directory will contain code used in the refactoring of
+the 3D viewer and 3D model management.
+
+Notes on building the test program on Linux:
+1. Configure to build KiCad; ensue you have "-DS3D_TEST=ON" to
+   enable the "test3dmm" test program.
+
+mkdir build
+cd build
+cmake   -DKICAD_SCRIPTING=ON \
+        -DKICAD_SCRIPTING_MODULES=ON \
+        -DBUILD_GITHUB_PLUGIN=ON  \
+        -DCMAKE_BUILD_TYPE=Debug \
+        -DKICAD_SKIP_BOOST=ON \
+        -DCMAKE_INSTALL_PREFIX=/usr \
+        -DS3D_TEST=ON \
+        -DCMAKE_VERBOSE_MAKEFILE=ON ..
+
+2. After configuring to build KiCad, descend into the 3dv build
+directory:
+
+  cd 3dv
+
+3. Build all files in the 3dv directory:
+
+  make -j8
+
+4. Install to a directory within the build directory:
+
+  mkdir inst
+  make install DESTDIR=./inst
+
+5. Set LD_LIBRARY_PATH so that the 3d manager code can be found:
+
+  export LD_LIBRARY_PATH=${PWD}/inst/usr/lib/kicad
+
+  ( note: the previous step may have installed the library in
+   ${PWD}/inst/usr/local/lib/kicad )
+  There is no need to include the plugins directory in
+  LD_LIBRARY_PATH since the manager should magically find
+  plugins there and load them.
+
+6. Run the test program:
+
+   ./inst/usr/bin/test3dmm
+
+   
+===========================
+     For OSX and MSWin
+===========================
+The dynamic plugin has only been built and tested on Linux; until
+the dynamic plugin system can be made to work on MSWin and OSX, those
+systems will not be able to use the 3D cache framework for anything
+other than a filename resolver and model file browser. Without the
+plugins the 3D viewer will not be able to use the new framework for
+loading generic 3D model formats.
+
+Dynamic plugins are managed in 3dv/3d_plugin_manager.cpp so that is the
+only source file which developers need to modify to support plugins
+on OSX and MSWin
+
+1. OSX:
+    + In general some attention is required wherever the __APPLE__
+      macro is found
+      
+    + void S3D_PLUGIN_MANAGER::loadPlugins( void )
+      In this function a list of reasonable search paths must be provided;
+      these paths will be checked for the existence of a plugin
+    
+    + void S3D_PLUGIN_MANAGER::listPlugins( ... )
+      In this function the list of suffixes to use in the plugin
+      discovery should be checked to ensure that they comply with
+      the expectations of OSX
+      
+    + bool S3D_PLUGIN_ITEM::Open( void )
+      This function loads the dynamic plugins. If OSX use the gcc dlopen
+      set of functions then there may be no further work to be done here.
+      
+2. MSWin:
+    + In general some attention is required wherever the _WIN32 macro is found
+      
+    + void S3D_PLUGIN_MANAGER::loadPlugins( void )
+      In this function a list of reasonable search paths must be provided;
+      these paths will be checked for the existence of a plugin
+    
+    + bool S3D_PLUGIN_ITEM::Open( void )
+      This function loads the dynamic plugins. Since the gcc dlopen family
+      of functions do not exist on MSWin, some _WIN32 specific code must
+      be added to handle the library loading.
+
+===
+
+Q. How do you know the plugin system is working?
+A. The plugin system is working if the dummy plugin is located and loaded.
+   If the plugin is located and the software was built with the DEBUG flag,
+   you will see a group of messages which, among other things, advertises
+   the file types supported by the dummy plugin:
+
+        ~/code/kicad/branch_3d/3dv/3d_plugin_manager.cpp:loadPlugins:404:
+        * [DEBUG] searching path: '~/usr/lib/kicad/plugins'
+        XXX - Initializing S3D_PLUGIN_DUMMY
+        ~/code/kicad/branch_3d/3dv/3d_plugin_manager.cpp:loadPlugins:426:
+        * [DEBUG] adding plugin
+        XXX - Destroying S3D_PLUGIN_DUMMY
+        ~/code/kicad/branch_3d/3dv/3d_plugin_manager.cpp:loadPlugins:461:
+        * [DEBUG] plugins loaded
+        * Extension [plugin name]:
+        + 'IDF' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'IGES' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'IGS' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'STEP' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'STP' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'WRL' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'X3D' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'idf' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'iges' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'igs' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'step' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'stp' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'wrl' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        + 'x3d' [~/usr/lib/kicad/plugins/libs3d_plugin_dummy.so]
+        * File filters:
+        + 'All Files (*.*)|*.*'
+        + 'VRML 1.0/2.0 (*.wrl;*.WRL)|*.wrl;*.WRL'
+        + 'X3D (*.x3d;*.X3D)|*.x3d;*.X3D'
+        + 'IDF 2.0/3.0 (*.idf;*.IDF)|*.idf;*.IDF'
+        + 'IGESv5.3 (*.igs;*.iges;*.IGS;*.IGES)|*.igs;*.iges;*.IGS;*.IGES'
+        + 'STEP (*.stp;*.step;*.STP;*.STEP)|*.stp;*.step;*.STP;*.STEP'
+
+   The supported file extensions should appear in the list of file filters within the
+   model selection dialog; if no plugins are loaded then the only available file
+   filter will be the wildcard filter *.*
diff --git a/3d-viewer/3d_cache/ansidecl.h b/3d-viewer/3d_cache/ansidecl.h
new file mode 100644
index 0000000000..f64990fbbf
--- /dev/null
+++ b/3d-viewer/3d_cache/ansidecl.h
@@ -0,0 +1,297 @@
+/* ANSI and traditional C compatability macros
+   Copyright 1991, 1992, 1*993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* ANSI and traditional C compatibility macros
+
+   ANSI C is assumed if __STDC__ is #defined.
+
+   Macro        ANSI C definition   Traditional C definition
+   -----        ---- - ----------   ----------- - ----------
+   ANSI_PROTOTYPES  1           not defined
+   PTR          `void *'        `char *'
+   PTRCONST     `void *const'       `char *'
+   LONG_DOUBLE      `long double'       `double'
+   const        not defined     `'
+   volatile     not defined     `'
+   signed       not defined     `'
+   VA_START(ap, var)    va_start(ap, var)   va_start(ap)
+
+   Note that it is safe to write "void foo();" indicating a function
+   with no return value, in all K+R compilers we have been able to test.
+
+   For declaring functions with prototypes, we also provide these:
+
+   PARAMS ((prototype))
+   -- for functions which take a fixed number of arguments.  Use this
+   when declaring the function.  When defining the function, write a
+   K+R style argument list.  For example:
+
+   char *strcpy PARAMS ((char *dest, char *source));
+   ...
+   char *
+   strcpy (dest, source)
+   char *dest;
+   char *source;
+   { ... }
+
+   VPARAMS ((prototype, ...))
+   -- for functions which take a variable number of arguments.  Use
+   PARAMS to declare the function, VPARAMS to define it.  For example:
+
+   int printf PARAMS ((const char *format, ...));
+   ...
+   int
+   printf VPARAMS ((const char *format, ...))
+   {
+   ...
+   }
+
+   For writing functions which take variable numbers of arguments, we
+   also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros.  These
+   hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
+   thoroughly than the simple VA_START() macro mentioned above.
+
+   VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end.
+   Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
+   corresponding to the list of fixed arguments.  Then use va_arg
+   normally to get the variable arguments, or pass your va_list object
+   around.  You do not declare the va_list yourself; VA_OPEN does it
+   for you.
+
+     Here is a complete example:
+
+     int
+     printf VPARAMS ((const char *format, ...))
+     {
+        int result;
+
+        VA_OPEN (ap, format);
+        VA_FIXEDARG (ap, const char *, format);
+
+        result = vfprintf (stdout, format, ap);
+        VA_CLOSE (ap);
+
+        return result;
+     }
+
+
+   You can declare variables either before or after the VA_OPEN,
+   VA_FIXEDARG sequence.  Also, VA_OPEN and VA_CLOSE are the beginning
+   and end of a block.  They must appear at the same nesting level,
+   and any variables declared after VA_OPEN go out of scope at
+   VA_CLOSE.  Unfortunately, with a K+R compiler, that includes the
+   argument list.  You can have multiple instances of VA_OPEN/VA_CLOSE
+   pairs in a single function in case you need to traverse the
+   argument list more than once.
+
+   For ease of writing code which uses GCC extensions but needs to be
+   portable to other compilers, we provide the GCC_VERSION macro that
+   simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
+   wrappers around __attribute__.  Also, __extension__ will be #defined
+   to nothing if it doesn't work.  See below.
+
+   This header also defines a lot of obsolete macros:
+   CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
+   AND, DOTS, NOARGS.  Don't use them.  */
+
+#ifndef _ANSIDECL_H
+#define _ANSIDECL_H 1
+
+/* Every source file includes this file,
+   so they will all get the switch for lint.  */
+/* LINTLIBRARY */
+
+/* Using MACRO(x,y) in cpp #if conditionals does not work with some
+   older preprocessors.  Thus we can't define something like this:
+
+   #define HAVE_GCC_VERSION(MAJOR, MINOR) \
+   (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR)))
+
+   and then test "#if HAVE_GCC_VERSION(2,7)".
+
+   So instead we use the macro below and test it against specific values.  */
+
+/* This macro simplifies testing whether we are using gcc, and if it
+   is of a particular mini*mum version. (Both major & minor numbers are
+   significant.)  This macro will evaluate to 0 if we are not using
+   gcc at all.  */
+#ifndef GCC_VERSION
+#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
+#endif /* GCC_VERSION */
+
+#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) || (defined(__alpha) && defined(__cplusplus))
+/* All known AIX compilers implement these things (but don't always
+   define __STDC__).  The RISC/OS MIPS compiler defines these things
+   in SVR4 mode, but does not define __STDC__.  */
+/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other
+   C ++ compilers, does not define __STDC__, though it acts as if this
+   was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */
+
+#define ANSI_PROTOTYPES 1
+#define PTR     void *
+#define PTRCONST    void *const
+#define LONG_DOUBLE long double
+
+#define PARAMS(ARGS)        ARGS
+#define VPARAMS(ARGS)       ARGS
+#define VA_START(VA_LIST, VAR)  va_start(VA_LIST, VAR)
+
+/* variadic function helper macros */
+/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
+   use without inhibiting further decls and without declaring an
+   actual variable.  */
+#define VA_OPEN(AP, VAR)    { va_list AP; va_start(AP, VAR); { struct Qdmy
+#define VA_CLOSE(AP)        } va_end(AP); }
+#define VA_FIXEDARG(AP, T, N)   struct Qdmy
+
+#undef const
+#undef volatile
+#undef signed
+
+/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
+   it too, but it's not in C89.  */
+#undef inline
+#if __STDC_VERSION__ > 199901L
+/* it's a keyword */
+#else
+# if GCC_VERSION >= 2007
+#  define inline __inline__   /* __inline__ prevents -pedantic warnings */
+# else
+#  define inline  /* nothing */
+# endif
+#endif
+
+/* These are obsolete.  Do not use.  */
+#ifndef IN_GCC
+#define CONST       const
+#define VOLATILE    volatile
+#define SIGNED      signed
+
+#define PROTO(type, name, arglist)  type name arglist
+#define EXFUN(name, proto)      name proto
+#define DEFUN(name, arglist, args)  name(args)
+#define DEFUN_VOID(name)        name(void)
+#define AND     ,
+#define DOTS        , ...
+#define NOARGS      void
+#endif /* ! IN_GCC */
+
+#else   /* Not ANSI C.  */
+
+#undef  ANSI_PROTOTYPES
+#define PTR     char *
+#define PTRCONST    PTR
+#define LONG_DOUBLE double
+
+#define PARAMS(args)        ()
+#define VPARAMS(args)       (va_alist) va_dcl
+#define VA_START(va_list, var)  va_start(va_list)
+
+#define VA_OPEN(AP, VAR)        { va_list AP; va_start(AP); { struct Qdmy
+#define VA_CLOSE(AP)            } va_end(AP); }
+#define VA_FIXEDARG(AP, TYPE, NAME) TYPE NAME = va_arg(AP, TYPE)
+
+/* some systems define these in header files for non-ansi mode */
+#undef const
+#undef volatile
+#undef signed
+#undef inline
+#define const
+#define volatile
+#define signed
+#define inline
+
+#ifndef IN_GCC
+#define CONST
+#define VOLATILE
+#define SIGNED
+
+#define PROTO(type, name, arglist)  type name ()
+#define EXFUN(name, proto)      name()
+#define DEFUN(name, arglist, args)  name arglist args;
+#define DEFUN_VOID(name)        name()
+#define AND     ;
+#define DOTS
+#define NOARGS
+#endif /* ! IN_GCC */
+
+#endif  /* ANSI C.  */
+
+/* Define macros for some gcc attributes.  This permits us to use the
+   macros freely, and know that they will come into play for the
+   version of gcc in which they are supported.  */
+
+#if (GCC_VERSION < 2007)
+# define __attribute__(x)
+#endif
+
+/* Attribute __malloc__ on functions was valid as of gcc 2.96. */
+#ifndef ATTRIBUTE_MALLOC
+# if (GCC_VERSION >= 2096)
+#  define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
+# else
+#  define ATTRIBUTE_MALLOC
+# endif /* GNUC >= 2.96 */
+#endif /* ATTRIBUTE_MALLOC */
+
+/* Attributes on labels were valid as of gcc 2.93. */
+#ifndef ATTRIBUTE_UNUSED_LABEL
+# if (GCC_VERSION >= 2093)
+#  define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
+# else
+#  define ATTRIBUTE_UNUSED_LABEL
+# endif /* GNUC >= 2.93 */
+#endif /* ATTRIBUTE_UNUSED_LABEL */
+
+#ifndef ATTRIBUTE_UNUSED
+#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+#endif /* ATTRIBUTE_UNUSED */
+
+#ifndef ATTRIBUTE_NORETURN
+#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
+#endif /* ATTRIBUTE_NORETURN */
+
+#ifndef ATTRIBUTE_PRINTF
+#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
+#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
+#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
+#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
+#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
+#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
+#endif /* ATTRIBUTE_PRINTF */
+
+/* We use __extension__ in some places to suppress -pedantic warnings
+   about GCC extensions.  This feature didn't work properly before
+   gcc 2.8.  */
+#if GCC_VERSION < 2008
+#define __extension__
+#endif
+
+/* Bootstrap support:  Adjust certain macros defined by Autoconf,
+  which are only valid for the stage1 compiler.  If we detect
+  a modern version of GCC, we are probably in stage2 or beyond,
+  so unconditionally reset the values.  Note that const, inline,
+  etc. have been dealt with above.  */
+#if (GCC_VERSION >= 2007)
+# ifndef HAVE_LONG_DOUBLE
+#  define HAVE_LONG_DOUBLE 1
+# endif
+#endif /* GCC >= 2.7 */
+
+#endif  /* ansidecl.h   */
diff --git a/3d-viewer/3d_cache/dialogs/3d_cache_dialogs.cpp b/3d-viewer/3d_cache/dialogs/3d_cache_dialogs.cpp
new file mode 100644
index 0000000000..13e78bc0f6
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/3d_cache_dialogs.cpp
@@ -0,0 +1,72 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <wx/filename.h>
+#include <3d_info.h>
+#include <3d_cache.h>
+#include <sg/ifsg_api.h>
+
+#include "3d_cache_dialogs.h"
+#include "dialog_config_3dpath.h"
+#include "dialog_select_3dmodel.h"
+
+
+bool S3D::Select3DModel( wxWindow* aParent, S3D_CACHE* aCache,
+    wxString& prevModelSelectDir, int& prevModelWildcard, S3D_INFO* aModel )
+{
+    DLG_SEL_3DMODEL* dm = new DLG_SEL_3DMODEL( aParent, aCache,
+        prevModelSelectDir, prevModelWildcard );
+
+    if( wxID_OK == dm->ShowModal() )
+    {
+        // retrieve the data entry for the 3D model
+        dm->GetModelData( aModel );
+
+        // remember the previous settings
+        prevModelWildcard = dm->GetFilterIndex();
+        wxFileName name( dm->GetPath() );
+        name.Normalize();
+        prevModelSelectDir = name.GetPath();
+
+        delete dm;
+        return true;
+    }
+
+    delete dm;
+    return false;
+}
+
+
+bool S3D::Configure3DPaths( wxWindow* aParent, S3D_FILENAME_RESOLVER* aResolver )
+{
+    DLG_CFG_3DPATH* dp = new DLG_CFG_3DPATH( aParent, aResolver );
+
+    if( wxID_OK == dp->ShowModal() )
+    {
+        delete dp;
+        return true;
+    }
+
+    delete dp;
+    return false;
+}
diff --git a/3d-viewer/3d_cache/dialogs/3d_cache_dialogs.h b/3d-viewer/3d_cache/dialogs/3d_cache_dialogs.h
new file mode 100644
index 0000000000..4fb3015ed7
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/3d_cache_dialogs.h
@@ -0,0 +1,41 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#ifndef CACHE_DIALOGS_3D_H
+#define CACHE_DIALOGS_3D_H
+
+#include <wx/wx.h>
+
+class S3D_CACHE;
+class S3D_FILENAME_RESOLVER;
+struct S3D_INFO;
+
+namespace S3D
+{
+    bool Select3DModel( wxWindow* aParent, S3D_CACHE* aCache,
+        wxString& prevModelSelectDir, int& prevModelWildcard, S3D_INFO* aModel );
+
+    bool Configure3DPaths( wxWindow* aParent, S3D_FILENAME_RESOLVER* aResolver );
+};
+
+#endif  // CACHE_DIALOGS_3D_H
diff --git a/3d-viewer/3d_cache/dialogs/dialog_config_3dpath.cpp b/3d-viewer/3d_cache/dialogs/dialog_config_3dpath.cpp
new file mode 100644
index 0000000000..0f4f39271c
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/dialog_config_3dpath.cpp
@@ -0,0 +1,257 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <cstdlib>
+#include <list>
+#include <wx/filename.h>
+#include <3d_cache.h>
+
+#include "dialog_config_3dpath.h"
+
+enum
+{
+    btnEditPath = wxID_HIGHEST + 1,
+    btnAddPath,
+    btnDeletePath,
+    lbPathList
+};
+
+
+wxBEGIN_EVENT_TABLE( DLG_CFG_3DPATH, wxDialog )
+    EVT_BUTTON( wxID_OK, DLG_CFG_3DPATH::OnOK )
+    EVT_BUTTON( wxID_CANCEL, DLG_CFG_3DPATH::OnExit )
+    EVT_BUTTON( btnEditPath, DLG_CFG_3DPATH::EditPath )
+    EVT_BUTTON( btnAddPath, DLG_CFG_3DPATH::AddPath )
+    EVT_BUTTON( btnDeletePath, DLG_CFG_3DPATH::DeletePath )
+wxEND_EVENT_TABLE()
+
+
+DLG_CFG_3DPATH::DLG_CFG_3DPATH( wxWindow* aParent, S3D_FILENAME_RESOLVER* aResolver )
+    : wxDialog( aParent, -1, _( "3D Model Path Configuration" ),
+    wxDefaultPosition, wxDefaultSize,  wxCAPTION | wxCLOSE_BOX | wxSYSTEM_MENU
+    | wxRESIZE_BORDER | wxMINIMIZE_BOX )
+{
+    resolver = aResolver;
+
+    Bind( wxEVT_LIST_ITEM_ACTIVATED, &DLG_CFG_3DPATH::EditPath, this, lbPathList );
+    Bind( wxEVT_LIST_ITEM_SELECTED, &DLG_CFG_3DPATH::PathSelect, this, lbPathList );
+    Bind( wxEVT_LIST_ITEM_DESELECTED, &DLG_CFG_3DPATH::PathSelect, this, lbPathList );
+
+    wxBoxSizer *vboxMain = new wxBoxSizer( wxVERTICAL );
+    wxBoxSizer *vboxSide = new wxBoxSizer( wxVERTICAL );
+    wxBoxSizer* hboxTop = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hboxBot = new wxBoxSizer( wxHORIZONTAL );
+
+    pathList = new wxListView( this, lbPathList, wxDefaultPosition, wxSize( 400, 200 ),
+        wxLC_REPORT | wxLC_NO_HEADER | wxLC_SINGLE_SEL );
+
+    pathList->AppendColumn( wxEmptyString );
+
+    editButton = new wxButton( this, btnEditPath, _( "Edit" ),
+        wxDefaultPosition, wxSize( 100, 30 ) );
+
+    editButton->Enable( false );
+
+    wxButton* addButton = new wxButton( this, btnAddPath, _( "Add" ),
+        wxDefaultPosition, wxSize( 100, 30 ) );
+
+    deleteButton = new wxButton( this, btnDeletePath, _( "Delete" ),
+        wxDefaultPosition, wxSize( 100, 30 ) );
+
+    deleteButton->Enable( false );
+
+    wxButton* okButton = new wxButton( this, wxID_OK, _( "Ok" ),
+        wxDefaultPosition, wxSize( 100, 30 ) );
+
+    wxButton* cancelButton = new wxButton( this, wxID_CANCEL, _( "Cancel" ),
+        wxDefaultPosition, wxSize( 100, 30 ) );
+
+    vboxSide->Add( editButton, 0, wxALL, 10 );
+    vboxSide->Add( addButton, 0, wxALL, 10 );
+    vboxSide->Add( deleteButton, 0, wxALL, 10 );
+
+    hboxTop->Add( pathList, 1, wxEXPAND | wxALL, 10 );
+    hboxTop->Add( vboxSide, 0, wxEXPAND | wxALL, 10 );
+
+    hboxBot->Add( okButton, 0, wxALL, 10 );
+    hboxBot->Add( cancelButton, 0, wxALL, 10 );
+
+    vboxMain->Add( hboxTop, 1, wxEXPAND | wxALL, 10 );
+    vboxMain->Add( hboxBot, 0, wxEXPAND | wxALL, 10 );
+
+    if( resolver )
+    {
+        const std::list< wxString >* pl = resolver->GetPaths();
+        std::list< wxString >::const_iterator sL = pl->begin();
+        std::list< wxString >::const_iterator eL = pl->end();
+
+        // always skip the first entry which is the current project dir
+        if( sL != eL )
+            ++sL;
+
+        long i = 0;
+
+        while( sL != eL )
+        {
+            m_paths.push_back( *sL );
+            pathList->InsertItem( i, *sL );
+            ++i;
+            ++sL;
+        }
+
+        pathList->SetColumnWidth(0, wxLIST_AUTOSIZE);
+    }
+
+    SetSizerAndFit( vboxMain );
+    Centre();
+
+    return;
+}
+
+
+void DLG_CFG_3DPATH::OnExit( wxCommandEvent& event )
+{
+    if( IsModal() )
+        EndModal( wxID_EXIT );
+    else
+        Close( true );
+
+    return;
+}
+
+
+void DLG_CFG_3DPATH::OnOK( wxCommandEvent& event )
+{
+    if( resolver )
+        resolver->UpdatePathList( m_paths );
+
+    if( IsModal() )
+        EndModal( wxID_OK );
+    else
+        Close( true );
+
+    return;
+}
+
+
+void DLG_CFG_3DPATH::EditPath( wxCommandEvent& event )
+{
+    long nItem = pathList->GetFirstSelected();
+    wxString tmpname = m_paths[ nItem ];
+
+    wxDirDialog* dd = new wxDirDialog( this, _( "Change 3D model directory" ),
+        m_paths[ nItem ] );
+
+    if( wxID_OK == dd->ShowModal() )
+    {
+        wxFileName path( wxFileName::DirName( dd->GetPath() ) );
+        path.Normalize();
+        wxString newname = path.GetPath();
+
+        if( tmpname.Cmp( newname ) )
+        {
+            pathList->DeleteItem( nItem );
+            pathList->InsertItem( nItem, newname );
+            m_paths[ nItem ] = newname;
+            pathList->Focus( nItem );
+            editButton->Enable( false );
+            deleteButton->Enable( false );
+            pathList->SetColumnWidth(0, wxLIST_AUTOSIZE);
+        }
+    }
+
+    delete dd;
+
+    return;
+}
+
+
+void DLG_CFG_3DPATH::AddPath( wxCommandEvent& event )
+{
+    wxDirDialog* dd = new wxDirDialog( this, _( "Add a 3D model directory" ) );
+
+    if( wxID_OK == dd->ShowModal() )
+    {
+        wxFileName path( wxFileName::DirName( dd->GetPath() ) );
+        path.Normalize();
+        wxString newname = path.GetPath();
+
+        m_paths.push_back( newname );
+        pathList->InsertItem( pathList->GetItemCount(), *m_paths.rbegin() );
+        pathList->Focus( pathList->GetItemCount() -1 );
+        editButton->Enable( false );
+        deleteButton->Enable( false );
+        pathList->SetColumnWidth(0, wxLIST_AUTOSIZE);
+    }
+
+    delete dd;
+
+    return;
+}
+
+
+void DLG_CFG_3DPATH::DeletePath( wxCommandEvent& event )
+{
+    long nItem = pathList->GetFirstSelected();
+
+    if( -1 == nItem )
+        return;
+
+    m_paths.erase( m_paths.begin() + nItem );
+    pathList->DeleteItem( nItem );
+
+    if( m_paths.size() > 0 )
+    {
+        if( nItem > 0 )
+            --nItem;
+
+        pathList->Select( nItem );
+    }
+    else
+    {
+        editButton->Enable( false );
+        deleteButton->Enable( false );
+        pathList->Select( -1 );
+    }
+
+    return;
+}
+
+
+void DLG_CFG_3DPATH::PathSelect( wxCommandEvent& event )
+{
+    long nItem = pathList->GetFirstSelected();
+
+    if( -1 == nItem )
+    {
+        editButton->Enable( false );
+        deleteButton->Enable( false );
+        return;
+    }
+
+    editButton->Enable( true );
+    deleteButton->Enable( true );
+
+    return;
+}
diff --git a/3d-viewer/3d_cache/dialogs/dialog_config_3dpath.h b/3d-viewer/3d_cache/dialogs/dialog_config_3dpath.h
new file mode 100644
index 0000000000..b8efb6b7dc
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/dialog_config_3dpath.h
@@ -0,0 +1,62 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file dialog_config_3dpath.h
+ * creates a dialog to edit the default search paths for 3D model files.
+ */
+
+#ifndef DIALOG_CONFIG_3DPATH_H
+#define DIALOG_CONFIG_3DPATH_H
+
+#include <vector>
+#include <wx/wx.h>
+#include <wx/listctrl.h>
+
+class S3D_FILENAME_RESOLVER;
+
+class DLG_CFG_3DPATH : public wxDialog
+{
+private:
+    wxListView* pathList;
+    wxButton* editButton;
+    wxButton* deleteButton;
+
+    S3D_FILENAME_RESOLVER* resolver;
+    std::vector< wxString > m_paths;
+
+public:
+    DLG_CFG_3DPATH( wxWindow* aParent, S3D_FILENAME_RESOLVER* aResolver );
+
+private:
+    void OnExit( wxCommandEvent& event );
+    void OnOK( wxCommandEvent& event );
+    void EditPath( wxCommandEvent& event );
+    void AddPath( wxCommandEvent& event );
+    void DeletePath( wxCommandEvent& event );
+    void PathSelect( wxCommandEvent& event );
+
+    wxDECLARE_EVENT_TABLE();
+};
+
+#endif  // DIALOG_CONFIG_3DPATH_H
diff --git a/3d-viewer/3d_cache/dialogs/dialog_select_3dmodel.cpp b/3d-viewer/3d_cache/dialogs/dialog_select_3dmodel.cpp
new file mode 100644
index 0000000000..b9999bc1a0
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/dialog_select_3dmodel.cpp
@@ -0,0 +1,119 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <3d_cache.h>
+#include "dialog_select_3dmodel.h"
+#include "panel_prev_model.h"
+
+static S3D_CACHE* mm = NULL;
+static wxFileDialog* fm = NULL;
+
+static wxWindow* mkPreviewPanel( wxWindow* aParent )
+{
+    PANEL_PREV_3D* pp = new PANEL_PREV_3D( aParent, true );
+    pp->SetModelManager( mm );
+    pp->SetFileSelectorDlg( fm );
+
+    return (wxWindow*)pp;
+}
+
+wxBEGIN_EVENT_TABLE( DLG_SEL_3DMODEL, wxFileDialog )
+        EVT_BUTTON( wxID_OK, DLG_SEL_3DMODEL::OnOK )
+        EVT_BUTTON( wxID_CANCEL, DLG_SEL_3DMODEL::OnExit )
+wxEND_EVENT_TABLE()
+
+
+DLG_SEL_3DMODEL::DLG_SEL_3DMODEL( wxWindow* aParent, S3D_CACHE* aManager,
+    const wxString& aDefaultDir, int aFilterIndex )
+    : wxFileDialog( aParent, _( "Select a 3D Model" ), aDefaultDir )
+{
+    m_manager = aManager;
+    mm = aManager;
+    fm = this;
+
+    long ws = GetWindowStyleFlag();
+    ws |= wxFD_FILE_MUST_EXIST;
+    SetWindowStyleFlag( ws );
+    SetExtraControlCreator( mkPreviewPanel );
+
+    if( NULL != m_manager )
+    {
+        std::list< wxString > const* fl = m_manager->GetFileFilters();
+        std::list< wxString >::const_iterator sL = fl->begin();
+        std::list< wxString >::const_iterator eL = fl->end();
+        wxString filter;
+
+        while( sL != eL )
+        {
+            filter.Append( *sL );
+
+            ++sL;
+
+            if( sL != eL )
+                filter.Append( wxT( "|" ) );
+
+        }
+
+        if( !filter.empty() )
+            SetWildcard( filter );
+
+        if( aFilterIndex >= 0 && aFilterIndex < (int)fl->size() )
+            SetFilterIndex( aFilterIndex );
+    }
+
+    return;
+}
+
+
+void DLG_SEL_3DMODEL::OnExit( wxCommandEvent& event )
+{
+    if( IsModal() )
+        EndModal( wxID_EXIT );
+    else
+        Close( true );
+
+    return;
+}
+
+
+void DLG_SEL_3DMODEL::OnOK( wxCommandEvent& event )
+{
+    if( IsModal() )
+        EndModal( wxID_OK );
+    else
+        Close( true );
+
+    return;
+}
+
+
+void DLG_SEL_3DMODEL::GetModelData( S3D_INFO* aModel )
+{
+    PANEL_PREV_3D* pp =  (PANEL_PREV_3D*)GetExtraControl();
+
+    if( pp )
+        pp->GetModelData( aModel );
+
+    return;
+}
diff --git a/3d-viewer/3d_cache/dialogs/dialog_select_3dmodel.h b/3d-viewer/3d_cache/dialogs/dialog_select_3dmodel.h
new file mode 100644
index 0000000000..156e8235f1
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/dialog_select_3dmodel.h
@@ -0,0 +1,57 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file dialog_select_3dmodel.h
+ * creates a dialog to select 3D model files
+ */
+
+#ifndef DIALOG_SELECT_3DMODEL_H
+#define DIALOG_SELECT_3DMODEL_H
+
+#include <wx/wx.h>
+#include <wx/filedlg.h>
+
+class S3D_CACHE;
+class S3D_INFO;
+
+class DLG_SEL_3DMODEL : public wxFileDialog
+{
+private:
+    S3D_CACHE* m_manager;
+
+public:
+    DLG_SEL_3DMODEL( wxWindow* aParent, S3D_CACHE* aManager,
+        const wxString& aDefaultDir, int aFilterIndex );
+
+    // Retrieve model data
+    void GetModelData( S3D_INFO* aModel );
+
+private:
+    void OnExit( wxCommandEvent& event );
+    void OnOK( wxCommandEvent& event );
+
+    wxDECLARE_EVENT_TABLE();
+};
+
+#endif  // DIALOG_SELECT_3DMODEL_H
diff --git a/3d-viewer/3d_cache/dialogs/panel_prev_model.cpp b/3d-viewer/3d_cache/dialogs/panel_prev_model.cpp
new file mode 100644
index 0000000000..9b2e3e0407
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/panel_prev_model.cpp
@@ -0,0 +1,634 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <3d_model_viewer/c3d_model_viewer.h>
+#include <3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.h>
+#include <common_ogl/cogl_att_list.h>
+#include <iostream>
+#include <cstdlib>
+#include <wx/sizer.h>
+#include <wx/choice.h>
+#include <wx/filename.h>
+#include <wx/glcanvas.h>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <3d_cache.h>
+#include <3d_info.h>
+#include <3d_filename_resolver.h>
+#include <3d_cache/sg/ifsg_api.h>
+
+#include "panel_prev_model.h"
+#include "dialog_select_3dmodel.h"
+#include "3d_cache_dialogs.h"
+
+
+// ensure -360 < rotation < 360
+static void checkRotation( double& rot )
+{
+    if( rot >= 360.0 )
+    {
+        int n = rot / 360.0;
+        rot -= 360.0 * (double)n;
+    }
+    else if( rot <= -360.0 )
+    {
+        int n = -rot / 360.0;
+        rot += 360.0 * (double)n;
+    }
+
+    return;
+}
+
+
+enum {
+    ID_SET_DIR = wxID_LAST + 1,
+    ID_CFG_PATHS,
+    ID_3D_ISO,
+    ID_3D_UPDATE,
+    ID_3D_LEFT,
+    ID_3D_RIGHT,
+    ID_3D_FRONT,
+    ID_3D_BACK,
+    ID_3D_TOP,
+    ID_3D_BOTTOM
+};
+
+wxBEGIN_EVENT_TABLE( PANEL_PREV_3D, wxPanel)
+        EVT_CHOICE( ID_SET_DIR, PANEL_PREV_3D::SetRootDir )
+        EVT_BUTTON( ID_CFG_PATHS, PANEL_PREV_3D::Cfg3DPaths )
+        EVT_BUTTON( ID_3D_ISO, PANEL_PREV_3D::View3DISO )
+        EVT_BUTTON( ID_3D_UPDATE, PANEL_PREV_3D::View3DUpdate )
+        EVT_BUTTON( ID_3D_LEFT, PANEL_PREV_3D::View3DLeft )
+        EVT_BUTTON( ID_3D_RIGHT, PANEL_PREV_3D::View3DRight )
+        EVT_BUTTON( ID_3D_FRONT, PANEL_PREV_3D::View3DFront )
+        EVT_BUTTON( ID_3D_BACK, PANEL_PREV_3D::View3DBack )
+        EVT_BUTTON( ID_3D_TOP, PANEL_PREV_3D::View3DTop )
+        EVT_BUTTON( ID_3D_BOTTOM, PANEL_PREV_3D::View3DBottom )
+wxEND_EVENT_TABLE()
+
+
+PANEL_PREV_3D::PANEL_PREV_3D( wxWindow* aParent, bool hasFileSelector ) :
+    wxPanel( aParent, -1 )
+{
+    m_ModelManager = NULL;
+    m_FileDlg = NULL;
+    canvas = NULL;
+    model = NULL;
+
+    wxBoxSizer* mainBox = new wxBoxSizer( wxVERTICAL );
+
+    wxStaticBoxSizer* vbox = new wxStaticBoxSizer( wxVERTICAL, this, _( "3D Model Orientation" ) );
+    wxBoxSizer* hboxDirChoice = NULL;
+    dirChoices = NULL;
+
+    if( hasFileSelector )
+    {
+        hboxDirChoice = new wxBoxSizer( wxHORIZONTAL );
+        dirChoices = new wxChoice( this, ID_SET_DIR );
+
+#ifdef _WIN32
+        // Note: On Win32 the native selector box will truncate text
+        // if the text is too long.
+        dirChoices->SetMinSize( wxSize( 450, -1 ) );
+#endif
+
+        wxStaticText* stDirChoice = new wxStaticText( this, -1, _( "Paths:" ) );
+        wxButton* cfgPaths = new wxButton( this, ID_CFG_PATHS, _( "Configure Paths" ) );
+        hboxDirChoice->Add( stDirChoice, 0, wxALL | wxCENTER, 5 );
+        hboxDirChoice->Add( dirChoices, 1, wxEXPAND | wxALL, 5 );
+        hboxDirChoice->Add( cfgPaths, 0, wxALL, 5 );
+    }
+
+    wxStaticBoxSizer* vbScale = new wxStaticBoxSizer( wxVERTICAL, this, _( "Scale" )  );
+    wxStaticBoxSizer* vbRotate = new wxStaticBoxSizer( wxVERTICAL, this, _( "Rotation" ) );
+    wxStaticBoxSizer* vbOffset = new wxStaticBoxSizer( wxVERTICAL, this, _( "Offset (inches)" ) );
+
+    wxStaticBox* modScale = vbScale->GetStaticBox();
+    wxStaticBox* modRotate = vbRotate->GetStaticBox();
+    wxStaticBox* modOffset = vbOffset->GetStaticBox();
+
+    wxBoxSizer* hbS1 = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbS2 = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbS3 = new wxBoxSizer( wxHORIZONTAL );
+    wxStaticText* txtS1 = new wxStaticText( modScale, -1, wxT( "X:" ) );
+    wxStaticText* txtS2 = new wxStaticText( modScale, -1, wxT( "Y:" ) );
+    wxStaticText* txtS3 = new wxStaticText( modScale, -1, wxT( "Z:" ) );
+    xscale = new wxTextCtrl( modScale, -1, "1.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    yscale = new wxTextCtrl( modScale, -1, "1.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    zscale = new wxTextCtrl( modScale, -1, "1.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    xscale->SetMaxLength( 9 );
+    yscale->SetMaxLength( 9 );
+    zscale->SetMaxLength( 9 );
+    hbS1->Add( txtS1, 0, wxALL, 2 );
+    hbS1->Add( xscale, 0, wxALL, 2 );
+    hbS2->Add( txtS2, 0, wxALL, 2 );
+    hbS2->Add( yscale, 0, wxALL, 2 );
+    hbS3->Add( txtS3, 0, wxALL, 2 );
+    hbS3->Add( zscale, 0, wxALL, 2 );
+    vbScale->Add( hbS1, 0, wxEXPAND | wxALL, 2 );
+    vbScale->Add( hbS2, 0, wxEXPAND | wxALL, 2 );
+    vbScale->Add( hbS3, 0, wxEXPAND | wxALL, 2 );
+
+    wxBoxSizer* hbR1 = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbR2 = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbR3 = new wxBoxSizer( wxHORIZONTAL );
+    wxStaticText* txtR1 = new wxStaticText( modRotate, -1, wxT( "X:" ) );
+    wxStaticText* txtR2 = new wxStaticText( modRotate, -1, wxT( "Y:" ) );
+    wxStaticText* txtR3 = new wxStaticText( modRotate, -1, wxT( "Z:" ) );
+    xrot = new wxTextCtrl( modRotate, -1, "0.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    yrot = new wxTextCtrl( modRotate, -1, "0.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    zrot = new wxTextCtrl( modRotate, -1, "0.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    xrot->SetMaxLength( 9 );
+    yrot->SetMaxLength( 9 );
+    zrot->SetMaxLength( 9 );
+    hbR1->Add( txtR1, 0, wxALL, 2 );
+    hbR1->Add( xrot, 0, wxALL, 2 );
+    hbR2->Add( txtR2, 0, wxALL, 2 );
+    hbR2->Add( yrot, 0, wxALL, 2 );
+    hbR3->Add( txtR3, 0, wxALL, 2 );
+    hbR3->Add( zrot, 0, wxALL, 2 );
+    vbRotate->Add( hbR1, 0, wxEXPAND | wxALL, 2 );
+    vbRotate->Add( hbR2, 0, wxEXPAND | wxALL, 2 );
+    vbRotate->Add( hbR3, 0, wxEXPAND | wxALL, 2 );
+
+    wxBoxSizer* hbO1 = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbO2 = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbO3 = new wxBoxSizer( wxHORIZONTAL );
+    wxStaticText* txtO1 = new wxStaticText( modOffset, -1, wxT( "X:" ) );
+    wxStaticText* txtO2 = new wxStaticText( modOffset, -1, wxT( "Y:" ) );
+    wxStaticText* txtO3 = new wxStaticText( modOffset, -1, wxT( "Z:" ) );
+    xoff = new wxTextCtrl( modOffset, -1, "0.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    yoff = new wxTextCtrl( modOffset, -1, "0.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    zoff = new wxTextCtrl( modOffset, -1, "0.0", wxDefaultPosition, wxDefaultSize,
+        wxTE_PROCESS_ENTER );
+    xoff->SetMaxLength( 9 );
+    yoff->SetMaxLength( 9 );
+    zoff->SetMaxLength( 9 );
+    hbO1->Add( txtO1, 0, wxALL, 2 );
+    hbO1->Add( xoff, 0, wxALL, 2 );
+    hbO2->Add( txtO2, 0, wxALL, 2 );
+    hbO2->Add( yoff, 0, wxALL, 2 );
+    hbO3->Add( txtO3, 0, wxALL, 2 );
+    hbO3->Add( zoff, 0, wxALL, 2 );
+    vbOffset->Add( hbO1, 0, wxEXPAND | wxALL, 2 );
+    vbOffset->Add( hbO2, 0, wxEXPAND | wxALL, 2 );
+    vbOffset->Add( hbO3, 0, wxEXPAND | wxALL, 2 );
+
+    if( NULL != hboxDirChoice )
+        mainBox->Add( hboxDirChoice, 0, wxEXPAND );
+
+    // hbox holding orientation data and preview
+    wxBoxSizer* hbox = new wxBoxSizer( wxHORIZONTAL );
+    // vbox holding orientation data
+    wxBoxSizer* vboxOrient = new wxBoxSizer( wxVERTICAL );
+    // vbox holding the preview and view buttons
+    wxBoxSizer* vboxPrev = new wxBoxSizer( wxVERTICAL );
+
+    vboxOrient->Add( vbScale, 0, wxALL, 5 );
+    vboxOrient->Add( vbRotate, 0, wxALL, 5 );
+    vboxOrient->Add( vbOffset, 0, wxALL, 5 );
+    vboxOrient->AddSpacer( 20 );
+
+    // add preview items
+    preview = new wxPanel( this, -1 );
+    preview->SetMinSize( wxSize( 320, 240 ) );
+    preview->SetBackgroundColour( wxColor( 0, 0, 0 ));
+    vboxPrev->Add( preview, 1, wxEXPAND | wxALIGN_CENTER | wxLEFT | wxRIGHT, 5 );
+    // buttons:
+    wxButton* vFront = new wxButton( this, ID_3D_FRONT, wxT( "F" ) );
+    wxButton* vBack = new wxButton( this, ID_3D_BACK, wxT( "B" ) );
+    wxButton* vLeft = new wxButton( this, ID_3D_LEFT, wxT( "L" ) );
+    wxButton* vRight = new wxButton( this, ID_3D_RIGHT, wxT( "R" ) );
+    wxButton* vTop = new wxButton( this, ID_3D_TOP, wxT( "T" ) );
+    wxButton* vBottom = new wxButton( this, ID_3D_BOTTOM, wxT( "B" ) );
+    wxButton* vISO = new wxButton( this, ID_3D_ISO, wxT( "I" ) );
+    wxButton* vUpdate = new wxButton( this, ID_3D_UPDATE, wxT( "U" ) );
+    wxBoxSizer* hbBT = new wxBoxSizer( wxHORIZONTAL );
+    wxBoxSizer* hbBB = new wxBoxSizer( wxHORIZONTAL );
+    hbBT->Add( vISO, 0, wxCENTER | wxALL, 3 );
+    hbBT->Add( vLeft, 0, wxCENTER | wxALL, 3 );
+    hbBT->Add( vFront, 0, wxCENTER | wxALL, 3 );
+    hbBT->Add( vTop, 0, wxCENTER | wxALL, 3 );
+    hbBT->AddSpacer( 17 );
+    hbBB->Add( vUpdate, 0, wxCENTER | wxALL, 3 );
+    hbBB->Add( vRight, 0, wxCENTER | wxALL, 3 );
+    hbBB->Add( vBack, 0, wxCENTER | wxALL, 3 );
+    hbBB->Add( vBottom, 0, wxCENTER | wxALL, 3 );
+    hbBB->AddSpacer( 17 );
+
+    vboxPrev->AddSpacer( 7 );
+    vboxPrev->Add( hbBT, 0 );
+    vboxPrev->Add( hbBB, 0 );
+
+    // XXX - Suppress the buttons until the Renderer code is ready.
+    // vboxPrev->Hide( preview, true );
+    vboxPrev->Hide( hbBT, true );
+    vboxPrev->Hide( hbBB, true );
+
+    hbox->Add( vboxOrient, 0, wxALL, 5 );
+    hbox->Add( vboxPrev, 1, wxEXPAND );
+    vbox->Add( hbox, 1, wxEXPAND );
+
+    mainBox->Add( vbox, 1, wxEXPAND | wxALL, 5 );
+
+    if( hasFileSelector )
+    {
+        // NOTE: if/when the FIle Selector preview is implemented
+        // we may need to hide the orientation boxes to ensure the
+        // users have sufficient display area for the browser.
+        // hbox->Hide( vboxOrient, true );
+        // XXX -
+        // NOTE: for now we always suppress the preview and model orientation
+        // panels while in the file selector
+        mainBox->Hide( vbox, true );
+    }
+
+    SetSizerAndFit( mainBox );
+    Centre();
+
+    return;
+}
+
+
+PANEL_PREV_3D::~PANEL_PREV_3D()
+{
+    if( NULL != canvas )
+    {
+        canvas->Clear3DModel();
+        canvas->Refresh();
+        canvas->Update();
+    }
+
+    if( model )
+        S3D::Destroy3DModel( &model );
+
+    return;
+}
+
+
+void PANEL_PREV_3D::SetModelManager( S3D_CACHE* aModelManager )
+{
+    m_ModelManager = aModelManager;
+    updateDirChoiceList();
+    return;
+}
+
+
+void PANEL_PREV_3D::SetFileSelectorDlg( wxFileDialog* aFileDlg )
+{
+    m_FileDlg = aFileDlg;
+    updateDirChoiceList();
+    return;
+}
+
+
+void PANEL_PREV_3D::updateDirChoiceList( void )
+{
+    if( NULL == m_FileDlg || NULL == m_ModelManager || NULL == dirChoices )
+        return;
+
+    std::list< wxString > const* md = m_ModelManager->GetResolver()->GetPaths();
+    std::list< wxString >::const_iterator sL = md->begin();
+    std::list< wxString >::const_iterator eL = md->end();
+    std::vector< wxString > cl;
+
+    while( sL != eL )
+    {
+        cl.push_back( *sL );
+        ++sL;
+    }
+
+    if( !cl.empty() )
+    {
+        dirChoices->Clear();
+        dirChoices->Append( (int)cl.size(), &cl[0] );
+        dirChoices->Select( 0 );
+    }
+
+    Layout();
+    return;
+}
+
+
+void PANEL_PREV_3D::SetRootDir( wxCommandEvent& event )
+{
+    if( !m_FileDlg )
+        return;
+
+    m_FileDlg->SetDirectory( dirChoices->GetString( dirChoices->GetSelection() ) );
+
+    return;
+}
+
+
+void PANEL_PREV_3D::Cfg3DPaths( wxCommandEvent& event )
+{
+    if( !m_FileDlg || !m_ModelManager )
+        return;
+
+    if( S3D::Configure3DPaths( this, m_ModelManager->GetResolver() ) )
+        updateDirChoiceList();
+
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DISO( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Isometric View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DUpdate( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Update 3D View\n";
+
+    // update the model filename if appropriate
+    if( NULL != m_FileDlg )
+    {
+        wxString modelName = m_FileDlg->GetCurrentlySelectedFilename();
+        UpdateModelName( modelName );
+    }
+
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DLeft( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Left View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DRight( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Right View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DFront( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Front View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DBack( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Back View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DTop( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Top View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::View3DBottom( wxCommandEvent& event )
+{
+    // XXX - TO BE IMPLEMENTED
+    std::cout << "Switch to Bottom View\n";
+    return;
+}
+
+
+void PANEL_PREV_3D::GetModelData( S3D_INFO* aModel )
+{
+    if( NULL == aModel )
+        return;
+
+    SGPOINT scale;
+    SGPOINT rotation;
+    SGPOINT offset;
+
+    xscale->GetValue().ToDouble( &scale.x );
+    yscale->GetValue().ToDouble( &scale.y );
+    zscale->GetValue().ToDouble( &scale.z );
+
+    if( 0.001 > scale.x || 0.001 > scale.y || 0.001 > scale.z )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] invalid scale values; setting all to 1.0\n";
+        scale.x = 1.0;
+        scale.y = 1.0;
+        scale.z = 1.0;
+    }
+
+    xrot->GetValue().ToDouble( &rotation.x );
+    yrot->GetValue().ToDouble( &rotation.y );
+    zrot->GetValue().ToDouble( &rotation.z );
+    checkRotation( rotation.x );
+    checkRotation( rotation.y );
+    checkRotation( rotation.z );
+
+    xoff->GetValue().ToDouble( &offset.x );
+    yoff->GetValue().ToDouble( &offset.y );
+    zoff->GetValue().ToDouble( &offset.z );
+
+    aModel->scale = scale;
+    aModel->offset = offset;
+    aModel->rotation = rotation;
+
+    // return if we are not in file selection mode
+    if( NULL == m_FileDlg )
+        return;
+
+    // file selection mode: retrieve the filename and specify a
+    // path relative to one of the config paths
+    wxFileName fname = m_FileDlg->GetPath();
+    fname.Normalize();
+    aModel->filename = m_ModelManager->GetResolver()->ShortenPath( fname.GetFullPath() );
+
+    return;
+}
+
+
+void PANEL_PREV_3D::SetModelData( S3D_INFO const* aModel )
+{
+    xscale->SetValue( wxString::FromDouble( aModel->scale.x ) );
+    yscale->SetValue( wxString::FromDouble( aModel->scale.y ) );
+    zscale->SetValue( wxString::FromDouble( aModel->scale.z ) );
+
+    xrot->SetValue( wxString::FromDouble( aModel->rotation.x ) );
+    yrot->SetValue( wxString::FromDouble( aModel->rotation.y ) );
+    zrot->SetValue( wxString::FromDouble( aModel->rotation.z ) );
+
+    xoff->SetValue( wxString::FromDouble( aModel->offset.x ) );
+    yoff->SetValue( wxString::FromDouble( aModel->offset.y ) );
+    zoff->SetValue( wxString::FromDouble( aModel->offset.z ) );
+
+    modelInfo = *aModel;
+    UpdateModelName( aModel->filename );
+
+    return;
+}
+
+
+void PANEL_PREV_3D::UpdateModelName( wxString const& aModelName )
+{
+    bool newModel = false;
+
+    // if the model name is a directory simply clear the current model
+    if( aModelName.empty() || wxFileName::DirExists( aModelName ) )
+    {
+        currentModelFile.clear();
+        modelInfo.filename.clear();
+    }
+    else
+    {
+        wxString newModelFile;
+
+        if( m_ModelManager )
+            newModelFile = m_ModelManager->GetResolver()->ResolvePath( aModelName );
+        else if( wxFileName::FileExists( aModelName ) )
+            newModelFile = aModelName;
+
+        if( newModelFile.empty() )
+        {
+            #ifdef DEBUG
+            std::cout << "[3dv] Update Model: (no such file) " << aModelName.ToUTF8() << "\n";
+            #endif
+        }
+        else if( newModelFile.Cmp( currentModelFile ) )
+        {
+            newModel = true;
+
+            #ifdef DEBUG
+            std::cout << "[3dv] Update Model: " << newModelFile.ToUTF8() << "\n";
+            #endif
+        }
+        #ifdef DEBUG
+        else
+        {
+            std::cout << "[3dv] Update Model: [model unchanged]\n";
+        }
+        #endif
+
+        currentModelFile = newModelFile;
+        modelInfo.filename = currentModelFile;
+    }
+
+    if( currentModelFile.empty() || newModel )
+    {
+#ifdef DEBUG
+        std::cout << "[3dv] Update Model: painting black\n";
+#endif
+        if( NULL != canvas )
+            canvas->Clear3DModel();
+
+        if( model )
+            S3D::Destroy3DModel( &model );
+
+        if( currentModelFile.empty() )
+            return;
+    }
+
+    SGPOINT rot;
+    SGPOINT trans;
+    model = m_ModelManager->Prepare( &modelInfo, rot, trans );
+
+    if( NULL == model )
+    {
+#ifdef DEBUG
+        std::cout << "[3dv] Update Model: no model loaded\n";
+#endif
+
+        if( NULL != canvas )
+        {
+            canvas->Refresh();
+            canvas->Update();
+        }
+
+        return;
+    }
+
+#ifdef DEBUG
+    std::cout << "[3dv] Update Model: loading preview\n";
+#endif
+
+    if( NULL == canvas )
+    {
+#ifdef DEBUG
+        std::cout << "[3dv] Update Model: creating canvas\n";
+#endif
+
+        canvas = new C3D_MODEL_VIEWER( preview,
+            COGL_ATT_LIST::GetAttributesList( true ) );
+
+        #ifdef DEBUG
+        if( NULL == canvas )
+            std::cout << "[3dv] Update Model: canvas creation FAILED\n";
+        #endif
+
+        canvas->SetSize( preview->GetClientSize() );
+    }
+
+    canvas->Set3DModel( *model );
+    canvas->Refresh();
+    canvas->Update();
+
+    return;
+}
+
+
+void PANEL_PREV_3D::UpdateWindowUI( long flags )
+{
+    /*
+     XXX -
+     NOTE: until we figure out how to ensure that a Paint Event is
+     generated for the File Selector's UI, we cannot display any
+     preview within the file browser.
+    if( wxUPDATE_UI_RECURSE == flags && m_FileDlg && m_ModelManager )
+    {
+        // check for a change in the current model file
+        S3D_INFO info;
+        modelInfo = info;
+        UpdateModelName( m_FileDlg->GetCurrentlySelectedFilename() );
+    }
+     */
+
+    wxPanel::UpdateWindowUI( flags );
+
+    return;
+}
diff --git a/3d-viewer/3d_cache/dialogs/panel_prev_model.h b/3d-viewer/3d_cache/dialogs/panel_prev_model.h
new file mode 100644
index 0000000000..72e1c648c4
--- /dev/null
+++ b/3d-viewer/3d_cache/dialogs/panel_prev_model.h
@@ -0,0 +1,97 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file panel_prev_model.h
+ * defines a panel which is to be added to a wxFileDialog via SetExtraControl();
+ * the panel shows a preview of the model being browsed (if preview is supported
+ * by a plugin) and provides controls to set the offset/rotation/scale of the
+ * model as per KiCad's current behavior. The panel may also be used in the 3D
+ * configuration dialog to tune the positioning of the models without invoking
+ * a file selector dialog.
+ */
+
+#ifndef PANEL_PREV_MODEL_H
+#define PANEL_PREV_MODEL_H
+
+#include <wx/wx.h>
+#include <wx/panel.h>
+
+#include <3d_rendering/c3dmodel.h>
+#include <3d_cache/3d_info.h>
+
+class  S3D_CACHE;
+class C3D_MODEL_VIEWER;
+
+class PANEL_PREV_3D : public wxPanel
+{
+public:
+    PANEL_PREV_3D( wxWindow* aParent, bool hasFileSelector = false );
+    ~PANEL_PREV_3D();
+
+    void SetModelManager( S3D_CACHE* aModelManager );
+    void SetFileSelectorDlg( wxFileDialog* aFileDlg );
+    void SetRootDir( wxCommandEvent& event );
+    void Cfg3DPaths( wxCommandEvent& event );
+    // 3D views
+    void View3DISO( wxCommandEvent& event );
+    void View3DUpdate( wxCommandEvent& event );
+    void View3DLeft( wxCommandEvent& event );
+    void View3DRight( wxCommandEvent& event );
+    void View3DFront( wxCommandEvent& event );
+    void View3DBack( wxCommandEvent& event );
+    void View3DTop( wxCommandEvent& event );
+    void View3DBottom( wxCommandEvent& event );
+    // Set / Retrieve model data
+    void SetModelData( S3D_INFO const* aModel );
+    void GetModelData( S3D_INFO* aModel );
+    void UpdateModelName( wxString const& aModel );
+    // Update on change of FileDlg selection
+    virtual void UpdateWindowUI( long flags = wxUPDATE_UI_NONE );
+
+private:
+    wxString currentModelFile;
+    S3D_CACHE* m_ModelManager;
+    wxFileDialog* m_FileDlg;
+    wxChoice* dirChoices;
+    wxTextCtrl* xscale;
+    wxTextCtrl* yscale;
+    wxTextCtrl* zscale;
+    wxTextCtrl* xrot;
+    wxTextCtrl* yrot;
+    wxTextCtrl* zrot;
+    wxTextCtrl* xoff;
+    wxTextCtrl* yoff;
+    wxTextCtrl* zoff;
+    wxPanel* preview;
+    C3D_MODEL_VIEWER* canvas;
+    S3DMODEL* model;
+    S3D_INFO  modelInfo;
+
+private:
+    void updateDirChoiceList( void );
+
+    wxDECLARE_EVENT_TABLE();
+};
+
+#endif  // PANEL_PREV_MODEL_H
diff --git a/3d-viewer/3d_cache/md5.cpp b/3d-viewer/3d_cache/md5.cpp
new file mode 100644
index 0000000000..d42ea0b3e7
--- /dev/null
+++ b/3d-viewer/3d_cache/md5.cpp
@@ -0,0 +1,409 @@
+/* md5.c - Functions to compute MD5 message digest of files or memory blocks
+ *  according to the definition of MD5 in RFC 1321 from April 1992.
+ *  Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ *
+ *  NOTE: This source is derived from an old version taken from the GNU C
+ *  Library (glibc).
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the
+ *  Free Software Foundation; either version 2, or (at your option) any
+ *  later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software Foundation,
+ *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <sys/types.h>
+
+# include <stdlib.h>
+# include <string.h>
+
+#include "ansidecl.h"
+#include "md5.h"
+
+#ifdef __APPLE__
+    # include <machine/endian.h>
+#elif !defined( _WIN32 )
+    # include <endian.h>
+#endif
+# if __BYTE_ORDER == __BIG_ENDIAN
+#  define WORDS_BIGENDIAN 1
+# endif
+
+#ifdef WORDS_BIGENDIAN
+# define SWAP(n)                            \
+(((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
+#else
+# define SWAP(n) (n)
+#endif
+
+
+/* This array contains the bytes used to pad the buffer to the next
+ * 64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
+static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
+
+
+/* Initialize structure containing state of computation.
+ *  (RFC 1321, 3.3: Step 3)  */
+void
+md5_init_ctx ( struct md5_ctx *ctx )
+{
+    ctx->A = (md5_uint32) 0x67452301;
+    ctx->B = (md5_uint32) 0xefcdab89;
+    ctx->C = (md5_uint32) 0x98badcfe;
+    ctx->D = (md5_uint32) 0x10325476;
+
+    ctx->total[0] = ctx->total[1] = 0;
+    ctx->buflen = 0;
+}
+
+/* Put result from CTX in first 16 bytes following RESBUF.  The result
+ * must be in little endian byte order.
+ *
+ * IMPORTANT: On some systems it is required that RESBUF is correctly
+ * aligned for a 32 bits value.  */
+void *
+md5_read_ctx ( const struct md5_ctx *ctx, void *resbuf )
+{
+    ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
+    ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
+    ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
+    ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
+
+    return resbuf;
+}
+
+/* Process the remaining bytes in the internal buffer and the usual
+ * prolog according to the standard and write the result to RESBUF.
+ *
+ * IMPORTANT: On some systems it is required that RESBUF is correctly
+ * aligned for a 32 bits value.  */
+void *
+md5_finish_ctx ( struct md5_ctx *ctx, void *resbuf )
+{
+    /* Take yet unprocessed bytes into account.  */
+    md5_uint32 bytes = ctx->buflen;
+    size_t pad;
+
+    /* Now count remaining bytes.  */
+    ctx->total[0] += bytes;
+    if (ctx->total[0] < bytes)
+        ++ctx->total[1];
+
+    pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
+    memcpy (&ctx->buffer[bytes], fillbuf, pad);
+
+    /* Put the 64-bit file length in *bits* at the end of the buffer.  */
+    *(md5_uint32 *) (&ctx->buffer[bytes + pad]) = SWAP (ctx->total[0] << 3);
+    *(md5_uint32 *) (&ctx->buffer[bytes + pad + 4]) = SWAP ((ctx->total[1] << 3) |
+                               (ctx->total[0] >> 29));
+
+    /* Process last bytes.  */
+    md5_process_block (ctx->buffer, bytes + pad + 8, ctx);
+
+    return md5_read_ctx (ctx, resbuf);
+}
+
+/* Compute MD5 message digest for bytes read from STREAM.  The
+ * resulting message digest number will be written into the 16 bytes
+ * beginning at RESBLOCK.  */
+int
+md5_stream ( FILE *stream, void *resblock )
+{
+    /* Important: BLOCKSIZE must be a multiple of 64.  */
+    #define BLOCKSIZE 4096
+    struct md5_ctx ctx;
+    char buffer[BLOCKSIZE + 72];
+    size_t sum;
+
+    /* Initialize the computation context.  */
+    md5_init_ctx (&ctx);
+
+    /* Iterate over full file contents.  */
+    while (1)
+    {
+        /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
+         *    computation function processes the whole buffer so that with the
+         *    next round of the loop another block can be read.  */
+        size_t n;
+        sum = 0;
+
+        /* Read block.  Take care for partial reads.  */
+        do
+        {
+            n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
+
+            sum += n;
+        }
+        while (sum < BLOCKSIZE && n != 0);
+        if (n == 0 && ferror (stream))
+            return 1;
+
+        /* If end of file is reached, end the loop.  */
+        if (n == 0)
+            break;
+
+        /* Process buffer with BLOCKSIZE bytes.  Note that
+         *           BLOCKSIZE % 64 == 0
+         */
+        md5_process_block (buffer, BLOCKSIZE, &ctx);
+    }
+
+    /* Add the last bytes if necessary.  */
+    if (sum > 0)
+        md5_process_bytes (buffer, sum, &ctx);
+
+    /* Construct result in desired memory.  */
+    md5_finish_ctx (&ctx, resblock);
+    return 0;
+}
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
+ * result is always in little endian byte order, so that a byte-wise
+ * output yields to the wanted ASCII representation of the message
+ * digest.  */
+void *
+md5_buffer ( const char *buffer, size_t len, void *resblock )
+{
+    struct md5_ctx ctx;
+
+    /* Initialize the computation context.  */
+    md5_init_ctx (&ctx);
+
+    /* Process whole buffer but last len % 64 bytes.  */
+    md5_process_bytes (buffer, len, &ctx);
+
+    /* Put result in desired memory area.  */
+    return md5_finish_ctx (&ctx, resblock);
+}
+
+
+void
+md5_process_bytes ( const void *buffer, size_t len, struct md5_ctx *ctx )
+{
+    /* When we already have some bits in our internal buffer concatenate
+     *    both inputs first.  */
+    if (ctx->buflen != 0)
+    {
+        size_t left_over = ctx->buflen;
+        size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+        memcpy (&ctx->buffer[left_over], buffer, add);
+        ctx->buflen += add;
+
+        if (left_over + add > 64)
+        {
+            md5_process_block (ctx->buffer, (left_over + add) & ~63, ctx);
+            /* The regions in the following copy operation cannot overlap.  */
+            memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
+                    (left_over + add) & 63);
+            ctx->buflen = (left_over + add) & 63;
+        }
+
+        buffer = (const void *) ((const char *) buffer + add);
+        len -= add;
+    }
+
+    /* Process available complete blocks.  */
+    if (len > 64)
+    {
+        md5_process_block (buffer, len & ~63, ctx);
+        buffer = (const void *) ((const char *) buffer + (len & ~63));
+        len &= 63;
+    }
+
+    /* Move remaining bytes in internal buffer.  */
+    if (len > 0)
+    {
+        memcpy (ctx->buffer, buffer, len);
+        ctx->buflen = len;
+    }
+}
+
+
+/* These are the four functions used in the four steps of the MD5 algorithm
+ * and defined in the RFC 1321.  The first function is a little bit optimized
+ * (as found in Colin Plumbs public domain implementation).  */
+/* #define FF(b, c, d) ((b & c) | (~b & d)) */
+#define FF(b, c, d) (d ^ (b & (c ^ d)))
+#define FG(b, c, d) FF (d, b, c)
+#define FH(b, c, d) (b ^ c ^ d)
+#define FI(b, c, d) (c ^ (b | ~d))
+
+/* Process LEN bytes of BUFFER, accumulating context into CTX.
+ *  It is assumed that LEN % 64 == 0.  */
+
+void
+md5_process_block ( const void *buffer, size_t len, struct md5_ctx *ctx )
+{
+    md5_uint32 correct_words[16];
+    const md5_uint32 *words = (const md5_uint32 *) buffer;
+    size_t nwords = len / sizeof (md5_uint32);
+    const md5_uint32 *endp = words + nwords;
+    md5_uint32 A = ctx->A;
+    md5_uint32 B = ctx->B;
+    md5_uint32 C = ctx->C;
+    md5_uint32 D = ctx->D;
+
+    /* First increment the byte count.  RFC 1321 specifies the possible
+     * length of the file up to 2^64 bits.  Here we only compute the
+     * number of bytes.  Do a double word increment.  */
+    ctx->total[0] += len;
+    if (ctx->total[0] < len)
+        ++ctx->total[1];
+
+    /* Process all bytes in the buffer with 64 bytes in each round of
+     * the loop.  */
+    while (words < endp)
+    {
+        md5_uint32 *cwp = correct_words;
+        md5_uint32 A_save = A;
+        md5_uint32 B_save = B;
+        md5_uint32 C_save = C;
+        md5_uint32 D_save = D;
+
+        /* First round: using the given function, the context and a constant
+         * the next context is computed.  Because the algorithms processing
+         * unit is a 32-bit word and it is determined to work on words in
+         * little endian byte order we perhaps have to change the byte order
+         * before the computation.  To reduce the work for the next steps
+         * we store the swapped words in the array CORRECT_WORDS.  */
+
+        #define OP(a, b, c, d, s, T)                        \
+        do                                \
+        {                               \
+        a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;     \
+        ++words;                          \
+        CYCLIC (a, s);                        \
+        a += b;                           \
+    }                               \
+    while (0)
+
+        /* It is unfortunate that C does not provide an operator for
+         * cyclic rotation.  Hope the C compiler is smart enough.  */
+        #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
+
+        /* Before we start, one word to the strange constants.
+         *    They are defined in RFC 1321 as
+         *
+         *    T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+         */
+
+        /* Round 1.  */
+        OP (A, B, C, D,  7, (md5_uint32) 0xd76aa478);
+        OP (D, A, B, C, 12, (md5_uint32) 0xe8c7b756);
+        OP (C, D, A, B, 17, (md5_uint32) 0x242070db);
+        OP (B, C, D, A, 22, (md5_uint32) 0xc1bdceee);
+        OP (A, B, C, D,  7, (md5_uint32) 0xf57c0faf);
+        OP (D, A, B, C, 12, (md5_uint32) 0x4787c62a);
+        OP (C, D, A, B, 17, (md5_uint32) 0xa8304613);
+        OP (B, C, D, A, 22, (md5_uint32) 0xfd469501);
+        OP (A, B, C, D,  7, (md5_uint32) 0x698098d8);
+        OP (D, A, B, C, 12, (md5_uint32) 0x8b44f7af);
+        OP (C, D, A, B, 17, (md5_uint32) 0xffff5bb1);
+        OP (B, C, D, A, 22, (md5_uint32) 0x895cd7be);
+        OP (A, B, C, D,  7, (md5_uint32) 0x6b901122);
+        OP (D, A, B, C, 12, (md5_uint32) 0xfd987193);
+        OP (C, D, A, B, 17, (md5_uint32) 0xa679438e);
+        OP (B, C, D, A, 22, (md5_uint32) 0x49b40821);
+
+        /* For the second to fourth round we have the possibly swapped words
+         * in CORRECT_WORDS.  Redefine the macro to take an additional first
+         * argument specifying the function to use.  */
+        #undef OP
+        #define OP(a, b, c, d, k, s, T)                     \
+        do                                \
+        {                               \
+        a += FX (b, c, d) + correct_words[k] + T;         \
+        CYCLIC (a, s);                        \
+        a += b;                           \
+    }                               \
+    while (0)
+
+        #define FX(b, c, d) FG (b, c, d)
+
+        /* Round 2.  */
+        OP (A, B, C, D,  1,  5, (md5_uint32) 0xf61e2562);
+    OP (D, A, B, C,  6,  9, (md5_uint32) 0xc040b340);
+    OP (C, D, A, B, 11, 14, (md5_uint32) 0x265e5a51);
+    OP (B, C, D, A,  0, 20, (md5_uint32) 0xe9b6c7aa);
+    OP (A, B, C, D,  5,  5, (md5_uint32) 0xd62f105d);
+    OP (D, A, B, C, 10,  9, (md5_uint32) 0x02441453);
+    OP (C, D, A, B, 15, 14, (md5_uint32) 0xd8a1e681);
+    OP (B, C, D, A,  4, 20, (md5_uint32) 0xe7d3fbc8);
+    OP (A, B, C, D,  9,  5, (md5_uint32) 0x21e1cde6);
+    OP (D, A, B, C, 14,  9, (md5_uint32) 0xc33707d6);
+    OP (C, D, A, B,  3, 14, (md5_uint32) 0xf4d50d87);
+    OP (B, C, D, A,  8, 20, (md5_uint32) 0x455a14ed);
+    OP (A, B, C, D, 13,  5, (md5_uint32) 0xa9e3e905);
+    OP (D, A, B, C,  2,  9, (md5_uint32) 0xfcefa3f8);
+    OP (C, D, A, B,  7, 14, (md5_uint32) 0x676f02d9);
+    OP (B, C, D, A, 12, 20, (md5_uint32) 0x8d2a4c8a);
+
+    #undef FX
+    #define FX(b, c, d) FH (b, c, d)
+
+    /* Round 3.  */
+    OP (A, B, C, D,  5,  4, (md5_uint32) 0xfffa3942);
+    OP (D, A, B, C,  8, 11, (md5_uint32) 0x8771f681);
+    OP (C, D, A, B, 11, 16, (md5_uint32) 0x6d9d6122);
+    OP (B, C, D, A, 14, 23, (md5_uint32) 0xfde5380c);
+    OP (A, B, C, D,  1,  4, (md5_uint32) 0xa4beea44);
+    OP (D, A, B, C,  4, 11, (md5_uint32) 0x4bdecfa9);
+    OP (C, D, A, B,  7, 16, (md5_uint32) 0xf6bb4b60);
+    OP (B, C, D, A, 10, 23, (md5_uint32) 0xbebfbc70);
+    OP (A, B, C, D, 13,  4, (md5_uint32) 0x289b7ec6);
+    OP (D, A, B, C,  0, 11, (md5_uint32) 0xeaa127fa);
+    OP (C, D, A, B,  3, 16, (md5_uint32) 0xd4ef3085);
+    OP (B, C, D, A,  6, 23, (md5_uint32) 0x04881d05);
+    OP (A, B, C, D,  9,  4, (md5_uint32) 0xd9d4d039);
+    OP (D, A, B, C, 12, 11, (md5_uint32) 0xe6db99e5);
+    OP (C, D, A, B, 15, 16, (md5_uint32) 0x1fa27cf8);
+    OP (B, C, D, A,  2, 23, (md5_uint32) 0xc4ac5665);
+
+    #undef FX
+    #define FX(b, c, d) FI (b, c, d)
+
+    /* Round 4.  */
+    OP (A, B, C, D,  0,  6, (md5_uint32) 0xf4292244);
+    OP (D, A, B, C,  7, 10, (md5_uint32) 0x432aff97);
+    OP (C, D, A, B, 14, 15, (md5_uint32) 0xab9423a7);
+    OP (B, C, D, A,  5, 21, (md5_uint32) 0xfc93a039);
+    OP (A, B, C, D, 12,  6, (md5_uint32) 0x655b59c3);
+    OP (D, A, B, C,  3, 10, (md5_uint32) 0x8f0ccc92);
+    OP (C, D, A, B, 10, 15, (md5_uint32) 0xffeff47d);
+    OP (B, C, D, A,  1, 21, (md5_uint32) 0x85845dd1);
+    OP (A, B, C, D,  8,  6, (md5_uint32) 0x6fa87e4f);
+    OP (D, A, B, C, 15, 10, (md5_uint32) 0xfe2ce6e0);
+    OP (C, D, A, B,  6, 15, (md5_uint32) 0xa3014314);
+    OP (B, C, D, A, 13, 21, (md5_uint32) 0x4e0811a1);
+    OP (A, B, C, D,  4,  6, (md5_uint32) 0xf7537e82);
+    OP (D, A, B, C, 11, 10, (md5_uint32) 0xbd3af235);
+    OP (C, D, A, B,  2, 15, (md5_uint32) 0x2ad7d2bb);
+    OP (B, C, D, A,  9, 21, (md5_uint32) 0xeb86d391);
+
+    /* Add the starting values of the context.  */
+    A += A_save;
+    B += B_save;
+    C += C_save;
+    D += D_save;
+    }
+
+    /* Put checksum in context given as argument.  */
+    ctx->A = A;
+    ctx->B = B;
+    ctx->C = C;
+    ctx->D = D;
+}
diff --git a/3d-viewer/3d_cache/md5.h b/3d-viewer/3d_cache/md5.h
new file mode 100644
index 0000000000..9e67521b72
--- /dev/null
+++ b/3d-viewer/3d_cache/md5.h
@@ -0,0 +1,146 @@
+/* md5.h - Declaration of functions and data types used for MD5 sum
+   computing library functions.
+
+   Copyright 1995, 1996, 2000 Free Software Foundation, Inc.
+   NOTE: The canonical source of this file is maintained with the GNU C
+   Library.  Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2, or (at your option) any
+   later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+#ifndef _MD5_H
+#define _MD5_H 1
+
+#include <stdio.h>
+
+#if defined HAVE_LIMITS_H || _LIBC
+# include <limits.h>
+#endif
+
+/* The following contortions are an attempt to use the C preprocessor
+   to determine an unsigned integral type that is 32 bits wide.  An
+   alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
+   doing that would require that the configure script compile and *run*
+   the resulting executable.  Locally running cross-compiled executables
+   is usually not possible.
+ */
+
+#ifdef _LIBC
+# include <sys/types.h>
+typedef u_int32_t md5_uint32;
+#else
+#  define INT_MAX_32_BITS 2147483647
+
+/* If UINT_MAX isn't defined, assume it's a 32-bit type.
+   This should be valid for all systems GNU cares about because
+   that doesn't include 16-bit systems, and only modern systems
+   (that certainly have <limits.h>) have 64+-bit integral types.
+ */
+
+# ifndef INT_MAX
+#  define INT_MAX INT_MAX_32_BITS
+# endif
+
+# if INT_MAX == INT_MAX_32_BITS
+typedef unsigned int md5_uint32;
+# else
+#  if SHRT_MAX == INT_MAX_32_BITS
+typedef unsigned short md5_uint32;
+#  else
+#   if LONG_MAX == INT_MAX_32_BITS
+typedef unsigned long md5_uint32;
+#   else
+/* The following line is intended to evoke an error.
+ *  Using #error is not portable enough.  */
+"Cannot determine unsigned 32-bit data type."
+#   endif
+#  endif
+# endif
+#endif
+
+#undef __P
+#if defined (__STDC__) && __STDC__
+#define __P(x) x
+#else
+#define __P(x) ()
+#endif
+
+/* Structure to save state of computation between the single steps.  */
+struct md5_ctx
+{
+    md5_uint32 A;
+    md5_uint32 B;
+    md5_uint32 C;
+    md5_uint32 D;
+
+    md5_uint32 total[2];
+    md5_uint32 buflen;
+    char buffer[128];
+};
+
+/*
+ * The following three functions are build up the low level used in
+ * the functions `md5_stream' and `md5_buffer'.
+ */
+
+/* Initialize structure containing state of computation.
+   (RFC 1321, 3.3: Step 3)  */
+extern void md5_init_ctx __P ((struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is necessary that LEN is a multiple of 64!!! */
+extern void md5_process_block __P ((const void *buffer, size_t len,
+                                    struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is NOT required that LEN is a multiple of 64.  */
+extern void md5_process_bytes __P ((const void *buffer, size_t len,
+                                    struct md5_ctx *ctx));
+
+/* Process the remaining bytes in the buffer and put result from CTX
+   in first 16 bytes following RESBUF.  The result is always in little
+   endian byte order, so that a byte-wise output yields to the wanted
+   ASCII representation of the message digest.
+
+   IMPORTANT: On some systems it is required that RESBUF is correctly
+   aligned for a 32 bits value.  */
+extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
+
+
+/* Put result from CTX in first 16 bytes following RESBUF.  The result is
+   always in little endian byte order, so that a byte-wise output yields
+   to the wanted ASCII representation of the message digest.
+
+   IMPORTANT: On some systems it is required that RESBUF is correctly
+   aligned for a 32 bits value.  */
+extern void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
+
+
+/* Compute MD5 message digest for bytes read from STREAM.  The
+   resulting message digest number will be written into the 16 bytes
+   beginning at RESBLOCK.  */
+extern int md5_stream __P ((FILE *stream, void *resblock));
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
+   result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+extern void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
+
+#endif
diff --git a/3d-viewer/3d_cache/sg/CMakeLists.txt b/3d-viewer/3d_cache/sg/CMakeLists.txt
new file mode 100644
index 0000000000..d7926c2e86
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/CMakeLists.txt
@@ -0,0 +1,55 @@
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+#    ${CMAKE_SOURCE_DIR}/include/gal/opengl
+    ${CMAKE_SOURCE_DIR}/3d-viewer
+  )
+
+
+add_library( s3d_sg SHARED
+    sg_base.cpp
+    sg_node.cpp
+    sg_helpers.cpp
+    scenegraph.cpp
+    sg_appearance.cpp
+    sg_faceset.cpp
+    sg_shape.cpp
+    sg_colors.cpp
+    sg_coords.cpp
+    sg_normals.cpp
+    sg_index.cpp
+    sg_colorindex.cpp
+    sg_coordindex.cpp
+    ifsg_node.cpp
+    ifsg_transform.cpp
+    ifsg_appearance.cpp
+    ifsg_index.cpp
+    ifsg_colorindex.cpp
+    ifsg_coordindex.cpp
+    ifsg_colors.cpp
+    ifsg_coords.cpp
+    ifsg_faceset.cpp
+    ifsg_normals.cpp
+    ifsg_shape.cpp
+    ifsg_api.cpp
+)
+
+if( MSVC )
+    # Define a flag to expose the appropriate SG_DLL macro at build time
+    target_compile_definitions( s3d_sg PRIVATE -DDLL_SGIF )
+endif()
+
+target_link_libraries( s3d_sg ${wxWidgets_LIBRARIES} )
+
+if( APPLE )
+        install( TARGETS
+                s3d_sg
+                DESTINATION /Applications/kicad.app/SharedSupport
+                COMPONENT binary
+        )
+else()
+        install( TARGETS
+                s3d_sg
+                DESTINATION lib/kicad
+                COMPONENT binary
+        )
+endif()
diff --git a/3d-viewer/3d_cache/sg/api_sg_node.cpp b/3d-viewer/3d_cache/sg/api_sg_node.cpp
new file mode 100644
index 0000000000..6af4099ee5
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/api_sg_node.cpp
@@ -0,0 +1,149 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include "sg_api.h"
+#include "sg_node.h"
+
+S3D::API_SGNODE::API_SGNODE()
+{
+    node = NULL;
+    nodeType = SGTYPE_END;  // signal an invalid type by default
+
+    return;
+}
+
+
+SGNODE* S3D::API_SGNODE::GetNode( void )
+{
+    return node;
+}
+
+
+bool S3D::API_SGNODE::AttachNode( SGNODE* aNode )
+{
+    if( NULL == aNode )
+    {
+        node = NULL;
+        return true;
+    }
+
+    if( aNode->GetNodeType() != nodeType )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] object with node type " << aNode->GetNodeType();
+        std::cerr << " is being attached to API node type " << nodeType << "\n";
+        return false;
+    }
+
+    node = aNode;
+    return true;
+}
+
+
+bool S3D::API_SGNODE::GetNodeType( S3D::SGTYPES& aNodeType ) const
+{
+    if( NULL == node )
+    {
+        aNodeType = SGTYPE_END;
+        return false;
+    }
+
+    aNodeType = node->GetNodeType();
+    return true;
+}
+
+
+bool S3D::API_SGNODE::GetParent( SGNODE const*& aParent ) const
+{
+    if( NULL == node )
+    {
+        aParent = NULL;
+        return false;
+    }
+
+    aParent = node->GetParent();
+    return true;
+}
+
+
+bool S3D::API_SGNODE::SetParent( SGNODE* aParent )
+{
+    if( NULL == node )
+        return false;
+
+    return node->SetParent( aParent );
+}
+
+
+bool S3D::API_SGNODE::GetName( const char*& aName )
+{
+    if( NULL == node )
+    {
+        aName = NULL;
+        return false;
+    }
+
+    aName = node->GetName();
+    return true;
+}
+
+
+bool S3D::API_SGNODE::SetName( const char *aName )
+{
+    if( NULL == node )
+        return false;
+
+    node->SetName( aName );
+    return true;
+}
+
+
+bool S3D::API_SGNODE::GetNodeTypeName( S3D::SGTYPES aNodeType, const char*& aName ) const
+{
+    if( NULL == node )
+    {
+        aName = NULL;
+        return false;
+    }
+
+    aName = node->GetNodeTypeName( aNodeType );
+    return true;
+}
+
+
+bool S3D::API_SGNODE::FindNode( const char *aNodeName, const SGNODE *aCaller, SGNODE*& aNode )
+{
+    if( NULL == node )
+    {
+        aNode = NULL;
+        return false;
+    }
+
+    aNode = node->FindNode( aNodeName, aCaller );
+
+    if( NULL == aNode )
+        return false;
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/api_sg_transform.cpp b/3d-viewer/3d_cache/sg/api_sg_transform.cpp
new file mode 100644
index 0000000000..13dd09e666
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/api_sg_transform.cpp
@@ -0,0 +1,26 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <3d_cache/sg/sg_api.h>
+
+XXX - TO BE IMPLEMENTED
diff --git a/3d-viewer/3d_cache/sg/ifsg_all.h b/3d-viewer/3d_cache/sg/ifsg_all.h
new file mode 100644
index 0000000000..43471aa229
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_all.h
@@ -0,0 +1,38 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_all.h
+ * collects header files for all SG* wrappers and the API
+ */
+
+#include <3d_cache/sg/ifsg_transform.h>
+#include <3d_cache/sg/ifsg_appearance.h>
+#include <3d_cache/sg/ifsg_colors.h>
+#include <3d_cache/sg/ifsg_coords.h>
+#include <3d_cache/sg/ifsg_faceset.h>
+#include <3d_cache/sg/ifsg_colorindex.h>
+#include <3d_cache/sg/ifsg_coordindex.h>
+#include <3d_cache/sg/ifsg_normals.h>
+#include <3d_cache/sg/ifsg_shape.h>
+#include <3d_cache/sg/ifsg_api.h>
diff --git a/3d-viewer/3d_cache/sg/ifsg_api.cpp b/3d-viewer/3d_cache/sg/ifsg_api.cpp
new file mode 100644
index 0000000000..00e4161748
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_api.cpp
@@ -0,0 +1,413 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <locale.h>
+#include <wx/filename.h>
+#include <wx/string.h>
+#include <3d_cache/sg/ifsg_api.h>
+#include <3d_cache/sg/sg_types.h>
+#include <3d_cache/sg/sg_node.h>
+#include <3d_cache/sg/scenegraph.h>
+#include <3d_cache/sg/sg_appearance.h>
+#include <3d_cache/sg/sg_colorindex.h>
+#include <3d_cache/sg/sg_colors.h>
+#include <3d_cache/sg/sg_coordindex.h>
+#include <3d_cache/sg/sg_coords.h>
+#include <3d_cache/sg/sg_faceset.h>
+#include <3d_cache/sg/sg_normals.h>
+#include <3d_cache/sg/sg_shape.h>
+#include <3d_info.h>
+#include <3d_rendering/c3dmodel.h>
+
+
+static char BadNode[] = " * [BUG] NULL pointer passed for aNode\n";
+
+static void formatMaterial( SMATERIAL& mat, SGAPPEARANCE const* app )
+{
+    float v0, v1, v2;
+
+    v0 = app->ambient;
+    mat.m_Ambient.x = v0;
+    mat.m_Ambient.y = v0;
+    mat.m_Ambient.z = v0;
+
+    app->diffuse.GetColor( v0, v1, v2 );
+    mat.m_Diffuse.x = v0;
+    mat.m_Diffuse.y = v1;
+    mat.m_Diffuse.z = v2;
+
+    app->emissive.GetColor( v0, v1, v2 );
+    mat.m_Emissive.x = v0;
+    mat.m_Emissive.y = v1;
+    mat.m_Emissive.z = v2;
+
+    app->specular.GetColor( v0, v1, v2 );
+    mat.m_Specular.x = v0;
+    mat.m_Specular.y = v1;
+    mat.m_Specular.z = v2;
+
+    mat.m_Shininess = app->shininess;
+    mat.m_Transparency = app->transparency;
+
+    return;
+}
+
+
+class VRML_LOCALE
+{
+private:
+    std::string lname;
+
+public:
+    VRML_LOCALE()
+    {
+        lname = setlocale( LC_NUMERIC, NULL );
+        setlocale( LC_NUMERIC, "C" );   // switch the numerics locale to "C"
+    }
+
+    ~VRML_LOCALE()
+    {
+        setlocale( LC_NUMERIC, lname.c_str() ); // revert to the previous locale
+    }
+};
+
+
+bool S3D::WriteVRML( const wxString& filename, bool overwrite, SGNODE* aTopNode,
+    bool reuse, bool renameNodes )
+{
+    if( wxFileName::Exists( filename ) )
+    {
+        if( !overwrite )
+            return false;
+
+        // make sure we make no attempt to write a directory
+        if( !wxFileName::FileExists( filename ) )
+            return false;
+    }
+
+    if( NULL == aTopNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aTopNode\n";
+        return false;
+    }
+
+    if( S3D::SGTYPE_TRANSFORM != aTopNode->GetNodeType() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] aTopNode is not a SCENEGRAPH object\n";
+        return false;
+    }
+
+    VRML_LOCALE vrmlLocale;
+    std::ofstream op;
+    op.open( filename.ToUTF8(), std::ios_base::out | std::ios_base::trunc
+                                 | std::ios_base::binary );
+
+    if( !op.is_open() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] failed to open file '" << filename.ToUTF8() << "'\n";
+        return false;
+    }
+
+    op << "#VRML V2.0 utf8\n";
+
+    if( renameNodes )
+    {
+        aTopNode->ResetNodeIndex();
+        aTopNode->ReNameNodes();
+    }
+
+    aTopNode->WriteVRML( op, reuse );
+
+    if( !op.fail() )
+    {
+        op.close();
+        return true;
+    }
+
+    op.close();
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [INFO] problems encountered writing file '" << filename.ToUTF8() << "'\n";
+    return false;
+}
+
+
+void S3D::ResetNodeIndex( SGNODE* aNode )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadNode;
+        return;
+    }
+
+    aNode->ResetNodeIndex();
+
+    return;
+}
+
+
+void S3D::RenameNodes( SGNODE* aNode )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadNode;
+        return;
+    }
+
+    aNode->ReNameNodes();
+
+    return;
+}
+
+
+void S3D::DestroyNode( SGNODE* aNode )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadNode;
+        return;
+    }
+
+    delete aNode;
+
+    return;
+}
+
+
+bool S3D::WriteCache( const wxString& aFileName, bool overwrite, SGNODE* aNode )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadNode;
+        return false;
+    }
+
+
+    if( wxFileName::Exists( aFileName ) )
+    {
+        if( !overwrite )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] file exists; not overwriting: '";
+            std::cerr << aFileName.ToUTF8() << "'\n";
+            return false;
+        }
+
+        // make sure we make no attempt to write a directory
+        if( !wxFileName::FileExists( aFileName ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] specified path is a directory: '";
+            std::cerr << aFileName.ToUTF8() << "'\n";
+            return false;
+        }
+    }
+
+    std::ofstream output;
+    output.open( aFileName.ToUTF8(), std::ios_base::out | std::ios_base::trunc
+                                | std::ios_base::binary );
+
+    if( !output.is_open() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] failed to open file '" << aFileName.ToUTF8() << "'\n";
+        return false;
+    }
+
+    bool rval = aNode->WriteCache( output, NULL );
+    output.close();
+
+    if( !rval )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] problems encountered writing cache file '";
+        std::cerr << aFileName.ToUTF8() << "'\n";
+    }
+
+    return rval;
+}
+
+
+SGNODE* S3D::ReadCache( const wxString& aFileName )
+{
+    if( !wxFileName::FileExists( aFileName ) )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] no such file: '";
+        std::cerr << aFileName.ToUTF8() << "'\n";
+    }
+
+    SGNODE* np = new SCENEGRAPH( NULL );
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] failed to instantiate SCENEGRAPH\n";
+        return NULL;
+    }
+
+    std::ifstream file;
+    file.open( aFileName.ToUTF8(), std::ios_base::in | std::ios_base::binary );
+
+    if( !file.is_open() )
+    {
+        delete np;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] failed to open file '";
+        std::cerr << aFileName.ToUTF8() << "'\n";
+        return NULL;
+    }
+
+    bool rval = np->ReadCache( file, NULL );
+    file.close();
+
+    if( !rval )
+    {
+        delete np;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] problems encountered reading cache file '";
+        std::cerr << aFileName.ToUTF8() << "'\n";
+        return NULL;
+    }
+
+    return np;
+}
+
+
+S3DMODEL* S3D::Prepare( SCENEGRAPH* aNode, const glm::dmat4* aTransform )
+{
+    S3D::MATLIST materials;
+    std::vector< SMESH > meshes;
+
+    // the materials list shall have a default color; although the VRML
+    // default is an opaque black, the default used here shall be a median
+    // gray in hopes that it may help highlight faulty models; this color is
+    // also typical of MCAD applications. When a model has no associated
+    // material color it shall be assigned the index 0.
+    SGAPPEARANCE app( NULL );
+    app.ambient = 0.9;
+    app.diffuse = SGCOLOR( 0.6, 0.6, 0.6 );
+    app.specular = app.diffuse;
+    app.shininess = 0.05;
+    app.transparency = 0.0;
+
+    materials.matorder.push_back( &app );
+    materials.matmap.insert( std::pair< SGAPPEARANCE const*, int >( &app, 0 ) );
+
+    if( aNode->Prepare( aTransform, materials, meshes ) )
+    {
+        if( meshes.empty() )
+            return NULL;
+
+        S3DMODEL* model = S3D::New3DModel();
+
+        // add all the materials
+        size_t j = materials.matorder.size();
+        SMATERIAL* lmat = new SMATERIAL[j];
+
+        for( int i = 0; i < j; ++i )
+            formatMaterial( lmat[i], materials.matorder[i] );
+
+        model->m_Materials = lmat;
+        model->m_MaterialsSize = j;
+
+        // add all the meshes
+        j = meshes.size();
+        SMESH* lmesh = new SMESH[j];
+
+        for( int i = 0; i < j; ++i )
+            lmesh[i] = meshes[i];
+
+        model->m_Meshes = lmesh;
+        model->m_MeshesSize = j;
+
+        return model;
+    }
+
+    size_t j = meshes.size();
+
+    for( size_t i = 0; i < j; ++i )
+        S3D::Free3DMesh( meshes[i] );
+
+    return NULL;
+}
+
+
+void S3D::Destroy3DModel( S3DMODEL** aModel )
+{
+    if( NULL == aModel || NULL == *aModel )
+        return;
+
+    S3DMODEL* m = *aModel;
+    S3D::FREE_S3DMODEL( *m );
+    delete m;
+    *aModel = NULL;
+
+    return;
+}
+
+
+void Free3DModel( S3DMODEL& aModel )
+{
+    S3D::FREE_S3DMODEL( aModel );
+    return;
+}
+
+
+void S3D::Free3DMesh( SMESH& aMesh )
+{
+    S3D::FREE_SMESH( aMesh );
+    return;
+}
+
+
+S3DMODEL* S3D::New3DModel( void )
+{
+    S3DMODEL* mp = new S3DMODEL;
+    S3D::INIT_S3DMODEL( *mp );
+    return mp;
+}
+
+
+void S3D::Init3DMaterial( SMATERIAL& aMat )
+{
+    S3D::INIT_SMATERIAL( aMat );
+    return;
+}
+
+
+void S3D::Init3DMesh( SMESH& aMesh )
+{
+    S3D::INIT_SMESH( aMesh );
+
+    return;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_api.h b/3d-viewer/3d_cache/sg/ifsg_api.h
new file mode 100644
index 0000000000..e7609dc332
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_api.h
@@ -0,0 +1,182 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_api.h
+ * defines the API calls for the manipulation of SG* classes
+ */
+
+#ifndef IFSG_API_H
+#define IFSG_API_H
+
+#include <wx/string.h>
+#include <glm/glm.hpp>
+#include <3d_cache/sg/sg_types.h>
+#include <3d_cache/sg/sg_base.h>
+#include <3d_rendering/c3dmodel.h>
+
+class SGNODE;
+class SCENEGRAPH;
+struct S3D_INFO;
+struct S3D_POINT;
+
+namespace S3D
+{
+    /**
+     * Function WriteCache
+     * writes the SGNODE tree to a binary cache file
+     *
+     * @param aFileName is the name of the file to write
+     * @param overwrite must be set to true to overwrite an existing file
+     * @param aNode is any node within the node tree which is to be written
+     * @return true on success
+     */
+    bool WriteCache( const wxString& aFileName, bool overwrite, SGNODE* aNode );
+
+    /**
+     * Function ReadCache
+     * reads a binary cache file and creates an SGNODE tree
+     *
+     * @param aFileName is the name of the binary cache file to be read
+     * @return NULL on failure, on success a pointer to the top level SCENEGRAPH node;
+     * if desired this node can be associated with an IFSG_TRANSFORM wrapper via
+     * the IFSG_TRANSFORM::Attach() function.
+     */
+    SGNODE* ReadCache( const wxString& aFileName );
+
+    /**
+     * Function WriteVRML
+     * writes out the given node and its subnodes to a VRML2 file
+     *
+     * @param filename is the name of the output file
+     * @param overwrite should be set to true to overwrite an existing VRML file
+     * @param aTopNode is a pointer to a SCENEGRAPH object representing the VRML scene
+     * @param reuse should be set to true to make use of VRML DEF/USE features
+     * @return true on success
+     */
+    bool WriteVRML( const wxString& filename, bool overwrite, SGNODE* aTopNode,
+                    bool reuse, bool renameNodes );
+
+    // NOTE: The following functions are used in combination to create a VRML
+    // assembly which may use various instances of each SG* representation of a module.
+    // A typical use case would be:
+    // 1. invoke 'ResetNodeIndex()' to reset the global node name indices
+    // 2. for each model pointer provided by 'S3DCACHE->Load()', invoke 'RenameNodes()' once;
+    //    this ensures that all nodes have a unique name to present to the final output file.
+    //    Internally, RenameNodes() will only rename the given node and all Child subnodes;
+    //    nodes which are only referenced will not be renamed. Using the pointer supplied
+    //    by 'S3DCACHE->Load()' ensures that all nodes but the returned node (top node) are
+    //    children of at least one node, so all nodes are given unique names.
+    // 3. if SG* trees are created independently of S3DCACHE->Load() the user must invoke
+    //    RenameNodes() as appropriate to ensure that all nodes have a unique name
+    // 4. create an assembly structure by creating new IFSG_TRANSFORM nodes as appropriate
+    //    for each instance of a component; the component base model as returned by
+    //    S3DCACHE->Load() may be added to these IFSG_TRANSFORM nodes via 'AddRefNode()';
+    //    set the offset, rotation, etc of the IFSG_TRANSFORM node to ensure correct
+    // 5. Ensure that all new IFSG_TRANSFORM nodes are placed as child nodes within a
+    //    top level IFSG_TRANSFORM node in preparation for final node naming and output
+    // 6. Invoke RenameNodes() on the top level assembly node
+    // 7. Invoke WriteVRML() as normal, with renameNodes = false, to write the entire assembly
+    //    structure to a single VRML file
+    // 8. Clean up by deleting any extra IFSG_TRANSFORM wrappers and their underlying SG*
+    //    classes which have been created solely for the assembly output
+
+    /**
+     * Function ResetNodeIndex
+     * resets the global SG* class indices
+     *
+     * @param aNode may be any valid SGNODE
+     */
+    void ResetNodeIndex( SGNODE* aNode );
+
+    /**
+     * Function RenameNodes
+     * renames a node and all children nodes based on the current
+     * values of the global SG* class indices
+     *
+     * @param aNode is a top level node
+     */
+    void RenameNodes( SGNODE* aNode );
+
+    /**
+     * Function DestroyNode
+     * deletes the given SG* class node. This function makes it possible
+     * to safely delete an SG* node without associating the node with
+     * its corresponding IFSG* wrapper.
+     */
+    void DestroyNode( SGNODE* aNode );
+
+    // NOTE: The following functions facilitate the creation and destruction
+    // of data structures for rendering
+
+    /**
+     * Function Prepare
+     * creates an S3DMODEL representation of aNode transformed by aTransform.
+     *
+     * @param aNode is the node to be transcribed into an S3DMODEL representation
+     * @param aTransform is the transform (Translation * Rotation * Scale) to apply
+     * to the representation of aNode; it must be a pointer to a glm::dmat4 entity
+     *
+     * @return an S3DMODEL representation of aNode on success, otherwise NULL
+     */
+    S3DMODEL* Prepare( SCENEGRAPH* aNode, const glm::dmat4* aTransform );
+
+    /**
+     * Function Destroy3DModel
+     * frees memory used by an S3DMODEL structure and sets the pointer to
+     * the structure to NULL
+     */
+    void Destroy3DModel( S3DMODEL** aModel );
+
+    /**
+     * Function Free3DModel
+     * frees memory used internally by an S3DMODEL structure
+     */
+    void Free3DModel( S3DMODEL& aModel );
+
+    /**
+     * Function Free3DMesh
+     * frees memory used internally by an SMESH structure
+     */
+    void Free3DMesh( SMESH& aMesh );
+
+    /**
+     * Function New3DModel
+     * creates and initializes an S3DMODEL struct
+     */
+    S3DMODEL* New3DModel( void );
+
+    /**
+     * Function Init3DMaterial
+     * initializes an SMATERIAL struct
+     */
+    void Init3DMaterial( SMATERIAL& aMat );
+
+    /**
+     * Function Init3DMesh
+     * creates and initializes an SMESH struct
+     */
+    void Init3DMesh( SMESH& aMesh );
+};
+
+#endif  // IFSG_API_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_appearance.cpp b/3d-viewer/3d_cache/sg/ifsg_appearance.cpp
new file mode 100644
index 0000000000..01f3c9cd21
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_appearance.cpp
@@ -0,0 +1,344 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_appearance.h>
+#include <3d_cache/sg/sg_appearance.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_APPEARANCE::IFSG_APPEARANCE( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return ;
+
+    m_node = new SGAPPEARANCE( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_APPEARANCE::IFSG_APPEARANCE( SGNODE* aParent )
+{
+    m_node = new SGAPPEARANCE( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+IFSG_APPEARANCE::IFSG_APPEARANCE( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( ! pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+    }
+
+    m_node = new SGAPPEARANCE( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( pp ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_APPEARANCE::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_APPEARANCE != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_APPEARANCE::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGAPPEARANCE( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGAPPEARANCE\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_APPEARANCE::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
+
+
+bool IFSG_APPEARANCE::SetEmissive( float aRVal, float aGVal, float aBVal )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetEmissive( aRVal, aGVal, aBVal );
+}
+
+
+bool IFSG_APPEARANCE::SetEmissive( const SGCOLOR* aRGBColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetEmissive( aRGBColor );
+}
+
+
+bool IFSG_APPEARANCE::SetEmissive( const SGCOLOR& aRGBColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetEmissive( aRGBColor );
+}
+
+
+bool IFSG_APPEARANCE::SetDiffuse( float aRVal, float aGVal, float aBVal )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetDiffuse( aRVal, aGVal, aBVal );
+}
+
+
+bool IFSG_APPEARANCE::SetDiffuse( const SGCOLOR* aRGBColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetDiffuse( aRGBColor );
+}
+
+
+bool IFSG_APPEARANCE::SetDiffuse( const SGCOLOR& aRGBColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetDiffuse( aRGBColor );
+}
+
+
+bool IFSG_APPEARANCE::SetSpecular( float aRVal, float aGVal, float aBVal )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetSpecular( aRVal, aGVal, aBVal );
+}
+
+
+bool IFSG_APPEARANCE::SetSpecular( const SGCOLOR* aRGBColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetSpecular( aRGBColor );
+}
+
+
+bool IFSG_APPEARANCE::SetSpecular( const SGCOLOR& aRGBColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGAPPEARANCE*)m_node)->SetSpecular( aRGBColor );
+}
+
+
+bool IFSG_APPEARANCE::SetAmbient( float aAmbientLight )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    if( aAmbientLight < 0 || aAmbientLight > 1.0 )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] ambient intensity out of range [0..1]\n";
+        return false;
+    }
+
+    ((SGAPPEARANCE*)m_node)->ambient = aAmbientLight;
+
+    return true;
+}
+
+bool IFSG_APPEARANCE::SetShininess( float aShininess )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    if( aShininess < 0 || aShininess > 1.0 )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] shininess out of range [0..1]\n";
+        return false;
+    }
+
+    ((SGAPPEARANCE*)m_node)->shininess = aShininess;
+
+    return true;
+}
+
+
+bool IFSG_APPEARANCE::SetTransparency( float aTransparency )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    if( aTransparency < 0 || aTransparency > 1.0 )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] shininess out of range [0..1]\n";
+        return false;
+    }
+
+    ((SGAPPEARANCE*)m_node)->transparency = aTransparency;
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_appearance.h b/3d-viewer/3d_cache/sg/ifsg_appearance.h
new file mode 100644
index 0000000000..bdc982e3e0
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_appearance.h
@@ -0,0 +1,63 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_appearance.h
+ * defines the wrapper of the SGAPPEARANCE class
+ */
+
+#ifndef IFSG_APPEARANCE_H
+#define IFSG_APPEARANCE_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+class IFSG_APPEARANCE : public IFSG_NODE
+{
+public:
+    IFSG_APPEARANCE( bool create );
+    IFSG_APPEARANCE( SGNODE* aParent );
+    IFSG_APPEARANCE( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+
+    bool SetEmissive( float aRVal, float aGVal, float aBVal );
+    bool SetEmissive( const SGCOLOR* aRGBColor );
+    bool SetEmissive( const SGCOLOR& aRGBColor );
+
+    bool SetDiffuse( float aRVal, float aGVal, float aBVal );
+    bool SetDiffuse( const SGCOLOR* aRGBColor );
+    bool SetDiffuse( const SGCOLOR& aRGBColor );
+
+    bool SetSpecular( float aRVal, float aGVal, float aBVal );
+    bool SetSpecular( const SGCOLOR* aRGBColor );
+    bool SetSpecular( const SGCOLOR& aRGBColor );
+
+    bool SetAmbient( float aAmbientLight );
+    bool SetShininess( float aShininess );
+    bool SetTransparency( float aTransparency );
+};
+
+#endif  // IFSG_APPEARANCE_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_colorindex.cpp b/3d-viewer/3d_cache/sg/ifsg_colorindex.cpp
new file mode 100644
index 0000000000..51a7181e41
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_colorindex.cpp
@@ -0,0 +1,158 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_colorindex.h>
+#include <3d_cache/sg/sg_colorindex.h>
+#include <3d_cache/sg/sg_types.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_COLORINDEX::IFSG_COLORINDEX( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return;
+
+    m_node = new SGCOLORINDEX( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_COLORINDEX::IFSG_COLORINDEX( SGNODE* aParent )
+{
+    m_node = new SGCOLORINDEX( NULL );
+
+    if( !m_node->SetParent( aParent ) )
+    {
+        delete m_node;
+        m_node = NULL;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << WrongParent << "\n";
+        return;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_COLORINDEX::IFSG_COLORINDEX( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( !pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return;
+    }
+
+    m_node = new SGCOLORINDEX( NULL );
+
+    if( !m_node->SetParent( pp ) )
+    {
+        delete m_node;
+        m_node = NULL;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << WrongParent << "\n";
+        return;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+bool IFSG_COLORINDEX::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_COLORINDEX != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COLORINDEX::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGCOLORINDEX( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGCOLORINDEX\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COLORINDEX::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_colorindex.h b/3d-viewer/3d_cache/sg/ifsg_colorindex.h
new file mode 100644
index 0000000000..e16023e645
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_colorindex.h
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_colorindex.h
+ * defines the ColorIndex node wrapper
+ */
+
+
+#ifndef IFSG_COLORINDEX_H
+#define IFSG_COLORINDEX_H
+
+#include <3d_cache/sg/ifsg_index.h>
+
+
+/**
+ * Class IFSG_COLORINDEX
+ * is the wrapper for SGCOLORINDEX
+ */
+class SG_DLL IFSG_COLORINDEX : public IFSG_INDEX
+{
+public:
+    IFSG_COLORINDEX( bool create );
+    IFSG_COLORINDEX( SGNODE* aParent );
+    IFSG_COLORINDEX( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+};
+
+#endif  // IFSG_COLORINDEX_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_colors.cpp b/3d-viewer/3d_cache/sg/ifsg_colors.cpp
new file mode 100644
index 0000000000..520aa937f1
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_colors.cpp
@@ -0,0 +1,218 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_colors.h>
+#include <3d_cache/sg/sg_colors.h>
+
+
+extern char BadObject[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_COLORS::IFSG_COLORS( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return ;
+
+    m_node = new SGCOLORS( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_COLORS::IFSG_COLORS( SGNODE* aParent )
+{
+    m_node = new SGCOLORS( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+IFSG_COLORS::IFSG_COLORS( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( ! pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+    }
+
+    m_node = new SGCOLORS( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( pp ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_COLORS::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_COLORS != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COLORS::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGCOLORS( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGCOLORS\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COLORS::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
+
+
+bool IFSG_COLORS::GetColorList( size_t& aListSize, SGCOLOR*& aColorList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGCOLORS*)m_node)->GetColorList( aListSize, aColorList );
+}
+
+
+bool IFSG_COLORS::SetColorList( size_t& aListSize, const SGCOLOR* aColorList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGCOLORS*)m_node)->SetColorList( aListSize, aColorList );
+
+    return true;
+}
+
+
+bool IFSG_COLORS::AddColor( double aRedValue, double aGreenValue, double aBlueValue )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGCOLORS*)m_node)->AddColor( aRedValue, aGreenValue, aBlueValue );
+
+    return true;
+}
+
+
+bool IFSG_COLORS::AddColor( const SGCOLOR& aColor )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGCOLORS*)m_node)->AddColor( aColor );
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_colors.h b/3d-viewer/3d_cache/sg/ifsg_colors.h
new file mode 100644
index 0000000000..456e34d491
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_colors.h
@@ -0,0 +1,57 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_colors.h
+ * defines the color list wrapper
+ */
+
+
+#ifndef IFSG_COLORS_H
+#define IFSG_COLORS_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_INDEX
+ * is the wrapper for SGCOLORS
+ */
+class SG_DLL IFSG_COLORS : public IFSG_NODE
+{
+public:
+    IFSG_COLORS( bool create );
+    IFSG_COLORS( SGNODE* aParent );
+    IFSG_COLORS( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+
+    bool GetColorList( size_t& aListSize, SGCOLOR*& aColorList );
+    bool SetColorList( size_t& aListSize, const SGCOLOR* aColorList );
+    bool AddColor( double aRedValue, double aGreenValue, double aBlueValue );
+    bool AddColor( const SGCOLOR& aColor );
+};
+
+#endif  // IFSG_COLORS_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_coordindex.cpp b/3d-viewer/3d_cache/sg/ifsg_coordindex.cpp
new file mode 100644
index 0000000000..19aaa7dbe0
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_coordindex.cpp
@@ -0,0 +1,158 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_coordindex.h>
+#include <3d_cache/sg/sg_coordindex.h>
+#include <3d_cache/sg/sg_types.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_COORDINDEX::IFSG_COORDINDEX( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return;
+
+    m_node = new SGCOORDINDEX( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_COORDINDEX::IFSG_COORDINDEX( SGNODE* aParent )
+{
+    m_node = new SGCOORDINDEX( NULL );
+
+    if( !m_node->SetParent( aParent ) )
+    {
+        delete m_node;
+        m_node = NULL;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << WrongParent << "\n";
+        return;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_COORDINDEX::IFSG_COORDINDEX( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( !pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return;
+    }
+
+    m_node = new SGCOORDINDEX( NULL );
+
+    if( !m_node->SetParent( pp ) )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << WrongParent << "\n";
+        delete m_node;
+        m_node = NULL;
+        return;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+bool IFSG_COORDINDEX::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_COORDINDEX != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COORDINDEX::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGCOORDINDEX( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGCOORDINDEX\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COORDINDEX::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_coordindex.h b/3d-viewer/3d_cache/sg/ifsg_coordindex.h
new file mode 100644
index 0000000000..604c071a1d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_coordindex.h
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_coordindex.h
+ * defines the CoordIndex node wrapper
+ */
+
+
+#ifndef IFSG_COORDINDEX_H
+#define IFSG_COORDINDEX_H
+
+#include <3d_cache/sg/ifsg_index.h>
+
+
+/**
+ * Class IFSG_COORDINDEX
+ * is the wrapper for SGCOORDINDEX
+ */
+class SG_DLL IFSG_COORDINDEX : public IFSG_INDEX
+{
+public:
+    IFSG_COORDINDEX( bool create );
+    IFSG_COORDINDEX( SGNODE* aParent );
+    IFSG_COORDINDEX( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+};
+
+#endif  // IFSG_COORDINDEX_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_coords.cpp b/3d-viewer/3d_cache/sg/ifsg_coords.cpp
new file mode 100644
index 0000000000..6375fdbe1d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_coords.cpp
@@ -0,0 +1,218 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_coords.h>
+#include <3d_cache/sg/sg_coords.h>
+
+
+extern char BadObject[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_COORDS::IFSG_COORDS( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return ;
+
+    m_node = new SGCOORDS( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_COORDS::IFSG_COORDS( SGNODE* aParent )
+{
+    m_node = new SGCOORDS( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+IFSG_COORDS::IFSG_COORDS( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( ! pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+    }
+
+    m_node = new SGCOORDS( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( pp ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_COORDS::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_COORDS != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COORDS::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGCOORDS( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGCOORDS\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_COORDS::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
+
+
+bool IFSG_COORDS::GetCoordsList( size_t& aListSize, SGPOINT*& aCoordsList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGCOORDS*)m_node)->GetCoordsList( aListSize, aCoordsList );
+}
+
+
+bool IFSG_COORDS::SetCoordsList( size_t aListSize, const SGPOINT* aCoordsList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGCOORDS*)m_node)->SetCoordsList( aListSize, aCoordsList );
+
+    return true;
+}
+
+
+bool IFSG_COORDS::AddCoord( double aXValue, double aYValue, double aZValue )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGCOORDS*)m_node)->AddCoord( aXValue, aYValue, aZValue );
+
+    return true;
+}
+
+
+bool IFSG_COORDS::AddCoord( const SGPOINT& aPoint )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGCOORDS*)m_node)->AddCoord( aPoint );
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_coords.h b/3d-viewer/3d_cache/sg/ifsg_coords.h
new file mode 100644
index 0000000000..14ac6a68bc
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_coords.h
@@ -0,0 +1,57 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_coords.h
+ * defines the coordinate list wrapper
+ */
+
+
+#ifndef IFSG_COORDS_H
+#define IFSG_COORDS_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_INDEX
+ * is the wrapper for SGCOORDS
+ */
+class SG_DLL IFSG_COORDS : public IFSG_NODE
+{
+public:
+    IFSG_COORDS( bool create );
+    IFSG_COORDS( SGNODE* aParent );
+    IFSG_COORDS( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+
+    bool GetCoordsList( size_t& aListSize, SGPOINT*& aCoordsList );
+    bool SetCoordsList( size_t aListSize, const SGPOINT* aCoordsList );
+    bool AddCoord( double aXValue, double aYValue, double aZValue );
+    bool AddCoord( const SGPOINT& aPoint );
+};
+
+#endif  // IFSG_COORDS_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_defs.h b/3d-viewer/3d_cache/sg/ifsg_defs.h
new file mode 100644
index 0000000000..da06d4b131
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_defs.h
@@ -0,0 +1,39 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#ifndef IFSG_DEFS_H
+#define IFSG_DEFS_H
+
+#if defined( MSVC )
+    #if defined( DLL_SGIF )
+        // we are building the library
+        #define SG_DLL __declspec( dllexport )
+    #else
+        // we must be using the library
+        #define SG_DLL __declspec( dllimport )
+    #endif
+#else
+    #define SG_DLL
+#endif
+
+#endif  // IFSG_DEFS_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_faceset.cpp b/3d-viewer/3d_cache/sg/ifsg_faceset.cpp
new file mode 100644
index 0000000000..130f412a3f
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_faceset.cpp
@@ -0,0 +1,161 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_faceset.h>
+#include <3d_cache/sg/sg_faceset.h>
+
+
+extern char BadObject[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_FACESET::IFSG_FACESET( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return ;
+
+    m_node = new SGFACESET( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_FACESET::IFSG_FACESET( SGNODE* aParent )
+{
+    m_node = new SGFACESET( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+IFSG_FACESET::IFSG_FACESET( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( ! pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+    }
+
+    m_node = new SGFACESET( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( pp ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_FACESET::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_FACESET != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_FACESET::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGFACESET( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGFACESET\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_FACESET::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_faceset.h b/3d-viewer/3d_cache/sg/ifsg_faceset.h
new file mode 100644
index 0000000000..a94d567212
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_faceset.h
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_faceset.h
+ * defines the wrapper for the SGFACESET class
+ */
+
+
+#ifndef IFSG_FACESET_H
+#define IFSG_FACESET_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_FACESET
+ * is the wrapper for the SGFACESET class
+ */
+class SG_DLL IFSG_FACESET : public IFSG_NODE
+{
+public:
+    IFSG_FACESET( bool create );
+    IFSG_FACESET( SGNODE* aParent );
+    IFSG_FACESET( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+};
+
+#endif  // IFSG_FACESET_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_index.cpp b/3d-viewer/3d_cache/sg/ifsg_index.cpp
new file mode 100644
index 0000000000..45b777d420
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_index.cpp
@@ -0,0 +1,83 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_index.h>
+#include <3d_cache/sg/sg_coordindex.h>
+#include <3d_cache/sg/sg_colorindex.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_INDEX::IFSG_INDEX() : IFSG_NODE()
+{
+    return;
+}
+
+
+bool IFSG_INDEX::GetIndices( size_t& nIndices, int*& aIndexList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGINDEX*)m_node)->GetIndices( nIndices, aIndexList );
+}
+
+
+bool IFSG_INDEX::SetIndices( size_t nIndices, int* aIndexList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGINDEX*)m_node)->SetIndices( nIndices, aIndexList );
+
+    return true;
+}
+
+
+bool IFSG_INDEX::AddIndex( int aIndex )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGINDEX*)m_node)->AddIndex( aIndex );
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_index.h b/3d-viewer/3d_cache/sg/ifsg_index.h
new file mode 100644
index 0000000000..175d2f0009
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_index.h
@@ -0,0 +1,71 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_index.h
+ * defines the index nodes wrapper
+ */
+
+
+#ifndef IFSG_INDEX_H
+#define IFSG_INDEX_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_INDEX
+ * is the wrapper for SGINDEX
+ */
+class SG_DLL IFSG_INDEX : public IFSG_NODE
+{
+public:
+    IFSG_INDEX();
+
+    virtual bool Attach( SGNODE* aNode ) = 0;
+    virtual bool NewNode( SGNODE* aParent ) = 0;
+    virtual bool NewNode( IFSG_NODE& aParent ) = 0;
+
+    bool GetIndices( size_t& nIndices, int*& aIndexList );
+
+    /**
+     * Function SetIndices
+     * sets the number of indices and creates a copy of the given index data.
+     *
+     * @param nIndices [in] the number of indices to be stored
+     * @param aIndexList [in] the index data
+     */
+    bool SetIndices( size_t nIndices, int* aIndexList );
+
+
+    /**
+     * Function AddIndex
+     * adds a single index to the list
+     *
+     * @param nIndices [in] the number of indices to be stored
+     * @param aIndexList [in] the index data
+     */
+    bool AddIndex( int aIndex );
+};
+
+#endif  // IFSG_INDEX_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_node.cpp b/3d-viewer/3d_cache/sg/ifsg_node.cpp
new file mode 100644
index 0000000000..485b3c4e2d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_node.cpp
@@ -0,0 +1,216 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_node.h>
+#include <3d_cache/sg/sg_node.h>
+#include <3d_cache/sg/ifsg_api.h>
+
+// collection of common error strings used by the wrappers
+char BadObject[] = " * [BUG] operating on an invalid wrapper (object may have been deleted)";
+char BadOperand[] = " * [BUG] parameter aNode is an invalid wrapper; its data may have been deleted";
+char BadParent[] = " * [BUG] invalid parent node (data may have been deleted)";
+char WrongParent[] = " * [BUG] parent node type is incompatible";
+
+IFSG_NODE::IFSG_NODE()
+{
+    m_node = NULL;
+}
+
+
+IFSG_NODE::~IFSG_NODE()
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    return;
+}
+
+
+SGNODE* IFSG_NODE::GetRawPtr( void )
+{
+    return m_node;
+}
+
+
+S3D::SGTYPES IFSG_NODE::GetNodeType( void ) const
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return S3D::SGTYPE_END;
+    }
+
+    return m_node->GetNodeType();
+}
+
+
+SGNODE* IFSG_NODE::GetParent( void ) const
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return NULL;
+    }
+
+    return m_node->GetParent();
+}
+
+
+bool IFSG_NODE::SetParent( SGNODE* aParent )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return m_node->SetParent( aParent );
+}
+
+
+const char* IFSG_NODE::GetName( void )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return NULL;
+    }
+
+    return m_node->GetName();
+}
+
+
+bool IFSG_NODE::SetName( const char *aName )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    m_node->SetName( aName );
+    return true;
+}
+
+
+const char * IFSG_NODE::GetNodeTypeName( S3D::SGTYPES aNodeType ) const
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return NULL;
+    }
+
+    return m_node->GetNodeTypeName( aNodeType );
+}
+
+
+SGNODE* IFSG_NODE::FindNode( const char *aNodeName )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return NULL;
+    }
+
+    return m_node->FindNode( aNodeName, NULL );
+}
+
+
+bool IFSG_NODE::AddRefNode( SGNODE* aNode )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return m_node->AddRefNode( aNode );
+}
+
+
+bool IFSG_NODE::AddRefNode( IFSG_NODE& aNode )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    SGNODE* np = aNode.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadOperand << "\n";
+        return false;
+    }
+
+    return m_node->AddRefNode( np );
+}
+
+
+bool IFSG_NODE::AddChildNode( SGNODE* aNode )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return m_node->AddChildNode( aNode );
+}
+
+
+bool IFSG_NODE::AddChildNode( IFSG_NODE& aNode )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    SGNODE* np = aNode.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadOperand << "\n";
+        return false;
+    }
+
+    return m_node->AddChildNode( np );
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_node.h b/3d-viewer/3d_cache/sg/ifsg_node.h
new file mode 100644
index 0000000000..5d5f6203cf
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_node.h
@@ -0,0 +1,174 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_node.h
+ * defines the wrapper of the base class SG_NODE
+ */
+
+/*
+ * NOTES:
+ * 1. The IFSG wrapper classes shall be aimed at creating a VRML-like
+ *    intermediate scenegraph representation. Although objects are
+ *    readily created and added to the structure, no provision shall
+ *    be made to inspect the structures in detail. For example the
+ *    SCENEGRAPH class may contain various SGSHAPE and SCENEGRAPH
+ *    nodes but there shall be no provision to extract those nodes.
+ *    This was done because in principle all the detailed data shall
+ *    only be handled within the SG* classes and only data processed
+ *    via GetRenderData() shall be available via the wrappers.
+ */
+
+#ifndef IFSG_NODE_H
+#define IFSG_NODE_H
+
+#include <3d_cache/sg/sg_base.h>
+#include <3d_cache/sg/sg_types.h>
+#include <3d_cache/sg/ifsg_defs.h>
+
+class SGNODE;
+
+/**
+ * Class IFSG_NODE
+ * represents the base class of all DLL-safe Scene Graph nodes
+ */
+class SG_DLL IFSG_NODE
+{
+private:
+    // hide the copy constructors and assignment operator to avoid accidental misuse
+    IFSG_NODE( const IFSG_NODE& aParent );
+    IFSG_NODE( IFSG_NODE& aParent );
+    IFSG_NODE( volatile const IFSG_NODE& aParent );
+    IFSG_NODE( volatile IFSG_NODE& aParent );
+    IFSG_NODE& operator= ( const IFSG_NODE& );
+
+protected:
+    SGNODE* m_node;
+
+public:
+    IFSG_NODE();
+    virtual ~IFSG_NODE();
+
+    /**
+     * Function Destroy
+     * deletes the object held by this wrapper
+     */
+    void Destroy( void );
+
+    /**
+     * Function Attach
+     * associates a given SGNODE* with this wrapper
+     */
+    virtual bool Attach( SGNODE* aNode ) = 0;
+
+    /**
+     * Function NewNode
+     * creates a new node to associate with this wrapper
+     */
+    virtual bool NewNode( SGNODE* aParent ) = 0;
+    virtual bool NewNode( IFSG_NODE& aParent ) = 0;
+
+    /**
+     * Function GetRawPtr()
+     * returns the raw internal SGNODE pointer
+     */
+    SGNODE* GetRawPtr( void );
+
+    /**
+     * Function GetNodeType
+     * returns the type of this node instance
+     */
+    S3D::SGTYPES GetNodeType( void ) const;
+
+    /**
+     * Function GetParent
+     * returns a pointer to the parent SGNODE of this object
+     * or NULL if the object has no parent (ie. top level transform).
+     */
+    SGNODE* GetParent( void ) const;
+
+    /**
+     * Function SetParent
+     * sets the parent SGNODE of this object.
+     *
+     * @param aParent [in] is the desired parent node
+     * @return true if the operation succeeds; false if
+     * the given node is not allowed to be a parent to
+     * the derived object
+     */
+    bool SetParent( SGNODE* aParent );
+
+    /**
+     * Function GetName
+     * returns a pointer to the node name (NULL if no name assigned)
+     */
+    const char* GetName( void );
+
+    /**
+     * Function SetName
+     * sets the node's name; if the pointer passed is NULL
+     * then the node's name is erased
+     *
+     * @return true on success
+     */
+    bool SetName( const char *aName );
+
+    /**
+     * Function GetNodeTypeName
+     * returns the text representation of the node type
+     * or NULL if the node somehow has an invalid type
+     */
+    const char * GetNodeTypeName( S3D::SGTYPES aNodeType ) const;
+
+    /**
+     * Function FindNode searches the tree of linked nodes and returns a
+     * reference to the first node found with the given name. The reference
+     * is then typically added to another node via AddRefNode().
+     *
+     * @param aNodeName is the name of the node to search for
+     * @param aCaller is a pointer to the node invoking this function
+     * @return is a valid node pointer on success, otherwise NULL
+     */
+    SGNODE* FindNode( const char *aNodeName );
+
+    /**
+     * Function AddRefNode
+     * adds a reference to an existing node which is not owned by
+     * (not a child of) this node.
+     *
+     * @return true on success
+     */
+    bool AddRefNode( SGNODE* aNode );
+    bool AddRefNode( IFSG_NODE& aNode );
+
+    /**
+     * Function AddChildNode
+     * adds a node as a child owned by this node.
+     *
+     * @return true on success
+     */
+    bool AddChildNode( SGNODE* aNode );
+    bool AddChildNode( IFSG_NODE& aNode );
+};
+
+#endif  // IFSG_NODE_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_normalindex.cpp b/3d-viewer/3d_cache/sg/ifsg_normalindex.cpp
new file mode 100644
index 0000000000..9e72e62f1e
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_normalindex.cpp
@@ -0,0 +1,158 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_normalindex.h>
+#include <3d_cache/sg/sg_normalindex.h>
+#include <3d_cache/sg/sg_types.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_NORMALINDEX::IFSG_NORMALINDEX( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return;
+
+    m_node = new SGNORMALINDEX( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_NORMALINDEX::IFSG_NORMALINDEX( SGNODE* aParent )
+{
+    m_node = new SGNORMALINDEX( NULL );
+
+    if( !m_node->SetParent( aParent ) )
+    {
+        delete m_node;
+        m_node = NULL;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << WrongParent << "\n";
+        return;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_NORMALINDEX::IFSG_NORMALINDEX( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( !pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return;
+    }
+
+    m_node = new SGNORMALINDEX( NULL );
+
+    if( !m_node->SetParent( pp ) )
+    {
+        delete m_node;
+        m_node = NULL;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << WrongParent << "\n";
+        return;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+bool IFSG_NORMALINDEX::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_NORMALINDEX != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_NORMALINDEX::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGNORMALINDEX( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGNORMALINDEX\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_NORMALINDEX::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_normalindex.h b/3d-viewer/3d_cache/sg/ifsg_normalindex.h
new file mode 100644
index 0000000000..35428ef41d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_normalindex.h
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_coordindex.h
+ * defines the CoordIndex node wrapper
+ */
+
+
+#ifndef IFSG_NORMALINDEX_H
+#define IFSG_NORMALINDEX_H
+
+#include <3d_cache/sg/ifsg_index.h>
+
+
+/**
+ * Class IFSG_NORMALINDEX
+ * is the wrapper for SGNORMALINDEX
+ */
+class SG_DLL IFSG_NORMALINDEX : public IFSG_INDEX
+{
+public:
+    IFSG_NORMALINDEX( bool create );
+    IFSG_NORMALINDEX( SGNODE* aParent );
+    IFSG_NORMALINDEX( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+};
+
+#endif  // IFSG_NORMALINDEX_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_normals.cpp b/3d-viewer/3d_cache/sg/ifsg_normals.cpp
new file mode 100644
index 0000000000..5715518bdb
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_normals.cpp
@@ -0,0 +1,217 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_normals.h>
+#include <3d_cache/sg/sg_normals.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_NORMALS::IFSG_NORMALS( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return;
+
+    m_node = new SGNORMALS( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_NORMALS::IFSG_NORMALS( SGNODE* aParent )
+{
+    m_node = new SGNORMALS( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+IFSG_NORMALS::IFSG_NORMALS( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( ! pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+    }
+
+    m_node = new SGNORMALS( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( pp ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_NORMALS::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_NORMALS != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_NORMALS::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGNORMALS( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGNORMALS\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_NORMALS::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
+
+
+bool IFSG_NORMALS::GetNormalList( size_t& aListSize, SGVECTOR*& aNormalList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    return ((SGNORMALS*)m_node)->GetNormalList( aListSize, aNormalList );
+}
+
+
+bool IFSG_NORMALS::SetNormalList( size_t aListSize, const SGVECTOR* aNormalList )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGNORMALS*)m_node)->SetNormalList( aListSize, aNormalList );
+    return true;
+}
+
+
+bool IFSG_NORMALS::AddNormal( double aXValue, double aYValue, double aZValue )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGNORMALS*)m_node)->AddNormal( aXValue, aYValue, aZValue );
+    return true;
+}
+
+
+bool IFSG_NORMALS::AddNormal( const SGVECTOR& aNormal )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SGNORMALS*)m_node)->AddNormal( aNormal );
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_normals.h b/3d-viewer/3d_cache/sg/ifsg_normals.h
new file mode 100644
index 0000000000..8c92dc75bd
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_normals.h
@@ -0,0 +1,57 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_transform.h
+ * defines the wrapper for the SGNORMALS class
+ */
+
+
+#ifndef IFSG_NORMALS_H
+#define IFSG_NORMALS_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_NORMALS
+ * is the wrapper for the SGNORMALS class
+ */
+class SG_DLL IFSG_NORMALS : public IFSG_NODE
+{
+public:
+    IFSG_NORMALS( bool create );
+    IFSG_NORMALS( SGNODE* aParent );
+    IFSG_NORMALS( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+
+    bool GetNormalList( size_t& aListSize, SGVECTOR*& aNormalList );
+    bool SetNormalList( size_t aListSize, const SGVECTOR* aNormalList );
+    bool AddNormal( double aXValue, double aYValue, double aZValue );
+    bool AddNormal( const SGVECTOR& aNormal );
+};
+
+#endif  // IFSG_NORMALS_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_shape.cpp b/3d-viewer/3d_cache/sg/ifsg_shape.cpp
new file mode 100644
index 0000000000..106d92ded9
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_shape.cpp
@@ -0,0 +1,162 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_shape.h>
+#include <3d_cache/sg/sg_shape.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+
+IFSG_SHAPE::IFSG_SHAPE( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return ;
+
+    m_node = new SGSHAPE( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_SHAPE::IFSG_SHAPE( SGNODE* aParent )
+{
+    m_node = new SGSHAPE( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+IFSG_SHAPE::IFSG_SHAPE( IFSG_NODE& aParent )
+{
+    SGNODE* pp = aParent.GetRawPtr();
+
+    if( ! pp )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+    }
+
+    m_node = new SGSHAPE( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( pp ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_SHAPE::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_SHAPE != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_SHAPE::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SGSHAPE( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SGSHAPE\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_SHAPE::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_shape.h b/3d-viewer/3d_cache/sg/ifsg_shape.h
new file mode 100644
index 0000000000..57400a31cd
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_shape.h
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_shape.h
+ * defines the wrapper for the SGSHAPE class
+ */
+
+
+#ifndef IFSG_SHAPE_H
+#define IFSG_SHAPE_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_SHAPE
+ * is the wrapper for the SGSHAPE class
+ */
+class SG_DLL IFSG_SHAPE : public IFSG_NODE
+{
+public:
+    IFSG_SHAPE( bool create );
+    IFSG_SHAPE( SGNODE* aParent );
+    IFSG_SHAPE( IFSG_NODE& aParent );
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+};
+
+#endif  // IFSG_SHAPE_H
diff --git a/3d-viewer/3d_cache/sg/ifsg_transform.cpp b/3d-viewer/3d_cache/sg/ifsg_transform.cpp
new file mode 100644
index 0000000000..68fa1223ef
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_transform.cpp
@@ -0,0 +1,230 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/ifsg_transform.h>
+#include <3d_cache/sg/scenegraph.h>
+
+
+extern char BadObject[];
+extern char BadOperand[];
+extern char BadParent[];
+extern char WrongParent[];
+
+IFSG_TRANSFORM::IFSG_TRANSFORM( bool create )
+{
+    m_node = NULL;
+
+    if( !create )
+        return ;
+
+    m_node = new SCENEGRAPH( NULL );
+
+    if( m_node )
+        m_node->AssociateWrapper( &m_node );
+
+    return;
+}
+
+
+IFSG_TRANSFORM::IFSG_TRANSFORM( SGNODE* aParent )
+{
+    m_node = new SCENEGRAPH( NULL );
+
+    if( m_node )
+    {
+        if( !m_node->SetParent( aParent ) )
+        {
+            delete m_node;
+            m_node = NULL;
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << WrongParent << "\n";
+            return;
+        }
+
+        m_node->AssociateWrapper( &m_node );
+    }
+
+    return;
+}
+
+
+bool IFSG_TRANSFORM::Attach( SGNODE* aNode )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = NULL;
+
+    if( !aNode )
+        return false;
+
+    if( S3D::SGTYPE_TRANSFORM != aNode->GetNodeType() )
+    {
+        return false;
+    }
+
+    m_node = aNode;
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::NewNode( SGNODE* aParent )
+{
+    if( m_node )
+        m_node->DisassociateWrapper( &m_node );
+
+    m_node = new SCENEGRAPH( aParent );
+
+    if( aParent != m_node->GetParent() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid SGNODE parent (";
+        std::cerr << aParent->GetNodeTypeName( aParent->GetNodeType() );
+        std::cerr << ") to SCENEGRAPH\n";
+        delete m_node;
+        m_node = NULL;
+        return false;
+    }
+
+    m_node->AssociateWrapper( &m_node );
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::NewNode( IFSG_NODE& aParent )
+{
+    SGNODE* np = aParent.GetRawPtr();
+
+    if( NULL == np )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadParent << "\n";
+        return false;
+    }
+
+    return NewNode( np );
+}
+
+
+bool IFSG_TRANSFORM::SetRotation( const SGVECTOR& aRotationAxis, double aAngle )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SCENEGRAPH*)m_node)->rotation_axis = aRotationAxis;
+    ((SCENEGRAPH*)m_node)->rotation_angle = aAngle;
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::SetScale( const SGPOINT& aScale )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SCENEGRAPH*)m_node)->scale = aScale;
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::SetScale( double aScale )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    if( aScale < 1e-8 && aScale > -1e-8 )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] |scale| is < 1e-8 - this seems strange\n";
+        return false;
+    }
+
+    ((SCENEGRAPH*)m_node)->scale = SGPOINT( aScale, aScale, aScale );
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::SetTranslation( const SGPOINT& aTranslation )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SCENEGRAPH*)m_node)->translation = aTranslation;
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::SetScaleOrientation( const SGVECTOR& aScaleAxis, double aAngle )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SCENEGRAPH*)m_node)->scale_axis = aScaleAxis;
+    ((SCENEGRAPH*)m_node)->scale_angle = aAngle;
+
+    return true;
+}
+
+
+bool IFSG_TRANSFORM::SetCenter( const SGPOINT& aCenter )
+{
+    if( NULL == m_node )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << BadObject << "\n";
+        return false;
+    }
+
+    ((SCENEGRAPH*)m_node)->center = aCenter;
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/ifsg_transform.h b/3d-viewer/3d_cache/sg/ifsg_transform.h
new file mode 100644
index 0000000000..8a426d461a
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/ifsg_transform.h
@@ -0,0 +1,61 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file ifsg_transform.h
+ * defines the wrapper for the SCENEGRAPH class
+ */
+
+
+#ifndef IFSG_TRANSFORM_H
+#define IFSG_TRANSFORM_H
+
+#include <3d_cache/sg/ifsg_node.h>
+
+
+/**
+ * Class IFSG_TRANSFORM
+ * is the wrapper for the VRML compatible TRANSFORM block class SCENEGRAPH
+ */
+class SG_DLL IFSG_TRANSFORM : public IFSG_NODE
+{
+public:
+    IFSG_TRANSFORM( bool create );
+    IFSG_TRANSFORM( SGNODE* aParent );
+    // note: IFSG_TRANSFORM( IFSG_NODE& aParent ) does not exist
+    // since a transform may own another transform and that construct
+    // invites accidental misuse of the copy constructor
+
+    bool Attach( SGNODE* aNode );
+    bool NewNode( SGNODE* aParent );
+    bool NewNode( IFSG_NODE& aParent );
+
+    bool SetScaleOrientation( const SGVECTOR& aScaleAxis, double aAngle );
+    bool SetRotation( const SGVECTOR& aRotationAxis, double aAngle );
+    bool SetScale( const SGPOINT& aScale );
+    bool SetScale( double aScale );
+    bool SetCenter( const SGPOINT& aCenter );
+    bool SetTranslation( const SGPOINT& aTranslation );
+};
+
+#endif  // IFSG_TRANSFORM_H
diff --git a/3d-viewer/3d_cache/sg/scenegraph.cpp b/3d-viewer/3d_cache/sg/scenegraph.cpp
new file mode 100644
index 0000000000..1b7275f9e7
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/scenegraph.cpp
@@ -0,0 +1,636 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <3d_cache/sg/scenegraph.h>
+#include <3d_cache/sg/sg_shape.h>
+#include <3d_cache/sg/sg_helpers.h>
+
+SCENEGRAPH::SCENEGRAPH( SGNODE* aParent ) : SGNODE( aParent )
+{
+    m_SGtype = S3D::SGTYPE_TRANSFORM;
+    rotation_angle = 0.0;
+    scale.x = 1.0;
+    scale.y = 1.0;
+    scale.z = 1.0;
+
+    if( NULL != aParent && S3D::SGTYPE_TRANSFORM != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SCENEGRAPH (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_TRANSFORM == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SCENEGRAPH::~SCENEGRAPH()
+{
+    // drop references
+    DROP_REFS( SCENEGRAPH, m_RTransforms );
+    DROP_REFS( SGSHAPE, m_RShape );
+
+    // delete owned objects
+    DEL_OBJS( SCENEGRAPH, m_Transforms );
+    DEL_OBJS( SGSHAPE, m_Shape );
+
+    return;
+}
+
+
+bool SCENEGRAPH::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a transform may be parent to a transform
+    if( NULL != aParent && S3D::SGTYPE_TRANSFORM != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SCENEGRAPH::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    FIND_NODE( SCENEGRAPH, aNodeName, m_Transforms, aCaller );
+    FIND_NODE( SGSHAPE, aNodeName, m_Shape, aCaller );
+
+    // query the parent if appropriate
+    if( aCaller == m_Parent || NULL == m_Parent )
+        return NULL;
+
+    return m_Parent->FindNode( aNodeName, this );
+}
+
+
+void SCENEGRAPH::unlinkNode( const SGNODE* aNode, bool isChild )
+{
+    if( NULL == aNode )
+        return;
+
+    UNLINK_NODE( S3D::SGTYPE_TRANSFORM, SCENEGRAPH, aNode, m_Transforms, m_RTransforms, isChild );
+    UNLINK_NODE( S3D::SGTYPE_SHAPE, SGSHAPE, aNode, m_Shape, m_RShape, isChild );
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unlinkNode() did not find its target\n";
+
+    return;
+}
+
+
+void SCENEGRAPH::unlinkChildNode( const SGNODE* aNode )
+{
+    unlinkNode( aNode, true );
+    return;
+}
+
+
+void SCENEGRAPH::unlinkRefNode( const SGNODE* aNode )
+{
+    unlinkNode( aNode, false );
+    return;
+}
+
+
+bool SCENEGRAPH::addNode( SGNODE* aNode, bool isChild )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aNode\n";
+        return false;
+    }
+
+    ADD_NODE( S3D::SGTYPE_TRANSFORM, SCENEGRAPH, aNode, m_Transforms, m_RTransforms, isChild );
+    ADD_NODE( S3D::SGTYPE_SHAPE, SGSHAPE, aNode, m_Shape, m_RShape, isChild );
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] object '" << aNode->GetName();
+    std::cerr << "' is not a valid type for this object (" << aNode->GetNodeType() << ")\n";
+    return false;
+}
+
+
+bool SCENEGRAPH::AddRefNode( SGNODE* aNode )
+{
+    return addNode( aNode, false );
+}
+
+
+bool SCENEGRAPH::AddChildNode( SGNODE* aNode )
+{
+    return addNode( aNode, true );
+}
+
+
+void SCENEGRAPH::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+
+    // rename all shapes
+    do
+    {
+        std::vector< SGSHAPE* >::iterator sL = m_Shape.begin();
+        std::vector< SGSHAPE* >::iterator eL = m_Shape.end();
+
+        while( sL != eL )
+        {
+            (*sL)->ReNameNodes();
+            ++sL;
+        }
+
+    } while(0);
+
+    // rename all transforms
+    do
+    {
+        std::vector< SCENEGRAPH* >::iterator sL = m_Transforms.begin();
+        std::vector< SCENEGRAPH* >::iterator eL = m_Transforms.end();
+
+        while( sL != eL )
+        {
+            (*sL)->ReNameNodes();
+            ++sL;
+        }
+
+    } while(0);
+
+    return;
+}
+
+
+bool SCENEGRAPH::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( m_Transforms.empty() && m_RTransforms.empty()
+        && m_Shape.empty() && m_RShape.empty() )
+    {
+        return false;
+    }
+
+    std::string tmp;
+
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << "DEF " << GetName() << " Transform {\n";
+            m_written = true;
+        }
+        else
+        {
+            aFile << "USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << " Transform {\n";
+    }
+
+    S3D::FormatPoint( tmp, center );
+    aFile << "  center " << tmp << "\n";
+    S3D::FormatOrientation( tmp, rotation_axis, rotation_angle );
+    aFile << "  rotation " << tmp << "\n";
+    S3D::FormatPoint( tmp, scale );
+    aFile << "  scale " << tmp << "\n";
+    S3D::FormatOrientation( tmp, scale_axis, scale_angle );
+    aFile << "  scaleOrientation " << tmp << "\n";
+    S3D::FormatPoint( tmp, translation );
+    aFile << "  translation " << tmp << "\n";
+
+    aFile << " children [\n";
+
+    if( !m_Transforms.empty() )
+    {
+        std::vector< SCENEGRAPH* >::iterator sL = m_Transforms.begin();
+        std::vector< SCENEGRAPH* >::iterator eL = m_Transforms.end();
+
+        while( sL != eL )
+        {
+            (*sL)->WriteVRML( aFile, aReuseFlag );
+            ++sL;
+        }
+    }
+
+    if( !m_RTransforms.empty() )
+    {
+        std::vector< SCENEGRAPH* >::iterator sL = m_RTransforms.begin();
+        std::vector< SCENEGRAPH* >::iterator eL = m_RTransforms.end();
+
+        while( sL != eL )
+        {
+            (*sL)->WriteVRML( aFile, aReuseFlag );
+            ++sL;
+        }
+    }
+
+    if( !m_Shape.empty() )
+    {
+        std::vector< SGSHAPE* >::iterator sL = m_Shape.begin();
+        std::vector< SGSHAPE* >::iterator eL = m_Shape.end();
+
+        while( sL != eL )
+        {
+            (*sL)->WriteVRML( aFile, aReuseFlag );
+            ++sL;
+        }
+    }
+
+    if( !m_RShape.empty() )
+    {
+        std::vector< SGSHAPE* >::iterator sL = m_RShape.begin();
+        std::vector< SGSHAPE* >::iterator eL = m_RShape.end();
+
+        while( sL != eL )
+        {
+            (*sL)->WriteVRML( aFile, aReuseFlag );
+            ++sL;
+        }
+    }
+
+    aFile << "] }\n";
+
+    return true;
+}
+
+
+bool SCENEGRAPH::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode && NULL != m_Parent )
+    {
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( NULL == m_Parent )
+    {
+        // ensure unique node names
+        ResetNodeIndex();
+        ReNameNodes();
+    }
+
+    if( aFile.fail() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    S3D::WritePoint( aFile, center );
+    S3D::WritePoint( aFile, translation );
+    S3D::WriteVector( aFile, rotation_axis );
+    aFile.write( (char*)&rotation_angle, sizeof( rotation_angle ) );
+    S3D::WritePoint( aFile, scale );
+    S3D::WriteVector( aFile, scale_axis );
+    aFile.write( (char*)&scale_angle, sizeof( scale_angle ) );
+
+    size_t asize = m_Transforms.size();
+    aFile.write( (char*)&asize, sizeof( size_t ) );
+    asize = m_RTransforms.size();
+    aFile.write( (char*)&asize, sizeof( size_t ) );
+    asize = m_Shape.size();
+    aFile.write( (char*)&asize, sizeof( size_t ) );
+    asize = m_RShape.size();
+    aFile.write( (char*)&asize, sizeof( size_t ) );
+
+    size_t i;
+    asize = m_Transforms.size();
+
+    // write child transforms
+    for( i = 0; i < asize; ++i )
+    {
+        if( !m_Transforms[i]->WriteCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] bad stream while writing child transforms\n";
+            return false;
+        }
+    }
+
+    // write referenced transform names
+    asize = m_RTransforms.size();
+    for( i = 0; i < asize; ++i )
+        aFile << "[" << m_RTransforms[i]->GetName() << "]";
+
+    // write child shapes
+    asize = m_Shape.size();
+    for( i = 0; i < asize; ++i )
+    {
+        if( !m_Shape[i]->WriteCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] bad stream while writing child shapes\n";
+            return false;
+        }
+    }
+
+    // write referenced transform names
+    asize = m_RShape.size();
+    for( i = 0; i < asize; ++i )
+        aFile << "[" << m_RShape[i]->GetName() << "]";
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SCENEGRAPH::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( !m_Transforms.empty() || !m_RTransforms.empty()
+        || !m_Shape.empty() || !m_RShape.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    std::string name;   // name of the node
+
+    if( NULL == parentNode )
+    {
+        // we need to read the tag and verify its type
+        if( S3D::SGTYPE_TRANSFORM != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; tag mismatch at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_Name = name;
+    }
+
+    // read fixed member data
+    S3D::ReadPoint( aFile, center );
+    S3D::ReadPoint( aFile, translation );
+    S3D::ReadVector( aFile, rotation_axis );
+    aFile.read( (char*)&rotation_angle, sizeof( rotation_angle ) );
+    S3D::ReadPoint( aFile, scale );
+    S3D::ReadVector( aFile, scale_axis );
+    aFile.read( (char*)&scale_angle, sizeof( scale_angle ) );
+
+    size_t sizeCT = 0;  // child transforms
+    size_t sizeRT = 0;  // referenced transforms
+    size_t sizeCS = 0;  // child shapes
+    size_t sizeRS = 0;  // referenced shapes
+
+    aFile.read( (char*)&sizeCT, sizeof( size_t ) );
+    aFile.read( (char*)&sizeRT, sizeof( size_t ) );
+    aFile.read( (char*)&sizeCS, sizeof( size_t ) );
+    aFile.read( (char*)&sizeRS, sizeof( size_t ) );
+
+    size_t i;
+
+    // read child transforms
+    for( i = 0; i < sizeCT; ++i )
+    {
+        if( S3D::SGTYPE_TRANSFORM != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child transform tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SCENEGRAPH* sp = new SCENEGRAPH( this );
+        sp->SetName( name.c_str() );
+
+        if( !sp->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading transform '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    // read referenced transforms
+    for( i = 0; i < sizeRT; ++i )
+    {
+        if( S3D::SGTYPE_TRANSFORM != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref transform tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* sp = FindNode( name.c_str(), this );
+
+        if( !sp )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref transform '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_TRANSFORM != sp->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not TRANSFORM '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        AddRefNode( sp );
+    }
+
+    // read child shapes
+    for( i = 0; i < sizeCS; ++i )
+    {
+        if( S3D::SGTYPE_SHAPE != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child shape tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGSHAPE* sp = new SGSHAPE( this );
+        sp->SetName( name.c_str() );
+
+        if( !sp->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading shape '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    // read referenced shapes
+    for( i = 0; i < sizeRS; ++i )
+    {
+        if( S3D::SGTYPE_SHAPE != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref shape tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* sp = FindNode( name.c_str(), this );
+
+        if( !sp )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref shape '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_SHAPE != sp->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not SGSHAPE '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        AddRefNode( sp );
+    }
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SCENEGRAPH::Prepare( const glm::dmat4* aTransform,
+                      S3D::MATLIST& materials, std::vector< SMESH >& meshes )
+{
+    // calculate the accumulated transform
+    double rX, rY, rZ;
+    rotation_axis.GetVector( rX, rY, rZ );
+    glm::dmat4 rM = glm::rotate( glm::degrees( rotation_angle ), glm::dvec3( rX, rY, rZ ) );
+    glm::dmat4 tM = glm::translate( glm::dvec3( translation.x, translation.y, translation.z ) );
+    glm::dmat4 tx0 = (*aTransform) * tM * rM;
+
+    bool ok = true;
+
+    // prepare all shapes
+    do
+    {
+        std::vector< SGSHAPE* >::iterator sL = m_Shape.begin();
+        std::vector< SGSHAPE* >::iterator eL = m_Shape.end();
+
+        while( sL != eL && ok )
+        {
+            ok = (*sL)->Prepare( &tx0, materials, meshes );
+            ++sL;
+        }
+
+        sL = m_RShape.begin();
+        eL = m_RShape.end();
+
+        while( sL != eL && ok )
+        {
+            ok = (*sL)->Prepare( &tx0, materials, meshes );
+            ++sL;
+        }
+
+    } while(0);
+
+    // prepare all transforms
+    do
+    {
+        std::vector< SCENEGRAPH* >::iterator sL = m_Transforms.begin();
+        std::vector< SCENEGRAPH* >::iterator eL = m_Transforms.end();
+
+        while( sL != eL && ok )
+        {
+            ok = (*sL)->Prepare( &tx0, materials, meshes );
+            ++sL;
+        }
+
+        sL = m_RTransforms.begin();
+        eL = m_RTransforms.end();
+
+        while( sL != eL && ok )
+        {
+            ok = (*sL)->Prepare( &tx0, materials, meshes );
+            ++sL;
+        }
+
+    } while(0);
+
+    return ok;
+}
diff --git a/3d-viewer/3d_cache/sg/scenegraph.h b/3d-viewer/3d_cache/sg/scenegraph.h
new file mode 100644
index 0000000000..ac48188a3f
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/scenegraph.h
@@ -0,0 +1,105 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file scenegraph.h
+ * defines the basic data set required to represent a 3D model;
+ * this model must remain compatible with VRML2.0 in order to
+ * facilitate VRML export of scene graph data created by avaiable
+ * 3D plugins.
+ */
+
+
+#ifndef SCENE_GRAPH_H
+#define SCENE_GRAPH_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+class SGSHAPE;
+
+class SCENEGRAPH : public SGNODE
+{
+private:
+    // The following are items which may be defined for reuse
+    // in a VRML output file. They do not necessarily correspond
+    // to the use of DEF within a VRML input file; it is the
+    // responsibility of the plugin to perform any necessary
+    // conversions to comply with the restrictions imposed by
+    // this scene graph structure
+    std::vector< SCENEGRAPH* > m_Transforms;   // local Transform nodes
+    std::vector< SGSHAPE* > m_Shape;           // local Shape nodes
+
+    std::vector< SCENEGRAPH* > m_RTransforms;   // referenced Transform nodes
+    std::vector< SGSHAPE* > m_RShape;           // referenced Shape nodes
+
+    void unlinkNode( const SGNODE* aNode, bool isChild );
+    bool addNode( SGNODE* aNode, bool isChild );
+
+public:
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+
+public:
+    // note: order of transformation is Translate, Rotate, Offset
+    SGPOINT  center;
+    SGPOINT  translation;
+    SGVECTOR rotation_axis;
+    double   rotation_angle;    // radians
+    SGPOINT  scale;
+    SGVECTOR scale_axis;
+    double   scale_angle;       // radians
+
+    SCENEGRAPH( SGNODE* aParent );
+    virtual ~SCENEGRAPH();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+
+    bool Prepare( const glm::dmat4* aTransform,
+        S3D::MATLIST& materials, std::vector< SMESH >& meshes );
+};
+
+/*
+    p.120
+    Transform {
+        center              0 0 0
+        children            []
+        rotation            0 0 1 0
+        scale               1 1 1
+        scaleOrientation    0 0 1 0
+        translation         0 0 0
+        bboxCenter          0 0 0
+        bboxSize            -1 -1 -1
+    }
+*/
+
+#endif  // SCENE_GRAPH_H
diff --git a/3d-viewer/3d_cache/sg/sg_api.h b/3d-viewer/3d_cache/sg/sg_api.h
new file mode 100644
index 0000000000..be9cd29c71
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_api.h
@@ -0,0 +1,172 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_api.h
+ * provides the API which plugins require to manipulate the SG* classes.
+ *
+ */
+
+#ifndef SG_API_H
+#define SG_API_H
+
+#include <3d_cache/sg/sg_types.h>
+
+class SGCOLOR;
+class SGPOINT;
+class SGVECTOR;
+class SGNODE;
+class SCENEGRAPH;
+
+// creation and manipulation of base types
+typedef SGCOLOR* (*NEW_SGBASE_COLOR)(void);
+typedef bool ( *SET_SGBASE_COLOR )( SGCOLOR* aColor,
+                                    float aRedVal, float aGreenVal, float aBlueVal );
+typedef bool ( *GET_SGBASE_COLOR )( SGCOLOR* aColor,
+                                    float& aRedVal, float& aGreenVal, float& aBlueVal );
+
+typedef SGPOINT* ( *NEW_SGBASE_POINT )(void);
+typedef bool ( *SET_SGBASE_POINT )( SGPOINT* aPoint,
+                                    double aXVal, double aYVal, double aZVal );
+typedef bool ( *GET_SGBASE_POINT )( SGPOINT* aPoint,
+                                    double& aXVal, double& aYVal, double& aZVal );
+
+typedef SGVECTOR* (*NEW_SGBASE_VECTOR)(void);
+typedef bool ( *SET_SGBASE_VECTOR )( SGPOINT* aVector,
+                                    double aXVal, double aYVal, double aZVal );
+typedef bool ( *GET_SGBASE_VECTOR )( SGPOINT* aVector,
+                                    double& aXVal, double& aYVal, double& aZVal );
+// creation of scenegraph nodes:
+typedef SGNODE* (*NEW_SG_NODE)( SGNODE* aParent, S3D::SGTYPES aNodeType);
+
+namespace S3D
+{
+    struct SG_API
+    {
+        // creation of basic SG types
+        NEW_SGBASE_COLOR  NewColor;
+        NEW_SGBASE_POINT  NewPoint;
+        NEW_SGBASE_VECTOR NewVector;
+        // manipulators for basic SG types
+        SET_SGBASE_COLOR SetSGColor;
+        GET_SGBASE_COLOR GetSGColor;
+        SET_SGBASE_POINT SetSGPoint;
+        GET_SGBASE_POINT GetSGPoint;
+        SET_SGBASE_VECTOR SetSGVector;
+        GET_SGBASE_VECTOR GetSGVector;
+
+        // creation of nodes
+        NEW_SG_NODE NewNode;
+
+    };
+
+    // generic node class; this must never be instantiated as an underived class
+    class API_SGNODE
+    {
+    protected:
+        SGNODE* node;
+        S3D::SGTYPES nodeType;
+
+    public:
+        API_SGNODE();
+
+        SGNODE* GetNode( void );
+
+        bool AttachNode( SGNODE* aNode );
+        bool GetNodeType( S3D::SGTYPES& aNodeType ) const;
+
+        bool GetParent( SGNODE const*& aParent ) const;
+        bool SetParent( SGNODE* aParent );
+
+        bool GetName( const char*& aName );
+        bool SetName( const char *aName );
+        bool GetNodeTypeName( S3D::SGTYPES aNodeType, const char*& aName ) const;
+
+        bool FindNode( const char *aNodeName, const SGNODE *aCaller, SGNODE*& aNode );
+    };
+
+    // Transforms and operations
+    class API_TRANSFORM : public API_SGNODE
+    {
+    public:
+        API_TRANSFORM( SGNODE* aParent );
+
+        bool GetLocalTransforms( SGNODE** aNodeList, int& nListItems );
+        bool GetOtherTransforms( SGNODE** aNodeList, int& nListItems );
+        bool AddOtherTransform( SGNODE* aTransformNode );
+
+        bool GetLocalShapes( SGNODE** aNodeList, int& nListItems );
+        bool GetOtherShapes( SGNODE** aNodeList, int& nListItems );
+        bool AddOtherShape( SGNODE* aTransformNode );
+
+        bool GetTranslation( SGPOINT& aPoint ) const;
+        bool GetRotation( SGVECTOR& aVector, double& aAngle ) const;
+        bool GetScale( SGPOINT& aScale ) const;
+
+        bool SetTranslation( const SGPOINT& aPoint );
+        bool SetRotation( const SGVECTOR& aVector, double aAngle );
+        bool SetScale( const SGPOINT& aScale );
+    };
+
+    // Appearance and operations
+    class API_APPEARANCE : public API_SGNODE
+    {
+    public:
+        API_APPEARANCE( SGNODE *aParent );
+
+        bool SetEmissive( float aRVal, float aGVal, float aBVal );
+        bool SetEmissive( const SGCOLOR* aRGBColor );
+        bool SetEmissive( const SGCOLOR& aRGBColor );
+
+        bool SetDiffuse( float aRVal, float aGVal, float aBVal );
+        bool SetDiffuse( const SGCOLOR* aRGBColor );
+        bool SetDiffuse( const SGCOLOR& aRGBColor );
+
+        bool SetSpecular( float aRVal, float aGVal, float aBVal );
+        bool SetSpecular( const SGCOLOR* aRGBColor );
+        bool SetSpecular( const SGCOLOR& aRGBColor );
+
+        bool SetAmbient( double aVal );
+        bool SetShininess( double aVal );
+        bool SetTransparency( double aVal );
+
+        bool GetEmissive( SGCOLOR& aRGBColor );
+        bool GetDiffuse( SGCOLOR& aRGBColor );
+        bool GetSpecular( SGCOLOR& aRGBColor );
+        bool GetAmbient( double& aVal );
+        bool GetShininess( double& aVal );
+        bool GetTransparency( double& aVal );
+    };
+
+    // XXX - Color Index and operations
+    // XXX - Colors and operations
+    // XXX - Coordinate Index and operations
+    // XXX - Coordinates and operations
+    // XXX - Face Set and operations
+    // XXX - Face Set Index (base class for other indices) and operations
+    // XXX - Normals Index and operations
+    // XXX - Normals and operations
+    // XXX - Shape and operations
+};
+
+#endif  // SG_API_H
diff --git a/3d-viewer/3d_cache/sg/sg_appearance.cpp b/3d-viewer/3d_cache/sg/sg_appearance.cpp
new file mode 100644
index 0000000000..1dd95c6ee6
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_appearance.cpp
@@ -0,0 +1,347 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <utility>
+
+#include <3d_cache/sg/sg_appearance.h>
+#include <3d_cache/sg/sg_helpers.h>
+
+SGAPPEARANCE::SGAPPEARANCE( SGNODE* aParent ) : SGNODE( aParent)
+{
+    m_SGtype = S3D::SGTYPE_APPEARANCE;
+
+    // defaults in accord with VRML2.0 spec
+    ambient = 0.2;
+    shininess = 0.2;
+    transparency = 0.0;
+    diffuse.SetColor( 0.8, 0.8, 0.8 );
+
+    if( NULL != aParent && S3D::SGTYPE_SHAPE != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGAPPEARANCE (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_SHAPE == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGAPPEARANCE::~SGAPPEARANCE()
+{
+    return;
+}
+
+
+bool SGAPPEARANCE::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGSHAPE may be parent to a SGAPPEARANCE
+    if( NULL != aParent && S3D::SGTYPE_SHAPE != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+bool SGAPPEARANCE::SetEmissive( float aRVal, float aGVal, float aBVal )
+{
+    return emissive.SetColor( aRVal, aGVal, aBVal );
+}
+
+
+bool SGAPPEARANCE::SetEmissive( const SGCOLOR* aRGBColor )
+{
+    if( NULL == aRGBColor )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aRGBColor\n";
+        return false;
+    }
+
+    return emissive.SetColor( aRGBColor );
+}
+
+
+bool SGAPPEARANCE::SetEmissive( const SGCOLOR& aRGBColor )
+{
+    return emissive.SetColor( aRGBColor );
+}
+
+
+bool SGAPPEARANCE::SetDiffuse( float aRVal, float aGVal, float aBVal )
+{
+    return diffuse.SetColor( aRVal, aGVal, aBVal );
+}
+
+
+bool SGAPPEARANCE::SetDiffuse( const SGCOLOR* aRGBColor )
+{
+    if( NULL == aRGBColor )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aRGBColor\n";
+        return false;
+    }
+
+    return diffuse.SetColor( aRGBColor );
+}
+
+
+bool SGAPPEARANCE::SetDiffuse( const SGCOLOR& aRGBColor )
+{
+    return diffuse.SetColor( aRGBColor );
+}
+
+
+bool SGAPPEARANCE::SetSpecular( float aRVal, float aGVal, float aBVal )
+{
+    return specular.SetColor( aRVal, aGVal, aBVal );
+}
+
+
+bool SGAPPEARANCE::SetSpecular( const SGCOLOR* aRGBColor )
+{
+    if( NULL == aRGBColor )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aRGBColor\n";
+        return false;
+    }
+
+    return specular.SetColor( aRGBColor );
+}
+
+bool SGAPPEARANCE::SetSpecular( const SGCOLOR& aRGBColor )
+{
+    return specular.SetColor( aRGBColor );
+}
+
+
+SGNODE* SGAPPEARANCE::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    return NULL;
+}
+
+
+void SGAPPEARANCE::unlinkChildNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+void SGAPPEARANCE::unlinkRefNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+bool SGAPPEARANCE::AddRefNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGAPPEARANCE::AddChildNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+void SGAPPEARANCE::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+}
+
+
+bool SGAPPEARANCE::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << " appearance DEF " << GetName() << " Appearance {\n";
+            m_written = true;
+        }
+        else
+        {
+            aFile << " appearance USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << " appearance Appearance {\n";
+    }
+
+    aFile << "  material Material {\n";
+
+    std::string tmp;
+    S3D::FormatFloat( tmp, ambient );
+    aFile << "   ambientIntensity " << tmp << "\n";
+
+    float red, green, blue;
+    diffuse.GetColor( red, green, blue );
+    S3D::FormatFloat( tmp, red );
+    aFile << "   diffuseColor " << tmp << " ";
+    S3D::FormatFloat( tmp, green );
+    aFile << tmp << " ";
+    S3D::FormatFloat( tmp, blue);
+    aFile << tmp << "\n";
+
+    emissive.GetColor( red, green, blue );
+    S3D::FormatFloat( tmp, red );
+    aFile << "   emissiveColor " << tmp << " ";
+    S3D::FormatFloat( tmp, green );
+    aFile << tmp << " ";
+    S3D::FormatFloat( tmp, blue);
+    aFile << tmp << "\n";
+
+    S3D::FormatFloat( tmp, shininess );
+    aFile << "   shininess " << tmp << "\n";
+
+    specular.GetColor( red, green, blue );
+    S3D::FormatFloat( tmp, red );
+    aFile << "   specularColor " << tmp << " ";
+    S3D::FormatFloat( tmp, green );
+    aFile << tmp << " ";
+    S3D::FormatFloat( tmp, blue);
+    aFile << tmp << "\n";
+
+    S3D::FormatFloat( tmp, transparency );
+    aFile << "   transparency " << tmp << "\n";
+
+    aFile << "} }\n";
+
+    return true;
+}
+
+
+bool SGAPPEARANCE::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    aFile.write( (char*)&ambient, sizeof(ambient) );
+    aFile.write( (char*)&shininess, sizeof(shininess) );
+    aFile.write( (char*)&transparency, sizeof(transparency) );
+    S3D::WriteColor( aFile, diffuse );
+    S3D::WriteColor( aFile, emissive );
+    S3D::WriteColor( aFile, specular );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGAPPEARANCE::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    aFile.read( (char*)&ambient, sizeof(ambient) );
+    aFile.read( (char*)&shininess, sizeof(shininess) );
+    aFile.read( (char*)&transparency, sizeof(transparency) );
+    S3D::ReadColor( aFile, diffuse );
+    S3D::ReadColor( aFile, emissive );
+    S3D::ReadColor( aFile, specular );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_appearance.h b/3d-viewer/3d_cache/sg/sg_appearance.h
new file mode 100644
index 0000000000..43994ff544
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_appearance.h
@@ -0,0 +1,76 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_appearance.h
+ * defines the generic material appearance of a scenegraph object
+ */
+
+#ifndef SG_APPEARANCE_H
+#define SG_APPEARANCE_H
+
+#include <3d_cache/sg/sg_node.h>
+
+class SGAPPEARANCE : public SGNODE
+{
+public:
+    float ambient;      // default 0.2
+    float shininess;    // default 0.2
+    float transparency; // default 0.0
+    SGCOLOR diffuse;    // default 0.8 0.8 0.8
+    SGCOLOR emissive;   // default 0.0 0.0 0.0
+    SGCOLOR specular;   // default 0.0 0.0 0.0
+
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+
+public:
+    SGAPPEARANCE( SGNODE* aParent );
+    virtual ~SGAPPEARANCE();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    bool SetEmissive( float aRVal, float aGVal, float aBVal );
+    bool SetEmissive( const SGCOLOR* aRGBColor );
+    bool SetEmissive( const SGCOLOR& aRGBColor );
+
+    bool SetDiffuse( float aRVal, float aGVal, float aBVal );
+    bool SetDiffuse( const SGCOLOR* aRGBColor );
+    bool SetDiffuse( const SGCOLOR& aRGBColor );
+
+    bool SetSpecular( float aRVal, float aGVal, float aBVal );
+    bool SetSpecular( const SGCOLOR* aRGBColor );
+    bool SetSpecular( const SGCOLOR& aRGBColor );
+
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+};
+
+#endif  // SG_APPEARANCE_H
diff --git a/3d-viewer/3d_cache/sg/sg_base.cpp b/3d-viewer/3d_cache/sg/sg_base.cpp
new file mode 100644
index 0000000000..3122f1284d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_base.cpp
@@ -0,0 +1,325 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <cmath>
+#include <3d_cache/sg/sg_base.h>
+
+
+SGCOLOR::SGCOLOR()
+{
+    red = 0.0;
+    green = 0.0;
+    blue = 0.0;
+
+    return;
+}
+
+SGCOLOR::SGCOLOR( float aRVal, float aGVal, float aBVal )
+{
+    if( !checkRange( aRVal, aGVal, aBVal ) )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid value passed to constructor\n";
+#endif
+        red = 0.0;
+        green = 0.0;
+        blue = 0.0;
+        return;
+    }
+
+    red = aRVal;
+    green = aGVal;
+    blue = aBVal;
+    return;
+}
+
+
+void SGCOLOR::GetColor( float& aRedVal, float& aGreenVal, float& aBlueVal ) const
+{
+    aRedVal = red;
+    aGreenVal = green;
+    aBlueVal = blue;
+    return;
+}
+
+
+void SGCOLOR::GetColor( SGCOLOR& aColor ) const
+{
+    aColor.red = red;
+    aColor.green = green;
+    aColor.blue = blue;
+    return;
+}
+
+
+void SGCOLOR::GetColor( SGCOLOR* aColor ) const
+{
+    if( NULL == aColor )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aColor\n";
+        return;
+    }
+
+    aColor->red = red;
+    aColor->green = green;
+    aColor->blue = blue;
+    return;
+}
+
+
+bool SGCOLOR::SetColor( float aRedVal, float aGreenVal, float aBlueVal )
+{
+    if( !checkRange( aRedVal, aGreenVal, aBlueVal ) )
+        return false;
+
+    red = aRedVal;
+    green = aGreenVal;
+    blue = aBlueVal;
+
+    return true;
+}
+
+
+bool SGCOLOR::SetColor( const SGCOLOR& aColor )
+{
+    red = aColor.red;
+    green = aColor.green;
+    blue = aColor.blue;
+    return true;
+}
+
+
+bool SGCOLOR::SetColor( const SGCOLOR* aColor )
+{
+    if( NULL == aColor )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aColor\n";
+        return false;
+    }
+
+    red = aColor->red;
+    green = aColor->green;
+    blue = aColor->blue;
+    return true;
+}
+
+
+bool SGCOLOR::checkRange( float aRedVal, float aGreenVal, float aBlueVal ) const
+{
+    bool ok = true;
+
+    if( aRedVal < 0.0 || aRedVal > 1.0 )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid RED value: " << aRedVal << "\n";
+#endif
+        ok = false;
+    }
+
+    if( aGreenVal < 0.0 || aGreenVal > 1.0 )
+    {
+#ifdef DEBUG
+        if( ok )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        }
+        std::cerr << " * [BUG] invalid GREEN value: " << aGreenVal << "\n";
+#endif
+        ok = false;
+    }
+
+    if( aBlueVal < 0.0 || aBlueVal > 1.0 )
+    {
+#ifdef DEBUG
+        if( ok )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        }
+        std::cerr << " * [BUG] invalid BLUE value: " << aBlueVal << "\n";
+#endif
+        ok = false;
+    }
+
+    return ok;
+}
+
+
+SGPOINT::SGPOINT()
+{
+    x = 0.0;
+    y = 0.0;
+    z = 0.0;
+    return;
+}
+
+
+SGPOINT::SGPOINT( double aXVal, double aYVal, double aZVal )
+{
+    x = aXVal;
+    y = aYVal;
+    z = aZVal;
+}
+
+
+void SGPOINT::GetPoint( double& aXVal, double& aYVal, double& aZVal )
+{
+    x = aXVal;
+    y = aYVal;
+    z = aZVal;
+    return;
+}
+
+
+void SGPOINT::GetPoint( SGPOINT& aPoint )
+{
+    x = aPoint.x;
+    y = aPoint.y;
+    z = aPoint.z;
+    return;
+}
+
+
+void SGPOINT::GetPoint( SGPOINT* aPoint )
+{
+    if( NULL == aPoint )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aPoint\n";
+        return;
+    }
+
+    x = aPoint->x;
+    y = aPoint->y;
+    z = aPoint->z;
+    return;
+}
+
+
+void SGPOINT::SetPoint( double aXVal, double aYVal, double aZVal )
+{
+    x = aXVal;
+    y = aYVal;
+    z = aZVal;
+    return;
+}
+
+
+void SGPOINT::SetPoint( const SGPOINT& aPoint )
+{
+    x = aPoint.x;
+    y = aPoint.y;
+    z = aPoint.z;
+    return;
+}
+
+
+SGVECTOR::SGVECTOR()
+{
+    vx = 0.0;
+    vy = 0.0;
+    vz = 1.0;
+    return;
+}
+
+
+SGVECTOR::SGVECTOR( double aXVal, double aYVal, double aZVal )
+{
+    vx = aXVal;
+    vy = aYVal;
+    vz = aZVal;
+    normalize();
+    return;
+}
+
+
+void SGVECTOR::GetVector( double& aXVal, double& aYVal, double& aZVal ) const
+{
+    aXVal = vx;
+    aYVal = vy;
+    aZVal = vz;
+    return;
+}
+
+
+void SGVECTOR::SetVector( double aXVal, double aYVal, double aZVal )
+{
+    vx = aXVal;
+    vy = aYVal;
+    vz = aZVal;
+    normalize();
+    return;
+}
+
+
+void SGVECTOR::SetVector( const SGVECTOR& aVector )
+{
+    aVector.GetVector( vx, vy, vz );
+    return;
+}
+
+
+void SGVECTOR::normalize( void )
+{
+    double dx = vx * vx;
+    double dy = vy * vy;
+    double dz = vz * vz;
+    double dv2 = dx + dy + dz;
+
+    // note: placing the limit at 1e-14 ensures that
+    // models representing mm to 1e-4 precision can
+    // be accepted before the calculations blow up
+    if( (dx + dy + dz) < 1e-14 )
+    {
+        // use the default; the numbers are too small
+        // to be believable
+        vx = 0.0;
+        vy = 0.0;
+        vz = 1.0;
+        return;
+    }
+
+    dx /= dv2;
+    dy /= dv2;
+    dz /= dv2;
+
+    vx = sqrt( dx );
+    vy = sqrt( dy );
+    vz = sqrt( dz );
+
+    return;
+}
+
+
+SGVECTOR& SGVECTOR::operator=( const SGVECTOR& source )
+{
+    vx = source.vx;
+    vy = source.vy;
+    vz = source.vz;
+    return *this;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_base.h b/3d-viewer/3d_cache/sg/sg_base.h
new file mode 100644
index 0000000000..8e9c6fa248
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_base.h
@@ -0,0 +1,100 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_base.h
+ * defines the low level classes common to scene graph nodes
+ */
+
+
+#ifndef SG_BASE_H
+#define SG_BASE_H
+
+
+class SGCOLOR
+{
+protected:
+    float red;
+    float green;
+    float blue;
+
+public:
+    SGCOLOR();
+    SGCOLOR( float aRVal, float aGVal, float aBVal );
+
+    void GetColor( float& aRedVal, float& aGreenVal, float& aBlueVal ) const;
+    void GetColor( SGCOLOR& aColor ) const;
+    void GetColor( SGCOLOR* aColor ) const;
+
+    bool SetColor( float aRedVal, float aGreenVal, float aBlueVal );
+    bool SetColor( const SGCOLOR& aColor );
+    bool SetColor( const SGCOLOR* aColor );
+
+private:
+    bool checkRange( float aRedVal, float aGreenVal, float aBlueVal ) const;
+};
+
+
+class SGPOINT
+{
+public:
+    double x;
+    double y;
+    double z;
+
+public:
+    SGPOINT();
+    SGPOINT( double aXVal, double aYVal, double aZVal );
+
+    void GetPoint( double& aXVal, double& aYVal, double& aZVal );
+    void GetPoint( SGPOINT& aPoint );
+    void GetPoint( SGPOINT* aPoint );
+
+    void SetPoint( double aXVal, double aYVal, double aZVal );
+    void SetPoint( const SGPOINT& aPoint );
+};
+
+
+class SGVECTOR
+{
+private:
+    void normalize( void );
+
+    double vx;
+    double vy;
+    double vz;
+
+public:
+    SGVECTOR();
+    SGVECTOR( double aXVal, double aYVal, double aZVal );
+
+    void GetVector( double& aXVal, double& aYVal, double& aZVal ) const;
+
+    void SetVector( double aXVal, double aYVal, double aZVal );
+    void SetVector( const SGVECTOR& aVector );
+
+    SGVECTOR& operator=( const SGVECTOR& source );
+};
+
+
+#endif  // SG_BASE_H
diff --git a/3d-viewer/3d_cache/sg/sg_colorindex.cpp b/3d-viewer/3d_cache/sg/sg_colorindex.cpp
new file mode 100644
index 0000000000..6610bebd2e
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_colorindex.cpp
@@ -0,0 +1,42 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <3d_cache/sg/sg_colorindex.h>
+
+SGCOLORINDEX::SGCOLORINDEX( SGNODE* aParent ) : SGINDEX( aParent )
+{
+    m_SGtype = S3D::SGTYPE_COLORINDEX;
+
+    if( NULL != aParent && S3D::SGTYPE_FACESET == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGCOLORINDEX::~SGCOLORINDEX()
+{
+    return;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_colorindex.h b/3d-viewer/3d_cache/sg/sg_colorindex.h
new file mode 100644
index 0000000000..937b957f9e
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_colorindex.h
@@ -0,0 +1,41 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_colorindex.h
+ * defines an RGB color index mapping for a scenegraph object
+ */
+
+#ifndef SG_COLORINDEX_H
+#define SG_COLORINDEX_H
+
+#include <3d_cache/sg/sg_index.h>
+
+class SGCOLORINDEX : public SGINDEX
+{
+public:
+    SGCOLORINDEX( SGNODE* aParent );
+    virtual ~SGCOLORINDEX();
+};
+
+#endif  // SG_COLORINDEX_H
diff --git a/3d-viewer/3d_cache/sg/sg_colors.cpp b/3d-viewer/3d_cache/sg/sg_colors.cpp
new file mode 100644
index 0000000000..d58b2206b8
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_colors.cpp
@@ -0,0 +1,313 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <3d_cache/sg/sg_colors.h>
+#include <3d_cache/sg/sg_helpers.h>
+
+SGCOLORS::SGCOLORS( SGNODE* aParent ) : SGNODE( aParent )
+{
+    m_SGtype = S3D::SGTYPE_COLORS;
+
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGCOLORS (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_FACESET == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGCOLORS::~SGCOLORS()
+{
+    colors.clear();
+    return;
+}
+
+
+bool SGCOLORS::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGFACESET may be parent to a SGCOLORS
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SGCOLORS::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    return NULL;
+}
+
+
+void SGCOLORS::unlinkChildNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+void SGCOLORS::unlinkRefNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+bool SGCOLORS::AddRefNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGCOLORS::AddChildNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGCOLORS::GetColorList( size_t& aListSize, SGCOLOR*& aColorList )
+{
+    if( colors.size() )
+    {
+        aListSize = 0;
+        aColorList = NULL;
+        return false;
+    }
+
+    aListSize = colors.size();
+    aColorList = &colors[0];
+    return true;
+}
+
+
+void SGCOLORS::SetColorList( size_t& aListSize, const SGCOLOR* aColorList )
+{
+    colors.clear();
+
+    if( 0 == aListSize || NULL == aColorList )
+        return;
+
+    for( size_t i = 0; i < aListSize; ++i )
+        colors.push_back( aColorList[i] );
+
+    return;
+}
+
+
+void SGCOLORS::AddColor( double aRedValue, double aGreenValue, double aBlueValue )
+{
+    colors.push_back( SGCOLOR( aRedValue, aGreenValue, aBlueValue ) );
+    return;
+}
+
+
+void SGCOLORS::AddColor( const SGCOLOR& aColor )
+{
+    colors.push_back( aColor );
+    return;
+}
+
+
+void SGCOLORS::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+}
+
+
+bool SGCOLORS::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( colors.empty() )
+        return false;
+
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << "color DEF " << GetName() << " Color { color [\n  ";
+            m_written = true;
+        }
+        else
+        {
+            aFile << "color USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << "color Color { color [\n  ";
+    }
+
+    std::string tmp;
+    size_t n = colors.size();
+    bool nline = false;
+
+    for( size_t i = 0; i < n; )
+    {
+        S3D::FormatColor( tmp, colors[i] );
+        aFile << tmp ;
+        ++i;
+
+        if( i < n )
+        {
+            aFile << ",";
+
+            if( nline )
+            {
+                aFile << "\n  ";
+                nline = false;
+            }
+            else
+            {
+                nline = true;
+            }
+
+        }
+    }
+
+    aFile << "] }\n";
+
+    return true;
+}
+
+
+bool SGCOLORS::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    size_t ncolors = colors.size();
+    aFile.write( (char*)&ncolors, sizeof(size_t) );
+
+    for( size_t i = 0; i < ncolors; ++i )
+        S3D::WriteColor( aFile, colors[i] );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGCOLORS::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( !colors.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    size_t ncolors;
+    aFile.read( (char*)&ncolors, sizeof(size_t) );
+    SGCOLOR tmp;
+
+    if( aFile.fail() )
+        return false;
+
+    for( size_t i = 0; i < ncolors; ++i )
+    {
+        if( !S3D::ReadColor( aFile, tmp ) || aFile.fail() )
+            return false;
+
+        colors.push_back( tmp );
+    }
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_colors.h b/3d-viewer/3d_cache/sg/sg_colors.h
new file mode 100644
index 0000000000..b23332399e
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_colors.h
@@ -0,0 +1,65 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_colors.h
+ * defines an RGB color set for a scenegraph object
+ */
+
+#ifndef SG_COLORS_H
+#define SG_COLORS_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+class SGCOLORS : public SGNODE
+{
+public:
+    std::vector< SGCOLOR > colors;
+
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+
+public:
+    SGCOLORS( SGNODE* aParent );
+    virtual ~SGCOLORS();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    bool GetColorList( size_t& aListSize, SGCOLOR*& aColorList );
+    void SetColorList( size_t& aListSize, const SGCOLOR* aColorList );
+    void AddColor( double aRedValue, double aGreenValue, double aBlueValue );
+    void AddColor( const SGCOLOR& aColor );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+};
+
+#endif  // SG_COLORS_H
diff --git a/3d-viewer/3d_cache/sg/sg_coordindex.cpp b/3d-viewer/3d_cache/sg/sg_coordindex.cpp
new file mode 100644
index 0000000000..0888cbff4d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_coordindex.cpp
@@ -0,0 +1,43 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <3d_cache/sg/sg_coordindex.h>
+
+
+SGCOORDINDEX::SGCOORDINDEX( SGNODE* aParent ) : SGINDEX( aParent )
+{
+    m_SGtype = S3D::SGTYPE_COORDINDEX;
+
+    if( NULL != aParent && S3D::SGTYPE_FACESET == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGCOORDINDEX::~SGCOORDINDEX()
+{
+    return;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_coordindex.h b/3d-viewer/3d_cache/sg/sg_coordindex.h
new file mode 100644
index 0000000000..5813d7caec
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_coordindex.h
@@ -0,0 +1,51 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_coordindex.h
+ * defines an coordinate index set for a scenegraph object
+ */
+
+#ifndef SG_COORDINDEX_H
+#define SG_COORDINDEX_H
+
+#include <3d_cache/sg/sg_index.h>
+
+/**
+ * Class SGCOORDINDEX
+ * is a class which maintains a coordinate index list. Users
+ * must ensure that coordinate indices are specified as
+ * triplets (triangular faces) since no checking is performed.
+ * In instances where it is not possible to determine which
+ * side of the triangle is to be rendered (for example IGES
+ * entities) then the user must supply each triplet in both
+ * point orders.
+ */
+class SGCOORDINDEX : public SGINDEX
+{
+public:
+    SGCOORDINDEX( SGNODE* aParent );
+    virtual ~SGCOORDINDEX();
+};
+
+#endif  // SG_COORDINDEX_H
diff --git a/3d-viewer/3d_cache/sg/sg_coords.cpp b/3d-viewer/3d_cache/sg/sg_coords.cpp
new file mode 100644
index 0000000000..9236ca0e1f
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_coords.cpp
@@ -0,0 +1,314 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <3d_cache/sg/sg_coords.h>
+#include <3d_cache/sg/sg_helpers.h>
+
+
+SGCOORDS::SGCOORDS( SGNODE* aParent ) : SGNODE( aParent )
+{
+    m_SGtype = S3D::SGTYPE_COORDS;
+
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGCOORDS (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_FACESET == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGCOORDS::~SGCOORDS()
+{
+    coords.clear();
+    return;
+}
+
+
+bool SGCOORDS::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGFACESET may be parent to a SGCOORDS
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SGCOORDS::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    return NULL;
+}
+
+
+void SGCOORDS::unlinkChildNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+void SGCOORDS::unlinkRefNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+bool SGCOORDS::AddRefNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGCOORDS::AddChildNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGCOORDS::GetCoordsList( size_t& aListSize, SGPOINT*& aCoordsList )
+{
+    if( coords.empty() )
+    {
+        aListSize = 0;
+        aCoordsList = NULL;
+        return false;
+    }
+
+    aListSize = coords.size();
+    aCoordsList = &coords[0];
+    return true;
+}
+
+
+void SGCOORDS::SetCoordsList( size_t aListSize, const SGPOINT* aCoordsList )
+{
+    coords.clear();
+
+    if( 0 == aListSize || NULL == aCoordsList )
+        return;
+
+    for( size_t i = 0; i < aListSize; ++i )
+        coords.push_back( aCoordsList[i] );
+
+    return;
+}
+
+
+void SGCOORDS::AddCoord( double aXValue, double aYValue, double aZValue )
+{
+    coords.push_back( SGPOINT( aXValue, aYValue, aZValue ) );
+    return;
+}
+
+
+void SGCOORDS::AddCoord( const SGPOINT& aPoint )
+{
+    coords.push_back( aPoint );
+    return;
+}
+
+
+void SGCOORDS::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+}
+
+
+bool SGCOORDS::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( coords.empty() )
+        return false;
+
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << "  coord DEF " << GetName() << " Coordinate { point [\n  ";
+            m_written = true;
+        }
+        else
+        {
+            aFile << "  coord USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << "  coord Coordinate { point [\n  ";
+    }
+
+    std::string tmp;
+    size_t n = coords.size();
+    bool nline = false;
+
+    for( size_t i = 0; i < n; )
+    {
+        S3D::FormatPoint( tmp, coords[i] );
+        aFile << tmp ;
+        ++i;
+
+        if( i < n )
+        {
+            aFile << ",";
+
+            if( nline )
+            {
+                aFile << "\n  ";
+                nline = false;
+            }
+            else
+            {
+                nline = true;
+            }
+
+        }
+    }
+
+    aFile << "] }\n";
+
+    return true;
+}
+
+
+bool SGCOORDS::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    size_t npts = coords.size();
+    aFile.write( (char*)&npts, sizeof(size_t) );
+
+    for( size_t i = 0; i < npts; ++i )
+        S3D::WritePoint( aFile, coords[i] );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGCOORDS::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( !coords.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    size_t npts;
+    aFile.read( (char*)&npts, sizeof(size_t) );
+    SGPOINT tmp;
+
+    if( aFile.fail() )
+        return false;
+
+    for( size_t i = 0; i < npts; ++i )
+    {
+        if( !S3D::ReadPoint( aFile, tmp ) || aFile.fail() )
+            return false;
+
+        coords.push_back( tmp );
+    }
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_coords.h b/3d-viewer/3d_cache/sg/sg_coords.h
new file mode 100644
index 0000000000..1b263489f1
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_coords.h
@@ -0,0 +1,65 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_coords.h
+ * defines a vertex coordinate set for a scenegraph object
+ */
+
+#ifndef SG_COORDS_H
+#define SG_COORDS_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+class SGCOORDS : public SGNODE
+{
+public:
+    std::vector< SGPOINT > coords;
+
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+
+public:
+    SGCOORDS( SGNODE* aParent );
+    virtual ~SGCOORDS();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    bool GetCoordsList( size_t& aListSize, SGPOINT*& aCoordsList );
+    void SetCoordsList( size_t aListSize, const SGPOINT* aCoordsList );
+    void AddCoord( double aXValue, double aYValue, double aZValue );
+    void AddCoord( const SGPOINT& aPoint );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+};
+
+#endif  // SG_COORDS_H
diff --git a/3d-viewer/3d_cache/sg/sg_faceset.cpp b/3d-viewer/3d_cache/sg/sg_faceset.cpp
new file mode 100644
index 0000000000..afae6494f5
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_faceset.cpp
@@ -0,0 +1,1032 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <3d_cache/sg/sg_faceset.h>
+#include <3d_cache/sg/sg_colors.h>
+#include <3d_cache/sg/sg_coords.h>
+#include <3d_cache/sg/sg_normals.h>
+#include <3d_cache/sg/sg_colorindex.h>
+#include <3d_cache/sg/sg_coordindex.h>
+#include <3d_cache/sg/sg_helpers.h>
+
+SGFACESET::SGFACESET( SGNODE* aParent ) : SGNODE( aParent )
+{
+    m_SGtype = S3D::SGTYPE_FACESET;
+    m_Colors = NULL;
+    m_ColorIndices = NULL;
+    m_Coords = NULL;
+    m_CoordIndices = NULL;
+    m_Normals = NULL;
+    m_RColors = NULL;
+    m_RCoords = NULL;
+    m_RNormals = NULL;
+    valid = false;
+    validated = false;
+
+    if( NULL != aParent && S3D::SGTYPE_SHAPE != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGFACESET (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_SHAPE == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGFACESET::~SGFACESET()
+{
+    // drop references
+    if( m_RColors )
+    {
+        m_RColors->delNodeRef( this );
+        m_RColors = NULL;
+    }
+
+    if( m_RCoords )
+    {
+        m_RCoords->delNodeRef( this );
+        m_RCoords = NULL;
+    }
+
+    if( m_RNormals )
+    {
+        m_RNormals->delNodeRef( this );
+        m_RNormals = NULL;
+    }
+
+    // delete owned objects
+    if( m_Colors )
+    {
+        m_Colors->SetParent( NULL, false );
+        delete m_Colors;
+        m_Colors = NULL;
+    }
+
+    if( m_Coords )
+    {
+        m_Coords->SetParent( NULL, false );
+        delete m_Coords;
+        m_Coords = NULL;
+    }
+
+    if( m_Normals )
+    {
+        m_Normals->SetParent( NULL, false );
+        delete m_Normals;
+        m_Normals = NULL;
+    }
+
+    if( m_ColorIndices )
+    {
+        m_ColorIndices->SetParent( NULL, false );
+        delete m_ColorIndices;
+        m_ColorIndices = NULL;
+    }
+
+    if( m_CoordIndices )
+    {
+        m_CoordIndices->SetParent( NULL, false );
+        delete m_CoordIndices;
+        m_CoordIndices = NULL;
+    }
+
+    return;
+}
+
+
+bool SGFACESET::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGSHAPE may be parent to a SGFACESET
+    if( NULL != aParent && S3D::SGTYPE_SHAPE != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SGFACESET::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    SGNODE* np = NULL;
+
+    if( m_Colors )
+    {
+        np = m_Colors->FindNode( aNodeName, this );
+
+        if( np )
+            return np;
+    }
+
+    if( m_ColorIndices )
+    {
+        np = m_ColorIndices->FindNode( aNodeName, this );
+
+        if( np )
+            return np;
+    }
+
+    if( m_Coords )
+    {
+        np = m_Coords->FindNode( aNodeName, this );
+
+        if( np )
+            return np;
+    }
+
+    if( m_CoordIndices )
+    {
+        np = m_CoordIndices->FindNode( aNodeName, this );
+
+        if( np )
+            return np;
+    }
+
+    if( m_Normals )
+    {
+        np = m_Normals->FindNode( aNodeName, this );
+
+        if( np )
+            return np;
+    }
+
+    // query the parent if appropriate
+    if( aCaller == m_Parent || NULL == m_Parent )
+        return NULL;
+
+    return m_Parent->FindNode( aNodeName, this );
+}
+
+
+void SGFACESET::unlinkNode( const SGNODE* aNode, bool isChild )
+{
+    if( NULL == aNode )
+        return;
+
+    valid = false;
+    validated = false;
+
+    if( isChild )
+    {
+        if( aNode == m_Colors )
+        {
+            m_Colors = NULL;
+            return;
+        }
+
+        if( aNode == m_Coords )
+        {
+            m_Coords = NULL;
+            return;
+        }
+
+        if( aNode == m_Normals )
+        {
+            m_Normals = NULL;
+            return;
+        }
+
+        if( aNode == m_ColorIndices )
+        {
+            m_ColorIndices = NULL;
+            return;
+        }
+
+        if( aNode == m_CoordIndices )
+        {
+            m_CoordIndices = NULL;
+            return;
+        }
+    }
+    else
+    {
+        if( aNode == m_RColors )
+        {
+            m_RColors = NULL;
+            return;
+        }
+
+        if( aNode == m_RCoords )
+        {
+            m_RCoords = NULL;
+            return;
+        }
+
+        if( aNode == m_RNormals )
+        {
+            m_RNormals = NULL;
+            return;
+        }
+    }
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unlinkNode() did not find its target\n";
+
+    return;
+}
+
+
+void SGFACESET::unlinkChildNode( const SGNODE* aNode )
+{
+    unlinkNode( aNode, true );
+    return;
+}
+
+
+void SGFACESET::unlinkRefNode( const SGNODE* aNode )
+{
+    unlinkNode( aNode, false );
+    return;
+}
+
+
+
+bool SGFACESET::addNode( SGNODE* aNode, bool isChild )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aNode\n";
+        return false;
+    }
+
+    valid = false;
+    validated = false;
+
+    if( S3D::SGTYPE_COLORS == aNode->GetNodeType() )
+    {
+        if( m_Colors || m_RColors )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple Colors nodes\n";
+            return false;
+        }
+
+        if( isChild )
+        {
+            m_Colors = (SGCOLORS*)aNode;
+            m_Colors->SetParent( this );
+        }
+        else
+        {
+            m_RColors = (SGCOLORS*)aNode;
+            m_RColors->addNodeRef( this );
+        }
+
+        return true;
+    }
+
+    if( S3D::SGTYPE_COORDS == aNode->GetNodeType() )
+    {
+        if( m_Coords || m_RCoords )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple Coords nodes\n";
+            return false;
+        }
+
+        if( isChild )
+        {
+            m_Coords = (SGCOORDS*)aNode;
+            m_Coords->SetParent( this );
+        }
+        else
+        {
+            m_RCoords = (SGCOORDS*)aNode;
+            m_RCoords->addNodeRef( this );
+        }
+
+        return true;
+    }
+
+    if( S3D::SGTYPE_NORMALS == aNode->GetNodeType() )
+    {
+        if( m_Normals || m_RNormals )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple Normals nodes\n";
+            return false;
+        }
+
+        if( isChild )
+        {
+            m_Normals = (SGNORMALS*)aNode;
+            m_Normals->SetParent( this );
+        }
+        else
+        {
+            m_RNormals = (SGNORMALS*)aNode;
+            m_RNormals->addNodeRef( this );
+        }
+
+        return true;
+    }
+
+    if( S3D::SGTYPE_COLORINDEX == aNode->GetNodeType() )
+    {
+        if( m_ColorIndices )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple ColorIndex nodes\n";
+            return false;
+        }
+
+        m_ColorIndices = (SGCOLORINDEX*)aNode;
+        m_ColorIndices->SetParent( this );
+
+        return true;
+    }
+
+    if( S3D::SGTYPE_COORDINDEX == aNode->GetNodeType() )
+    {
+        if( m_CoordIndices )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple CoordIndex nodes\n";
+            return false;
+        }
+
+        m_CoordIndices = (SGCOORDINDEX*)aNode;
+        m_CoordIndices->SetParent( this );
+
+        return true;
+    }
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] object '" << aNode->GetName();
+    std::cerr << "' (type " << aNode->GetNodeType();
+    std::cerr << ") is not a valid type for this object (" << aNode->GetNodeType() << ")\n";
+
+    return false;
+}
+
+
+bool SGFACESET::AddRefNode( SGNODE* aNode )
+{
+    return addNode( aNode, false );
+}
+
+
+bool SGFACESET::AddChildNode( SGNODE* aNode )
+{
+    return addNode( aNode, true );
+}
+
+
+void SGFACESET::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+
+    // rename all Colors and Indices
+    if( m_Colors )
+        m_Colors->ReNameNodes();
+
+    if( m_ColorIndices )
+        m_ColorIndices->ReNameNodes();
+
+    // rename all Coordinates and Indices
+    if( m_Coords )
+        m_Coords->ReNameNodes();
+
+    if( m_CoordIndices )
+        m_CoordIndices->ReNameNodes();
+
+    // rename all Normals and Indices
+    if( m_Normals )
+        m_Normals->ReNameNodes();
+
+    return;
+}
+
+
+bool SGFACESET::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( ( NULL == m_Coords && NULL == m_RCoords )
+        || ( NULL == m_CoordIndices ) )
+    {
+        return false;
+    }
+
+    std::string tmp;
+
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << " geometry DEF " << GetName() << " IndexedFaceSet {\n";
+            m_written = true;
+        }
+        else
+        {
+            aFile << "USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << " geometry IndexedFaceSet {\n";
+    }
+
+    if( m_Coords )
+        m_Coords->WriteVRML( aFile, aReuseFlag );
+
+    if( m_RCoords )
+        m_RCoords->WriteVRML( aFile, aReuseFlag );
+
+    if( m_CoordIndices )
+        m_CoordIndices->WriteVRML( aFile, aReuseFlag );
+
+    if( m_Normals || m_RNormals )
+        aFile << "  normalPerVertex TRUE\n";
+
+    if( m_Normals )
+        m_Normals->WriteVRML( aFile, aReuseFlag );
+
+    if( m_RNormals )
+        m_RNormals->WriteVRML( aFile, aReuseFlag );
+
+    if( m_Colors )
+        m_Colors->WriteVRML( aFile, aReuseFlag );
+
+    if( m_RColors )
+        m_RColors->WriteVRML( aFile, aReuseFlag );
+
+    if( m_ColorIndices )
+        m_ColorIndices->WriteVRML( aFile, aReuseFlag );
+
+    aFile << "}\n";
+
+    return true;
+}
+
+
+bool SGFACESET::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    #define NITEMS 8
+    bool items[NITEMS];
+    int i;
+
+    for( i = 0; i < NITEMS; ++i )
+        items[i] = 0;
+
+    i = 0;
+    if( NULL != m_Coords )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_RCoords )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_CoordIndices )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_Normals )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_RNormals )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_Colors )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_RColors )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_ColorIndices )
+        items[i] = true;
+
+    for( int i = 0; i < NITEMS; ++i )
+        aFile.write( (char*)&items[i], sizeof(bool) );
+
+    if( items[0] )
+        m_Coords->WriteCache( aFile, this );
+
+    if( items[1] )
+        aFile << "[" << m_RCoords->GetName() << "]";
+
+    if( items[2] )
+        m_CoordIndices->WriteCache( aFile, this );
+
+    if( items[3] )
+        m_Normals->WriteCache( aFile, this );
+
+    if( items[4] )
+        aFile << "[" << m_RNormals->GetName() << "]";
+
+    if( items[5] )
+        m_Colors->WriteCache( aFile, this );
+
+    if( items[6] )
+        aFile << "[" << m_RColors->GetName() << "]";
+
+    if( items[7] )
+        m_ColorIndices->WriteCache( aFile, this );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGFACESET::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( m_Coords || m_RCoords || m_CoordIndices
+        || m_Colors || m_RColors || m_ColorIndices
+        || m_Normals || m_RNormals )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    #define NITEMS 8
+    bool items[NITEMS];
+
+    for( int i = 0; i < NITEMS; ++i )
+        aFile.read( (char*)&items[i], sizeof(bool) );
+
+    if( ( items[0] && items[1] ) || ( items[3] && items[4] )
+        || ( items[5] && items[6] ) )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] corrupt data; multiple item definitions at position ";
+        std::cerr << aFile.tellg() << "\n";
+        return false;
+    }
+
+    std::string name;
+
+    if( items[0] )
+    {
+        if( S3D::SGTYPE_COORDS != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child coords tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_Coords = new SGCOORDS( this );
+        m_Coords->SetName( name.c_str() );
+
+        if( !m_Coords->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading coords '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( items[1] )
+    {
+        if( S3D::SGTYPE_COORDS != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref coords tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* np = FindNode( name.c_str(), this );
+
+        if( !np )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref coords '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_COORDS != np->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not SGCOORDS '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        m_RCoords = (SGCOORDS*)np;
+        m_RCoords->addNodeRef( this );
+    }
+
+    if( items[2] )
+    {
+        if( S3D::SGTYPE_COORDINDEX != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad coord index tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_CoordIndices = new SGCOORDINDEX( this );
+        m_CoordIndices->SetName( name.c_str() );
+
+        if( !m_CoordIndices->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading coord index '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( items[3] )
+    {
+        if( S3D::SGTYPE_NORMALS != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child normals tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_Normals = new SGNORMALS( this );
+        m_Normals->SetName( name.c_str() );
+
+        if( !m_Normals->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading normals '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( items[4] )
+    {
+        if( S3D::SGTYPE_NORMALS != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref normals tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* np = FindNode( name.c_str(), this );
+
+        if( !np )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref normals '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_NORMALS != np->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not SGNORMALS '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        m_RNormals = (SGNORMALS*)np;
+        m_RNormals->addNodeRef( this );
+    }
+
+    if( items[5] )
+    {
+        if( S3D::SGTYPE_COLORS != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child colors tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_Colors = new SGCOLORS( this );
+        m_Colors->SetName( name.c_str() );
+
+        if( !m_Colors->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading colors '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( items[6] )
+    {
+        if( S3D::SGTYPE_COLORS != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref colors tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* np = FindNode( name.c_str(), this );
+
+        if( !np )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref colors '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_COLORS != np->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not SGCOLORS '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        m_RColors = (SGCOLORS*)np;
+        m_RColors->addNodeRef( this );
+    }
+
+    if( items[7] )
+    {
+        if( S3D::SGTYPE_COLORINDEX != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad color index tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_ColorIndices = new SGCOLORINDEX( this );
+        m_ColorIndices->SetName( name.c_str() );
+
+        if( !m_ColorIndices->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading color index '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGFACESET::validate( void )
+{
+    // verify the integrity of this object's data
+    if( validated )
+        return valid;
+
+    // ensure we have at least coordinates and their normals
+    if( (NULL == m_Coords && NULL == m_RCoords)
+        || (NULL == m_Normals && NULL == m_RNormals)
+        || (NULL == m_CoordIndices) )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad model; no vertices, vertex indices, or normals\n";
+#endif
+        validated = true;
+        valid = false;
+        return false;
+    }
+
+    // check that there are >3 vertices
+    SGCOORDS* coords = m_Coords;
+
+    if( NULL == coords )
+        coords = m_RCoords;
+
+    size_t nCoords = 0;
+    SGPOINT* lCoords = NULL;
+    coords->GetCoordsList( nCoords, lCoords );
+
+    if( nCoords < 3 )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad model; fewer than 3 vertices\n";
+#endif
+        validated = true;
+        valid = false;
+        return false;
+    }
+
+    // check that nVertices is divisible by 3 (facets are triangles)
+    size_t nCIdx = 0;
+    int* lCIdx = NULL;
+    m_CoordIndices->GetIndices( nCIdx, lCIdx );
+
+    if( nCIdx < 3 || ( nCIdx % 3 > 0 ) )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad model; no vertex indices or not multiple of 3\n";
+#endif
+        validated = true;
+        valid = false;
+        return false;
+    }
+
+    // check that vertex[n] >= 0 and < nVertices
+    for( size_t i = 0; i < nCIdx; ++i )
+    {
+        if( lCIdx[i] < 0 || lCIdx[i] >= nCoords )
+        {
+#ifdef DEBUG
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] bad model; vertex index out of bounds\n";
+#endif
+            validated = true;
+            valid = false;
+            return false;
+        }
+    }
+
+    // check that there are as many normals as vertices
+    size_t nNorms = 0;
+    SGVECTOR* lNorms = NULL;
+    SGNORMALS* pNorms = m_Normals;
+
+    if( NULL == pNorms )
+        pNorms = m_RNormals;
+
+    pNorms->GetNormalList( nNorms, lNorms );
+
+    if( nNorms != nCoords )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad model; number of normals does not match number of vertices\n";
+#endif
+        validated = true;
+        valid = false;
+        return false;
+    }
+
+    // if there are colors then ensure there are as many colors as vertices
+    SGCOLORS* pColors = m_Colors;
+
+    if( NULL == pColors )
+        pColors = m_RColors;
+
+    if( NULL != pColors )
+    {
+        if( NULL == m_ColorIndices )
+        {
+#ifdef DEBUG
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] bad model; no color indices\n";
+#endif
+            validated = true;
+            valid = false;
+            return false;
+        }
+
+        // we must have at least 1 color in the list
+        size_t nColor = 0;
+        SGCOLOR* pColor = NULL;
+        pColors->GetColorList( nColor, pColor );
+
+        if( nColor < 1 )
+        {
+#ifdef DEBUG
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] bad model; no colors\n";
+#endif
+            validated = true;
+            valid = false;
+            return false;
+        }
+
+        size_t nCLIdx = 0;
+        int* pCLIdx = NULL;
+        m_ColorIndices->GetIndices( nCLIdx, pCLIdx );
+
+        if( nCLIdx != nCoords )
+        {
+#ifdef DEBUG
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] bad model; color indices do not match number of vertices\n";
+#endif
+            validated = true;
+            valid = false;
+            return false;
+        }
+
+        // check that color[n] >= 0 and < nColors
+        for( size_t i = 0; i < nCLIdx; ++i )
+        {
+            if( pCLIdx[i] < 0 || pCLIdx[i] >= nCLIdx )
+            {
+#ifdef DEBUG
+                std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+                std::cerr << " * [INFO] bad model; color index out of bounds\n";
+#endif
+                validated = true;
+                valid = false;
+                return false;
+            }
+        }
+    }
+
+    validated = true;
+    valid = true;
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_faceset.h b/3d-viewer/3d_cache/sg/sg_faceset.h
new file mode 100644
index 0000000000..fa21ef3bb1
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_faceset.h
@@ -0,0 +1,112 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_faceset.h
+ * defines an indexed face set for a scenegraph
+ */
+
+// BUG:
+// 1. Since we always use Normal Per Vertex we can deprecate SGNORMALINDEX
+// 2. There is no such thing as a Referenced Index so deprecate these
+
+#ifndef SG_FACESET_H
+#define SG_FACESET_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+// BUG: eliminate NormalIndices; they are not necessary since
+// we use per-vertex normals
+
+class SGCOLORS;
+class SGCOORDS;
+class SGNORMALS;
+class SGCOLORINDEX;
+class SGCOORDINDEX;
+class SGNORMALINDEX;
+
+class SGFACESET : public SGNODE
+{
+private:
+    bool valid;
+    bool validated;
+    void unlinkNode( const SGNODE* aNode, bool isChild );
+    bool addNode( SGNODE* aNode, bool isChild );
+
+public:
+    // owned objects
+    SGCOLORS*       m_Colors;
+    SGCOLORINDEX*   m_ColorIndices;
+    SGCOORDS*       m_Coords;
+    SGCOORDINDEX*   m_CoordIndices;
+    SGNORMALS*      m_Normals;
+
+    // referenced objects
+    SGCOLORS*       m_RColors;
+    SGCOORDS*       m_RCoords;
+    SGNORMALS*      m_RNormals;
+
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+    // validate the data held by this face set
+    bool validate( void );
+
+public:
+    SGFACESET( SGNODE* aParent );
+    virtual ~SGFACESET();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    SGNODE* FindNode( const char *aNodeName, const SGNODE *aCaller );
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+};
+
+/*
+    p.88
+    IndexedFaceSet {
+        color               NULL
+        coord               NULL
+        normal              NULL
+        texCoord            NULL
+        ccw                 TRUE
+        colorIndex          []
+        colorPerVertex      TRUE
+        convex              TRUE
+        coordIndex          []
+        creaseAngle         0
+        normalIndex         []
+        normalPerVertex     TRUE
+        solid               TRUE
+        texCoordIndex       []
+    }
+*/
+
+#endif  // SG_FACESET_H
diff --git a/3d-viewer/3d_cache/sg/sg_helpers.cpp b/3d-viewer/3d_cache/sg/sg_helpers.cpp
new file mode 100644
index 0000000000..a738b5adf9
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_helpers.cpp
@@ -0,0 +1,306 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <sstream>
+#include <streambuf>
+#include <iomanip>
+#include <string>
+#include <3d_cache/sg/sg_helpers.h>
+#include <3d_cache/sg/sg_node.h>
+
+// formats a floating point number for text output to a VRML file
+void S3D::FormatFloat( std::string& result, double value )
+{
+    if( value < 1e-8 &&  value > -1e-8 )
+    {
+        result = "0";
+        return;
+    }
+
+    // note: many VRML implementations use float so we use the max.
+    // precision here of 8 digits.
+    std::ostringstream out;
+    out << std::setprecision( 8 ) << value;
+
+    result = out.str();
+
+    size_t p = result.find( "." );
+
+    // trim trailing 0 if appropriate
+
+    if( std::string::npos == p )
+        return;
+
+    p = result.find_first_of( "eE" );
+
+    if( std::string::npos == p )
+    {
+        while( '0' == *(result.rbegin()) )
+            result.erase( result.size() - 1 );
+
+        return;
+    }
+
+    if( '0' != result.at( p -1 ) )
+        return;
+
+    // trim all 0 to the left of 'p'
+    std::string tmp = result.substr( p );
+    result = result.substr( 0, p );
+
+    while( '0' == *(result.rbegin()) )
+        result.erase( result.size() - 1 );
+
+    result.append( tmp );
+
+    return;
+}
+
+// format orientation data for VRML output
+void S3D::FormatOrientation( std::string& result, const SGVECTOR& axis, double rotation )
+{
+    double aX;
+    double aY;
+    double aZ;
+
+    axis.GetVector( aX, aY, aZ );
+    FormatFloat( result, aX );
+    std::string tmp;
+    FormatFloat( tmp, aY );
+    result.append( " " );
+    result.append( tmp );
+    FormatFloat( tmp, aZ );
+    result.append( " " );
+    result.append( tmp );
+    FormatFloat( tmp, rotation );
+    result.append( " " );
+    result.append( tmp );
+
+    return;
+}
+
+// format point data for VRML output
+void S3D::FormatPoint( std::string& result, const SGPOINT& point )
+{
+    FormatFloat( result, point.x );
+
+    std::string tmp;
+    FormatFloat( tmp, point.y );
+    result.append( " " );
+    result.append( tmp );
+
+    FormatFloat( tmp, point.z );
+    result.append( " " );
+    result.append( tmp );
+
+    return;
+}
+
+
+// format vector data for VRML output
+void S3D::FormatVector( std::string& result, const SGVECTOR& aVector )
+{
+    double X, Y, Z;
+    aVector.GetVector( X, Y, Z );
+    FormatFloat( result, X );
+
+    std::string tmp;
+    FormatFloat( tmp, Y );
+    result.append( " " );
+    result.append( tmp );
+
+    FormatFloat( tmp, Z );
+    result.append( " " );
+    result.append( tmp );
+
+    return;
+}
+
+
+// format Color data for VRML output
+void S3D::FormatColor( std::string& result, const SGCOLOR& aColor )
+{
+    float R, G, B;
+    aColor.GetColor( R, G, B );
+    FormatFloat( result, R );
+
+    std::string tmp;
+    FormatFloat( tmp, G );
+    result.append( " " );
+    result.append( tmp );
+
+    FormatFloat( tmp, B );
+    result.append( " " );
+    result.append( tmp );
+
+    return;
+}
+
+
+bool S3D::WritePoint( std::ofstream& aFile, const SGPOINT& aPoint )
+{
+    aFile.write( (char*)&aPoint.x, sizeof(aPoint.x) );
+    aFile.write( (char*)&aPoint.y, sizeof(aPoint.y) );
+    aFile.write( (char*)&aPoint.z, sizeof(aPoint.z) );
+}
+
+
+bool S3D::WriteVector( std::ofstream& aFile, const SGVECTOR& aVector )
+{
+    double x, y, z;
+    aVector.GetVector( x, y, z );
+    aFile.write( (char*)&x, sizeof(double) );
+    aFile.write( (char*)&y, sizeof(double) );
+    aFile.write( (char*)&z, sizeof(double) );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool S3D::WriteColor( std::ofstream& aFile, const SGCOLOR& aColor )
+{
+    float r, g, b;
+    aColor.GetColor( r, g, b );
+    aFile.write( (char*)&r, sizeof(float) );
+    aFile.write( (char*)&g, sizeof(float) );
+    aFile.write( (char*)&b, sizeof(float) );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+S3D::SGTYPES S3D::ReadTag( std::ifstream& aFile, std::string& aName )
+{
+    char schar;
+    aFile.get( schar );
+
+    if( '[' != schar )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] corrupt data; missing left bracket at position ";
+        std::cerr << aFile.tellg() << "\n";
+        return S3D::SGTYPE_END;
+    }
+
+    std::string name;
+    aFile.get( schar );
+
+    while( ']' != schar && aFile.good() )
+    {
+        name.push_back( schar );
+        aFile.get( schar );
+    }
+
+    if( schar != ']' )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] corrupt data; could not find right bracket\n";
+        return S3D::SGTYPE_END;
+    }
+
+    aName = name;
+    size_t upos = name.find( '_' );
+
+    if( std::string::npos == upos )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] corrupt data; no underscore in name '";
+        std::cerr << name << "'\n";
+        return S3D::SGTYPE_END;
+    }
+
+    name = name.substr( 0, upos );
+    S3D::SGTYPES types[S3D::SGTYPE_END] = {
+        SGTYPE_TRANSFORM,
+        SGTYPE_APPEARANCE,
+        SGTYPE_COLORS,
+        SGTYPE_COLORINDEX,
+        SGTYPE_FACESET,
+        SGTYPE_COORDS,
+        SGTYPE_COORDINDEX,
+        SGTYPE_NORMALS,
+        SGTYPE_SHAPE
+    };
+
+    for( int i = 0; i < S3D::SGTYPE_END; ++i )
+    {
+        if( !name.compare( S3D::GetNodeTypeName( types[i] ) ) )
+            return types[i];
+    }
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [INFO] corrupt data; no node type matching '";
+    std::cerr << name << "'\n";
+    return S3D::SGTYPE_END;
+}
+
+
+bool S3D::ReadPoint( std::ifstream& aFile, SGPOINT& aPoint )
+{
+    aFile.read( (char*)&aPoint.x, sizeof( aPoint.x ) );
+    aFile.read( (char*)&aPoint.y, sizeof( aPoint.y ) );
+    aFile.read( (char*)&aPoint.z, sizeof( aPoint.z ) );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool S3D::ReadVector( std::ifstream& aFile, SGVECTOR& aVector )
+{
+    double x, y, z;
+    aFile.read( (char*)&x, sizeof(double) );
+    aFile.read( (char*)&y, sizeof(double) );
+    aFile.read( (char*)&z, sizeof(double) );
+    aVector.SetVector( x, y, z );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool S3D::ReadColor( std::ifstream& aFile, SGCOLOR& aColor )
+{
+    float r, g, b;
+    aFile.read( (char*)&r, sizeof(float) );
+    aFile.read( (char*)&g, sizeof(float) );
+    aFile.read( (char*)&b, sizeof(float) );
+    aColor.SetColor( r, g, b );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_helpers.h b/3d-viewer/3d_cache/sg/sg_helpers.h
new file mode 100644
index 0000000000..14309181dd
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_helpers.h
@@ -0,0 +1,209 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_helpers.h
+ * defines a number of macro functions to aid in repetitious code which
+ * is probably best expressed as a preprocessor macro rather than as
+ * a template. This header also declares a number of functions which are
+ * only of use within the sg_* classes.
+ */
+
+#ifndef SG_HELPERS_H
+#define SG_HELPERS_H
+
+#include <fstream>
+#include <string>
+#include <algorithm>
+#include <3d_cache/sg/sg_base.h>
+#include "sg_types.h"
+
+// Function to drop references within an SGNODE
+// The node being destroyed must remove itself from the object reference's
+// backpointer list in order to avoid a segfault.
+#define DROP_REFS( aType, aList ) do { \
+        std::vector< aType* >::iterator sL = aList.begin(); \
+        std::vector< aType* >::iterator eL = aList.end(); \
+        while( sL != eL ) { \
+            ((SGNODE*)*sL)->delNodeRef( this ); \
+            ++sL; \
+        } \
+        aList.clear(); \
+    } while( 0 )
+
+
+// Function to delete owned objects within an SGNODE
+// The owned object's parent is set to NULL before
+// deletion to avoid a redundant 'unlinkChildNode' call.
+#define DEL_OBJS( aType, aList ) do { \
+        std::vector< aType* >::iterator sL = aList.begin(); \
+        std::vector< aType* >::iterator eL = aList.end(); \
+        while( sL != eL ) { \
+            ((SGNODE*)*sL)->SetParent( NULL, false ); \
+            delete *sL; \
+            ++sL; \
+        } \
+        aList.clear(); \
+    } while( 0 )
+
+
+// Function to unlink a child or reference node when that child or
+// reference node is being destroyed.
+#define UNLINK_NODE( aNodeID, aType, aNode, aOwnedList, aRefList, isChild ) do { \
+        if( aNodeID == aNode->GetNodeType() ) { \
+            std::vector< aType* >* oSL; \
+            std::vector< aType* >::iterator sL; \
+            std::vector< aType* >::iterator eL; \
+            if( isChild ) { \
+                oSL = &aOwnedList; \
+                sL =  aOwnedList.begin(); \
+                eL =  aOwnedList.end(); \
+            } else { \
+                oSL = &aRefList; \
+                sL =  aRefList.begin(); \
+                eL =  aRefList.end(); \
+            } \
+            while( sL != eL ) { \
+                if( (SGNODE*)*sL == aNode ) { \
+                    oSL->erase( sL ); \
+                    return; \
+                } \
+                ++sL; \
+            } \
+            return; \
+        } } while( 0 )
+
+
+// Function to check a node type, check for an existing reference,
+// and add the node type to the reference list if applicable
+#define ADD_NODE( aNodeID, aType, aNode, aOwnedList, aRefList, isChild ) do { \
+    if( aNodeID == aNode->GetNodeType() ) { \
+        std::vector< aType* >::iterator sL; \
+        SGNODE* psg = NULL; \
+        sL = std::find( aOwnedList.begin(), aOwnedList.end(), aNode ); \
+        if( sL != aOwnedList.end() ) return true; \
+        sL = std::find( aRefList.begin(), aRefList.end(), aNode ); \
+        if( sL != aRefList.end() ) return true; \
+        if( isChild ) { \
+            SGNODE* ppn = (SGNODE*)aNode->GetParent(); \
+            if( NULL != ppn ) { \
+                if( this != ppn ) { \
+                    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n"; \
+                    std::cerr << " * [BUG] object '" << aNode->GetName(); \
+                    std::cerr << "' has multiple parents '" << ppn->GetName() << "', '"; \
+                    std::cerr << m_Name << "'\n"; \
+                    return false; \
+                } \
+            } \
+            aOwnedList.push_back( (aType*)aNode ); \
+            aNode->SetParent( this, false ); \
+        } else { \
+            if( NULL == aNode->GetParent() ) { \
+                std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n"; \
+                std::cerr << " * [BUG] object '" << aNode->GetName(); \
+                std::cerr << "' has no parent\n"; \
+                std::cerr << " * [INFO] possible copy assignment or copy constructor bug\n"; \
+                return false; \
+            } \
+            aRefList.push_back( (aType*)aNode ); \
+            aNode->addNodeRef( this ); \
+        } \
+        return true; \
+    } } while( 0 )
+
+
+// Function to find a node object given a (non-unique) node name
+#define FIND_NODE( aType, aName, aNodeList, aCallingNode ) do { \
+    std::vector< aType* >::iterator sLA = aNodeList.begin(); \
+    std::vector< aType* >::iterator eLA = aNodeList.end(); \
+    SGNODE* psg = NULL; \
+    while( sLA != eLA ) { \
+        if( (SGNODE*)*sLA != aCallingNode ) { \
+            psg = (SGNODE*) (*sLA)->FindNode( aName, this ); \
+            if( NULL != psg) \
+                return psg; \
+        } \
+        ++sLA; \
+    } } while ( 0 )
+
+namespace S3D
+{
+    //
+    // VRML related functions
+    //
+
+    // formats a floating point number for text output to a VRML file
+    void FormatFloat( std::string& result, double value );
+
+    // format orientation data for VRML output
+    void FormatOrientation( std::string& result, const SGVECTOR& axis, double rotation );
+
+    // format point data for VRML output
+    void FormatPoint( std::string& result, const SGPOINT& point );
+
+    // format vector data for VRML output
+    void FormatVector( std::string& result, const SGVECTOR& aVector );
+
+    // format Color data for VRML output
+    void FormatColor( std::string& result, const SGCOLOR& aColor );
+
+    //
+    // Cache related WRITE functions
+    //
+
+    // write out an XYZ vertex
+    bool WritePoint( std::ofstream& aFile, const SGPOINT& aPoint );
+
+    // write out a unit vector
+    bool WriteVector( std::ofstream& aFile, const SGVECTOR& aVector );
+
+    // write out an RGB color
+    bool WriteColor( std::ofstream& aFile, const SGCOLOR& aColor );
+
+    //
+    // Cache related READ functions
+    //
+
+    /**
+     * Function ReadTag
+     * reads the text tag of a binary cache file which is the
+     * NodeTag and unique ID number combined
+     *
+     * @param aFile is a binary file open for reading
+     * @param aName will hold the tag name on successful return
+     * @return will be the NodeType which the tag represents or
+     * S3D::SGTYPES::SGTYPE_END on failure
+     */
+    S3D::SGTYPES ReadTag( std::ifstream& aFile, std::string& aName );
+
+    // read an XYZ vertex
+    bool ReadPoint( std::ifstream& aFile, SGPOINT& aPoint );
+
+    // read a unit vector
+    bool ReadVector( std::ifstream& aFile, SGVECTOR& aVector );
+
+    // read an RGB color
+    bool ReadColor( std::ifstream& aFile, SGCOLOR& aColor );
+};
+
+#endif  // SG_HELPERS_H
diff --git a/3d-viewer/3d_cache/sg/sg_index.cpp b/3d-viewer/3d_cache/sg/sg_index.cpp
new file mode 100644
index 0000000000..076c5fb8d8
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_index.cpp
@@ -0,0 +1,342 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <fstream>
+#include <3d_cache/sg/sg_index.h>
+
+
+SGINDEX::SGINDEX( SGNODE* aParent ) : SGNODE( aParent )
+{
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGINDEX (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+
+    return;
+}
+
+
+SGINDEX::~SGINDEX()
+{
+    index.clear();
+    return;
+}
+
+
+bool SGINDEX::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGFACESET may be parent to a SGINDEX and derived types
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SGINDEX::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    return NULL;
+}
+
+
+void SGINDEX::unlinkChildNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+void SGINDEX::unlinkRefNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+bool SGINDEX::AddRefNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGINDEX::AddChildNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGINDEX::GetIndices( size_t& nIndices, int*& aIndexList )
+{
+    if( index.empty() )
+    {
+        nIndices = 0;
+        aIndexList = NULL;
+        return false;
+    }
+
+    nIndices = index.size();
+    aIndexList = & index[0];
+    return true;
+}
+
+
+void SGINDEX::SetIndices( size_t nIndices, int* aIndexList )
+{
+    index.clear();
+
+    if( 0 == nIndices || NULL == aIndexList )
+        return;
+
+    for( size_t i = 0; i < nIndices; ++i )
+        index.push_back( aIndexList[i] );
+
+    return;
+}
+
+
+void SGINDEX::AddIndex( int aIndex )
+{
+    index.push_back( aIndex );
+    return;
+}
+
+
+void SGINDEX::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+}
+
+
+bool SGINDEX::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( index.empty() )
+        return false;
+
+    if( S3D::SGTYPE_COORDINDEX == m_SGtype )
+        return writeCoordIndex( aFile );
+
+    return writeColorIndex( aFile );
+}
+
+
+bool SGINDEX::writeCoordIndex( std::ofstream& aFile )
+{
+    size_t n = index.size();
+
+    if( n % 3 )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] coord index is not divisible by three (violates triangle constraint)\n";
+        return false;
+    }
+
+    aFile << " coordIndex [\n  ";
+
+    // indices to control formatting
+    int nv0 = 0;
+    int nv1 = 0;
+
+    for( size_t i = 0; i < n; )
+    {
+        aFile << index[i];
+        ++i;
+
+        if( ++nv0 == 3 )
+        {
+            aFile << ",-1";
+            ++nv1;
+            nv0 = 0;
+        }
+
+        if( i < n )
+        {
+            aFile << ",";
+
+            if( nv1 == 8 )
+            {
+                nv1 = 0;
+                aFile << "\n  ";
+            }
+        }
+    }
+
+    aFile << "]\n";
+
+    return true;
+}
+
+
+bool SGINDEX::writeColorIndex( std::ofstream& aFile )
+{
+    aFile << " colorIndex [\n  ";
+    return writeIndexList( aFile );
+}
+
+
+bool SGINDEX::writeIndexList( std::ofstream& aFile )
+{
+    // index to control formatting
+    int nv = 0;
+    size_t n = index.size();
+
+    for( size_t i = 0; i < n; )
+    {
+        aFile << index[i];
+        ++i;
+
+        if( i < n )
+        {
+            aFile << ",";
+
+            if( ++nv == 20 )
+            {
+                aFile << "\n  ";
+                nv = 0;
+            }
+        }
+    }
+
+    aFile << "]\n";
+
+    return true;
+}
+
+
+bool SGINDEX::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    size_t npts = index.size();
+    aFile.write( (char*)&npts, sizeof(size_t) );
+
+    for( size_t i = 0; i < npts; ++i )
+        aFile.write( (char*)&index[i], sizeof(int) );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGINDEX::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( !index.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    size_t npts;
+    aFile.read( (char*)&npts, sizeof(size_t) );
+    int tmp;
+
+    if( aFile.fail() )
+        return false;
+
+    for( size_t i = 0; i < npts; ++i )
+    {
+        aFile.read( (char*)&tmp, sizeof(int) );
+
+        if( aFile.fail() )
+            return false;
+
+        index.push_back( tmp );
+    }
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_index.h b/3d-viewer/3d_cache/sg/sg_index.h
new file mode 100644
index 0000000000..a82ed9eff2
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_index.h
@@ -0,0 +1,98 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_index.h
+ * defines a generic Index interface for a scenegraph object
+ */
+
+#ifndef SG_INDEX_H
+#define SG_INDEX_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+class SGINDEX : public SGNODE
+{
+protected:
+    bool writeCoordIndex( std::ofstream& aFile );
+    bool writeColorIndex( std::ofstream& aFile );
+    bool writeIndexList( std::ofstream& aFile );
+
+public:
+    // for internal SG consumption only
+    std::vector< int > index;
+    void unlinkChildNode( const SGNODE* aCaller );
+    void unlinkRefNode( const SGNODE* aCaller );
+
+public:
+    SGINDEX( SGNODE* aParent );
+    virtual ~SGINDEX();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    /**
+     * Function GetIndices
+     * retrieves the number of indices and a pointer to
+     * the list. Note: the returned pointer may be invalidated
+     * by future operations on the SGNODE; the caller must make
+     * immediate use of the data and must not rely on the pointer's
+     * validity in the future.
+     *
+     * @param nIndices [out] will hold the number of indices in the list
+     * @param aIndexList [out] will store a pointer to the data
+     * @return true if there was available data (nIndices > 0) otherwise false
+     */
+    bool GetIndices( size_t& nIndices, int*& aIndexList );
+
+    /**
+     * Function SetIndices
+     * sets the number of indices and creates a copy of the given index data.
+     *
+     * @param nIndices [in] the number of indices to be stored
+     * @param aIndexList [in] the index data
+     */
+    void SetIndices( size_t nIndices, int* aIndexList );
+
+
+    /**
+     * Function AddIndex
+     * adds a single index to the list
+     *
+     * @param nIndices [in] the number of indices to be stored
+     * @param aIndexList [in] the index data
+     */
+    void AddIndex( int aIndex );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+};
+
+#endif  // SG_INDEX_H
diff --git a/3d-viewer/3d_cache/sg/sg_node.cpp b/3d-viewer/3d_cache/sg/sg_node.cpp
new file mode 100644
index 0000000000..dc1054c4a5
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_node.cpp
@@ -0,0 +1,367 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <sstream>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <3d_cache/sg/sg_node.h>
+#include <3d_rendering/c3dmodel.h>
+
+static const std::string node_names[S3D::SGTYPE_END + 1] = {
+    "TXFM",
+    "APP",
+    "COL",
+    "COLIDX",
+    "FACE",
+    "COORD",
+    "COORDIDX",
+    "NORM",
+    "SHAPE",
+    "INVALID"
+};
+
+
+static unsigned int node_counts[S3D::SGTYPE_END] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+
+
+char const* S3D::GetNodeTypeName( S3D::SGTYPES aType )
+{
+    return node_names[aType].c_str();
+}
+
+
+static void getNodeName( S3D::SGTYPES nodeType, std::string& aName )
+{
+    if( nodeType < 0 || nodeType >= S3D::SGTYPE_END )
+    {
+        aName = node_names[S3D::SGTYPE_END];
+        return;
+    }
+
+    unsigned int seqNum = node_counts[nodeType];
+    ++node_counts[nodeType];
+
+    std::ostringstream ostr;
+    ostr << node_names[nodeType] << "_" << seqNum;
+    aName = ostr.str();
+
+    return;
+}
+
+
+SGNODE::SGNODE( SGNODE* aParent )
+{
+    m_Parent = aParent;
+    m_Association = NULL;
+    m_written = false;
+    m_SGtype = S3D::SGTYPE_END;
+
+    return;
+}
+
+
+SGNODE::~SGNODE()
+{
+    if( m_Parent )
+        m_Parent->unlinkChildNode( this );
+
+    if( m_Association )
+        *m_Association = NULL;
+
+    std::list< SGNODE* >::iterator sBP = m_BackPointers.begin();
+    std::list< SGNODE* >::iterator eBP = m_BackPointers.end();
+
+    while( sBP != eBP )
+    {
+        (*sBP)->unlinkRefNode( this );
+        ++sBP;
+    }
+
+    return;
+}
+
+
+S3D::SGTYPES SGNODE::GetNodeType( void ) const
+{
+    return m_SGtype;
+}
+
+
+SGNODE* SGNODE::GetParent( void ) const
+{
+    return m_Parent;
+}
+
+
+const char* SGNODE::GetName( void )
+{
+    if( m_Name.empty() )
+        getNodeName( m_SGtype, m_Name );
+
+    return m_Name.c_str();
+}
+
+
+void SGNODE::SetName( const char *aName )
+{
+    if( NULL == aName || 0 == aName[0] )
+        getNodeName( m_SGtype, m_Name );
+    else
+        m_Name = aName;
+
+    return;
+}
+
+
+const char * SGNODE::GetNodeTypeName( S3D::SGTYPES aNodeType ) const
+{
+    return node_names[aNodeType].c_str();
+}
+
+
+void SGNODE::addNodeRef( SGNODE* aNode )
+{
+    std::list< SGNODE* >::iterator np =
+        std::find( m_BackPointers.begin(), m_BackPointers.end(), aNode );
+
+    if( np != m_BackPointers.end() )
+        return;
+
+    m_BackPointers.push_back( aNode );
+    return;
+}
+
+
+void SGNODE::delNodeRef( SGNODE* aNode )
+{
+    std::list< SGNODE* >::iterator np =
+        std::find( m_BackPointers.begin(), m_BackPointers.end(), aNode );
+
+    if( np != m_BackPointers.end() )
+    {
+        m_BackPointers.erase( np );
+        return;
+    }
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] delNodeRef() did not find its target\n";
+
+    return;
+}
+
+
+void SGNODE::AssociateWrapper( SGNODE** aWrapperRef )
+{
+    if( NULL == aWrapperRef )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL handle\n";
+        return;
+    }
+
+    if( *aWrapperRef != this )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] handle value does not match this object's pointer\n";
+        return;
+    }
+
+    // if there is an existing association then break it and emit a warning
+    // just in case the behavior is undesired
+    if( m_Association )
+    {
+        *m_Association = NULL;
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [WARNING] association being broken with previous wrapper\n";
+    }
+
+    m_Association = aWrapperRef;
+
+    return;
+}
+
+void SGNODE::DisassociateWrapper( SGNODE** aWrapperRef )
+{
+    if( !m_Association )
+        return;
+
+    if( !aWrapperRef )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] invalid handle value aWrapperRef\n";
+        return;
+    }
+
+    if( *aWrapperRef != *m_Association || aWrapperRef != m_Association )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] *aWrapperRef (" << *aWrapperRef;
+        std::cerr << ") does not match *m_Association (" << *m_Association << ") in type ";
+        std::cerr << node_names[ m_SGtype] << "\n";
+        std::cerr << " * [INFO] OR aWrapperRef(" << aWrapperRef << ") != m_Association(";
+        std::cerr << m_Association << ")\n";
+        std::cerr << " * [INFO] node name: " << GetName() << "\n";
+        return;
+    }
+
+    m_Association = NULL;
+
+    return;
+}
+
+
+void SGNODE::ResetNodeIndex( void )
+{
+    for( int i = 0; i < (int)S3D::SGTYPE_END; ++i )
+        node_counts[i] = 1;
+
+    return;
+}
+
+
+bool S3D::GetMatIndex( MATLIST& aList, SGNODE* aNode, int& aIndex )
+{
+    aIndex = 0;
+
+    if( NULL == aNode || S3D::SGTYPE_APPEARANCE != aNode->GetNodeType() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+
+        if( NULL == aNode )
+        {
+            std::cerr << " * [BUG] aNode is NULL\n";
+        }
+        else
+        {
+            std::cerr << " * [BUG] invalid node type (" << aNode->GetNodeType();
+            std::cerr << "), expected " << S3D::SGTYPE_APPEARANCE << "\n";
+        }
+
+        return false;
+    }
+
+    SGAPPEARANCE* node = (SGAPPEARANCE*)aNode;
+
+    std::map< SGAPPEARANCE const*, int >::iterator it = aList.matmap.find( node );
+
+    if( it != aList.matmap.end() )
+    {
+        aIndex = it->second;
+        return true;
+    }
+
+    int idx = (int)aList.matorder.size();
+    aList.matorder.push_back( node );
+    aList.matmap.insert( std::pair< SGAPPEARANCE const*, int >( node, idx ) );
+    aIndex = idx;
+
+    return true;
+}
+
+
+void S3D::INIT_SMATERIAL( SMATERIAL& aMaterial )
+{
+    memset( &aMaterial, 0, sizeof( aMaterial ) );
+    return;
+}
+
+
+void S3D::INIT_SMESH( SMESH& aMesh )
+{
+    memset( &aMesh, 0, sizeof( aMesh ) );
+    return;
+}
+
+
+void S3D::INIT_S3DMODEL( S3DMODEL& aModel )
+{
+    memset( &aModel, 0, sizeof( aModel ) );
+    return;
+}
+
+
+void S3D::FREE_SMESH( SMESH& aMesh)
+{
+    if( NULL != aMesh.m_Positions )
+    {
+        delete [] aMesh.m_Positions;
+        aMesh.m_Positions = NULL;
+    }
+
+    if( NULL != aMesh.m_Normals )
+    {
+        delete [] aMesh.m_Normals;
+        aMesh.m_Normals = NULL;
+    }
+
+    if( NULL != aMesh.m_Texcoords )
+    {
+        delete [] aMesh.m_Texcoords;
+        aMesh.m_Texcoords = NULL;
+    }
+
+    if( NULL != aMesh.m_Color )
+    {
+        delete [] aMesh.m_Color;
+        aMesh.m_Color = NULL;
+    }
+
+    if( NULL != aMesh.m_FaceIdx )
+    {
+        delete [] aMesh.m_FaceIdx;
+        aMesh.m_FaceIdx = NULL;
+    }
+
+    aMesh.m_VertexSize = 0;
+    aMesh.m_FaceIdxSize = 0;
+    aMesh.m_MaterialIdx = 0;
+
+    return;
+}
+
+
+void S3D::FREE_S3DMODEL( S3DMODEL& aModel )
+{
+    if( NULL != aModel.m_Materials )
+    {
+        delete [] aModel.m_Materials;
+        aModel.m_Materials = NULL;
+    }
+
+    aModel.m_MaterialsSize = 0;
+
+    if( NULL != aModel.m_Meshes )
+    {
+        for( unsigned int i = 0; i < aModel.m_MeshesSize; ++i )
+            FREE_SMESH( aModel.m_Meshes[i] );
+
+        delete [] aModel.m_Meshes;
+        aModel.m_Meshes = NULL;
+    }
+
+    aModel.m_MeshesSize = 0;
+
+    return;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_node.h b/3d-viewer/3d_cache/sg/sg_node.h
new file mode 100644
index 0000000000..264602f384
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_node.h
@@ -0,0 +1,229 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_node.h
+ * defines the base class of the intermediate scene graph NODE
+ */
+
+
+#ifndef SG_NODE_H
+#define SG_NODE_H
+
+#include <fstream>
+#include <string>
+#include <list>
+#include <vector>
+#include <map>
+#include <glm/glm.hpp>
+
+#include <3d_rendering/c3dmodel.h>
+#include <3d_cache/sg/sg_base.h>
+#include <3d_cache/sg/sg_types.h>
+
+class SGNODE;
+class SGAPPEARANCE;
+
+namespace S3D
+{
+    /**
+     * Function GetNodeTypeName
+     * returns the name of the given type of node
+     */
+    char const* GetNodeTypeName( S3D::SGTYPES aType );
+
+    struct MATLIST
+    {
+        std::vector< SGAPPEARANCE const* > matorder;    // materials in order of addition
+        std::map< SGAPPEARANCE const*, int > matmap;    // mapping from material to index
+    };
+
+    bool GetMatIndex( MATLIST& aList, SGNODE* aNode, int& aIndex );
+
+    void INIT_SMATERIAL( SMATERIAL& aMaterial );
+    void INIT_SMESH( SMESH& aMesh );
+    void INIT_S3DMODEL( S3DMODEL& aModel );
+
+    void FREE_SMESH( SMESH& aMesh);
+    void FREE_S3DMODEL( S3DMODEL& aModel );
+};
+
+
+/**
+ * Class SGNODE
+ * represents the base class of all Scene Graph nodes
+ */
+class SGNODE
+{
+private:
+    std::list< SGNODE* > m_BackPointers;    // nodes which hold a reference to this
+    SGNODE** m_Association;                 // handle to the instance held by a wrapper
+
+protected:
+    SGNODE* m_Parent;       // pointer to parent node; may be NULL for top level transform
+    S3D::SGTYPES m_SGtype;  // type of SG node
+    std::string m_Name;     // name to use for referencing the entity by name
+    bool m_written;         // set true when the object has been written after a ReNameNodes()
+
+public:
+    /**
+     * Function unlinkChild
+     * removes references to an owned child; it is invoked by the child upon destruction
+     * to ensure that the parent has no invalid references.
+     *
+     * @param aNode is the child which is being deleted
+     */
+    virtual void unlinkChildNode( const SGNODE* aNode ) = 0;
+
+    /**
+     * Function unlinkRef
+     * removes pointers to a referenced node; it is invoked by the referenced node
+     * upon destruction to ensure that the referring node has no invalid references.
+     *
+     * @param aNode is the node which is being deleted
+     */
+    virtual void unlinkRefNode( const SGNODE* aNode ) = 0;
+
+    /**
+     * Function addNodeRef
+     * adds a pointer to a node which references, but does not own, this node.
+     * Such back-pointers are required to ensure that invalidated references
+     * are removed when a node is deleted
+     *
+     * @param aNode is the node holding a reference to this object
+     */
+    void addNodeRef( SGNODE* aNode );
+
+    /**
+     * Function delNodeRef
+     * removes a pointer to a node which references, but does not own, this node.
+     *
+     * @param aNode is the node holding a reference to this object
+     */
+    void delNodeRef( SGNODE* aNode );
+
+public:
+    SGNODE( SGNODE* aParent );
+    virtual ~SGNODE();
+
+    /**
+     * Function GetNodeType
+     * returns the type of this node instance
+     */
+    S3D::SGTYPES GetNodeType( void ) const;
+
+    /**
+     * Function GetParent
+     * returns a pointer to the parent SGNODE of this object
+     * or NULL if the object has no parent (ie. top level transform)
+     */
+    SGNODE* GetParent( void ) const;
+
+    /**
+     * Function SetParent
+     * sets the parent SGNODE of this object.
+     *
+     * @param aParent [in] is the desired parent node
+     * @return true if the operation succeeds; false if
+     * the given node is not allowed to be a parent to
+     * the derived object.
+     */
+    virtual bool SetParent( SGNODE* aParent, bool notify = true ) = 0;
+
+    const char* GetName( void );
+    void SetName(const char *aName);
+
+    const char * GetNodeTypeName( S3D::SGTYPES aNodeType ) const;
+
+    /**
+     * Function FindNode searches the tree of linked nodes and returns a
+     * reference to the first node found with the given name. The reference
+     * is then typically added to another node via AddRefNode().
+     *
+     * @param aNodeName is the name of the node to search for
+     * @param aCaller is a pointer to the node invoking this function
+     * @return is a valid node pointer on success, otherwise NULL
+     */
+    virtual SGNODE* FindNode( const char *aNodeName, const SGNODE *aCaller ) = 0;
+
+    virtual bool AddRefNode( SGNODE* aNode ) = 0;
+
+    virtual bool AddChildNode( SGNODE* aNode ) = 0;
+
+    /**
+     * Function AssociateWrapper
+     * associates this object with a handle to itself; this handle
+     * is typically held by an IFSG* wrapper and the pointer which
+     * it refers to is set to NULL upon destruction of this object.
+     * This mechanism provides a scheme by which a wrapper can be
+     * notified of the destruction of the object which it wraps.
+     */
+    void AssociateWrapper( SGNODE** aWrapperRef );
+
+    /**
+     * Function DisassociateWrapper
+     * removes the association between an IFSG* wrapper
+     * object and this object.
+     */
+    void DisassociateWrapper( SGNODE** aWrapperRef );
+
+    /**
+     * Function ResetNodeIndex
+     * resets the global SG* node indices in preparation for
+     * Write() operations
+     */
+    void ResetNodeIndex( void );
+
+    /**
+     * Function ReNameNodes
+     * renames a node and all its child nodes in preparation for
+     * Write() operations
+     */
+    virtual void ReNameNodes( void ) = 0;
+
+    /**
+     * Function WriteVRML
+     * writes this node's data to a VRML file; this includes
+     * all data of child and referenced nodes.
+     */
+    virtual bool WriteVRML( std::ofstream& aFile, bool aReuseFlag ) = 0;
+
+    /**
+     * Function WriteCache
+     * write's this node's data to a binary cache file; the data
+     * includes all data of children and references to children.
+     * If this function is invoked by the user, parentNode must be
+     * set to NULL in order to ensure coherent data.
+     */
+    virtual bool WriteCache( std::ofstream& aFile, SGNODE* parentNode ) = 0;
+
+    /**
+     * Function ReadCache
+     * Reads binary format data from a cache file. To read a cache file,
+     * open the file for reading and invoke this function from a new
+     * SCENEGRAPH node.
+     */
+    virtual bool ReadCache( std::ifstream& aFile, SGNODE* parentNode ) = 0;
+};
+
+#endif  // SG_NODE_H
diff --git a/3d-viewer/3d_cache/sg/sg_normals.cpp b/3d-viewer/3d_cache/sg/sg_normals.cpp
new file mode 100644
index 0000000000..cab5729c42
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_normals.cpp
@@ -0,0 +1,314 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <iostream>
+#include <3d_cache/sg/sg_normals.h>
+#include <3d_cache/sg/sg_helpers.h>
+
+
+SGNORMALS::SGNORMALS( SGNODE* aParent ) : SGNODE( aParent )
+{
+    m_SGtype = S3D::SGTYPE_NORMALS;
+
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGNORMALS (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_FACESET == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGNORMALS::~SGNORMALS()
+{
+    norms.clear();
+    return;
+}
+
+
+bool SGNORMALS::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGFACESET may be parent to a SGNORMALS
+    if( NULL != aParent && S3D::SGTYPE_FACESET != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SGNORMALS::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    return NULL;
+}
+
+
+void SGNORMALS::unlinkChildNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+void SGNORMALS::unlinkRefNode( const SGNODE* aCaller )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unexpected code branch; node should have no children or refs\n";
+    return;
+}
+
+
+bool SGNORMALS::AddRefNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGNORMALS::AddChildNode( SGNODE* aNode )
+{
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] this node does not accept children or refs\n";
+    return false;
+}
+
+
+bool SGNORMALS::GetNormalList( size_t& aListSize, SGVECTOR*& aNormalList )
+{
+    if( norms.empty() )
+    {
+        aListSize = 0;
+        aNormalList = NULL;
+        return false;
+    }
+
+    aListSize = norms.size();
+    aNormalList = &norms[0];
+    return true;
+}
+
+
+void SGNORMALS::SetNormalList( size_t aListSize, const SGVECTOR* aNormalList )
+{
+    norms.clear();
+
+    if( 0 == aListSize || NULL == aNormalList )
+        return;
+
+    for( int i = 0; i < aListSize; ++i )
+        norms.push_back( aNormalList[i] );
+
+    return;
+}
+
+
+void SGNORMALS::AddNormal( double aXValue, double aYValue, double aZValue )
+{
+    norms.push_back( SGVECTOR( aXValue, aYValue, aZValue ) );
+    return;
+}
+
+
+void SGNORMALS::AddNormal( const SGVECTOR& aNormal )
+{
+    norms.push_back( aNormal );
+    return;
+}
+
+
+void SGNORMALS::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+}
+
+
+bool SGNORMALS::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( norms.empty() )
+        return false;
+
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << "  normal DEF " << GetName() << " Normal { vector [\n  ";
+            m_written = true;
+        }
+        else
+        {
+            aFile << "  normal USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << "  normal Normal { vector [\n  ";
+    }
+
+    std::string tmp;
+    size_t n = norms.size();
+    bool nline = false;
+
+    for( size_t i = 0; i < n; )
+    {
+        S3D::FormatVector( tmp, norms[i] );
+        aFile << tmp ;
+        ++i;
+
+        if( i < n )
+        {
+            aFile << ",";
+
+            if( nline )
+            {
+                aFile << "\n  ";
+                nline = false;
+            }
+            else
+            {
+                nline = true;
+            }
+
+        }
+    }
+
+    aFile << "] }\n";
+
+    return true;
+}
+
+
+bool SGNORMALS::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    size_t npts = norms.size();
+    aFile.write( (char*)&npts, sizeof(size_t) );
+
+    for( size_t i = 0; i < npts; ++i )
+        S3D::WriteVector( aFile, norms[i] );
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGNORMALS::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( !norms.empty() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    size_t npts;
+    aFile.read( (char*)&npts, sizeof(size_t) );
+    SGVECTOR tmp;
+
+    if( aFile.fail() )
+        return false;
+
+    for( size_t i = 0; i < npts; ++i )
+    {
+        if( !S3D::ReadVector( aFile, tmp ) || aFile.fail() )
+            return false;
+
+        norms.push_back( tmp );
+    }
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_normals.h b/3d-viewer/3d_cache/sg/sg_normals.h
new file mode 100644
index 0000000000..777ae80676
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_normals.h
@@ -0,0 +1,65 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_normals.h
+ * defines a set of vertex normals for a scene graph object
+ */
+
+#ifndef SG_NORMALS_H
+#define SG_NORMALS_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+class SGNORMALS : public SGNODE
+{
+public:
+    std::vector< SGVECTOR > norms;
+
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+
+public:
+    SGNORMALS( SGNODE* aParent );
+    virtual ~SGNORMALS();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    bool GetNormalList( size_t& aListSize, SGVECTOR*& aNormalList );
+    void SetNormalList( size_t aListSize, const SGVECTOR* aNormalList );
+    void AddNormal( double aXValue, double aYValue, double aZValue );
+    void AddNormal( const SGVECTOR& aNormal );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+};
+
+#endif  // SG_NORMALS_H
diff --git a/3d-viewer/3d_cache/sg/sg_shape.cpp b/3d-viewer/3d_cache/sg/sg_shape.cpp
new file mode 100644
index 0000000000..71db77528d
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_shape.cpp
@@ -0,0 +1,748 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include <iostream>
+#include <fstream>
+#include <3d_cache/sg/sg_shape.h>
+#include <3d_cache/sg/sg_faceset.h>
+#include <3d_cache/sg/sg_appearance.h>
+#include <3d_cache/sg/sg_helpers.h>
+#include <3d_cache/sg/sg_coordindex.h>
+#include <3d_cache/sg/sg_colorindex.h>
+#include <3d_cache/sg/sg_coords.h>
+#include <3d_cache/sg/sg_colors.h>
+#include <3d_cache/sg/sg_normals.h>
+
+
+SGSHAPE::SGSHAPE( SGNODE* aParent ) : SGNODE( aParent )
+{
+    m_SGtype = S3D::SGTYPE_SHAPE;
+    m_Appearance = NULL;
+    m_RAppearance = NULL;
+    m_FaceSet = NULL;
+    m_RFaceSet = NULL;
+
+    if( NULL != aParent && S3D::SGTYPE_TRANSFORM != aParent->GetNodeType() )
+    {
+        m_Parent = NULL;
+
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] inappropriate parent to SGSHAPE (type ";
+        std::cerr << aParent->GetNodeType() << ")\n";
+#endif
+    }
+    else if( NULL != aParent && S3D::SGTYPE_TRANSFORM == aParent->GetNodeType() )
+    {
+        m_Parent->AddChildNode( this );
+    }
+
+    return;
+}
+
+
+SGSHAPE::~SGSHAPE()
+{
+    // drop references
+    if( m_RAppearance )
+    {
+        m_RAppearance->delNodeRef( this );
+        m_RAppearance = NULL;
+    }
+
+    if( m_RFaceSet )
+    {
+        m_RFaceSet->delNodeRef( this );
+        m_RFaceSet = NULL;
+    }
+
+    // delete objects
+    if( m_Appearance )
+    {
+        m_Appearance->SetParent( NULL, false );
+        delete m_Appearance;
+        m_Appearance = NULL;
+    }
+
+    if( m_FaceSet )
+    {
+        m_FaceSet->SetParent( NULL, false );
+        delete m_FaceSet;
+        m_FaceSet = NULL;
+    }
+
+    return;
+}
+
+
+bool SGSHAPE::SetParent( SGNODE* aParent, bool notify )
+{
+    if( NULL != m_Parent )
+    {
+        if( aParent == m_Parent )
+            return true;
+
+        // handle the change in parents
+        if( notify )
+            m_Parent->unlinkChildNode( this );
+
+        m_Parent = NULL;
+
+        if( NULL == aParent )
+            return true;
+    }
+
+    // only a SGTRANSFORM may be parent to a SGSHAPE
+    if( NULL != aParent && S3D::SGTYPE_TRANSFORM != aParent->GetNodeType() )
+        return false;
+
+    m_Parent = aParent;
+
+    if( m_Parent )
+        m_Parent->AddChildNode( this );
+
+    return true;
+}
+
+
+SGNODE* SGSHAPE::FindNode(const char *aNodeName, const SGNODE *aCaller)
+{
+    if( NULL == aNodeName || 0 == aNodeName[0] )
+        return NULL;
+
+    if( !m_Name.compare( aNodeName ) )
+        return this;
+
+    SGNODE* tmp = NULL;
+
+    if( NULL != m_Appearance )
+    {
+        tmp = m_Appearance->FindNode( aNodeName, this );
+
+        if( tmp )
+        {
+            return tmp;
+        }
+    }
+
+    if( NULL != m_FaceSet )
+    {
+        tmp = m_FaceSet->FindNode( aNodeName, this );
+
+        if( tmp )
+        {
+            return tmp;
+        }
+    }
+
+    // query the parent if appropriate
+    if( aCaller == m_Parent || NULL == m_Parent )
+        return NULL;
+
+    return m_Parent->FindNode( aNodeName, this );
+}
+
+
+void SGSHAPE::unlinkNode( const SGNODE* aNode, bool isChild )
+{
+    if( NULL == aNode )
+        return;
+
+    if( isChild )
+    {
+        if( aNode == m_Appearance )
+        {
+            m_Appearance = NULL;
+            return;
+        }
+
+        if( aNode == m_FaceSet )
+        {
+            m_FaceSet = NULL;
+            return;
+        }
+    }
+    else
+    {
+        if( aNode == m_RAppearance )
+        {
+            m_RAppearance = NULL;
+            return;
+        }
+
+        if( aNode == m_RFaceSet )
+        {
+            m_RFaceSet = NULL;
+        }
+    }
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] unlinkNode() did not find its target\n";
+
+    return;
+}
+
+
+void SGSHAPE::unlinkChildNode( const SGNODE* aNode )
+{
+    unlinkNode( aNode, true );
+    return;
+}
+
+
+void SGSHAPE::unlinkRefNode( const SGNODE* aNode )
+{
+    unlinkNode( aNode, false );
+    return;
+}
+
+
+bool SGSHAPE::addNode( SGNODE* aNode, bool isChild )
+{
+    if( NULL == aNode )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] NULL pointer passed for aNode\n";
+        return false;
+    }
+
+    if( S3D::SGTYPE_APPEARANCE == aNode->GetNodeType() )
+    {
+        if( m_Appearance || m_RAppearance )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple Appearance nodes\n";
+            return false;
+        }
+
+        if( isChild )
+        {
+            m_Appearance = (SGAPPEARANCE*)aNode;
+            m_Appearance->SetParent( this );
+        }
+        else
+        {
+            m_RAppearance = (SGAPPEARANCE*)aNode;
+            m_RAppearance->addNodeRef( this );
+        }
+
+        return true;
+    }
+
+    if( S3D::SGTYPE_FACESET == aNode->GetNodeType() )
+    {
+        if( m_FaceSet || m_RFaceSet )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] assigning multiple FaceSet nodes\n";
+            return false;
+        }
+
+        if( isChild )
+        {
+            m_FaceSet = (SGFACESET*)aNode;
+            m_FaceSet->SetParent( this );
+        }
+        else
+        {
+            m_RFaceSet = (SGFACESET*)aNode;
+            m_RFaceSet->addNodeRef( this );
+        }
+
+        return true;
+    }
+
+    std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+    std::cerr << " * [BUG] object '" << aNode->GetName();
+    std::cerr << "' is not a valid type for this object (" << aNode->GetNodeType() << ")\n";
+    return false;
+}
+
+
+bool SGSHAPE::AddRefNode( SGNODE* aNode )
+{
+    return addNode( aNode, false );
+}
+
+
+bool SGSHAPE::AddChildNode( SGNODE* aNode )
+{
+    return addNode( aNode, true );
+}
+
+
+void SGSHAPE::ReNameNodes( void )
+{
+    m_written = false;
+
+    // rename this node
+    m_Name.clear();
+    GetName();
+
+    // rename Appearance
+    if( m_Appearance )
+        m_Appearance->ReNameNodes();
+
+    // rename FaceSet
+    if( m_FaceSet )
+        m_FaceSet->ReNameNodes();
+
+    return;
+}
+
+
+bool SGSHAPE::WriteVRML( std::ofstream& aFile, bool aReuseFlag )
+{
+    if( !m_Appearance && !m_RAppearance
+        && !m_FaceSet && !m_RFaceSet )
+    {
+        return false;
+    }
+
+    std::string tmp;
+
+    if( aReuseFlag )
+    {
+        if( !m_written )
+        {
+            aFile << "DEF " << GetName() << " Shape {\n";
+            m_written = true;
+        }
+        else
+        {
+            aFile << " USE " << GetName() << "\n";
+            return true;
+        }
+    }
+    else
+    {
+        aFile << " Shape {\n";
+    }
+
+    if( m_Appearance )
+        m_Appearance->WriteVRML( aFile, aReuseFlag );
+
+    if( m_RAppearance )
+        m_RAppearance->WriteVRML( aFile, aReuseFlag );
+
+    if( m_FaceSet )
+        m_FaceSet->WriteVRML( aFile, aReuseFlag );
+
+    if( m_RFaceSet )
+        m_RFaceSet->WriteVRML( aFile, aReuseFlag );
+
+    aFile << "}\n";
+
+    return true;
+}
+
+
+bool SGSHAPE::WriteCache( std::ofstream& aFile, SGNODE* parentNode )
+{
+    if( NULL == parentNode )
+    {
+        if( NULL == m_Parent )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [BUG] corrupt data; m_aParent is NULL\n";
+            return false;
+        }
+
+        SGNODE* np = m_Parent;
+
+        while( NULL != np->GetParent() )
+            np = np->GetParent();
+
+        return np->WriteCache( aFile, NULL );
+    }
+
+    if( parentNode != m_Parent )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] corrupt data; parentNode != m_aParent\n";
+        return false;
+    }
+
+    if( !aFile.good() )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad stream\n";
+        return false;
+    }
+
+    aFile << "[" << GetName() << "]";
+    #define NITEMS 4
+    bool items[NITEMS];
+    int i;
+
+    for( i = 0; i < NITEMS; ++i )
+        items[i] = 0;
+
+    i = 0;
+    if( NULL != m_Appearance )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_RAppearance )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_FaceSet )
+        items[i] = true;
+
+    ++i;
+    if( NULL != m_RFaceSet )
+        items[i] = true;
+
+    for( int i = 0; i < NITEMS; ++i )
+        aFile.write( (char*)&items[i], sizeof(bool) );
+
+    if( items[0] )
+        m_Appearance->WriteCache( aFile, this );
+
+    if( items[1] )
+        aFile << "[" << m_RAppearance->GetName() << "]";
+
+    if( items[2] )
+        m_FaceSet->WriteCache( aFile, this );
+
+    if( items[3] )
+        aFile << "[" << m_RFaceSet->GetName() << "]";
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGSHAPE::ReadCache( std::ifstream& aFile, SGNODE* parentNode )
+{
+    if( m_Appearance || m_RAppearance || m_FaceSet || m_RFaceSet )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [BUG] non-empty node\n";
+        return false;
+    }
+
+    #define NITEMS 4
+    bool items[NITEMS];
+
+    for( int i = 0; i < NITEMS; ++i )
+        aFile.read( (char*)&items[i], sizeof(bool) );
+
+    if( ( items[0] && items[1] ) || ( items[2] && items[3] ) )
+    {
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] corrupt data; multiple item definitions at position ";
+        std::cerr << aFile.tellg() << "\n";
+        return false;
+    }
+
+    std::string name;
+
+    if( items[0] )
+    {
+        if( S3D::SGTYPE_APPEARANCE != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child apperance tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_Appearance = new SGAPPEARANCE( this );
+        m_Appearance->SetName( name.c_str() );
+
+        if( !m_Appearance->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading appearance '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( items[1] )
+    {
+        if( S3D::SGTYPE_APPEARANCE != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref appearance tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* np = FindNode( name.c_str(), this );
+
+        if( !np )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref appearance '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_APPEARANCE != np->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not SGAPPEARANCE '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        m_RAppearance = (SGAPPEARANCE*)np;
+        m_RAppearance->addNodeRef( this );
+    }
+
+    if( items[2] )
+    {
+        if( S3D::SGTYPE_FACESET != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad child face set tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        m_FaceSet = new SGFACESET( this );
+        m_FaceSet->SetName( name.c_str() );
+
+        if( !m_FaceSet->ReadCache( aFile, this ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data while reading face set '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+    }
+
+    if( items[3] )
+    {
+        if( S3D::SGTYPE_FACESET != S3D::ReadTag( aFile, name ) )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data; bad ref face set tag at position ";
+            std::cerr << aFile.tellg() << "\n";
+            return false;
+        }
+
+        SGNODE* np = FindNode( name.c_str(), this );
+
+        if( !np )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: cannot find ref face set '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        if( S3D::SGTYPE_FACESET != np->GetNodeType() )
+        {
+            std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+            std::cerr << " * [INFO] corrupt data: type is not SGFACESET '";
+            std::cerr << name << "'\n";
+            return false;
+        }
+
+        m_RFaceSet = (SGFACESET*)np;
+        m_RFaceSet->addNodeRef( this );
+    }
+
+    if( aFile.fail() )
+        return false;
+
+    return true;
+}
+
+
+bool SGSHAPE::Prepare( const glm::dmat4* aTransform,
+    S3D::MATLIST& materials, std::vector< SMESH >& meshes )
+{
+    SMESH m;
+    S3D::INIT_SMESH( m );
+
+    SGAPPEARANCE* pa = m_Appearance;
+    SGFACESET* pf = m_FaceSet;
+
+    if( NULL == pa )
+        pa = m_RAppearance;
+
+    if( NULL == pf )
+        pf = m_RFaceSet;
+
+    // no face sets = nothing to render, which is valid though pointless
+    if( NULL == pf )
+        return true;
+
+    if( !pf->validate() )
+    {
+#ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad model; inconsistent data\n";
+#endif
+        return true;
+    }
+
+    if( NULL == m_Appearance )
+    {
+        m.m_MaterialIdx = 0;
+    }
+    else
+    {
+        int idx;
+
+        if( !S3D::GetMatIndex( materials, pa, idx ) )
+        {
+            m.m_MaterialIdx = 0;
+        }
+        else
+        {
+            m.m_MaterialIdx = idx;
+        }
+    }
+
+    SGCOLORS* pc = pf->m_Colors;
+    SGCOLORINDEX* cidx = pf->m_ColorIndices;
+    SGCOORDS* pv = pf->m_Coords;
+    SGCOORDINDEX* vidx = pf->m_CoordIndices;
+    SGNORMALS* pn = pf->m_Normals;
+
+    if( NULL == pc )
+        pc = pf->m_RColors;
+
+    if( NULL == pv )
+        pv = pf->m_RCoords;
+
+    if( NULL == pn )
+        pn = pf->m_RNormals;
+
+    // set the vertex points and indices
+    size_t nCoords = 0;
+    SGPOINT* pCoords = NULL;
+    pv->GetCoordsList( nCoords, pCoords );
+
+    // set the vertex indices
+    size_t nvidx = 0;
+    int*   lv = NULL;
+    vidx->GetIndices( nvidx, lv );
+
+    // note: reduce the vertex set to include only the referenced vertices
+    std::vector< int > vertices;            // store the list of temp vertex indices
+    std::map< int, unsigned int > indexmap; // map temp vertex to true vertex
+    std::map< int, unsigned int >::iterator mit;
+
+    for( unsigned int i = 0; i < nvidx; ++i )
+    {
+        mit = indexmap.find( lv[i] );
+
+        if( mit == indexmap.end() )
+        {
+            indexmap.insert( std::pair< int, unsigned int >( lv[i], vertices.size() ) );
+            vertices.push_back( lv[i] );
+        }
+    }
+
+    if( vertices.size() < 3 )
+    {
+        #ifdef DEBUG
+        std::cerr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
+        std::cerr << " * [INFO] bad model; not enough vertices\n";
+        #endif
+        return true;
+    }
+
+    // construct the final vertex list
+    SFVEC3F* lCoords = new SFVEC3F[ vertices.size() ];
+    int ti, ii;
+
+    for( size_t i = 0; i < vertices.size(); ++i )
+    {
+        ti = vertices[i];
+        glm::dvec4 pt( pCoords[ti].x, pCoords[ti].y, pCoords[ti].z, 1.0 );
+        pt = (*aTransform) * pt;
+
+        lCoords[i] = SFVEC3F( pt.x, pt.y, pt.z );
+    }
+
+    m.m_VertexSize = (unsigned int) vertices.size();
+    m.m_Positions = lCoords;
+    unsigned int* lvidx = new unsigned int[ nvidx ];
+
+    for( unsigned int i = 0; i < nvidx; ++i )
+    {
+        mit = indexmap.find( lv[i] );
+        lvidx[i] = mit->second;
+    }
+
+    m.m_FaceIdxSize = (unsigned int )nvidx;
+    m.m_FaceIdx = lvidx;
+
+    // set the per-vertex normals
+    size_t nNorms = 0;
+    SGVECTOR* pNorms = NULL;
+    double x, y, z;
+
+    pn->GetNormalList( nNorms, pNorms );
+    SFVEC3F* lNorms = new SFVEC3F[ vertices.size() ];
+
+    for( size_t i = 0; i < vertices.size(); ++i )
+    {
+        ti = vertices[i];
+        pNorms[ti].GetVector( x, y, z );
+        glm::dvec4 pt( x, y, z, 0.0 );
+        pt = (*aTransform) * pt;
+
+        lNorms[i] = SFVEC3F( pt.x, pt.y, pt.z );
+    }
+
+    m.m_Normals = lNorms;
+
+    // use per-vertex colors if available
+    if( pc )
+    {
+        size_t ncidx = 0;
+        int*   lcidx = NULL;
+        cidx->GetIndices( ncidx, lcidx );
+
+        // set the vertex colors
+        size_t nColors = 0;
+        SGCOLOR* pColors = NULL;
+        pc->GetColorList( nColors, pColors );
+        SFVEC3F* lColors = new SFVEC3F[ vertices.size() ];
+        double red, green, blue;
+
+        for( size_t i = 0; i < vertices.size(); ++i )
+        {
+            ti = vertices[i];
+            pColors[ lcidx[ti] ].GetColor( lColors[i].x, lColors[i].y, lColors[i].z );
+        }
+
+        m.m_Color = lColors;
+    }
+
+    meshes.push_back( m );
+
+    return true;
+}
diff --git a/3d-viewer/3d_cache/sg/sg_shape.h b/3d-viewer/3d_cache/sg/sg_shape.h
new file mode 100644
index 0000000000..8239c7232c
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_shape.h
@@ -0,0 +1,85 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file sg_shape.h
+ * defines a complex 3D shape for a scenegraph object
+ */
+
+
+#ifndef SG_SHAPE_H
+#define SG_SHAPE_H
+
+#include <vector>
+#include <3d_cache/sg/sg_node.h>
+
+class SGAPPEARANCE;
+class SGFACESET;
+
+class SGSHAPE : public SGNODE
+{
+private:
+    void unlinkNode( const SGNODE* aNode, bool isChild );
+    bool addNode( SGNODE* aNode, bool isChild );
+
+public:
+    // owned node
+    SGAPPEARANCE* m_Appearance;
+    SGFACESET*    m_FaceSet;
+
+    // referenced nodes
+    SGAPPEARANCE* m_RAppearance;
+    SGFACESET*    m_RFaceSet;
+
+    void unlinkChildNode( const SGNODE* aNode );
+    void unlinkRefNode( const SGNODE* aNode );
+
+public:
+    SGSHAPE( SGNODE* aParent );
+    virtual ~SGSHAPE();
+
+    virtual bool SetParent( SGNODE* aParent, bool notify = true );
+
+    SGNODE* FindNode(const char *aNodeName, const SGNODE *aCaller);
+    bool AddRefNode( SGNODE* aNode );
+    bool AddChildNode( SGNODE* aNode );
+
+    void ReNameNodes( void );
+    bool WriteVRML( std::ofstream& aFile, bool aReuseFlag );
+
+    bool WriteCache( std::ofstream& aFile, SGNODE* parentNode );
+    bool ReadCache( std::ifstream& aFile, SGNODE* parentNode );
+
+    bool Prepare( const glm::dmat4* aTransform,
+        S3D::MATLIST& materials, std::vector< SMESH >& meshes );
+};
+
+/*
+    p.107
+    Shape {
+        appearance  NULL
+        geometry    NULL
+    }
+*/
+
+#endif  // SG_SHAPE_H
diff --git a/3d-viewer/3d_cache/sg/sg_types.h b/3d-viewer/3d_cache/sg/sg_types.h
new file mode 100644
index 0000000000..5a4dc6e4be
--- /dev/null
+++ b/3d-viewer/3d_cache/sg/sg_types.h
@@ -0,0 +1,22 @@
+
+#ifndef SG_TYPES_H
+#define SG_TYPES_H
+
+namespace S3D
+{
+    enum SGTYPES
+    {
+        SGTYPE_TRANSFORM = 0,
+        SGTYPE_APPEARANCE,
+        SGTYPE_COLORS,
+        SGTYPE_COLORINDEX,
+        SGTYPE_FACESET,
+        SGTYPE_COORDS,
+        SGTYPE_COORDINDEX,
+        SGTYPE_NORMALS,
+        SGTYPE_SHAPE,
+        SGTYPE_END
+    };
+};
+
+#endif  // SG_TYPES_H
diff --git a/3d-viewer/3d_cache/str_rsort.h b/3d-viewer/3d_cache/str_rsort.h
new file mode 100644
index 0000000000..13c00e05fb
--- /dev/null
+++ b/3d-viewer/3d_cache/str_rsort.h
@@ -0,0 +1,87 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file str_rsort.h
+ * provides a wxString sorting functino which works from the
+ * end of the string towards the beginning
+ */
+
+#ifndef STR_RSORT_H
+#define STR_RSORT_H
+
+#include <wx/string.h>
+
+namespace S3D
+{
+
+    struct rsort_wxString
+    {
+        bool operator() (const wxString& strA, const wxString& strB ) const
+        {
+            // sort a wxString using the reverse character order; for 3d model
+            // filenames this will typically be a much faster operation than
+            // a normal alphabetic sort
+            wxString::const_reverse_iterator sA = strA.rbegin();
+            wxString::const_reverse_iterator eA = strA.rend();
+
+            wxString::const_reverse_iterator sB = strB.rbegin();
+            wxString::const_reverse_iterator eB = strB.rend();
+
+            if( strA.empty() )
+            {
+                if( strB.empty() )
+                    return false;
+
+                // note: this rule implies that a null string is first in the sort order
+                return true;
+            }
+
+            if( strB.empty() )
+                return false;
+
+            while( sA != eA && sB != eB )
+            {
+                if( (*sA) == (*sB) )
+                {
+                    ++sA;
+                    ++sB;
+                    continue;
+                }
+
+                if( (*sA) < (*sB) )
+                    return true;
+                else
+                    return false;
+            }
+
+            if( sB == eB )
+                return false;
+
+            return true;
+        }
+    };
+
+};  // end NAMESPACE
+
+#endif  // STR_RSORT_H
diff --git a/3d-viewer/3d_cache/testmd5.cpp b/3d-viewer/3d_cache/testmd5.cpp
new file mode 100644
index 0000000000..027ba93956
--- /dev/null
+++ b/3d-viewer/3d_cache/testmd5.cpp
@@ -0,0 +1,63 @@
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <iomanip>
+#include <stdint.h>
+
+#include "md5.h"
+
+
+using namespace std;
+
+int main( int argc, char** argv )
+{
+    if( argc != 2 )
+    {
+        cerr << "No filename given\n";
+        return 0;
+    }
+
+    FILE* fp = fopen( argv[1], "rb" );
+
+    if( !fp )
+    {
+        cout << "Could not open file '" << argv[1] << "'\n";
+        return 0;
+    }
+
+    struct md5_ctx msum;
+    md5_init_ctx( &msum );
+    unsigned char rb[16];
+    int res = md5_stream( fp, rb );
+
+    cout << "Result: " << res << "\n";
+    cout << "md5sum:\n";
+    for( int i = 0; i < 16; ++i )
+    {
+        cout << setfill( '0' ) << setw(2) << nouppercase << hex << ((int)rb[i] & 0xff);
+    }
+    cout << "\n";
+
+    fclose( fp );
+
+    /*
+    ifstream afile;
+    afile.open( argv[1], ios::in | ios::binary | ios::ate );
+    streampos fsize;
+
+    if( !afile.is_open() )
+    {
+        cout << "Could not open file '" << argv[1] << "'\n";
+        return 0;
+    }
+
+    fsize = afile.tellg();
+    afile.seekg( 0, ios::beg );
+
+
+
+    afile.close();
+    */
+
+    return 0;
+}
\ No newline at end of file
diff --git a/3d-viewer/3d_canvas.h b/3d-viewer/3d_canvas.h
index f3cd5d4d24..1f1ff5dd9c 100644
--- a/3d-viewer/3d_canvas.h
+++ b/3d-viewer/3d_canvas.h
@@ -45,7 +45,7 @@
 #include <3d_struct.h>
 #include <modelparsers.h>
 #include <class_module.h>
-#include <CBBox.h>
+#include "3d_rendering/3d_render_raytracing/shapes3D/cbbox.h"
 
 class BOARD_DESIGN_SETTINGS;
 class EDA_3D_FRAME;
diff --git a/3d-viewer/3d_canvas/cinfo3d_visu.h b/3d-viewer/3d_canvas/cinfo3d_visu.h
new file mode 100644
index 0000000000..aff2491070
--- /dev/null
+++ b/3d-viewer/3d_canvas/cinfo3d_visu.h
@@ -0,0 +1,376 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cinfo3d_visu.h
+ * @brief Handles data related with the board to be visualized
+ */
+
+#ifndef CINFO3D_VISU_H
+#define CINFO3D_VISU_H
+
+#include <vector>
+#include "../3d_rendering/3d_render_raytracing/accelerators/ccontainer2d.h"
+#include "../3d_rendering/3d_render_raytracing/accelerators/ccontainer.h"
+#include "../3d_rendering/3d_render_raytracing/shapes3D/cbbox.h"
+#include "../3d_rendering/ccamera.h"
+#include "../3d_rendering/ctrack_ball.h"
+#include <layers_id_colors_and_visibility.h>
+#include <class_pad.h>
+#include <class_track.h>
+#include <wx/gdicmn.h>
+#include <wxBasePcbFrame.h>
+#include <clipper.hpp>
+#include <class_pcb_text.h>
+#include <class_drawsegment.h>
+#include <class_zone.h>
+
+
+/**
+ *  Flags used in rendering options
+ */
+enum DISPLAY3D_FLG {
+    FL_AXIS=0, FL_MODULE, FL_ZONE,
+    FL_ADHESIVE, FL_SILKSCREEN, FL_SOLDERMASK, FL_SOLDERPASTE,
+    FL_COMMENTS, FL_ECO,
+    FL_USE_COPPER_THICKNESS,
+    FL_SHOW_BOARD_BODY,
+    FL_USE_REALISTIC_MODE,
+    FL_RENDER_SHADOWS,
+    FL_RENDER_SHOW_HOLES_IN_ZONES,
+    FL_RENDER_TEXTURES,
+    FL_RENDER_SMOOTH_NORMALS,
+    FL_RENDER_USE_MODEL_NORMALS,
+    FL_RENDER_MATERIAL,
+    FL_RENDER_SHOW_MODEL_BBOX,
+    FL_LAST
+};
+
+
+/**
+ *  Camera types
+ */
+enum CAMERA_TYPE
+{
+    CAMERA_TRACKBALL
+};
+
+
+/**
+ *  Grid types
+ */
+enum GRID3D_TYPE
+{
+    GRID3D_NONE,
+    GRID3D_1MM,
+    GRID3D_2P5MM,
+    GRID3D_5MM,
+    GRID3D_10MM
+};
+
+
+/// A type that stores a container of 2d objects for each layer id
+typedef std::map< LAYER_ID, CBVHCONTAINER2D *> MAP_CONTAINER_2D;
+
+
+/// This defines the range that all coord will have to be rendered.
+/// It will use this value to convert to a normalized value between
+/// -(RANGE_SCALE_3D/2) .. +(RANGE_SCALE_3D/2)
+#define RANGE_SCALE_3D 8.0f
+
+
+/**
+ *  Class CINFO3D_VISU
+ *  Helper class to handle information needed to display 3D board
+ */
+class CINFO3D_VISU
+{
+ public:
+
+    CINFO3D_VISU();
+
+    ~CINFO3D_VISU();
+
+    /**
+     * @brief GetFlag - get a configuration status of a flag
+     * @param aFlag: the flag to get the status
+     * @return true if flag is set, false if not
+     */
+    bool GetFlag( DISPLAY3D_FLG aFlag ) const ;
+
+    /**
+     * @brief SetFlag - set the status of a flag
+     * @param aFlag: the flag to get the status
+     * @param aState: status to set
+     */
+    void SetFlag( DISPLAY3D_FLG aFlag, bool aState );
+
+    /**
+     * @brief Is3DLayerEnabled - Check if a layer is enabled
+     * @param aLayer: layer ID to get status
+     * @return true if layer should be displayed, false if not
+     */
+    bool Is3DLayerEnabled( LAYER_ID aLayer ) const;
+
+    /**
+     * @brief SetBoard - Set current board to be rendered
+     * @param aBoard: board to process
+     */
+    void SetBoard( BOARD *aBoard ) { m_board = aBoard; }
+
+    /**
+     * @brief GetBoard - Get current board to be rendered
+     * @return BOARD pointer
+     */
+    const BOARD *GetBoard() const { return m_board; }
+
+    /**
+     * @brief InitSettings - Function to be called by the render when it need to
+     * reload the settings for the board.
+     */
+    void InitSettings();
+
+    /**
+     * Function BiuTo3Dunits
+     * @return the conversion factor to transform a position from the board to 3d units
+     */
+    double BiuTo3Dunits() const { return m_biuTo3Dunits; }
+
+    /**
+     * @brief GetBBox3DU - Get the bbox of the pcb board
+     * @return
+     */
+    const CBBOX &GetBBox3DU() const { return m_boardBoudingBox; }
+
+    /**
+     * @brief GetEpoxyThickness3DU - Get the current epoxy thickness
+     * @return thickness in 3d unities
+     */
+    float GetEpoxyThickness3DU() const { return m_epoxyThickness; }
+
+    /**
+     * @brief GetNonCopperLayerThickness3DU - Get the current non copper layers thickness
+     * @return thickness in 3d unities of non copperlayers
+     */
+    float GetNonCopperLayerThickness3DU() const { return m_nonCopperLayerThickness; }
+
+    /**
+     * @brief GetCopperThickness3DU - Get the current copper layer thickness
+     * @return thickness in 3d unities of copperlayers
+     */
+    float GetCopperThickness3DU() const { return m_copperThickness; }
+
+    /**
+     * @brief GetCopperThicknessBIU - Get the current copper layer thickness
+     * @return thickness in board unities
+     */
+    int GetCopperThicknessBIU() const;
+
+    /**
+     * @brief GetBoardSize3DU - Get the board size
+     * @return size in 3D unities
+     */
+    wxSize GetBoardSize3DU() const { return m_boardSize; }
+
+    /**
+     * Function GetBoardCenter
+     * @return board center in 3d units
+     */
+    SFVEC3F &GetBoardCenter3DU() { return m_boardCenter; }
+
+    /**
+     *  @param aIsFlipped: true for use in modules on Front (top) layer, false
+     *                     if module is on back (bottom) layer
+     *  @return the Z position of 3D shapes, in 3D Units
+     */
+    float GetModulesZcoord3DIU( bool aIsFlipped ) const ;
+
+    /**
+     *  @param aCameraType: camera type to use in this canvas
+     */
+    void CameraSetType( CAMERA_TYPE aCameraType );
+
+    /**
+     * @brief CameraGet - get current camera in use
+     * @return a camera
+     */
+    CCAMERA &CameraGet() const { return m_currentCamera; }
+
+    /**
+     *  Function GridGet
+     *  @return space type of the grid
+     */
+    GRID3D_TYPE GridGet() const { return m_3D_Grid_type; }
+
+    /**
+     *  Function GridSet
+     *  @param aGridType = the type space of the grid
+     */
+    void GridSet( GRID3D_TYPE aGridType ) { m_3D_Grid_type = aGridType; }
+
+    /**
+     * @brief GetBoardPoly - Get the current polygon of the epoxy board
+     * @return the shape polygon
+     */
+    const SHAPE_POLY_SET &GetBoardPoly() const { return m_boardPoly; }
+
+    /**
+     * @brief GetLayerColor - get the technical color of a layer
+     * @param aLayerId: the layer to get the color information
+     * @return the color in SFVEC3F format
+     */
+    SFVEC3F GetLayerColor( LAYER_ID aLayerId ) const;
+
+    /**
+     * @brief GetItemColor - get the technical color of a layer
+     * @param aItemId: the item id to get the color information
+     * @return the color in SFVEC3F format
+     */
+    SFVEC3F GetItemColor( int aItemId ) const;
+
+    /**
+     * @brief GetLayerTopZpos3DU - Get the top z position
+     * @param aLayerId: layer id
+     * @return position in 3D unities
+     */
+    float GetLayerTopZpos3DU( LAYER_ID aLayerId ) const { return m_layerZcoordTop[aLayerId]; }
+
+    /**
+     * @brief GetLayerBottomZpos3DU - Get the bottom z position
+     * @param aLayerId: layer id
+     * @return position in 3D unities
+     */
+    float GetLayerBottomZpos3DU( LAYER_ID aLayerId ) const { return m_layerZcoordBottom[aLayerId]; }
+
+    /**
+     * @brief GetMapLayers - Get the map of container that have the objects per layer
+     * @return the map containers of this board
+     */
+    const MAP_CONTAINER_2D &GetMapLayers() const { return m_layers_container2D; }
+
+    /**
+     * @brief GetMapLayersHoles -Get the map of container that have the holes per layer
+     * @return the map containers of holes from this board
+     */
+    const MAP_CONTAINER_2D &GetMapLayersHoles() const { return m_layers_holes2D; }
+
+    /**
+     * @brief GetThroughHole_Inflated - Get the inflated ThroughHole container
+     * @return a container with holes
+     */
+    const CBVHCONTAINER2D &GetThroughHole_Inflated() const { return m_throughHoles_inflated; }
+
+    /**
+     * @brief GetThroughHole - Get the ThroughHole container
+     * @return a container with holes
+     */
+    const CBVHCONTAINER2D &GetThroughHole() const { return m_throughHoles; }
+
+    unsigned int GetStats_Nr_Vias() const { return m_stats_nr_vias; }
+    unsigned int GetStats_Nr_Holes() const { return m_stats_nr_holes; }
+
+    float GetStats_Med_Via_Hole_Diameter3DU() const { return m_stats_via_med_hole_diameter; }
+    float GetStats_Med_Hole_Diameter3DU() const { return m_stats_hole_med_diameter; }
+    float GetStats_Med_Track_Width() const { return m_stats_track_med_width; }
+
+ private:
+    void createBoardPolygon();
+    void createLayers();
+    void destroyLayers();
+
+    // Helper functions to create the board
+    COBJECT2D *createNewTrack( const TRACK* aTrack , int aClearanceValue ) const;
+    void createNewPad(const D_PAD* aPad, CGENERICCONTAINER2D *aDstContainer, const wxSize &aInflateValue ) const;
+    void createNewPadWithClearance( const D_PAD* aPad, CGENERICCONTAINER2D *aDstContainer, int aClearanceValue ) const;
+    COBJECT2D *createNewPadDrill(const D_PAD* aPad, int aInflateValue);
+    void AddPadsShapesWithClearanceToContainer( const MODULE* aModule, CGENERICCONTAINER2D *aDstContainer, LAYER_ID aLayerId, int aInflateValue, bool aSkipNPTHPadsWihNoCopper );
+    void AddGraphicsShapesWithClearanceToContainer( const MODULE* aModule, CGENERICCONTAINER2D *aDstContainer, LAYER_ID aLayerId, int aInflateValue );
+    void AddShapeWithClearanceToContainer( const TEXTE_PCB* aTextPCB, CGENERICCONTAINER2D *aDstContainer, LAYER_ID aLayerId, int aClearanceValue );
+    void AddShapeWithClearanceToContainer(const DRAWSEGMENT* aDrawSegment, CGENERICCONTAINER2D *aDstContainer, LAYER_ID aLayerId, int aClearanceValue );
+    void AddSolidAreasShapesToContainer( const ZONE_CONTAINER* aZoneContainer, CGENERICCONTAINER2D *aDstContainer, LAYER_ID aLayerId );
+    void TransformArcToSegments(const wxPoint &aCentre, const wxPoint &aStart, double aArcAngle, int aCircleToSegmentsCount, int aWidth, CGENERICCONTAINER2D *aDstContainer , const BOARD_ITEM &aBoardItem);
+    void buildPadShapeThickOutlineAsSegments( const D_PAD*  aPad, CGENERICCONTAINER2D *aDstContainer, int aWidth);
+
+ public:
+    wxColour m_BgColor;
+    wxColour m_BgColor_Top;
+
+ private:
+    BOARD *m_board;
+
+    // Render options
+    std::vector< bool > m_drawFlags;                ///< options flags to render the board
+    GRID3D_TYPE m_3D_Grid_type;                     ///< Stores the current grid type
+
+    // Pcb board position
+    wxPoint m_boardPos;                             ///< center board actual position in board units
+    wxSize  m_boardSize;                            ///< board actual size in board units
+    SFVEC3F m_boardCenter;                          ///< 3d center position of the pcb board in 3d units
+
+    // Pcb board bounding boxes
+    CBBOX   m_boardBoudingBox;                      ///< 3d bouding box of the pcb board in 3d units
+    CBBOX2D m_board2dBBox3DU;                       ///< 2d bouding box of the pcb board in 3d units
+
+    SHAPE_POLY_SET    m_boardPoly;                  ///< PCB board outline polygon
+
+    // 2D element containers
+    MAP_CONTAINER_2D  m_layers_container2D;         ///< It contains the 2d elements of each layer
+    MAP_CONTAINER_2D  m_layers_holes2D;             ///< It contains the holes per each layer
+    CBVHCONTAINER2D   m_throughHoles_inflated;      ///< It contains the list of throughHoles of the board, the radius of the hole is inflated with the copper tickness
+    CBVHCONTAINER2D   m_throughHoles;               ///< It contains the list of throughHoles of the board, the radius of the hole is inflated with the copper tickness
+
+    // Layers information
+    unsigned int m_copperLayersCount;               ///< Number of copper layers actually used by the board
+    double m_biuTo3Dunits;                          ///< Normalization scale to convert board internal units to 3D units to normalize 3D units between -1.0 and +1.0
+    float  m_layerZcoordTop[LAYER_ID_COUNT];        ///< Top (End) Z position of each layer (normalized)
+    float  m_layerZcoordBottom[LAYER_ID_COUNT];     ///< Bottom (Start) Z position of each layer (normalized)
+    float  m_copperThickness;                       ///< Copper thickness (normalized)
+    float  m_epoxyThickness;                        ///< Epoxy thickness (normalized)
+    float  m_nonCopperLayerThickness;               ///< Non copper layers thickness
+
+    // Cameras
+    CCAMERA &m_currentCamera;                       ///< Holds a pointer to current camera in use.
+    CTRACK_BALL m_trackBallCamera;
+
+    // Statistics
+    unsigned int m_stats_nr_tracks;
+    float        m_stats_track_med_width;
+    unsigned int m_stats_nr_vias;                   ///< Nr of vias
+    float        m_stats_via_med_hole_diameter;     ///< Computed medium diameter of the via holes in 3dunits
+    unsigned int m_stats_nr_holes;
+    float        m_stats_hole_med_diameter;         ///< Computed medium diameter of the holes in 3dunits
+
+    /**
+     *  Trace mask used to enable or disable the trace output of this class.
+     *  The debug output can be turned on by setting the WXTRACE environment variable to
+     *  "KI_TRACE_EDA_CINFO3D_VISU".  See the wxWidgets documentation on wxLogTrace for
+     *  more information.
+     */
+    static const wxChar *m_logTrace;
+
+};
+
+extern CINFO3D_VISU G_null_CINFO3D_VISU;
+
+#endif // CINFO3D_VISU_H
diff --git a/3d-viewer/3d_draw.cpp b/3d-viewer/3d_draw.cpp
index ba0a2bab3d..2937dd7047 100644
--- a/3d-viewer/3d_draw.cpp
+++ b/3d-viewer/3d_draw.cpp
@@ -45,7 +45,7 @@
 #include <colors_selection.h>
 #include <convert_basic_shapes_to_polygon.h>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
 #include <gal/opengl/opengl_compositor.h>
 #ifdef __WINDOWS__
 #include <GL/glew.h>        // must be included before gl.h
@@ -1128,16 +1128,24 @@ void EDA_3D_CANVAS::render3DComponentShape( MODULE* module,
             shape3D->Render( aIsRenderingJustNonTransparentObjects,
                              aIsRenderingJustTransparentObjects );
 
-            if( isEnabled( FL_RENDER_SHOW_MODEL_BBOX ) )
+            /*
+             * XXX - CB - DEPRECATE THIS - the old renderer will eventually
+             * be replaced anyway so all debugging of 3D Plugins should be
+             * done via the new rendering system
+             */
+            if( 0 )
             {
-                // Set the alpha current color to opaque
-                float currentColor[4];
-                glGetFloatv( GL_CURRENT_COLOR,currentColor );
-                currentColor[3] = 1.0f;
-                glColor4fv( currentColor );
+                if( isEnabled( FL_RENDER_SHOW_MODEL_BBOX ) )
+                {
+                    // Set the alpha current color to opaque
+                    float currentColor[4];
+                    glGetFloatv( GL_CURRENT_COLOR,currentColor );
+                    currentColor[3] = 1.0f;
+                    glColor4fv( currentColor );
 
-                CBBOX thisBBox = shape3D->getBBox();
-                thisBBox.GLdebug();
+                    CBBOX thisBBox = shape3D->getBBox();
+                    thisBBox.GLdebug();
+                }
             }
 
             glPopMatrix();
diff --git a/3d-viewer/3d_draw_board_body.cpp b/3d-viewer/3d_draw_board_body.cpp
index 37d985826e..62251fdd40 100644
--- a/3d-viewer/3d_draw_board_body.cpp
+++ b/3d-viewer/3d_draw_board_body.cpp
@@ -45,7 +45,7 @@
 #include <colors_selection.h>
 #include <convert_basic_shapes_to_polygon.h>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
 #include <gal/opengl/opengl_compositor.h>
 #ifdef __WINDOWS__
 #include <GL/glew.h>        // must be included before gl.h
diff --git a/3d-viewer/3d_material.h b/3d-viewer/3d_material.h
index bee9e85253..3bff7e600c 100644
--- a/3d-viewer/3d_material.h
+++ b/3d-viewer/3d_material.h
@@ -32,7 +32,7 @@
 #include <common.h>
 #include <base_struct.h>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/glm.hpp>
+#include <glm/glm.hpp>
 
 class S3D_MASTER;
 
diff --git a/3d-viewer/3d_math/3d_fastmath.h b/3d-viewer/3d_math/3d_fastmath.h
new file mode 100644
index 0000000000..683082b302
--- /dev/null
+++ b/3d-viewer/3d_math/3d_fastmath.h
@@ -0,0 +1,138 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  3d_fastmath.h
+ * @brief Defines math related functions
+ */
+
+#ifndef _3D_FASTMATH_H
+#define _3D_FASTMATH_H
+
+#include <string.h>
+#include <stdint.h>
+#include <cmath>
+
+
+// Define this flag to use fast math optimizations
+#define FASTMATH_USE
+
+#define L1_CACHE_LINE_SIZE 64
+
+#ifdef FASTMATH_USE
+#define INTFLOORF(s) (lrintf( (s) - (0.5f - FLT_EPSILON) ))
+#else
+#define INTFLOORF(s) ((int)( floor(s) ))
+#endif
+
+
+/**
+ * This part contains some functions from the PBRT 3 source code.
+ * https://github.com/mmp/pbrt-v3/blob/master/src/core/pbrt.h
+ */
+
+/*
+    pbrt source code is Copyright(c) 1998-2015
+                        Matt Pharr, Greg Humphreys, and Wenzel Jakob.
+
+    This file is part of pbrt.
+
+    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.
+
+    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
+    HOLDER 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.
+
+ */
+
+
+// Global Inline Functions
+inline uint32_t FloatToBits(float f) {
+    uint32_t ui;
+    memcpy(&ui, &f, sizeof(float));
+    return ui;
+}
+
+inline float BitsToFloat(uint32_t ui) {
+    float f;
+    memcpy(&f, &ui, sizeof(uint32_t));
+    return f;
+}
+
+inline uint64_t FloatToBits(double f) {
+    uint64_t ui;
+    memcpy(&ui, &f, sizeof(double));
+    return ui;
+}
+
+inline double BitsToFloat(uint64_t ui) {
+    double f;
+    memcpy(&f, &ui, sizeof(uint64_t));
+    return f;
+}
+
+inline float NextFloatUp(float v) {
+    // Handle infinity and negative zero for _NextFloatUp()_
+    if (std::isinf(v) && v > 0.) return v;
+    if (v == -0.f) v = 0.f;
+
+    // Advance _v_ to next higher float
+    uint32_t ui = FloatToBits(v);
+    if (v >= 0.)
+        ++ui;
+    else
+        --ui;
+    return BitsToFloat(ui);
+}
+
+inline float NextFloatDown(float v) {
+    // Handle infinity and positive zero for _NextFloatDown()_
+    if (std::isinf(v) && v < 0.) return v;
+    if (v == 0.f) v = -0.f;
+    uint32_t ui = FloatToBits(v);
+    if (v > 0.)
+        --ui;
+    else
+        ++ui;
+    return BitsToFloat(ui);
+}
+
+#endif // 3D_FASTMATH_H
diff --git a/3d-viewer/3d_math/3d_math.h b/3d-viewer/3d_math/3d_math.h
new file mode 100644
index 0000000000..af3ca2a5b7
--- /dev/null
+++ b/3d-viewer/3d_math/3d_math.h
@@ -0,0 +1,125 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  3d_math.h
+ * @brief Defines math related functions
+ */
+
+#ifndef _3D_MATH_H
+#define _3D_MATH_H
+
+#include "3d_xv3d/xv3d_types.h"
+
+
+// https://en.wikipedia.org/wiki/Spherical_coordinate_system
+/**
+ * @brief SphericalToCartesian
+ * @param aInclination θ ∈ [0, π]
+ * @param aAzimuth φ ∈ [0, 2π]
+ * @return Cartesian cordinates
+ */
+inline SFVEC3F SphericalToCartesian( float aInclination, float aAzimuth )
+{
+    float sinInc = glm::sin( aInclination );
+    return SFVEC3F( sinInc * glm::cos( aAzimuth ),
+                    sinInc * glm::sin( aAzimuth ),
+                    glm::cos( aInclination ) );
+}
+
+
+// https://pathtracing.wordpress.com/2011/03/03/cosine-weighted-hemisphere/
+// !TODO: this is not correct because it is not a gaussian random
+inline SFVEC3F UniformRandomHemisphereDirection( )
+{
+    SFVEC3F b( (rand()/(float)RAND_MAX) - 0.5f, (rand()/(float)RAND_MAX) - 0.5f, (rand()/(float)RAND_MAX) - 0.5f);
+    return b;
+}
+
+
+// https://pathtracing.wordpress.com/2011/03/03/cosine-weighted-hemisphere/
+inline SFVEC3F CosWeightedRandomHemisphereDirection( SFVEC3F n )
+{
+    const float Xi1 = (float)rand() / (float)RAND_MAX;
+    const float Xi2 = (float)rand() / (float)RAND_MAX;
+
+    const float theta = acos( sqrt( 1.0f - Xi1 ) );
+    const float phi = 2.0f * glm::pi<float>() * Xi2;
+
+    const float xs = sinf( theta ) * cosf( phi );
+    const float ys = cosf( theta );
+    const float zs = sinf( theta ) * sinf( phi );
+
+    const SFVEC3F y( n.x, n.y, n.z );
+    SFVEC3F h = y;
+
+    if (fabs( h.x ) <= fabs( h.y ) && fabs( h.x ) <= fabs( h.z ) )
+        h.x= 1.0f;
+    else if (fabs(h.y)<=fabs(h.x) && fabs(h.y)<=fabs(h.z))
+        h.y= 1.0f;
+    else
+        h.z= 1.0f;
+
+
+    const SFVEC3F x = glm::normalize( glm::cross( h, y ) );
+    const SFVEC3F z = glm::normalize( glm::cross( x, y ) );
+
+    SFVEC3F direction = xs * x + ys * y + zs * z;
+    return glm::normalize( direction );
+}
+
+
+/**
+ * @brief Refract
+ * Based on: https://github.com/mmp/pbrt-v3/blob/master/src/core/reflection.h
+ * See also: http://www.flipcode.com/archives/Raytracing_Topics_Techniques-Part_3_Refractions_and_Beers_Law.shtml
+ * @param aInVector incoming vector
+ * @param aNormal normal in the intersection point
+ * @param aRin_over_Rout incoming refraction index / out refraction index
+ * @param aOutVector the refracted vector
+ * @return true
+ */
+inline bool Refract( const SFVEC3F &aInVector, const SFVEC3F &aNormal, float aRin_over_Rout, SFVEC3F &aOutVector )
+{
+    float cosThetaI = -glm::dot( aNormal, aInVector );
+    float sin2ThetaI = glm::max( 0.0f, 1.0f - cosThetaI * cosThetaI );
+    float sin2ThetaT = aRin_over_Rout * aRin_over_Rout * sin2ThetaI;
+
+    // Handle total internal reflection for transmission
+    if( sin2ThetaT >= 1.0f )
+        return false;
+
+    float cosThetaT = sqrtf( 1.0f - sin2ThetaT );
+    aOutVector = glm::normalize( aRin_over_Rout * aInVector + ( aRin_over_Rout * cosThetaI - cosThetaT ) * aNormal );
+
+    return true;
+}
+
+inline float mapf( float x, float in_min, float in_max, float out_min, float out_max)
+{
+  x = glm::clamp( x, in_min, in_max );
+  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+#endif // 3D_MATH_H
diff --git a/3d-viewer/3d_mesh_model.cpp b/3d-viewer/3d_mesh_model.cpp
index 41906e6dd7..04dcdbb4a4 100644
--- a/3d-viewer/3d_mesh_model.cpp
+++ b/3d-viewer/3d_mesh_model.cpp
@@ -31,8 +31,8 @@
 #include <3d_mesh_model.h>
 #include <boost/geometry/algorithms/area.hpp>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/gtc/matrix_transform.hpp>
-#include <gal/opengl/glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/glm.hpp>
 
 #ifdef __WXMAC__
 #  ifdef __DARWIN__
diff --git a/3d-viewer/3d_mesh_model.h b/3d-viewer/3d_mesh_model.h
index 85777f02bb..734789fbd6 100644
--- a/3d-viewer/3d_mesh_model.h
+++ b/3d-viewer/3d_mesh_model.h
@@ -34,10 +34,10 @@
 #include <boost/shared_ptr.hpp>
 #include <vector>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/glm.hpp>
+#include <glm/glm.hpp>
 #include "3d_struct.h"
 #include "3d_material.h"
-#include "CBBox.h"
+#include "3d_rendering/3d_render_raytracing/shapes3D/cbbox.h"
 
 class S3D_MESH;
 
diff --git a/3d-viewer/3d_model_viewer/c3d_model_viewer.cpp b/3d-viewer/3d_model_viewer/c3d_model_viewer.cpp
new file mode 100644
index 0000000000..2899c0dc70
--- /dev/null
+++ b/3d-viewer/3d_model_viewer/c3d_model_viewer.cpp
@@ -0,0 +1,436 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3d_model_viewer.cpp
+ * @brief Implements a model viewer canvas
+ */
+
+#include <iostream>
+#include "c3d_model_viewer.h"
+#include "3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.h"
+#include "common_ogl/ogl_utils.h"
+#include <wx/dcclient.h>
+
+/**
+ *  Trace mask used to enable or disable the trace output of this class.
+ *  The debug output can be turned on by setting the WXTRACE environment variable to
+ *  "KI_TRACE_EDA_3D_MODEL_VIEWER".  See the wxWidgets documentation on wxLogTrace for
+ *  more information.
+ */
+const wxChar * C3D_MODEL_VIEWER::m_logTrace = wxT( "KI_TRACE_EDA_3D_MODEL_VIEWER" );
+
+
+BEGIN_EVENT_TABLE( C3D_MODEL_VIEWER, wxGLCanvas )
+    EVT_PAINT( C3D_MODEL_VIEWER::OnPaint )
+
+    // mouse events
+    EVT_LEFT_DOWN(  C3D_MODEL_VIEWER::OnLeftDown )
+    EVT_LEFT_UP(    C3D_MODEL_VIEWER::OnLeftUp )
+    EVT_MIDDLE_UP(  C3D_MODEL_VIEWER::OnMiddleUp )
+    EVT_MIDDLE_DOWN(C3D_MODEL_VIEWER::OnMiddleDown)
+    EVT_RIGHT_DOWN( C3D_MODEL_VIEWER::OnRightClick )
+    EVT_MOUSEWHEEL( C3D_MODEL_VIEWER::OnMouseWheel )
+    EVT_MOTION(     C3D_MODEL_VIEWER::OnMouseMove )
+
+#ifdef USE_OSX_MAGNIFY_EVENT
+     EVT_MAGNIFY(   C3D_MODEL_VIEWER::OnMagnify )
+#endif
+
+    // other events
+    EVT_ERASE_BACKGROUND( C3D_MODEL_VIEWER::OnEraseBackground )
+END_EVENT_TABLE()
+
+
+/// This defines the range that all coord will have to be rendered.
+/// It will use this value to convert to a normalized value between
+/// -(RANGE_SCALE_3D/2) .. +(RANGE_SCALE_3D/2)
+#define RANGE_SCALE_3D 8.0f
+
+
+C3D_MODEL_VIEWER::C3D_MODEL_VIEWER( wxWindow *aParent,
+                                    const int *aAttribList ) :
+
+                  wxGLCanvas( aParent,
+                              wxID_ANY,
+                              aAttribList,
+                              wxDefaultPosition,
+                              wxDefaultSize,
+                              wxFULL_REPAINT_ON_RESIZE ),
+                  m_trackBallCamera( RANGE_SCALE_3D * 2.0f )
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::C3D_MODEL_VIEWER" ) );
+
+    m_ogl_initialized = false;
+    m_reload_is_needed = false;
+    m_ogl_3dmodel = NULL;
+    m_3d_model = NULL;
+
+    // Explicitly create a new rendering context instance for this canvas.
+    m_glRC = new wxGLContext( this );
+}
+
+
+C3D_MODEL_VIEWER::~C3D_MODEL_VIEWER()
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::~C3D_MODEL_VIEWER" ) );
+
+    delete m_ogl_3dmodel;
+    m_ogl_3dmodel = NULL;
+
+    delete m_glRC;
+    m_glRC = NULL;
+}
+
+
+void C3D_MODEL_VIEWER::Set3DModel( const S3DMODEL &a3DModel )
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::Set3DModel" ) );
+
+    // Validate a3DModel pointers
+    wxASSERT( a3DModel.m_Materials != NULL );
+    wxASSERT( a3DModel.m_Meshes != NULL );
+    wxASSERT( a3DModel.m_MaterialsSize > 0 );
+    wxASSERT( a3DModel.m_MeshesSize > 0 );
+
+    // Delete the old model
+    delete m_ogl_3dmodel;
+    m_ogl_3dmodel = NULL;
+
+    m_3d_model = NULL;
+
+    if( (a3DModel.m_Materials != NULL) && (a3DModel.m_Meshes != NULL) &&
+        (a3DModel.m_MaterialsSize > 0) && (a3DModel.m_MeshesSize > 0) )
+    {
+        m_3d_model = &a3DModel;
+        m_reload_is_needed = true;
+    }
+}
+
+void C3D_MODEL_VIEWER::Clear3DModel()
+{
+    // Delete the old model
+    m_reload_is_needed = false;
+    delete m_ogl_3dmodel;
+    m_ogl_3dmodel = NULL;
+
+    m_3d_model = NULL;
+}
+
+
+void C3D_MODEL_VIEWER::ogl_initialize()
+{
+    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
+    glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
+    glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
+
+    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+    glEnable( GL_DEPTH_TEST );
+    //glDepthFunc( GL_LEQUAL );
+    glEnable( GL_CULL_FACE );
+    glShadeModel( GL_SMOOTH );
+    glEnable( GL_LINE_SMOOTH );
+    glEnable( GL_NORMALIZE );
+
+    // Setup light
+    // https://www.opengl.org/sdk/docs/man2/xhtml/glLight.xml
+    // /////////////////////////////////////////////////////////////////////////
+    const GLfloat ambient[]  = { 0.1f, 0.1f, 0.1f, 1.0f };
+    const GLfloat diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
+    const GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    const GLfloat position[] = { 0.0f, 0.0f, 1.0f, 0.0f };                      // defines a directional light that points along the negative z-axis
+    const GLfloat lmodel_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f };
+
+    glLightfv( GL_LIGHT0, GL_AMBIENT,  ambient );
+    glLightfv( GL_LIGHT0, GL_DIFFUSE,  diffuse );
+    glLightfv( GL_LIGHT0, GL_SPECULAR, specular );
+    glLightfv( GL_LIGHT0, GL_POSITION, position );
+    glLightModelfv( GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
+}
+
+
+void C3D_MODEL_VIEWER::ogl_set_arrow_material()
+{
+    glEnable( GL_COLOR_MATERIAL );
+    glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
+
+    const SFVEC4F specular = SFVEC4F( 0.1f, 0.1f, 0.1f, 1.0f );
+
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
+    glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, 96.0f );
+}
+
+
+void C3D_MODEL_VIEWER::OnPaint( wxPaintEvent &event )
+{
+    wxPaintDC( this );
+
+    // SwapBuffer requires the window to be shown before calling
+    if( !IsShownOnScreen() )
+    {
+        wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::OnPaint !IsShown" ) );
+        return;
+    }
+
+    // "Makes the OpenGL state that is represented by the OpenGL rendering
+    //  context context current, i.e. it will be used by all subsequent OpenGL calls.
+    //  This function may only be called when the window is shown on screen"
+    SetCurrent( *m_glRC );
+
+    // Set the OpenGL viewport according to the client size of this canvas.
+    // This is done here rather than in a wxSizeEvent handler because our
+    // OpenGL rendering context (and thus viewport setting) is used with
+    // multiple canvases: If we updated the viewport in the wxSizeEvent
+    // handler, changing the size of one canvas causes a viewport setting that
+    // is wrong when next another canvas is repainted.
+    wxSize clientSize = GetClientSize();
+
+    if( !m_ogl_initialized )
+    {
+        m_ogl_initialized = true;
+        ogl_initialize();
+    }
+
+    if( m_reload_is_needed )
+    {
+        wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::OnPaint m_reload_is_needed" ) );
+
+        m_reload_is_needed = false;
+        m_ogl_3dmodel = new C_OGL_3DMODEL( *m_3d_model );
+
+        // It convert a model as it was a board, so get the max size dimension of the board
+        // and compute the conversion scale
+        m_BiuTo3Dunits = (double)RANGE_SCALE_3D / ((double)m_ogl_3dmodel->GetBBox().GetMaxDimension() * UNITS3D_TO_UNITSPCB);
+    }
+
+    glViewport( 0, 0, clientSize.x, clientSize.y );
+
+    m_trackBallCamera.SetCurWindowSize( clientSize );
+
+    // clear color and depth buffers
+    // /////////////////////////////////////////////////////////////////////////
+    glEnable( GL_DEPTH_TEST );
+
+    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
+    glClearDepth( 1.0f );
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+    // Set projection and modelview matrixes
+    // /////////////////////////////////////////////////////////////////////////
+    glMatrixMode( GL_PROJECTION );
+    glLoadMatrixf( glm::value_ptr( m_trackBallCamera.GetProjectionMatrix() ) );
+
+    glMatrixMode( GL_MODELVIEW );
+    glLoadMatrixf( glm::value_ptr( m_trackBallCamera.GetViewMatrix() ) );
+
+    glEnable(GL_LIGHTING);
+    glEnable(GL_LIGHT0);
+
+    ogl_set_arrow_material();
+
+    glColor3f( 0.9f, 0.0f, 0.0f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( RANGE_SCALE_3D / 1.0f, 0.0f, 0.0f ),
+                    0.2f );
+
+    glColor3f( 0.0f, 0.9f, 0.0f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, RANGE_SCALE_3D / 1.0f, 0.0f ),
+                    0.2f );
+
+    glColor3f( 0.0f, 0.0f, 0.9f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, 0.0f, RANGE_SCALE_3D / 1.0f ),
+                    0.2f );
+
+    // Render Model
+    if( m_ogl_3dmodel )
+    {
+        glPushMatrix();
+
+        double modelunit_to_3d_units_factor = m_BiuTo3Dunits * UNITS3D_TO_UNITSPCB;
+
+        const SFVEC3F model_center = m_ogl_3dmodel->GetBBox().GetCenter();
+        glTranslatef( model_center.x, model_center.y, model_center.z );
+
+        glScaled( modelunit_to_3d_units_factor, modelunit_to_3d_units_factor, modelunit_to_3d_units_factor);
+
+        m_ogl_3dmodel->Draw_opaque();
+        //m_ogl_3dmodel->Draw_transparent();
+        //m_ogl_3dmodel->Draw_bboxes();
+
+        glPopMatrix();
+    }
+
+
+    glViewport( 0, 0, clientSize.y / 8 , clientSize.y / 8 );                    // YxY squared view port
+    glClear( GL_DEPTH_BUFFER_BIT );
+
+    glMatrixMode( GL_PROJECTION );
+    glLoadIdentity();
+    gluPerspective( 45.0f, 1.0f, 0.01f, RANGE_SCALE_3D * 2.0f );
+
+    glMatrixMode( GL_MODELVIEW );
+    glLoadIdentity();
+
+    glm::mat4 TranslationMatrix = glm::translate( glm::mat4(1.0f), SFVEC3F( 0.0f, 0.0f, -RANGE_SCALE_3D ) );
+    glm::mat4 ViewMatrix = TranslationMatrix * m_trackBallCamera.GetRotationMatrix();
+
+    glLoadMatrixf( glm::value_ptr( ViewMatrix ) );
+
+    ogl_set_arrow_material();
+
+    glColor3f( 0.9f, 0.0f, 0.0f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( RANGE_SCALE_3D / 2.65f, 0.0f, 0.0f ),
+                    0.275f );
+
+    glColor3f( 0.0f, 0.9f, 0.0f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, RANGE_SCALE_3D / 2.65f, 0.0f ),
+                    0.275f );
+
+    glColor3f( 0.0f, 0.0f, 0.9f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, 0.0f, RANGE_SCALE_3D / 2.65f ),
+                    0.275f );
+
+    // "Swaps the double-buffer of this window, making the back-buffer the
+    //  front-buffer and vice versa, so that the output of the previous OpenGL
+    //  commands is displayed on the window."
+    SwapBuffers();
+
+    event.Skip();
+}
+
+
+void C3D_MODEL_VIEWER::OnEraseBackground( wxEraseEvent &event )
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::OnEraseBackground" ) );
+    // Do nothing, to avoid flashing.
+}
+
+
+void C3D_MODEL_VIEWER::OnMouseWheel( wxMouseEvent &event )
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_MODEL_VIEWER::OnMouseWheel" ) );
+
+    if( event.ShiftDown() )
+    {
+        //if( event.GetWheelRotation() < 0 )
+            //SetView3D( WXK_UP );    // move up
+        //else
+            //SetView3D( WXK_DOWN );  // move down
+    }
+    else if( event.ControlDown() )
+    {
+        //if( event.GetWheelRotation() > 0 )
+            //SetView3D( WXK_RIGHT ); // move right
+        //else
+            //SetView3D( WXK_LEFT );  // move left
+    }
+    else
+    {
+        if( event.GetWheelRotation() > 0 )
+        {
+            m_trackBallCamera.ZoomIn( 1.1f );
+        }
+        else
+        {
+            m_trackBallCamera.ZoomOut( 1.1f );
+        }
+
+        //DisplayStatus();
+        Refresh( false );
+    }
+
+    m_trackBallCamera.SetCurMousePosition( event.GetPosition() );
+}
+
+
+#ifdef USE_OSX_MAGNIFY_EVENT
+void C3D_MODEL_VIEWER::OnMagnify( wxMouseEvent& event )
+{
+    /*
+    double magnification = ( event.GetMagnification() + 1.0f );
+    GetPrm3DVisu().m_Zoom /= magnification;
+    if( GetPrm3DVisu().m_Zoom <= 0.01 )
+        GetPrm3DVisu().m_Zoom = 0.01;
+    DisplayStatus();
+    Refresh( false );
+    */
+}
+#endif
+
+
+void C3D_MODEL_VIEWER::OnMouseMove( wxMouseEvent &event )
+{
+    m_trackBallCamera.SetCurWindowSize( GetClientSize() );
+
+    if( event.Dragging() )
+    {
+        if( event.LeftIsDown() )            // Drag
+            m_trackBallCamera.Drag( event.GetPosition() );
+        //else if( event.MiddleIsDown() )     // Pan
+        //    m_trackBallCamera.Pan( event.GetPosition() );
+
+        // orientation has changed, redraw mesh
+        Refresh( false );
+    }
+
+    m_trackBallCamera.SetCurMousePosition( event.GetPosition() );
+}
+
+
+void C3D_MODEL_VIEWER::OnLeftDown( wxMouseEvent &event )
+{
+    //m_is_moving_mouse = true;
+}
+
+
+void C3D_MODEL_VIEWER::OnLeftUp( wxMouseEvent &event )
+{
+    //m_is_moving_mouse = false;
+    //Refresh( false );
+}
+
+
+void C3D_MODEL_VIEWER::OnMiddleDown( wxMouseEvent &event )
+{
+    //m_is_moving_mouse = true;
+}
+
+
+void C3D_MODEL_VIEWER::OnMiddleUp( wxMouseEvent &event )
+{
+    //m_is_moving_mouse = false;
+    //Refresh( false );
+}
+
+
+void C3D_MODEL_VIEWER::OnRightClick( wxMouseEvent &event )
+{
+
+}
+
diff --git a/3d-viewer/3d_model_viewer/c3d_model_viewer.h b/3d-viewer/3d_model_viewer/c3d_model_viewer.h
new file mode 100644
index 0000000000..690dfd886e
--- /dev/null
+++ b/3d-viewer/3d_model_viewer/c3d_model_viewer.h
@@ -0,0 +1,131 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3d_model_viewer.h
+ * @brief   Implements a model viewer canvas
+ */
+
+#ifndef _C3D_MODEL_VIEWER_H_
+#define _C3D_MODEL_VIEWER_H_
+
+#include "3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.h"
+#include "3d_rendering/ctrack_ball.h"
+#include <wx/glcanvas.h>
+
+
+/**
+ *  Class C3D_MODEL_VIEWER
+ *  Implement a canvas based on a wxGLCanvas
+ */
+class C3D_MODEL_VIEWER : public wxGLCanvas
+{
+
+public:
+
+
+    /**
+     *  Creates a new 3D Canvas with a attribute list
+     *  @param aParent = the parent creator of this canvas
+     *  @param aAttribList = a list of openGL options created by COGL_ATT_LIST::GetAttributesList
+     */
+    C3D_MODEL_VIEWER( wxWindow *aParent,
+                      const int *aAttribList  = 0 );
+
+    ~C3D_MODEL_VIEWER();
+
+    /**
+     * @brief Set3DModel - Set this model to be displayed
+     * @param a3DModel - 3d model data
+     */
+    void Set3DModel( const S3DMODEL &a3DModel );
+
+    /**
+     * @brief Clear3DModel - Unloads the displayed 3d model
+     */
+    void Clear3DModel();
+
+private:
+    void ogl_initialize();
+    void ogl_set_arrow_material();
+
+private:
+
+    void OnPaint( wxPaintEvent &event );
+
+    void OnEraseBackground( wxEraseEvent &event );
+
+    void OnMouseWheel( wxMouseEvent &event );
+
+#ifdef USE_OSX_MAGNIFY_EVENT
+    void   OnMagnify( wxMouseEvent& event );
+#endif
+
+    void OnMouseMove( wxMouseEvent &event );
+
+    void OnLeftDown( wxMouseEvent &event );
+
+    void OnLeftUp( wxMouseEvent &event );
+
+    void OnMiddleUp( wxMouseEvent &event );
+    void OnMiddleDown( wxMouseEvent &event );
+
+    void OnRightClick( wxMouseEvent &event );
+
+    DECLARE_EVENT_TABLE();
+
+
+private:
+    /// openGL context
+    wxGLContext *m_glRC;
+
+    /// Camera used in this canvas
+    CTRACK_BALL m_trackBallCamera;
+
+    /// Original 3d model data
+    const S3DMODEL *m_3d_model;
+
+    /// Class holder for 3d model to display on openGL
+    C_OGL_3DMODEL  *m_ogl_3dmodel;
+
+    /// Flag that we have a new model and it need to be reloaded when the paint is called
+    bool m_reload_is_needed;
+
+    /// Flag if open gl was initialized
+    bool m_ogl_initialized;
+
+    /// factor to convert the model or any other items to keep it in relation to the +/-RANGE_SCALE_3D
+    /// (it is named same as the board render for better understanding proposes)
+    double m_BiuTo3Dunits;
+
+    /**
+     *  Trace mask used to enable or disable the trace output of this class.
+     *  The debug output can be turned on by setting the WXTRACE environment variable to
+     *  "KI_TRACE_EDA_3D_MODEL_VIEWER".  See the wxWidgets documentation on wxLogTrace for
+     *  more information.
+     */
+    static const wxChar *m_logTrace;
+};
+
+#endif // _C3D_MODEL_VIEWER_H_
diff --git a/3d-viewer/3d_read_mesh.cpp b/3d-viewer/3d_read_mesh.cpp
index dcebd4b7cb..af269ce979 100644
--- a/3d-viewer/3d_read_mesh.cpp
+++ b/3d-viewer/3d_read_mesh.cpp
@@ -34,7 +34,7 @@
 #include <kicad_string.h>
 #include <pgm_base.h>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/matrix_transform.hpp>
 #include <3d_viewer.h>
 #include <info3d_visu.h>
 #include "3d_struct.h"
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_createscene_ogl_legacy.cpp b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_createscene_ogl_legacy.cpp
new file mode 100644
index 0000000000..fec8dbda51
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_createscene_ogl_legacy.cpp
@@ -0,0 +1,816 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3d_render_createscene_ogl_legacy.cpp
+ * @brief
+ */
+
+#include "c3d_render_ogl_legacy.h"
+
+#include "ogl_legacy_utils.h"
+
+#include "../3d_render_raytracing/shapes2D/cpolygon2d.h"
+#include "../3d_render_raytracing/shapes2D/ctriangle2d.h"
+#include "../3d_render_raytracing/shapes2D/cpolygon4pts2d.h"
+#include "../3d_render_raytracing/shapes2D/cfilledcircle2d.h"
+#include "../3d_render_raytracing/shapes2D/cring2d.h"
+#include "3d_math/3d_math.h"
+#include "3d_math/3d_fastmath.h"
+#include <trigo.h>
+
+void C3D_RENDER_OGL_LEGACY::reload()
+{
+    m_reloadRequested = false;
+
+    ogl_free_all_display_lists();
+
+    COBJECT2D_STATS::Instance().ResetStats();
+
+    printf("InitSettings...\n");
+    unsigned stats_startReloadTime = GetRunningMicroSecs();
+    m_settings.InitSettings();
+    unsigned stats_endReloadTime = GetRunningMicroSecs();
+
+    SFVEC3F camera_pos = m_settings.GetBoardCenter3DU();
+    m_settings.CameraGet().SetBoardLookAtPos( camera_pos );
+
+    unsigned stats_start_OpenGL_Load_Time = GetRunningMicroSecs();
+
+    // Create Board
+    // /////////////////////////////////////////////////////////////////////////
+    printf("Create board...\n");
+    CCONTAINER2D boardContainer;
+    Convert_shape_line_polygon_to_triangles( m_settings.GetBoardPoly(),
+                                             boardContainer,
+                                             m_settings.BiuTo3Dunits(),
+                                             (const BOARD_ITEM &)*m_settings.GetBoard() );
+
+    const LIST_OBJECT2D listBoardObject2d = boardContainer.GetList();
+
+    if( listBoardObject2d.size() > 0 )
+    {
+        /*
+        float layer_z_top = m_settings.GetLayerBottomZpos3DU( F_Cu );
+        float layer_z_bot = m_settings.GetLayerBottomZpos3DU( B_Cu );
+*/
+        float layer_z_top = m_settings.GetLayerBottomZpos3DU( B_Mask );
+        float layer_z_bot = m_settings.GetLayerTopZpos3DU( B_Mask );
+        CLAYER_TRIANGLES *layerTriangles = new CLAYER_TRIANGLES( listBoardObject2d.size() );
+
+        for( LIST_OBJECT2D::const_iterator itemOnLayer = listBoardObject2d.begin();
+             itemOnLayer != listBoardObject2d.end();
+             itemOnLayer++ )
+        {
+            const COBJECT2D *object2d_A = static_cast<const COBJECT2D *>(*itemOnLayer);
+
+            wxASSERT( object2d_A->GetObjectType() == OBJ2D_TRIANGLE );
+
+            const CTRIANGLE2D *tri = (const CTRIANGLE2D *)object2d_A;
+            const SFVEC2F &v1 = tri->GetP1();
+            const SFVEC2F &v2 = tri->GetP2();
+            const SFVEC2F &v3 = tri->GetP3();
+
+            add_triangle_top_bot( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
+        }
+
+        const SHAPE_POLY_SET boardPoly = m_settings.GetBoardPoly();
+        SHAPE_POLY_SET boardPolyCopy = boardPoly;
+
+        boardPolyCopy.Simplify( true );
+
+        if( boardPolyCopy.OutlineCount() == 1 )
+        {
+            const SHAPE_LINE_CHAIN& outlinePath = boardPolyCopy.COutline( 0 );
+
+            std::vector< SFVEC2F > contournPoints;
+            contournPoints.clear();
+            contournPoints.reserve( outlinePath.PointCount() + 2 );
+
+            for( unsigned int i = 0; i < (unsigned int)outlinePath.PointCount(); ++i )
+            {
+                const VECTOR2I& v = outlinePath.CPoint( i );
+                contournPoints.push_back( SFVEC2F( v.x * m_settings.BiuTo3Dunits(),
+                                                  -v.y * m_settings.BiuTo3Dunits() ) );
+            }
+            contournPoints.push_back( contournPoints[0] );
+
+            if( contournPoints.size() > 4 )
+            {
+                // Calculate normals of each segment of the contourn
+                std::vector< SFVEC2F > contournNormals;
+                contournNormals.clear();
+                contournNormals.reserve( contournPoints.size() );
+                for( unsigned int i = 0; i < ( contournPoints.size() - 1 ); ++i )
+                {
+                    const SFVEC2F &v0 = contournPoints[i + 0];
+                    const SFVEC2F &v1 = contournPoints[i + 1];
+
+                    SFVEC2F n = glm::normalize( v1 - v0 );
+                    contournNormals.push_back( SFVEC2F( -n.y, n.x ) );
+                }
+
+                SFVEC2F lastNormal = contournNormals[contournPoints.size() - 2];
+                for( unsigned int i = 0; i < ( contournPoints.size() - 1 ); ++i )
+                {
+                    const SFVEC2F &v0 = contournPoints[i + 0];
+                    const SFVEC2F &v1 = contournPoints[i + 1];
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, NextFloatUp( layer_z_top ) ),
+                                                                             SFVEC3F( v1.x, v1.y, NextFloatUp( layer_z_top ) ),
+                                                                             SFVEC3F( v1.x, v1.y, NextFloatDown( layer_z_bot ) ),
+                                                                             SFVEC3F( v0.x, v0.y, NextFloatDown( layer_z_bot ) ) );
+
+                    SFVEC2F n0 = contournNormals[i];
+
+                    if( glm::dot( n0, lastNormal ) > 0.5f )
+                        n0 += lastNormal;
+                    else
+                        n0 += contournNormals[i];
+
+                    const SFVEC2F &nextNormal = contournNormals[ (i + 1) % (contournPoints.size() - 1) ];
+                    SFVEC2F n1 = contournNormals[i];
+
+                    if( glm::dot( n1, nextNormal ) > 0.5f )
+                        n1 += nextNormal;
+                    else
+                        n1 += contournNormals[i];
+
+                    n0 = glm::normalize( n0 );
+                    n1 = glm::normalize( n1 );
+
+                    const SFVEC3F n3d0 = SFVEC3F( n0.x, n0.y, 0.0f );
+                    const SFVEC3F n3d1 = SFVEC3F( n1.x, n1.y, 0.0f );
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( n3d0, n3d1, n3d1, n3d0 );
+
+                    lastNormal = contournNormals[i];
+/*
+                    const SFVEC2F n0 = glm::normalize( v0 - center );
+                    const SFVEC2F n1 = glm::normalize( v1 - center );
+                    const SFVEC3F n0z = SFVEC3F( n0.x, n0.y, 0.0f );
+                    const SFVEC3F n1z = SFVEC3F( n1.x, n1.y, 0.0f );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( n0z, n1z, n1z, n0z );*/
+                }
+            }
+            contournPoints.clear();
+        }
+
+        m_ogl_disp_list_board = new CLAYERS_OGL_DISP_LISTS( *layerTriangles, m_ogl_circle_texture, SFVEC3F(0.65f,0.55f,0.05f) );
+
+        delete layerTriangles;
+    }
+
+
+    float calc_sides_min_factor = (float)(   10.0 * IU_PER_MILS * m_settings.BiuTo3Dunits() );
+    float calc_sides_max_factor = (float)( 1000.0 * IU_PER_MILS * m_settings.BiuTo3Dunits() );
+
+
+    // Add layers maps (except B_Mask and F_Mask)
+    // /////////////////////////////////////////////////////////////////////////
+    printf("Add layers maps...\n");
+    for( MAP_CONTAINER_2D::const_iterator ii = m_settings.GetMapLayers().begin();
+         ii != m_settings.GetMapLayers().end();
+         ii++ )
+    {
+        LAYER_ID layer_id = static_cast<LAYER_ID>(ii->first);
+
+        if( !m_settings.Is3DLayerEnabled( layer_id ) )
+            continue;
+
+        const CBVHCONTAINER2D *container2d = static_cast<const CBVHCONTAINER2D *>(ii->second);
+        const LIST_OBJECT2D listObject2d = container2d->GetList();
+
+        if( listObject2d.size() == 0 )
+            continue;
+
+        //CMATERIAL *materialLayer = &m_materials.m_SilkS;
+        SFVEC3F layerColor = SFVEC3F( 0.3f, 0.4f, 0.5f );
+
+        float layer_z_bot = m_settings.GetLayerBottomZpos3DU( layer_id );
+        float layer_z_top = m_settings.GetLayerTopZpos3DU( layer_id );
+
+        if( layer_z_top < layer_z_bot )
+        {
+            float tmpFloat = layer_z_bot;
+            layer_z_bot = layer_z_top;
+            layer_z_top = tmpFloat;
+        }
+
+        layer_z_bot -= m_settings.GetNonCopperLayerThickness3DU();
+        layer_z_top += m_settings.GetNonCopperLayerThickness3DU();
+
+        if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) )
+        {
+            switch( layer_id )
+            {
+                case B_Adhes:
+                case F_Adhes:
+
+                break;
+
+                case B_Paste:
+                case F_Paste:
+    //                materialLayer = &m_materials.m_Paste;
+                break;
+
+                case B_SilkS:
+                case F_SilkS:
+
+    //                materialLayer = &m_materials.m_SilkS;
+    //                layerColor = g_silkscreenColor;
+                break;
+
+                case Dwgs_User:
+                case Cmts_User:
+                case Eco1_User:
+                case Eco2_User:
+                case Edge_Cuts:
+                case Margin:
+                break;
+
+                case B_CrtYd:
+                case F_CrtYd:
+                break;
+
+                case B_Fab:
+                case F_Fab:
+                break;
+
+                default:
+                    //materialLayer = &m_materials.m_Copper;
+
+                        //layerColor = g_copperColor;
+
+
+                break;
+            }
+        }
+        else
+        {
+            layerColor = m_settings.GetLayerColor( layer_id );
+
+        }
+
+
+        // Calculate an estiation for then nr of triangles based on the nr of objects
+        unsigned int nrTrianglesEstimation = listObject2d.size() * 8;
+
+        CLAYER_TRIANGLES *layerTriangles = new CLAYER_TRIANGLES( nrTrianglesEstimation );
+
+        m_triangles[layer_id] = layerTriangles;
+
+        for( LIST_OBJECT2D::const_iterator itemOnLayer = listObject2d.begin();
+             itemOnLayer != listObject2d.end();
+             itemOnLayer++ )
+        {
+            const COBJECT2D *object2d_A = static_cast<const COBJECT2D *>(*itemOnLayer);
+
+            switch( object2d_A->GetObjectType() )
+            {
+
+                case OBJ2D_FILLED_CIRCLE:
+                {
+                    const CFILLEDCIRCLE2D *filledCircle = (const CFILLEDCIRCLE2D *)object2d_A;
+                    const SFVEC2F &center = filledCircle->GetCenter();
+                    float radius = filledCircle->GetRadius() * 2.0f;            // Double because the render triangle
+                    float radiusSquared = radius * radius;
+
+                    const float texture_factor = (0.9f/(float)SIZE_OF_CIRCLE_TEXTURE) + 1.0f;
+                    const float f = (sqrtf(2.0f) / 2.0f) * radius * 0.9;// * texture_factor;
+
+                    layerTriangles->m_layer_top_segment_ends->AddTriangle( SFVEC3F( center.x + f, center.y, layer_z_top ),
+                                                                           SFVEC3F( center.x - f, center.y, layer_z_top ),
+                                                                           SFVEC3F( center.x,
+                                                                                    center.y - f, layer_z_top ) );
+
+                    layerTriangles->m_layer_top_segment_ends->AddTriangle( SFVEC3F( center.x - f, center.y, layer_z_top ),
+                                                                           SFVEC3F( center.x + f, center.y, layer_z_top ),
+                                                                           SFVEC3F( center.x,
+                                                                                    center.y + f, layer_z_top ) );
+
+                    layerTriangles->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( center.x - f, center.y, layer_z_bot ),
+                                                                           SFVEC3F( center.x + f, center.y, layer_z_bot ),
+                                                                           SFVEC3F( center.x,
+                                                                                    center.y - f, layer_z_bot ) );
+
+                    layerTriangles->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( center.x + f, center.y, layer_z_bot ),
+                                                                           SFVEC3F( center.x - f, center.y, layer_z_bot ),
+                                                                           SFVEC3F( center.x,
+                                                                                    center.y + f, layer_z_bot ) );
+
+                    unsigned int nr_sides_per_circle = (unsigned int)mapf( radiusSquared,
+                                                                           calc_sides_min_factor, calc_sides_max_factor,
+                                                                           24.0f, 256.0f );
+
+                    wxASSERT( nr_sides_per_circle >= 24 );
+
+                    // Normal radius for the circle
+                    radius = filledCircle->GetRadius();
+
+                    std::vector< SFVEC2F > contournPoints;
+
+                    contournPoints.clear();
+                    contournPoints.reserve( nr_sides_per_circle + 2 );
+                    int    delta       = 3600 / nr_sides_per_circle;
+                    int ii;
+                    for( ii = 0; ii < 3600; ii += delta )
+                    {
+                        const SFVEC2F rotatedDir = glm::rotate( SFVEC2F( 0.0f, 1.0f ),  (float)ii  * 2.0f * 3.14f / 3600.0f );
+                        contournPoints.push_back(   SFVEC2F( center.x - rotatedDir.y * radius, center.y + rotatedDir.x * radius ) );
+                    }
+                    contournPoints.push_back( contournPoints[0] );
+
+                    if( contournPoints.size() > 1 )
+                    {
+                        for( unsigned int i = 0; i < ( contournPoints.size() - 1 ); ++i )
+                        {
+                            const SFVEC2F &v0 = contournPoints[i + 0];
+                            const SFVEC2F &v1 = contournPoints[i + 1];
+
+                            layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, NextFloatUp( layer_z_bot ) ),
+                                                                                     SFVEC3F( v1.x, v1.y, NextFloatUp( layer_z_bot ) ),
+                                                                                     SFVEC3F( v1.x, v1.y, NextFloatDown( layer_z_top ) ),
+                                                                                     SFVEC3F( v0.x, v0.y, NextFloatDown( layer_z_top ) ) );
+
+
+                            const SFVEC2F n0 = glm::normalize( v0 - center );
+                            const SFVEC2F n1 = glm::normalize( v1 - center );
+                            const SFVEC3F n0z = SFVEC3F( n0.x, n0.y, 0.0f );
+                            const SFVEC3F n1z = SFVEC3F( n1.x, n1.y, 0.0f );
+                            layerTriangles->m_layer_middle_contourns_quads->AddNormal( n0z, n1z, n1z, n0z );
+                        }
+                    }
+                    contournPoints.clear();
+
+                }
+                break;
+
+                case OBJ2D_DUMMYBLOCK:
+                {
+                }
+                break;
+
+                case OBJ2D_POLYGON4PT:
+                {
+                    const CPOLYGON4PTS2D *poly = (const CPOLYGON4PTS2D *)object2d_A;
+                    const SFVEC2F &v0 = poly->GetV0();
+                    const SFVEC2F &v1 = poly->GetV1();
+                    const SFVEC2F &v2 = poly->GetV2();
+                    const SFVEC2F &v3 = poly->GetV3();
+
+                    add_triangle_top_bot( layerTriangles, v0, v2, v1, layer_z_top, layer_z_bot );
+                    add_triangle_top_bot( layerTriangles, v2, v0, v3, layer_z_top, layer_z_bot );
+
+                    const SFVEC2F &n0 = poly->GetN0();
+                    const SFVEC2F &n1 = poly->GetN1();
+                    const SFVEC2F &n2 = poly->GetN2();
+                    const SFVEC2F &n3 = poly->GetN3();
+
+                    const SFVEC3F n3d0 = SFVEC3F(-n0.y, n0.x, 0.0f );
+                    const SFVEC3F n3d1 = SFVEC3F(-n1.y, n1.x, 0.0f );
+                    const SFVEC3F n3d2 = SFVEC3F(-n2.y, n2.x, 0.0f );
+                    const SFVEC3F n3d3 = SFVEC3F(-n3.y, n3.x, 0.0f );
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, layer_z_bot ),
+                                                                             SFVEC3F( v1.x, v1.y, layer_z_bot ),
+                                                                             SFVEC3F( v1.x, v1.y, layer_z_top ),
+                                                                             SFVEC3F( v0.x, v0.y, layer_z_top ) );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( n3d0, n3d0, n3d0, n3d0 );
+
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v2.x, v2.y, layer_z_top ),
+                                                                             SFVEC3F( v1.x, v1.y, layer_z_top ),
+                                                                             SFVEC3F( v1.x, v1.y, layer_z_bot ),
+                                                                             SFVEC3F( v2.x, v2.y, layer_z_bot ) );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( n3d1, n3d1, n3d1, n3d1 );
+
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v3.x, v3.y, layer_z_top ),
+                                                                             SFVEC3F( v2.x, v2.y, layer_z_top ),
+                                                                             SFVEC3F( v2.x, v2.y, layer_z_bot ),
+                                                                             SFVEC3F( v3.x, v3.y, layer_z_bot ) );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( n3d2, n3d2, n3d2, n3d2 );
+
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, layer_z_top ),
+                                                                             SFVEC3F( v3.x, v3.y, layer_z_top ),
+                                                                             SFVEC3F( v3.x, v3.y, layer_z_bot ),
+                                                                             SFVEC3F( v0.x, v0.y, layer_z_bot ) );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( n3d3, n3d3, n3d3, n3d3 );
+                }
+                break;
+
+
+                case OBJ2D_RING:
+                {
+                    const CRING2D *ring = (const CRING2D *)object2d_A;
+                    const SFVEC2F &center = ring->GetCenter();
+                    float inner = ring->GetInnerRadius();
+                    float outer = ring->GetOuterRadius();
+
+                    unsigned int nr_sides_per_circle = (unsigned int)mapf( outer,
+                                                                           calc_sides_min_factor, calc_sides_max_factor,
+                                                                           24.0f, 256.0f );
+
+                    wxASSERT( nr_sides_per_circle >= 24 );
+
+
+                    std::vector< SFVEC2F > innerContour;
+                    std::vector< SFVEC2F > outerContour;
+                    innerContour.clear();
+                    innerContour.reserve( nr_sides_per_circle + 2 );
+
+                    outerContour.clear();
+                    outerContour.reserve( nr_sides_per_circle + 2 );
+
+                    int    delta       = 3600 / nr_sides_per_circle;
+                    for( int ii = 0; ii < 3600; ii += delta )
+                    {
+                        const SFVEC2F rotatedDir = glm::rotate( SFVEC2F( 0.0f, 1.0f),  (float)        ii  * 2.0f * 3.14f / 3600.0f );
+
+                        innerContour.push_back( SFVEC2F( center.x - rotatedDir.y * inner, center.y + rotatedDir.x * inner ) );
+                        outerContour.push_back( SFVEC2F( center.x - rotatedDir.y * outer, center.y + rotatedDir.x * outer ) );
+                    }
+
+                    innerContour.push_back( innerContour[0] );
+                    outerContour.push_back( outerContour[0] );
+
+                    wxASSERT( innerContour.size() == outerContour.size() );
+
+                    for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
+                    {
+                        const SFVEC2F &vi0 = innerContour[i + 0];
+                        const SFVEC2F &vi1 = innerContour[i + 1];
+                        const SFVEC2F &vo0 = outerContour[i + 0];
+                        const SFVEC2F &vo1 = outerContour[i + 1];
+
+                        layerTriangles->m_layer_top_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, layer_z_top ),
+                                                                        SFVEC3F( vi0.x, vi0.y, layer_z_top ),
+                                                                        SFVEC3F( vo0.x, vo0.y, layer_z_top ),
+                                                                        SFVEC3F( vo1.x, vo1.y, layer_z_top ) );
+
+                        layerTriangles->m_layer_bot_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, layer_z_bot ),
+                                                                        SFVEC3F( vo1.x, vo1.y, layer_z_bot ),
+                                                                        SFVEC3F( vo0.x, vo0.y, layer_z_bot ),
+                                                                        SFVEC3F( vi0.x, vi0.y, layer_z_bot ) );
+                    }
+
+                    for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
+                    {
+                        const SFVEC2F &v0 = innerContour[i + 0];
+                        const SFVEC2F &v1 = innerContour[i + 1];
+
+                        layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v1.x, v1.y, NextFloatUp( layer_z_bot ) ),
+                                                                                 SFVEC3F( v0.x, v0.y, NextFloatUp( layer_z_bot ) ),
+                                                                                 SFVEC3F( v0.x, v0.y, NextFloatDown( layer_z_top ) ),
+                                                                                 SFVEC3F( v1.x, v1.y, NextFloatDown( layer_z_top ) ) );
+
+
+                        const SFVEC2F n0 = glm::normalize( v0 - center );
+                        const SFVEC2F n1 = glm::normalize( v1 - center );
+                        const SFVEC3F n0z = SFVEC3F( n0.x, n0.y, 0.0f );
+                        const SFVEC3F n1z = SFVEC3F( n1.x, n1.y, 0.0f );
+                        layerTriangles->m_layer_middle_contourns_quads->AddNormal( n0z, n1z, n1z, n0z );
+                    }
+
+
+                    for( unsigned int i = 0; i < ( outerContour.size() - 1 ); ++i )
+                    {
+                        const SFVEC2F &v0 = outerContour[i + 0];
+                        const SFVEC2F &v1 = outerContour[i + 1];
+
+                        layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, NextFloatUp( layer_z_bot ) ),
+                                                                                 SFVEC3F( v1.x, v1.y, NextFloatUp( layer_z_bot ) ),
+                                                                                 SFVEC3F( v1.x, v1.y, NextFloatDown( layer_z_top ) ),
+                                                                                 SFVEC3F( v0.x, v0.y, NextFloatDown( layer_z_top ) ) );
+
+
+                        const SFVEC2F n0 = glm::normalize( v0 - center );
+                        const SFVEC2F n1 = glm::normalize( v1 - center );
+                        const SFVEC3F n0z = SFVEC3F( n0.x, n0.y, 0.0f );
+                        const SFVEC3F n1z = SFVEC3F( n1.x, n1.y, 0.0f );
+                        layerTriangles->m_layer_middle_contourns_quads->AddNormal( n0z, n1z, n1z, n0z );
+                    }
+
+                }
+                break;
+
+
+                case OBJ2D_TRIANGLE:
+                {
+                    const CTRIANGLE2D *tri = (const CTRIANGLE2D *)object2d_A;
+                    const SFVEC2F &v1 = tri->GetP1();
+                    const SFVEC2F &v2 = tri->GetP2();
+                    const SFVEC2F &v3 = tri->GetP3();
+
+                    add_triangle_top_bot( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
+                }
+                break;
+
+                case OBJ2D_ROUNDSEG:
+                {
+                    const CROUNDSEGMENT2D &roundSeg = (const CROUNDSEGMENT2D &) *object2d_A;
+                    unsigned int nr_sides_per_circle = (unsigned int)mapf( roundSeg.GetWidth(),
+                                                                           calc_sides_min_factor, calc_sides_max_factor,
+                                                                           24.0f, 256.0f );
+
+                    wxASSERT( nr_sides_per_circle >= 24 );
+
+                    SFVEC2F leftStart   = roundSeg.GetLeftStar();
+                    SFVEC2F leftEnd     = roundSeg.GetLeftEnd();
+                    SFVEC2F leftDir     = roundSeg.GetLeftDir();
+
+                    SFVEC2F rightStart  = roundSeg.GetRightStar();
+                    SFVEC2F rightEnd    = roundSeg.GetRightEnd();
+                    SFVEC2F rightDir    = roundSeg.GetRightDir();
+                    float   radius      = roundSeg.GetRadius();
+
+                    SFVEC2F start       = roundSeg.GetStart();
+                    SFVEC2F end         = roundSeg.GetEnd();
+
+                    float texture_factor = (12.0f/(float)SIZE_OF_CIRCLE_TEXTURE) + 1.0f;
+                    float texture_factorF= ( 4.0f/(float)SIZE_OF_CIRCLE_TEXTURE) + 1.0f;
+
+                    const float radius_of_the_square = sqrtf( roundSeg.GetRadiusSquared() * 2.0f );
+                    const float radius_triangle_factor = (radius_of_the_square - radius) / radius;
+
+                    const SFVEC2F factorS = SFVEC2F( -rightDir.y * radius * radius_triangle_factor, rightDir.x * radius * radius_triangle_factor );
+                    const SFVEC2F factorE = SFVEC2F( -leftDir.y  * radius * radius_triangle_factor, leftDir.x  * radius * radius_triangle_factor );
+
+                    // Top end segment triangles
+                    layerTriangles->m_layer_top_segment_ends->AddTriangle( SFVEC3F( rightEnd.x   + texture_factor * factorS.x, rightEnd.y  + texture_factor * factorS.y, layer_z_top ),
+                                                                           SFVEC3F( leftStart.x  + texture_factor * factorE.x, leftStart.y + texture_factor * factorE.y, layer_z_top ),
+                                                                           SFVEC3F( start.x - texture_factorF * leftDir.x * radius * sqrtf(2.0f),
+                                                                                    start.y - texture_factorF * leftDir.y * radius * sqrtf(2.0f), layer_z_top ) );
+
+                    layerTriangles->m_layer_top_segment_ends->AddTriangle( SFVEC3F( leftEnd.x    + texture_factor * factorE.x, leftEnd.y    + texture_factor * factorE.y, layer_z_top ),
+                                                                           SFVEC3F( rightStart.x + texture_factor * factorS.x, rightStart.y + texture_factor * factorS.y, layer_z_top ),
+                                                                           SFVEC3F( end.x - texture_factorF * rightDir.x * radius * sqrtf(2.0f),
+                                                                                    end.y - texture_factorF * rightDir.y * radius * sqrtf(2.0f), layer_z_top ) );
+
+                    // Bot end segment triangles
+                    layerTriangles->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( leftStart.x  + texture_factor * factorE.x, leftStart.y + texture_factor * factorE.y, layer_z_bot ),
+                                                                           SFVEC3F( rightEnd.x   + texture_factor * factorS.x, rightEnd.y  + texture_factor * factorS.y, layer_z_bot ),
+                                                                           SFVEC3F( start.x - texture_factorF * leftDir.x * radius * sqrtf(2.0f),
+                                                                                    start.y - texture_factorF * leftDir.y * radius * sqrtf(2.0f), layer_z_bot ) );
+
+                    layerTriangles->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( rightStart.x + texture_factor * factorS.x, rightStart.y + texture_factor * factorS.y, layer_z_bot ),
+                                                                           SFVEC3F( leftEnd.x    + texture_factor * factorE.x, leftEnd.y    + texture_factor * factorE.y, layer_z_bot ),
+                                                                           SFVEC3F( end.x - texture_factorF * rightDir.x * radius * sqrtf(2.0f),
+                                                                                    end.y - texture_factorF * rightDir.y * radius * sqrtf(2.0f), layer_z_bot ) );
+
+                    // Segment top and bot planes
+                    layerTriangles->m_layer_top_triangles->AddQuad( SFVEC3F( rightEnd.x,   rightEnd.y,   layer_z_top ),
+                                                                    SFVEC3F( rightStart.x, rightStart.y, layer_z_top ),
+                                                                    SFVEC3F( leftEnd.x,    leftEnd.y,    layer_z_top ),
+                                                                    SFVEC3F( leftStart.x,  leftStart.y,  layer_z_top ) );
+
+                    layerTriangles->m_layer_bot_triangles->AddQuad( SFVEC3F( rightEnd.x,   rightEnd.y,   layer_z_bot ),
+                                                                    SFVEC3F( leftStart.x,  leftStart.y,  layer_z_bot ),
+                                                                    SFVEC3F( leftEnd.x,    leftEnd.y,    layer_z_bot ),
+                                                                    SFVEC3F( rightStart.x, rightStart.y, layer_z_bot ) );
+
+                    // Middle contourns (two sides of the segment)
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( leftStart.x, leftStart.y, layer_z_top ),
+                                                                             SFVEC3F( leftEnd.x,   leftEnd.y,   layer_z_top ),
+                                                                             SFVEC3F( leftEnd.x,   leftEnd.y,   layer_z_bot ),
+                                                                             SFVEC3F( leftStart.x, leftStart.y, layer_z_bot ) );
+                    const SFVEC3F leftNormal = SFVEC3F( -leftDir.y, leftDir.x, 0.0f );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( leftNormal, leftNormal, leftNormal, leftNormal );
+
+
+                    layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( rightStart.x, rightStart.y, layer_z_top ),
+                                                                             SFVEC3F( rightEnd.x,   rightEnd.y,   layer_z_top ),
+                                                                             SFVEC3F( rightEnd.x,   rightEnd.y,   layer_z_bot ),
+                                                                             SFVEC3F( rightStart.x, rightStart.y, layer_z_bot ) );
+                    const SFVEC3F rightNormal = SFVEC3F( -rightDir.y, rightDir.x, 0.0f );
+                    layerTriangles->m_layer_middle_contourns_quads->AddNormal( rightNormal, rightNormal, rightNormal, rightNormal );
+
+
+                    // Compute the outlines of the segment, and creates a polygon
+                    // add right rounded end:
+
+                    std::vector< SFVEC2F > roundedEndPointsStart;
+                    std::vector< SFVEC2F > roundedEndPointsEnd;
+                    roundedEndPointsStart.clear();
+                    roundedEndPointsStart.reserve( nr_sides_per_circle + 2 );
+
+                    roundedEndPointsEnd.clear();
+                    roundedEndPointsEnd.reserve( nr_sides_per_circle + 2 );
+
+                    roundedEndPointsStart.push_back( SFVEC2F( leftStart.x, leftStart.y ) );
+                    roundedEndPointsEnd.push_back(   SFVEC2F( leftEnd.x,   leftEnd.y ) );
+
+                    int    delta       = 3600 / nr_sides_per_circle;
+                    for( int ii = delta; ii < 1800; ii += delta )
+                    {
+                        const SFVEC2F rotatedDirL = glm::rotate( leftDir,  (float)        ii  * 2.0f * 3.14f / 3600.0f );
+                        const SFVEC2F rotatedDirR = glm::rotate( rightDir, (float)(1800 - ii) * 2.0f * 3.14f / 3600.0f );
+                        roundedEndPointsStart.push_back( SFVEC2F( start.x - rotatedDirL.y * radius, start.y + rotatedDirL.x * radius ) );
+                        roundedEndPointsEnd.push_back(   SFVEC2F( end.x   - rotatedDirR.y * radius, end.y   + rotatedDirR.x * radius ) );
+                    }
+                    roundedEndPointsStart.push_back( SFVEC2F( rightEnd.x, rightEnd.y ) );
+                    roundedEndPointsEnd.push_back(   SFVEC2F( rightStart.x, rightStart.y ) );
+
+                    if( roundedEndPointsStart.size() > 1 )
+                    {
+                        for( unsigned int i = 0; i < ( roundedEndPointsStart.size() - 1 ); ++i )
+                        {
+                            const SFVEC2F &v0 = roundedEndPointsStart[i + 0];
+                            const SFVEC2F &v1 = roundedEndPointsStart[i + 1];
+
+                            layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, layer_z_bot ),
+                                                                                     SFVEC3F( v1.x, v1.y, layer_z_bot ),
+                                                                                     SFVEC3F( v1.x, v1.y, layer_z_top ),
+                                                                                     SFVEC3F( v0.x, v0.y, layer_z_top ) );
+
+
+                            const SFVEC2F n0 = glm::normalize( v0 - start );
+                            const SFVEC2F n1 = glm::normalize( v1 - start );
+                            const SFVEC3F n0z = SFVEC3F( n0.x, n0.y, 0.0f );
+                            const SFVEC3F n1z = SFVEC3F( n1.x, n1.y, 0.0f );
+                            layerTriangles->m_layer_middle_contourns_quads->AddNormal( n0z, n1z, n1z, n0z );
+                        }
+                    }
+                    roundedEndPointsStart.clear();
+
+                    if( roundedEndPointsEnd.size() > 1 )
+                    {
+                        for( unsigned int i = 0; i < ( roundedEndPointsEnd.size() - 1 ); ++i )
+                        {
+                            const SFVEC2F &v0 = roundedEndPointsEnd[i + 0];
+                            const SFVEC2F &v1 = roundedEndPointsEnd[i + 1];
+
+                            layerTriangles->m_layer_middle_contourns_quads->AddQuad( SFVEC3F( v0.x, v0.y, layer_z_top ),
+                                                                                     SFVEC3F( v1.x, v1.y, layer_z_top ),
+                                                                                     SFVEC3F( v1.x, v1.y, layer_z_bot ),
+                                                                                     SFVEC3F( v0.x, v0.y, layer_z_bot ) );
+
+
+                            const SFVEC2F n0 = glm::normalize( v0 - end );
+                            const SFVEC2F n1 = glm::normalize( v1 - end );
+                            const SFVEC3F n0z = SFVEC3F( n0.x, n0.y, 0.0f );
+                            const SFVEC3F n1z = SFVEC3F( n1.x, n1.y, 0.0f );
+                            layerTriangles->m_layer_middle_contourns_quads->AddNormal( n0z, n1z, n1z, n0z );
+                        }
+                    }
+                    roundedEndPointsEnd.clear();
+                }
+                break;
+
+                default:
+                {
+                }
+                break;
+            }
+#if 0
+            // not yet used / implemented (can be used in future to clip the objects in the board borders
+            COBJECT2D *object2d_C = CSGITEM_FULL;
+
+            std::vector<const COBJECT2D *> *object2d_B = CSGITEM_EMPTY;
+
+            if( m_settings.GetFlag( FL_RENDER_SHOW_HOLES_IN_ZONES ) )
+            {
+                object2d_B = new std::vector<const COBJECT2D *>();
+
+                // Check if there are any layerhole that intersects this object
+                // Eg: a segment is cutted by a via hole or THT hole.
+                // /////////////////////////////////////////////////////////////
+                const MAP_CONTAINER_2D &layerHolesMap = m_settings.GetMapLayersHoles();
+                if( layerHolesMap.find(layer_id) != layerHolesMap.end() )
+                {
+                    MAP_CONTAINER_2D::const_iterator ii_hole = layerHolesMap.find(layer_id);
+                    const CBVHCONTAINER2D *containerLayerHoles2d = static_cast<const CBVHCONTAINER2D *>(ii_hole->second);
+
+
+                    CONST_LIST_OBJECT2D intersectionList;
+                    containerLayerHoles2d->GetListObjectsIntersects( object2d_A->GetBBox(), intersectionList );
+
+                    if( !intersectionList.empty() )
+                    {
+                        for( CONST_LIST_OBJECT2D::const_iterator holeOnLayer = intersectionList.begin();
+                             holeOnLayer != intersectionList.end();
+                             holeOnLayer++ )
+                        {
+                            const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*holeOnLayer);
+
+                            //if( object2d_A->Intersects( hole2d->GetBBox() ) )
+                                //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
+                                    object2d_B->push_back( hole2d );
+                        }
+                    }
+                }
+
+                // Check if there are any THT that intersects this object
+                // /////////////////////////////////////////////////////////////
+                if( !m_settings.GetThroughHole_Inflated().GetList().empty() )
+                {
+                    CONST_LIST_OBJECT2D intersectionList;
+                    m_settings.GetThroughHole_Inflated().GetListObjectsIntersects( object2d_A->GetBBox(), intersectionList );
+
+                    if( !intersectionList.empty() )
+                    {
+                        for( CONST_LIST_OBJECT2D::const_iterator hole = intersectionList.begin();
+                             hole != intersectionList.end();
+                             hole++ )
+                        {
+                            const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*hole);
+
+                            //if( object2d_A->Intersects( hole2d->GetBBox() ) )
+                                //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
+                                    object2d_B->push_back( hole2d );
+                        }
+                    }
+                }
+
+                if( object2d_B->empty() )
+                {
+                    delete object2d_B;
+                    object2d_B = CSGITEM_EMPTY;
+                }
+            }
+
+            if( (object2d_B == CSGITEM_EMPTY) &&
+                (object2d_C == CSGITEM_FULL) )
+            {
+#if 0
+               create_3d_object_from( m_object_container, object2d_A, m_settings.GetLayerBottomZpos3DU( layer_id ),
+                                                                       m_settings.GetLayerTopZpos3DU( layer_id ),
+                                       materialLayer,
+                                       layerColor );
+#else
+                CLAYERITEM *objPtr = new CLAYERITEM( object2d_A, m_settings.GetLayerBottomZpos3DU( layer_id ),
+                                                                 m_settings.GetLayerTopZpos3DU( layer_id ) );
+                objPtr->SetMaterial( materialLayer );
+                objPtr->SetColor( layerColor );
+                m_object_container.Add( objPtr );
+#endif
+            }
+            else
+            {
+#if 1
+                CITEMLAYERCSG2D *itemCSG2d = new CITEMLAYERCSG2D( object2d_A, object2d_B, object2d_C,
+                                                                  object2d_A->GetBoardItem() );
+                m_containerWithObjectsToDelete.Add( itemCSG2d );
+
+                CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d, m_settings.GetLayerBottomZpos3DU( layer_id ),
+                                                     m_settings.GetLayerTopZpos3DU( layer_id ) );
+
+                objPtr->SetMaterial( materialLayer );
+                objPtr->SetColor( layerColor );
+                m_object_container.Add( objPtr );
+#endif
+            }
+#endif
+        }
+
+        // Create display list
+        // /////////////////////////////////////////////////////////////////////
+        m_ogl_disp_lists_layers[layer_id] = new CLAYERS_OGL_DISP_LISTS( *layerTriangles,
+                                                                        m_ogl_circle_texture,
+                                                                        layerColor );
+    }// for each layer on map
+
+    unsigned stats_end_OpenGL_Load_Time = GetRunningMicroSecs();
+
+#ifdef RAYTRACING_PRINT_STATISTICS
+    printf( "C3D_RENDER_OGL_LEGACY::reload times:\n" );
+    printf( "  Reload board:             %.3f ms\n", (float)( stats_endReloadTime        - stats_startReloadTime        ) / 1000.0f );
+    printf( "  Loading to openGL:        %.3f ms\n", (float)( stats_end_OpenGL_Load_Time - stats_start_OpenGL_Load_Time ) / 1000.0f );
+    COBJECT2D_STATS::Instance().PrintStats();
+#endif
+}
+
+
+void C3D_RENDER_OGL_LEGACY::add_triangle_top_bot( CLAYER_TRIANGLES *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot )
+{
+    aDst->m_layer_bot_triangles->AddTriangle( SFVEC3F( v0.x, v0.y, bot ),
+                                              SFVEC3F( v1.x, v1.y, bot ),
+                                              SFVEC3F( v2.x, v2.y, bot ) );
+
+    aDst->m_layer_top_triangles->AddTriangle( SFVEC3F( v2.x, v2.y, top ),
+                                              SFVEC3F( v1.x, v1.y, top ),
+                                              SFVEC3F( v0.x, v0.y, top ) );
+}
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.cpp b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.cpp
new file mode 100644
index 0000000000..555c16eb61
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.cpp
@@ -0,0 +1,723 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3d_render_ogl_legacy.cpp
+ * @brief
+ */
+
+
+#include "c3d_render_ogl_legacy.h"
+#include "ogl_legacy_utils.h"
+#include "common_ogl/ogl_utils.h"
+#include "../cimage.h"
+
+C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY( CINFO3D_VISU &aSettings,
+                                              S3D_CACHE *a3DModelManager ) :
+                       C3D_RENDER_BASE( aSettings, a3DModelManager )
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY" ) );
+
+    m_ogl_disp_lists_layers.clear();
+    m_triangles.clear();
+    m_ogl_disp_list_board = 0;
+}
+
+
+C3D_RENDER_OGL_LEGACY::~C3D_RENDER_OGL_LEGACY()
+{
+    wxLogTrace( m_logTrace, wxT( "C3D_RENDER_OGL_LEGACY::~C3D_RENDER_OGL_LEGACY" ) );
+
+}
+
+
+void C3D_RENDER_OGL_LEGACY::SetCurWindowSize( const wxSize &aSize )
+{
+    if( m_windowSize != aSize )
+    {
+        m_windowSize = aSize;
+        glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
+
+        // Initialize here any screen dependent data
+    }
+}
+
+/* defines */
+#define SPHERE 1
+#define CONE   2
+#define CUBE   3
+
+
+/* csgOperation
+ *  types of CSG operations
+ */
+typedef enum {
+    CSG_A,
+    CSG_B,
+    CSG_A_OR_B,
+    CSG_A_AND_B,
+    CSG_A_SUB_B,
+    CSG_B_SUB_A
+} csgOperation;
+
+GLfloat cone_x = 0.0;
+GLfloat cone_y = 0.0;
+GLfloat cone_z = 0.0;
+
+GLfloat cube_x = 0.0;
+GLfloat cube_y = 0.0;
+GLfloat cube_z = 0.0;
+
+GLfloat sphere_x = 0.0;
+GLfloat sphere_y = 0.0;
+GLfloat sphere_z = 0.0;
+
+GLint mouse_state = -1;
+GLint mouse_button = -1;
+
+csgOperation Op = CSG_A_OR_B;
+
+void (*A)(void);
+void (*B)(void);
+
+
+/* functions */
+
+/* one()
+ *  draw a single object
+ */
+void op_one(void(*a)(void))
+{
+  glEnable(GL_DEPTH_TEST);
+  a();
+  glDisable(GL_DEPTH_TEST);
+}
+
+/* or()
+ *  boolean A or B (draw wherever A or B)
+ *  algorithm: simple, just draw both with depth test enabled
+ */
+void op_or(void(*a)(void), void(*b)())
+{
+    glPushAttrib(GL_ALL_ATTRIB_BITS);  /* TODO - should just push depth */
+    glEnable(GL_DEPTH_TEST);
+    //glDisable(GL_CULL_FACE);
+    a(); b();
+    glPopAttrib();
+}
+
+/* inside()
+ *  sets stencil buffer to show the part of A
+ *  (front or back face according to 'face')
+ *  that is inside of B.
+ */
+void op_inside(void(*a)(void), void(*b)(void), GLenum face, GLenum test)
+{
+    /* draw A into depth buffer, but not into color buffer */
+    glEnable(GL_DEPTH_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glCullFace(face);
+    a();
+
+    /* use stencil buffer to find the parts of A that are inside of B
+     * by first incrementing the stencil buffer wherever B's front faces
+     * are...
+     */
+
+    glDepthMask(GL_FALSE);
+    glEnable(GL_STENCIL_TEST);
+    //glStencilFunc(GL_LESS, 1, 0);
+    glStencilFunc(GL_ALWAYS, 0, 0);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT ); //GL_INCR);
+    glCullFace(GL_BACK);
+    b();
+
+    /* ...then decrement the stencil buffer wherever B's back faces are */
+    //glStencilFunc(GL_EQUAL, 0, 0);
+  //glStencilFunc(GL_ALWAYS, 0, 0);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO );
+    glCullFace(GL_FRONT);
+    b();
+
+
+    /* now draw the part of A that is inside of B */
+    glDepthMask(GL_TRUE);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glStencilFunc(test, 0, 1);
+    glDisable(GL_DEPTH_TEST);
+    glCullFace(face);
+    a();
+
+    /* reset stencil test */
+    glDisable(GL_STENCIL_TEST);
+}
+
+/* fixup()
+ *  fixes up the depth buffer with A's depth values
+ */
+void fixup(void(*a)(void))
+{
+    /* fix up the depth buffer */
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glEnable(GL_DEPTH_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glDepthFunc(GL_ALWAYS);
+    a();
+
+    /* reset depth func */
+    glDepthFunc(GL_LESS);
+}
+
+/* and()
+ *  boolean A and B (draw wherever A intersects B)
+ *  algorithm: find where A is inside B, then find where
+ *             B is inside A
+ */
+void op_and(void(*a)(void), void(*b)(void))
+{
+    op_inside(a, b, GL_BACK, GL_NOTEQUAL);
+#if 1  /* set to 0 for faster, but incorrect results */
+    fixup(b);
+#endif
+    op_inside(b, a, GL_BACK, GL_NOTEQUAL);
+}
+
+/*
+ * sub()
+ *  boolean A subtract B (draw wherever A is and B is NOT)
+ *  algorithm: find where a is inside B, then find where
+ *             the BACK faces of B are NOT in A
+ */
+void op_sub(void(*a)(void), void(*b)(void))
+{
+    op_inside(a, b, GL_FRONT, GL_NOTEQUAL);
+
+#if 1  /* set to 0 for faster, but incorrect results */
+    fixup(b);
+#endif
+    op_inside(b, a, GL_BACK, GL_EQUAL);
+    //op_inside(a, b, GL_FRONT, GL_NOTEQUAL);
+
+}
+
+/* sphere()
+ *  draw a yellow sphere
+ */
+void sphere(void)
+{/*
+    glLoadName(2);
+    glPushMatrix();
+    glTranslatef(sphere_x, sphere_y, sphere_z);
+    glColor3f(1.0, 1.0, 0.0);
+    glutSolidSphere(5.0, 16, 16);
+    glPopMatrix();*/
+    glBegin(GL_QUADS);                // Begin drawing the color cube with 6 quads
+       // Top face (y = 1.0f)
+       // Define vertices in counter-clockwise (CCW) order with normal pointing out
+       glColor3f(0.0f, 1.0f, 0.0f);     // Green
+       glVertex3f( 1.0f, 1.0f, -1.0f);
+       glVertex3f(-1.0f, 1.0f, -1.0f);
+       glVertex3f(-1.0f, 1.0f,  1.0f);
+       glVertex3f( 1.0f, 1.0f,  1.0f);
+
+       // Bottom face (y = -1.0f)
+       glColor3f(1.0f, 0.5f, 0.0f);     // Orange
+       glVertex3f( 1.0f, -1.0f,  1.0f);
+       glVertex3f(-1.0f, -1.0f,  1.0f);
+       glVertex3f(-1.0f, -1.0f, -1.0f);
+       glVertex3f( 1.0f, -1.0f, -1.0f);
+
+       // Front face  (z = 1.0f)
+       glColor3f(1.0f, 0.0f, 0.0f);     // Red
+       glVertex3f( 1.0f,  1.0f, 1.0f);
+       glVertex3f(-1.0f,  1.0f, 1.0f);
+       glVertex3f(-1.0f, -1.0f, 1.0f);
+       glVertex3f( 1.0f, -1.0f, 1.0f);
+
+       // Back face (z = -1.0f)
+       glColor3f(1.0f, 1.0f, 0.0f);     // Yellow
+       glVertex3f( 1.0f, -1.0f, -1.0f);
+       glVertex3f(-1.0f, -1.0f, -1.0f);
+       glVertex3f(-1.0f,  1.0f, -1.0f);
+       glVertex3f( 1.0f,  1.0f, -1.0f);
+
+       // Left face (x = -1.0f)
+       glColor3f(0.0f, 0.0f, 1.0f);     // Blue
+       glVertex3f(-1.0f,  1.0f,  1.0f);
+       glVertex3f(-1.0f,  1.0f, -1.0f);
+       glVertex3f(-1.0f, -1.0f, -1.0f);
+       glVertex3f(-1.0f, -1.0f,  1.0f);
+
+       // Right face (x = 1.0f)
+       glColor3f(1.0f, 0.0f, 1.0f);     // Magenta
+       glVertex3f(1.0f,  1.0f, -1.0f);
+       glVertex3f(1.0f,  1.0f,  1.0f);
+       glVertex3f(1.0f, -1.0f,  1.0f);
+       glVertex3f(1.0f, -1.0f, -1.0f);
+    glEnd();  // End of drawing color-cube
+}
+
+/* cube()
+ *  draw a red cube
+ */
+void cube(void)
+{
+    glPushMatrix();
+    glColor3f(0.3, 0.8, 0.1);
+    OGL_draw_arrow( SFVEC3F( 1.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    0.2f );
+    glPopMatrix();
+}
+
+/* cone()
+ *  draw a green cone
+ */
+void cone(void)
+{
+   /* glLoadName(3);
+    glPushMatrix();
+    glTranslatef(cone_x, cone_y, cone_z);
+    glColor3f(0.0, 1.0, 0.0);
+    glTranslatef(0.0, 0.0, -6.5);
+    glutSolidCone(4.0, 15.0, 16, 16);
+    glRotatef(180.0, 1.0, 0.0, 0.0);
+    glutSolidCone(4.0, 0.0, 16, 1);
+    glPopMatrix();*/
+}
+
+void init(void)
+{
+    //tbInit(GLUT_MIDDLE_BUTTON);
+
+    //glSelectBuffer(SELECT_BUFFER, select_buffer);
+
+    // glEnable( GL_DITHER );
+
+    glDepthFunc(GL_LESS);
+    glEnable(GL_DEPTH_TEST);
+
+    //glEnable(GL_LIGHT0);
+    //glEnable(GL_LIGHT1);
+    //glEnable(GL_LIGHT2);
+    //glEnable(GL_LIGHTING);
+
+    // Setup light
+    // https://www.opengl.org/sdk/docs/man2/xhtml/glLight.xml
+    // /////////////////////////////////////////////////////////////////////////
+    {
+    const GLfloat ambient[]  = { 0.1f, 0.0f, 0.1f, 1.0f };
+    const GLfloat diffuse[]  = { 0.3f, 0.3f, 0.3f, 1.0f };
+    const GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    //const GLfloat lmodel_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f };
+
+    glLightfv( GL_LIGHT0, GL_AMBIENT,  ambient );
+    glLightfv( GL_LIGHT0, GL_DIFFUSE,  diffuse );
+    glLightfv( GL_LIGHT0, GL_SPECULAR, specular );
+
+    const GLfloat position1[]= { 0.0f, 0.0f, 1.0f, 0.0f };                      // defines a directional light that points along the negative z-axis
+    glLightfv( GL_LIGHT2, GL_AMBIENT,  ambient );
+    glLightfv( GL_LIGHT2, GL_DIFFUSE,  diffuse );
+    glLightfv( GL_LIGHT2, GL_SPECULAR, specular );
+    glLightfv( GL_LIGHT2, GL_POSITION, position1 );
+
+    const GLfloat position2[]= { 0.0f, 0.0f, -1.0f, 0.0f };                     // defines a directional light that points along the positive z-axis
+    glLightfv( GL_LIGHT2, GL_AMBIENT,  ambient );
+    glLightfv( GL_LIGHT2, GL_DIFFUSE,  diffuse );
+    glLightfv( GL_LIGHT2, GL_SPECULAR, specular );
+    glLightfv( GL_LIGHT2, GL_POSITION, position2 );
+    //glLightModelfv( GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
+}
+
+    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
+
+
+    glEnable(GL_CULL_FACE);
+
+    glClearColor(0.0, 0.0, 1.0, 0.0);
+{
+    const SFVEC4F ambient  = SFVEC4F( 0.2,0.2,0.2,  1.0f );
+    const SFVEC4F diffuse  = SFVEC4F( 0.5,0.1,0.1,  1.0f );
+    const SFVEC4F specular = SFVEC4F( 0.1,0.1,0.8, 1.0f );
+    //const SFVEC4F emissive = SFVEC4F( material.m_Emissive, 1.0f );
+
+    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT,  &ambient.r );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE,  &diffuse.r );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
+    //glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r );
+    }
+    glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, 128 );
+    glDisable( GL_COLOR_MATERIAL );
+
+    glFrontFace( GL_CCW );                                                      // This is the openGL default
+    glEnable( GL_NORMALIZE );                                                   // This allow openGL to normalize the normals after transformations
+}
+
+
+void display(void)
+{
+  glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
+  //glClearDepth( 1.0f );
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+  glPushMatrix();
+  //tbMatrix();
+
+  switch(Op) {
+  case CSG_A:
+    op_one(A);
+    break;
+  case CSG_B:
+    op_one(B);
+    break;
+  case CSG_A_OR_B:
+    op_or(A, B);
+    break;
+  case CSG_A_AND_B:
+    op_and(A, B);
+    break;
+  case CSG_A_SUB_B:
+    op_sub(A, B);
+    break;
+  case CSG_B_SUB_A:
+    op_sub(B, A);
+    break;
+  }
+
+  glPopMatrix();
+}
+
+static const C3D_RENDER_OGL_LEGACY *renderclass = NULL;
+
+void draw_board(void)
+{
+    if( renderclass )
+    {
+        renderclass->GetBoardDispList()->DrawTop();
+        renderclass->GetBoardDispList()->DrawBot();
+    }
+}
+
+void draw_b_mask(void)
+{
+    if( renderclass )
+    {
+        const CLAYERS_OGL_DISP_LISTS *layer = renderclass->GetLayerDispList( B_Mask );
+        layer->DrawTop();
+        layer->DrawBot();
+    }
+}
+
+
+
+static SFVEC3F light = SFVEC3F();
+
+void C3D_RENDER_OGL_LEGACY::Redraw( bool aIsMoving )
+{
+    // Initialize openGL
+    if( !m_is_opengl_initialized )
+    {
+        if( !initializeOpenGL() )
+            return;
+        aIsMoving = true;
+
+
+
+        A = sphere;
+        B = cube;
+
+        //Op = CSG_A;
+        //Op = CSG_B;
+        //Op = CSG_A_OR_B;
+        //Op = CSG_A_AND_B;
+        //Op = CSG_A_SUB_B;
+        Op = CSG_B_SUB_A;
+    }
+/*
+    const GLfloat position0[]= { 0.0f, 0.0f, 1.0f, 0.0f };                      // defines a directional light that points along the negative z-axis
+    glLightfv( GL_LIGHT0, GL_POSITION, position0 );
+*/
+    if( m_reloadRequested )
+        reload();
+
+    init();
+
+    glEnable( GL_LIGHT0 );
+    glEnable(GL_LIGHTING);
+
+
+    // clear color and depth buffers
+    // /////////////////////////////////////////////////////////////////////////
+    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
+    glClearDepth( 1.0f );
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
+
+    // Set projection and modelview matrixes
+    // /////////////////////////////////////////////////////////////////////////
+    glMatrixMode( GL_PROJECTION );
+    glLoadMatrixf( glm::value_ptr( m_settings.CameraGet().GetProjectionMatrix() ) );
+
+    glMatrixMode( GL_MODELVIEW );
+
+    // Position the headlight
+    glLoadIdentity();
+
+    //glTranslatef( -m_settings.GetBBox3DU().GetCenter().x, -m_settings.GetBBox3DU().GetCenter().y, -m_settings.GetBBox3DU().GetCenter().z );
+//    glTranslatef( m_settings.GetBBox3DU().GetCenter().x, m_settings.GetBBox3DU().GetCenter().y, m_settings.GetBBox3DU().GetCenter().z );
+
+    glLoadMatrixf( glm::value_ptr( m_settings.CameraGet().GetViewMatrix() ) );
+
+    {
+        const SFVEC3F &cameraPos = m_settings.CameraGet().GetPos();//m_settings.CameraGet().GetPos();
+        const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, cameraPos.z, 1.0f };
+        glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos );
+    }
+
+
+    const SFVEC4F specular = SFVEC4F( 0.5f, 1.0f, 0.5f, 1.0f );
+
+    glMaterialfv( GL_FRONT, GL_SPECULAR, &specular.r );
+    glMaterialf(  GL_FRONT, GL_SHININESS, 10.0f );
+
+    SFVEC4F layerColor4 = SFVEC4F( specular.x, specular.y, specular.z, 1.0f );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE,  &layerColor4.x );
+    glDisable( GL_COLOR_MATERIAL );
+
+/*
+    glPushMatrix();
+
+    glTranslatef( m_settings.GetBBox3DU().GetCenter().x, m_settings.GetBBox3DU().GetCenter().y, m_settings.GetBBox3DU().GetCenter().z );
+
+
+    glEnable( GL_COLOR_MATERIAL );
+    glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );
+
+    //const SFVEC4F specular = SFVEC4F( 0.5f, 0.5f, 0.5f, 1.0f );
+
+    glMaterialfv( GL_FRONT, GL_SPECULAR, &specular.r );
+    glMaterialf(  GL_FRONT, GL_SHININESS, 10.0f );
+
+    glColor3f( 0.9f, 0.0f, 0.0f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( RANGE_SCALE_3D / 1.0f, 0.0f, 0.0f ),
+                    0.2f );
+
+    glColor3f( 0.0f, 0.9f, 0.0f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, RANGE_SCALE_3D / 1.0f, 0.0f ),
+                    0.2f );
+
+    glColor3f( 0.0f, 0.0f, 0.9f );
+    OGL_draw_arrow( SFVEC3F( 0.0f, 0.0f, 0.0f ),
+                    SFVEC3F( 0.0f, 0.0f, RANGE_SCALE_3D / 1.0f ),
+                    0.2f );
+    glPopMatrix();
+*/
+
+/*
+    for( MAP_OGL_DISP_LISTS::const_iterator ii = m_ogl_disp_lists_layers.begin();
+         ii != m_ogl_disp_lists_layers.end();
+         ii++ )
+    {
+
+        LAYER_ID layer_id = (LAYER_ID)(ii->first);
+
+        // Mask kayers are not processed here because they are a special case
+        if( (layer_id == B_Mask) || (layer_id == F_Mask) )
+            continue;
+
+        CLAYERS_OGL_DISP_LISTS *pLayerDispList = static_cast<CLAYERS_OGL_DISP_LISTS*>(ii->second);
+        pLayerDispList->DrawAll();
+    }
+*/
+    renderclass = this;
+    //op_sub( draw_b_mask, draw_board );
+    //op_sub( draw_board, draw_b_mask );
+
+
+    const CLAYERS_OGL_DISP_LISTS *layer = renderclass->GetLayerDispList( B_Mask );
+
+    //glEnable(GL_LIGHTING);
+    //glEnable(GL_LIGHT0);
+/*
+    glEnable(GL_DEPTH_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glDisable(GL_CULL_FACE);
+    m_ogl_disp_list_board->DrawBot();
+*/
+
+    glCullFace(GL_BACK);
+
+    glDisable(GL_DEPTH_TEST);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glDepthMask(GL_FALSE);
+    glEnable(GL_STENCIL_TEST);
+    glStencilFunc(GL_ALWAYS, 1, 0);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE );
+    layer->DrawBot();
+
+    glEnable(GL_DEPTH_TEST);
+    glDepthMask(GL_TRUE);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glStencilFunc(GL_EQUAL, 0, 1);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP );
+    //glDisable(GL_DEPTH_TEST);
+    //glCullFace(face);
+    m_ogl_disp_list_board->DrawBot();
+
+    //glClear( GL_STENCIL_BUFFER_BIT );
+
+    glDisable(GL_DEPTH_TEST);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glDepthMask(GL_FALSE);
+    glEnable(GL_STENCIL_TEST);
+    glStencilFunc(GL_ALWAYS, 2, 0);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE );
+    layer->DrawTop();
+
+    glEnable(GL_DEPTH_TEST);
+    glDepthMask(GL_TRUE);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glStencilFunc(GL_NOTEQUAL, 2, 0xFF);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_INCR );
+    //glDisable(GL_DEPTH_TEST);
+    //glCullFace(face);
+    m_ogl_disp_list_board->DrawTop();
+
+    //glClear( GL_STENCIL_BUFFER_BIT );
+
+    //glCullFace(GL_FRONT);
+/*
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glDepthMask(GL_FALSE);
+    glEnable(GL_STENCIL_TEST);
+    glStencilFunc(GL_GEQUAL, 3, 0xFF);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_INCR );
+    layer->DrawBot();
+    layer->DrawTop();
+
+*/
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+    glDepthMask(GL_TRUE);
+    glCullFace(GL_FRONT);
+    glStencilFunc(GL_GEQUAL, 3, 0x03);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP );
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    layer->DrawMiddle();
+
+
+}
+
+
+bool C3D_RENDER_OGL_LEGACY::initializeOpenGL()
+{
+    GLenum err = glewInit();
+
+    if( GLEW_OK != err )
+    {
+        std::string msgError = (const char*) glewGetErrorString( err );
+
+        return false;
+    }
+    else
+    {
+        wxLogTrace( m_logTrace,
+                    wxString( wxT( "C3D_RENDER_OGL_LEGACY::initializeOpenGL Using GLEW " ) ) +
+                    FROM_UTF8( (char*) glewGetString( GLEW_VERSION ) ) );
+    }
+
+    // 4-byte pixel alignment
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
+
+    // Initialize the open GL texture to draw the filled semi-circle of the segments
+    CIMAGE *circleImage = new CIMAGE( SIZE_OF_CIRCLE_TEXTURE, SIZE_OF_CIRCLE_TEXTURE );
+    if( !circleImage )
+        return false;
+
+    circleImage->CircleFilled( (SIZE_OF_CIRCLE_TEXTURE / 2) - 0, (SIZE_OF_CIRCLE_TEXTURE / 2) - 0, (SIZE_OF_CIRCLE_TEXTURE / 2) - 4, 0xFF );
+    //circleImage->CircleFilled( (SIZE_OF_CIRCLE_TEXTURE / 4)*1.5f - 1, (SIZE_OF_CIRCLE_TEXTURE / 4)*1.5f - 1, (SIZE_OF_CIRCLE_TEXTURE / 4)*1.5f - 2, 0xFF );
+
+    CIMAGE *bluredCircle = new CIMAGE( *circleImage );
+    circleImage->EfxFilter( bluredCircle, FILTER_GAUSSIAN_BLUR2 );
+
+    m_ogl_circle_texture = OGL_LoadTexture( *circleImage );
+
+    circleImage->SaveAsPNG("circleImage.png");
+    delete circleImage;
+    circleImage = 0;
+
+    if( bluredCircle )
+    {
+        bluredCircle->SaveAsPNG("circleImage_blured.png");
+        delete bluredCircle;
+        bluredCircle = 0;
+    }
+
+    m_is_opengl_initialized = true;
+    return true;
+}
+
+
+void C3D_RENDER_OGL_LEGACY::ogl_set_arrow_material()
+{
+    glEnable( GL_COLOR_MATERIAL );
+    glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
+
+    const SFVEC4F specular = SFVEC4F( 0.1f, 0.1f, 0.1f, 1.0f );
+
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
+    glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, 96.0f );
+}
+
+
+void C3D_RENDER_OGL_LEGACY::ogl_free_all_display_lists()
+{
+    for( MAP_OGL_DISP_LISTS::const_iterator ii = m_ogl_disp_lists_layers.begin();
+         ii != m_ogl_disp_lists_layers.end();
+         ii++ )
+    {
+        CLAYERS_OGL_DISP_LISTS *pLayerDispList = static_cast<CLAYERS_OGL_DISP_LISTS*>(ii->second);
+        delete pLayerDispList;
+    }
+
+    m_ogl_disp_lists_layers.clear();
+
+    for( MAP_TRIANGLES::const_iterator ii = m_triangles.begin();
+         ii != m_triangles.end();
+         ii++ )
+    {
+        CLAYER_TRIANGLES *pointer = static_cast<CLAYER_TRIANGLES*>(ii->second);
+        delete pointer;
+    }
+
+    m_triangles.clear();
+
+    delete m_ogl_disp_list_board;
+    m_ogl_disp_list_board = 0;
+}
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.h b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.h
new file mode 100644
index 0000000000..2bdd331548
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.h
@@ -0,0 +1,80 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3d_render_ogl_legacy.h
+ * @brief
+ */
+
+#ifndef C3D_RENDER_OGL_LEGACY_H_
+#define C3D_RENDER_OGL_LEGACY_H_
+
+#include "../c3d_render_base.h"
+#include "clayer_triangles.h"
+#include <map>
+
+
+typedef std::map< LAYER_ID, CLAYERS_OGL_DISP_LISTS* > MAP_OGL_DISP_LISTS;
+typedef std::map< LAYER_ID, CLAYER_TRIANGLES * > MAP_TRIANGLES;
+
+#define SIZE_OF_CIRCLE_TEXTURE 512
+
+/**
+ * @brief The C3D_RENDER_OGL_LEGACY class render the board using openGL legacy mode
+ */
+class C3D_RENDER_OGL_LEGACY : public C3D_RENDER_BASE
+{
+public:
+    C3D_RENDER_OGL_LEGACY( CINFO3D_VISU &aSettings,
+                           S3D_CACHE *a3DModelManager );
+
+    ~C3D_RENDER_OGL_LEGACY();
+
+    // Imported from C3D_RENDER_BASE
+    void SetCurWindowSize( const wxSize &aSize );
+    void Redraw( bool aIsMoving );
+
+private:
+    bool initializeOpenGL();
+    void reload();
+
+    void ogl_set_arrow_material();
+
+    void ogl_free_all_display_lists();
+    MAP_OGL_DISP_LISTS      m_ogl_disp_lists_layers;
+    CLAYERS_OGL_DISP_LISTS* m_ogl_disp_list_board;
+    MAP_TRIANGLES           m_triangles;
+
+    GLuint m_ogl_circle_texture;
+
+private:
+    void add_triangle_top_bot( CLAYER_TRIANGLES *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot );
+
+public:
+    const MAP_OGL_DISP_LISTS &GetLayerDispListMap() const { return m_ogl_disp_lists_layers; }
+    const CLAYERS_OGL_DISP_LISTS *GetLayerDispList( LAYER_ID aLayerId ) const { return m_ogl_disp_lists_layers.at( aLayerId ); }
+    const CLAYERS_OGL_DISP_LISTS *GetBoardDispList() const { return m_ogl_disp_list_board; }
+};
+
+#endif // C3D_RENDER_OGL_LEGACY_H_
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.cpp b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.cpp
new file mode 100644
index 0000000000..cd6b4e06f2
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.cpp
@@ -0,0 +1,281 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c_ogl_3dmodel.cpp
+ * @brief
+ */
+
+#include "c_ogl_3dmodel.h"
+#include "ogl_legacy_utils.h"
+#include "common_ogl/ogl_utils.h"
+#include <wx/debug.h>
+
+
+C_OGL_3DMODEL::C_OGL_3DMODEL( const S3DMODEL &a3DModel )
+{
+    m_ogl_idx_list_opaque = 0;
+    m_ogl_idx_list_transparent = 0;
+    m_nr_meshes = 0;
+    m_meshs_bbox = NULL;
+
+    // Validate a3DModel pointers
+    wxASSERT( a3DModel.m_Materials != NULL );
+    wxASSERT( a3DModel.m_Meshes != NULL );
+    wxASSERT( a3DModel.m_MaterialsSize > 0 );
+    wxASSERT( a3DModel.m_MeshesSize > 0 );
+
+    if( (a3DModel.m_Materials != NULL) && (a3DModel.m_Meshes != NULL) &&
+        (a3DModel.m_MaterialsSize > 0) && (a3DModel.m_MeshesSize > 0) )
+    {
+        m_nr_meshes = a3DModel.m_MeshesSize;
+
+        m_meshs_bbox = new CBBOX[a3DModel.m_MeshesSize];
+
+        // Generate m_MeshesSize auxiliar lists to render the meshes
+        GLuint m_ogl_idx_list_meshes = glGenLists( a3DModel.m_MeshesSize );
+
+        // Render each mesh of the model
+        // /////////////////////////////////////////////////////////////////////
+        for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
+        {
+            if( glIsList( m_ogl_idx_list_meshes + mesh_i ) )
+            {
+                const SMESH &mesh = a3DModel.m_Meshes[mesh_i];
+
+                // Validate the mesh pointers
+                wxASSERT( mesh.m_Positions != NULL );
+                wxASSERT( mesh.m_FaceIdx != NULL );
+                wxASSERT( mesh.m_Normals != NULL );
+
+                if( (mesh.m_Positions != NULL) &&
+                    (mesh.m_Normals != NULL) &&
+                    (mesh.m_FaceIdx != NULL) &&
+                    (mesh.m_FaceIdxSize > 0) && (mesh.m_VertexSize > 0) )
+                {
+                    // Create the bbox for this mesh
+                    // /////////////////////////////////////////////////////////
+                    m_meshs_bbox[mesh_i].Reset();
+
+                    for( unsigned int vertex_i = 0; vertex_i < mesh.m_VertexSize; ++vertex_i )
+                        m_meshs_bbox[mesh_i].Union( mesh.m_Positions[vertex_i] );
+
+                    // Make sure we start with client state disabled
+                    // /////////////////////////////////////////////////////////
+                    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
+                    glDisableClientState( GL_COLOR_ARRAY );
+
+
+                    // Enable arrays client states
+                    // /////////////////////////////////////////////////////////
+                    glEnableClientState( GL_VERTEX_ARRAY );
+                    glEnableClientState( GL_NORMAL_ARRAY );
+
+                    glVertexPointer( 3, GL_FLOAT, 0, mesh.m_Positions );
+                    glNormalPointer( GL_FLOAT, 0, mesh.m_Normals );
+
+                    if( mesh.m_Color != NULL )
+                    {
+                        glEnableClientState( GL_COLOR_ARRAY );
+                        glColorPointer( 3, GL_FLOAT, 0, mesh.m_Color );
+                    }
+
+                    if( mesh.m_Texcoords != NULL )
+                    {
+                        glEnableClientState( GL_TEXTURE_COORD_ARRAY );
+                        glTexCoordPointer( 2, GL_FLOAT, 0, mesh.m_Texcoords );
+                    }
+
+                    // Compile the display list to store triangles
+                    // /////////////////////////////////////////////////////////
+                    glNewList( m_ogl_idx_list_meshes + mesh_i, GL_COMPILE );
+
+                    // Set material properties
+                    // /////////////////////////////////////////////////////////
+
+                    if( mesh.m_Color != NULL )
+                    {
+                        glEnable( GL_COLOR_MATERIAL );
+                        glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
+                    }
+                    else
+                    {
+                        glDisable( GL_COLOR_MATERIAL );
+                    }
+
+                    if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
+                    {
+                        OGL_SetMaterial( a3DModel.m_Materials[mesh.m_MaterialIdx] );
+                    }
+
+                    // Draw mesh
+                    // /////////////////////////////////////////////////////////
+                    glDrawElements( GL_TRIANGLES, mesh.m_FaceIdxSize, GL_UNSIGNED_INT, mesh.m_FaceIdx );
+
+                    glEndList();
+
+                    // Disable arrays client states
+                    // /////////////////////////////////////////////////////////
+                    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
+                    glDisableClientState( GL_COLOR_ARRAY );
+                    glDisableClientState( GL_NORMAL_ARRAY );
+                    glDisableClientState( GL_VERTEX_ARRAY );
+                }
+            }
+        }// for each mesh
+
+        bool have_opaque_meshes = false;
+        bool have_transparent_meshes = false;
+
+        m_ogl_idx_list_opaque = glGenLists( 1 );
+
+        // Check if the generated list is valid
+        if( glIsList( m_ogl_idx_list_opaque ) )
+        {
+            // Compile the model display list
+            glNewList( m_ogl_idx_list_opaque, GL_COMPILE );
+
+            // Render each mesh display list (opaque first)
+            // /////////////////////////////////////////////////////////////////
+            for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
+            {
+                const SMESH &mesh = a3DModel.m_Meshes[mesh_i];
+
+                if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
+                {
+                    const SMATERIAL &material = a3DModel.m_Materials[mesh.m_MaterialIdx];
+
+                    if( material.m_Transparency == 0.0f )
+                    {
+                        have_opaque_meshes = true;                              // Flag that we have at least one opaque mesh
+                        glCallList( m_ogl_idx_list_meshes + mesh_i );
+                    }
+                    else
+                    {
+                        have_transparent_meshes = true;                         // Flag that we found a transparent mesh
+                    }
+                }
+            }
+
+            glEndList();
+
+            if( !have_opaque_meshes )
+            {
+                glDeleteLists( m_ogl_idx_list_opaque, 1 );                      // If we dont have opaque meshes, we can free the list
+                m_ogl_idx_list_opaque = 0;
+            }
+
+            if( have_transparent_meshes )
+            {
+                m_ogl_idx_list_transparent = glGenLists( 1 );
+
+                // Check if the generated list is valid
+                if( glIsList( m_ogl_idx_list_transparent ) )
+                {
+                    // Compile the model display list
+                    glNewList( m_ogl_idx_list_transparent, GL_COMPILE );
+
+                    // Render each mesh display list (opaque first)
+                    // /////////////////////////////////////////////////////////
+                    for( unsigned mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
+                    {
+                        const SMESH &mesh = a3DModel.m_Meshes[mesh_i];
+
+                        if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
+                        {
+                            const SMATERIAL &material = a3DModel.m_Materials[mesh.m_MaterialIdx];
+
+                            if( material.m_Transparency != 0.0f )
+                                glCallList( m_ogl_idx_list_meshes + mesh_i );           // Render the transparent mesh
+                        }
+                    }
+
+                    glEndList();
+                }
+                else
+                {
+                    m_ogl_idx_list_transparent = 0;
+                }
+            }
+        }
+        else
+        {
+            m_ogl_idx_list_opaque = 0;
+        }
+
+        // Create the main bbox
+        // /////////////////////////////////////////////////////////////////////
+        m_model_bbox.Reset();
+
+        for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
+            m_model_bbox.Union( m_meshs_bbox[mesh_i] );
+    }
+}
+
+
+void C_OGL_3DMODEL::Draw_opaque() const
+{
+    if( glIsList( m_ogl_idx_list_opaque ) )
+        glCallList( m_ogl_idx_list_opaque );
+}
+
+
+void C_OGL_3DMODEL::Draw_transparent() const
+{
+    if( glIsList( m_ogl_idx_list_transparent ) )
+        glCallList( m_ogl_idx_list_transparent );
+}
+
+
+C_OGL_3DMODEL::~C_OGL_3DMODEL()
+{
+    if( glIsList( m_ogl_idx_list_opaque ) )
+        glDeleteLists( m_ogl_idx_list_opaque, 1 );
+
+    if( glIsList( m_ogl_idx_list_transparent ) )
+        glDeleteLists( m_ogl_idx_list_transparent, 1 );
+
+    if( glIsList( m_ogl_idx_list_meshes ) )
+        glDeleteLists( m_ogl_idx_list_meshes, m_nr_meshes );
+
+    m_ogl_idx_list_meshes = 0;
+    m_ogl_idx_list_opaque = 0;
+    m_ogl_idx_list_transparent = 0;
+
+    delete[] m_meshs_bbox;
+    m_meshs_bbox = NULL;
+}
+
+
+void C_OGL_3DMODEL::Draw_bbox() const
+{
+    OGL_draw_bbox( m_model_bbox );
+}
+
+
+void C_OGL_3DMODEL::Draw_bboxes() const
+{
+    for( unsigned int mesh_i = 0; mesh_i < m_nr_meshes; ++mesh_i )
+        OGL_draw_bbox( m_meshs_bbox[mesh_i] );
+}
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.h b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.h
new file mode 100644
index 0000000000..26ba5a8e8e
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.h
@@ -0,0 +1,85 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c_ogl_3dmodel.h
+ * @brief implement a legacy 3dmodel render
+ */
+
+#ifndef _C_OGL_3DMODEL_H_
+#define _C_OGL_3DMODEL_H_
+
+#include "3d_rendering/c3dmodel.h"
+#include "common_ogl/openGL_includes.h"
+#include "3d_rendering/3d_render_raytracing/shapes3D/cbbox.h"
+
+/// 
+class GLM_ALIGN(CLASS_ALIGNMENT) C_OGL_3DMODEL
+{
+public:
+    /**
+     * @brief C_OGL_3DMODEL - Load a 3d model. This must be called inside a gl context
+     * @param a3DModel: a 3d model data to load.
+     */
+    C_OGL_3DMODEL( const S3DMODEL &a3DModel );
+
+    ~C_OGL_3DMODEL();
+
+    /**
+     * @brief Draw_opaque - render the model into the current context
+     */
+    void Draw_opaque() const;
+
+    /**
+     * @brief Draw_transparent - render the model into the current context
+     */
+    void Draw_transparent() const;
+
+    /**
+     * @brief Draw_bbox - draw main bounding box of the model
+     */
+    void Draw_bbox() const;
+
+    /**
+     * @brief Draw_bboxes - draw individual bounding boxes of each mesh
+     */
+    void Draw_bboxes() const;
+
+    /**
+     * @brief GetBBox - Get main bbox
+     * @return the main model bbox
+     */
+    const CBBOX &GetBBox() const { return m_model_bbox; }
+
+private:
+    GLuint  m_ogl_idx_list_opaque;                                              ///< display list for rendering opaque meshes
+    GLuint  m_ogl_idx_list_transparent;                                         ///< display list for rendering transparent meshes
+    GLuint  m_ogl_idx_list_meshes;                                              ///< display lists for all meshes.
+    unsigned int m_nr_meshes;                                                   ///< number of meshes of this model
+
+    CBBOX   m_model_bbox;                                                       ///< global bounding box for this model
+    CBBOX  *m_meshs_bbox;                                                       ///< individual bbox for each mesh
+};
+
+#endif // _C_OGL_3DMODEL_H_
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/clayer_triangles.cpp b/3d-viewer/3d_rendering/3d_render_ogl_legacy/clayer_triangles.cpp
new file mode 100644
index 0000000000..a69712a387
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/clayer_triangles.cpp
@@ -0,0 +1,441 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  clayer_triangles.cpp
+ * @brief
+ */
+
+
+#include "clayer_triangles.h"
+#include <wx/debug.h>                                                           // For the wxASSERT
+
+
+CLAYER_TRIANGLE_CONTAINER::CLAYER_TRIANGLE_CONTAINER(unsigned int aNrReservedTriangles, bool aReserveNormals)
+{
+    wxASSERT( aNrReservedTriangles > 0 );
+
+    m_vertexs.clear();
+    m_normals.clear();
+
+    m_vertexs.reserve( aNrReservedTriangles * 3 );
+
+    if( aReserveNormals )
+        m_normals.reserve( aNrReservedTriangles * 3 );
+}
+
+
+void CLAYER_TRIANGLE_CONTAINER::AddQuad( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, const SFVEC3F &aV4 )
+{
+    m_vertexs.push_back( aV1 );
+    m_vertexs.push_back( aV2 );
+    m_vertexs.push_back( aV3 );
+
+    m_vertexs.push_back( aV3 );
+    m_vertexs.push_back( aV4 );
+    m_vertexs.push_back( aV1 );
+}
+
+
+void CLAYER_TRIANGLE_CONTAINER::AddTriangle( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3 )
+{
+    m_vertexs.push_back( aV1 );
+    m_vertexs.push_back( aV2 );
+    m_vertexs.push_back( aV3 );
+}
+
+
+void CLAYER_TRIANGLE_CONTAINER::AddNormal( const SFVEC3F &aN1, const SFVEC3F &aN2, const SFVEC3F &aN3 )
+{
+    m_normals.push_back( aN1 );
+    m_normals.push_back( aN2 );
+    m_normals.push_back( aN3 );
+}
+
+void CLAYER_TRIANGLE_CONTAINER::AddNormal( const SFVEC3F &aN1, const SFVEC3F &aN2, const SFVEC3F &aN3, const SFVEC3F &aN4 )
+{
+    m_normals.push_back( aN1 );
+    m_normals.push_back( aN2 );
+    m_normals.push_back( aN3 );
+
+    m_normals.push_back( aN3 );
+    m_normals.push_back( aN4 );
+    m_normals.push_back( aN1 );
+}
+
+
+CLAYER_TRIANGLES::CLAYER_TRIANGLES( unsigned int aNrReservedTriangles )
+{
+    wxASSERT( aNrReservedTriangles > 0 );
+
+    m_layer_top_segment_ends            = new CLAYER_TRIANGLE_CONTAINER( aNrReservedTriangles, false );
+    m_layer_top_triangles               = new CLAYER_TRIANGLE_CONTAINER( aNrReservedTriangles, false );
+    m_layer_middle_contourns_quads      = new CLAYER_TRIANGLE_CONTAINER( aNrReservedTriangles, true  );
+    m_layer_bot_triangles               = new CLAYER_TRIANGLE_CONTAINER( aNrReservedTriangles, false );
+    m_layer_bot_segment_ends            = new CLAYER_TRIANGLE_CONTAINER( aNrReservedTriangles, false );
+}
+
+
+CLAYER_TRIANGLES::~CLAYER_TRIANGLES()
+{
+    delete m_layer_top_segment_ends;
+    m_layer_top_segment_ends = 0;
+
+    delete m_layer_top_triangles;
+    m_layer_top_triangles = 0;
+
+    delete m_layer_middle_contourns_quads;
+    m_layer_middle_contourns_quads = 0;
+
+    delete m_layer_bot_triangles;
+    m_layer_bot_triangles = 0;
+
+    delete m_layer_bot_segment_ends;
+    m_layer_bot_segment_ends = 0;
+}
+
+
+CLAYERS_OGL_DISP_LISTS::CLAYERS_OGL_DISP_LISTS(const CLAYER_TRIANGLES &aLayerTriangles,
+                                               GLuint aTextureIndexForSegEnds,
+                                               const SFVEC3F& aLayerColor )
+{
+    wxASSERT( glIsTexture( aTextureIndexForSegEnds ) );
+
+    m_layer_top_segment_ends        = 0;
+    m_layer_top_triangles           = 0;
+    m_layer_middle_contourns_quads  = 0;
+    m_layer_bot_triangles           = 0;
+    m_layer_bot_segment_ends        = 0;
+
+    m_layer_top_segment_ends = generate_top_or_bot_seg_ends(  aLayerTriangles.m_layer_top_segment_ends, aLayerColor, true, aTextureIndexForSegEnds );
+    m_layer_top_triangles    = generate_top_or_bot_triangles( aLayerTriangles.m_layer_top_triangles,    aLayerColor, true  );
+    m_layer_bot_triangles    = generate_top_or_bot_triangles( aLayerTriangles.m_layer_bot_triangles,    aLayerColor, false );
+    m_layer_bot_segment_ends = generate_top_or_bot_seg_ends(  aLayerTriangles.m_layer_bot_segment_ends, aLayerColor, false, aTextureIndexForSegEnds );
+
+    m_layer_middle_contourns_quads = generate_middle_triangles( aLayerTriangles.m_layer_middle_contourns_quads, aLayerColor );
+}
+
+
+CLAYERS_OGL_DISP_LISTS::~CLAYERS_OGL_DISP_LISTS()
+{
+    if( glIsList( m_layer_top_segment_ends ) )
+        glDeleteLists( m_layer_top_segment_ends, 1 );
+
+    if( glIsList( m_layer_top_triangles ) )
+        glDeleteLists( m_layer_top_triangles, 1 );
+
+    if( glIsList( m_layer_middle_contourns_quads ) )
+        glDeleteLists( m_layer_middle_contourns_quads, 1 );
+
+    if( glIsList( m_layer_bot_triangles ) )
+        glDeleteLists( m_layer_bot_triangles, 1 );
+
+    if( glIsList( m_layer_bot_segment_ends ) )
+        glDeleteLists( m_layer_bot_segment_ends, 1 );
+}
+
+
+void CLAYERS_OGL_DISP_LISTS::DrawTopAndMiddle() const
+{
+    if( glIsList( m_layer_top_triangles ) )
+        glCallList( m_layer_top_triangles );
+
+    if( glIsList( m_layer_middle_contourns_quads ) )
+        glCallList( m_layer_middle_contourns_quads );
+
+    if( glIsList( m_layer_top_segment_ends ) )
+        glCallList( m_layer_top_segment_ends );
+
+}
+
+
+void CLAYERS_OGL_DISP_LISTS::DrawBotAndMiddle() const
+{
+    if( glIsList( m_layer_bot_triangles ) )
+        glCallList( m_layer_bot_triangles );
+
+    if( glIsList( m_layer_middle_contourns_quads ) )
+        glCallList( m_layer_middle_contourns_quads );
+
+    if( glIsList( m_layer_bot_segment_ends ) )
+        glCallList( m_layer_bot_segment_ends );
+
+}
+
+
+void CLAYERS_OGL_DISP_LISTS::DrawTop() const
+{
+    if( glIsList( m_layer_top_triangles ) )
+        glCallList( m_layer_top_triangles );
+
+    if( glIsList( m_layer_top_segment_ends ) )
+        glCallList( m_layer_top_segment_ends );
+}
+
+
+void CLAYERS_OGL_DISP_LISTS::DrawBot() const
+{
+    if( glIsList( m_layer_bot_triangles ) )
+        glCallList( m_layer_bot_triangles );
+
+    if( glIsList( m_layer_bot_segment_ends ) )
+        glCallList( m_layer_bot_segment_ends );
+}
+
+
+void CLAYERS_OGL_DISP_LISTS::DrawMiddle() const
+{
+    if( glIsList( m_layer_middle_contourns_quads ) )
+        glCallList( m_layer_middle_contourns_quads );
+}
+
+
+void CLAYERS_OGL_DISP_LISTS::DrawAll() const
+{
+
+    if( glIsList( m_layer_top_triangles ) )
+        glCallList( m_layer_top_triangles );
+
+    if( glIsList( m_layer_middle_contourns_quads ) )
+        glCallList( m_layer_middle_contourns_quads );
+
+    if( glIsList( m_layer_bot_triangles ) )
+        glCallList( m_layer_bot_triangles );
+
+    if( glIsList( m_layer_top_segment_ends ) )
+        glCallList( m_layer_top_segment_ends );
+
+    if( glIsList( m_layer_bot_segment_ends ) )
+        glCallList( m_layer_bot_segment_ends );
+
+}
+
+
+GLuint CLAYERS_OGL_DISP_LISTS::generate_top_or_bot_seg_ends(const CLAYER_TRIANGLE_CONTAINER *aTriangleContainer, const SFVEC3F &aLayerColor, bool aIsNormalUp, GLuint aTextureId ) const
+{
+    wxASSERT( aTriangleContainer != NULL );
+
+    wxASSERT( (aTriangleContainer->GetVertexSize() % 3) == 0 );
+
+    wxASSERT( aTriangleContainer->GetNormalsSize() == 0 );
+
+    if( (aTriangleContainer->GetVertexSize() > 0) &&
+        ((aTriangleContainer->GetVertexSize() % 3) == 0) )
+    {
+        GLuint listIdx = glGenLists( 1 );
+
+        if( glIsList( listIdx ) )
+        {
+            // Prepare an array of UV text coordinates
+            SFVEC2F *uvArray = new SFVEC2F[aTriangleContainer->GetVertexSize()];
+
+            for( unsigned int i = 0; i < aTriangleContainer->GetVertexSize(); i += 3 )
+            {
+                uvArray[i + 0] = SFVEC2F( 1.0f, 0.0f );
+                uvArray[i + 1] = SFVEC2F( 0.0f, 1.0f );
+                uvArray[i + 2] = SFVEC2F( 0.0f, 0.0f );
+            }
+
+            glEnableClientState( GL_TEXTURE_COORD_ARRAY );
+            glDisableClientState( GL_COLOR_ARRAY );
+            glDisableClientState( GL_NORMAL_ARRAY );
+            glEnableClientState( GL_VERTEX_ARRAY );
+            glVertexPointer( 3, GL_FLOAT, 0, aTriangleContainer->GetVertexPointer() );
+            glTexCoordPointer( 2, GL_FLOAT, 0, uvArray );
+
+            glNewList( listIdx, GL_COMPILE );
+
+            glEnable( GL_TEXTURE_2D );
+            glBindTexture( GL_TEXTURE_2D, aTextureId );
+
+            glAlphaFunc( GL_GREATER, 0.60f );
+            glEnable( GL_ALPHA_TEST );
+
+            glEnable( GL_BLEND );
+            glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+
+            //SFVEC4F layerColor4 = SFVEC4F( aLayerColor.x, aLayerColor.y, aLayerColor.z, 1.0f );
+            //glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,  &layerColor4.x );
+            //glDisable( GL_COLOR_MATERIAL );
+            glEnable( GL_COLOR_MATERIAL );
+            glColor4f( aLayerColor.x, aLayerColor.y, aLayerColor.z, 1.0f );
+
+            // OGL_SetMaterial()
+            glNormal3f( 0.0f, 0.0f, aIsNormalUp?1.0f:-1.0f );
+
+            glDrawArrays( GL_TRIANGLES, 0, aTriangleContainer->GetVertexSize() );
+
+            glDisable( GL_TEXTURE_2D );
+            glDisable( GL_ALPHA_TEST );
+            glDisable( GL_BLEND );
+            glDisable( GL_COLOR_MATERIAL );
+
+            glEndList();
+
+            glDisableClientState( GL_VERTEX_ARRAY );
+            glDisableClientState( GL_TEXTURE_COORD_ARRAY );
+
+            delete uvArray;
+            return listIdx;
+        }
+    }
+
+    return 0;
+}
+
+
+GLuint CLAYERS_OGL_DISP_LISTS::generate_top_or_bot_triangles(const CLAYER_TRIANGLE_CONTAINER *aTriangleContainer, const SFVEC3F &aLayerColor , bool aIsNormalUp) const
+{
+    wxASSERT( aTriangleContainer != NULL );
+
+    wxASSERT( (aTriangleContainer->GetVertexSize() % 3) == 0 );
+
+    wxASSERT( aTriangleContainer->GetNormalsSize() == 0 );
+
+    if( (aTriangleContainer->GetVertexSize() > 0) &&
+        ((aTriangleContainer->GetVertexSize() % 3) == 0) )
+    {
+        GLuint listIdx = glGenLists( 1 );
+
+        if( glIsList( listIdx ) )
+        {
+            glDisableClientState( GL_TEXTURE_COORD_ARRAY );
+            glDisableClientState( GL_COLOR_ARRAY );
+            glDisableClientState( GL_NORMAL_ARRAY );
+            glEnableClientState( GL_VERTEX_ARRAY );
+            glVertexPointer( 3, GL_FLOAT, 0, aTriangleContainer->GetVertexPointer() );
+
+            glNewList( listIdx, GL_COMPILE );
+
+            //SFVEC4F layerColor4 = SFVEC4F( aLayerColor.x, aLayerColor.y, aLayerColor.z, 1.0f );
+            //glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,  &layerColor4.x );
+            glEnable( GL_COLOR_MATERIAL );
+            glColor4f( aLayerColor.x, aLayerColor.y, aLayerColor.z, 1.0f );
+
+            // OGL_SetMaterial()
+            glNormal3f( 0.0f, 0.0f, aIsNormalUp?1.0f:-1.0f );
+
+            glDrawArrays( GL_TRIANGLES, 0, aTriangleContainer->GetVertexSize() );
+/*
+            glEnable( GL_COLOR_MATERIAL );
+            glColor3f( 0.0,1.0,1.0);
+            for( unsigned int i=0; i < aTriangleContainer->GetVertexSize(); ++i )
+            {
+                const SFVEC3F &v1 = aTriangleContainer->GetVertexPointer()[ i * 3];
+
+                glBegin(GL_LINES);
+                glVertex3f( v1.x, v1.y, v1.z );
+                if( aIsNormalUp )
+                {
+                    glVertex3f( v1.x, v1.y, v1.z+1.0f*.0051f );
+                }
+                else
+                {
+                    glVertex3f( v1.x, v1.y, v1.z-1.0f*.0051f );
+                }
+                glEnd();
+            }
+*/
+            glEndList();
+
+            glDisableClientState( GL_VERTEX_ARRAY );
+
+            return listIdx;
+        }
+    }
+
+    return 0;
+}
+
+GLuint CLAYERS_OGL_DISP_LISTS::generate_middle_triangles( const CLAYER_TRIANGLE_CONTAINER *aTriangleContainer, const SFVEC3F &aLayerColor ) const
+{
+    wxASSERT( aTriangleContainer != NULL );
+
+    // We expect that it is a multiple of 3 vertex
+    wxASSERT( (aTriangleContainer->GetVertexSize() % 3) == 0 );
+
+    // We expect that it is a multiple of 6 vertex (because we expect to add quads)
+    wxASSERT( (aTriangleContainer->GetVertexSize() % 6) == 0 );
+
+    // We expect that there are normals with same size as vertex
+    wxASSERT( aTriangleContainer->GetNormalsSize() == aTriangleContainer->GetVertexSize() );
+
+
+    if( ( aTriangleContainer->GetVertexSize() > 0 ) &&
+        ( (aTriangleContainer->GetVertexSize() % 3) == 0 ) &&
+        ( (aTriangleContainer->GetVertexSize() % 6) == 0 ) &&
+        ( aTriangleContainer->GetNormalsSize() == aTriangleContainer->GetVertexSize() ) )
+    {
+        GLuint listIdx = glGenLists( 1 );
+
+        if( glIsList( listIdx ) )
+        {
+            glDisableClientState( GL_TEXTURE_COORD_ARRAY );
+            glDisableClientState( GL_COLOR_ARRAY );
+            glEnableClientState( GL_NORMAL_ARRAY );
+            glEnableClientState( GL_VERTEX_ARRAY );
+            glVertexPointer( 3, GL_FLOAT, 0, aTriangleContainer->GetVertexPointer() );
+            glNormalPointer( GL_FLOAT, 0, aTriangleContainer->GetNormalsPointer() );
+
+            glNewList( listIdx, GL_COMPILE );
+/*
+            const SFVEC4F specular = SFVEC4F( 0.5f, 0.5f, 0.5f, 1.0f );
+
+            glMaterialfv( GL_FRONT, GL_SPECULAR, &specular.r );
+            glMaterialf(  GL_FRONT, GL_SHININESS, 10.0f );*/
+
+            //SFVEC4F layerColor4 = SFVEC4F( aLayerColor.x, aLayerColor.y, aLayerColor.z, 1.0f );
+            //glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,  &layerColor4.x );
+            //glDisable( GL_COLOR_MATERIAL );
+            glEnable( GL_COLOR_MATERIAL );
+            glColor4f( aLayerColor.x, aLayerColor.y, aLayerColor.z, 1.0f );
+
+            // OGL_SetMaterial()
+
+            glDrawArrays( GL_TRIANGLES, 0, aTriangleContainer->GetVertexSize() );
+/*
+            glEnable( GL_COLOR_MATERIAL );
+            glColor3f( 1.0,0.0,1.0);
+            for( unsigned int i=0; i < aTriangleContainer->GetVertexSize() / 3 ; ++i )
+            {
+                const SFVEC3F &v1 = ((const SFVEC3F*)aTriangleContainer->GetVertexPointer())[i * 3];
+                const SFVEC3F &n1 = ((const SFVEC3F*)aTriangleContainer->GetNormalsPointer())[i * 3];
+                glBegin(GL_LINES);
+                glVertex3f( v1.x, v1.y, v1.z );
+                glVertex3f( v1.x+n1.x*.01f, v1.y+n1.y*.01f, v1.z+n1.z*.01f );
+                glEnd();
+            }
+*/
+            glEndList();
+
+            glDisableClientState( GL_VERTEX_ARRAY );
+            glDisableClientState( GL_NORMAL_ARRAY );
+
+            return listIdx;
+        }
+    }
+
+    return 0;
+}
+
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/clayer_triangles.h b/3d-viewer/3d_rendering/3d_render_ogl_legacy/clayer_triangles.h
new file mode 100644
index 0000000000..9709a00eb4
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/clayer_triangles.h
@@ -0,0 +1,215 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  clayer_triangles.h
+ * @brief
+ */
+
+#ifndef CLAYER_TRIANGLES_H_
+#define CLAYER_TRIANGLES_H_
+
+#include "common_ogl/openGL_includes.h"
+#include "3d_xv3d/xv3d_types.h"
+#include <vector>
+
+
+typedef std::vector< SFVEC3F > SFVEC3F_VECTOR;
+
+
+/**
+ * @brief The CLAYER_TRIANGLE_CONTAINER class stores an manage vector of triangles
+ */
+class CLAYER_TRIANGLE_CONTAINER
+{
+
+public:
+
+    /**
+     * @brief CLAYER_TRIANGLE_CONTAINER
+     * @param aNrReservedTriangles: number of triangles expected to be used
+     * @param aReserveNormals: if you will use normals, set it to bool to pre reserve space
+     */
+    CLAYER_TRIANGLE_CONTAINER( unsigned int aNrReservedTriangles, bool aReserveNormals );
+
+    /**
+     * @brief AddTriangle
+     * @param aV1
+     * @param aV2
+     * @param aV3
+     */
+    void AddTriangle( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3 );
+
+    /**
+     * @brief AddQuad
+     * @param aV1
+     * @param aV2
+     * @param aV3
+     * @param aV4
+     */
+    void AddQuad( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, const SFVEC3F &aV4 );
+
+    /**
+     * @brief AddNormal
+     * @param aN1
+     * @param aN2
+     * @param aN3
+     */
+    void AddNormal( const SFVEC3F &aN1, const SFVEC3F &aN2, const SFVEC3F &aN3 );
+
+    /**
+     * @brief AddNormal
+     * @param aN1
+     * @param aN2
+     * @param aN3
+     */
+    void AddNormal( const SFVEC3F &aN1, const SFVEC3F &aN2, const SFVEC3F &aN3, const SFVEC3F &aN4 );
+
+    /**
+     * @brief GetVertexPointer - Get the array of vertexes
+     * @return The pointer to the start of array vertex
+     */
+    const float *GetVertexPointer() const { return (const float *)&m_vertexs[0].x; }
+
+    /**
+     * @brief GetNormalsPointer - Get the array of normals
+     * @return The pointer to start of array of normals
+     */
+    const float *GetNormalsPointer() const { return (const float *)&m_normals[0].x; }
+
+    /**
+     * @brief GetVertexSize
+     * @return
+     */
+    unsigned int GetVertexSize() const { return m_vertexs.size(); }
+
+    /**
+     * @brief GetNormalsSize
+     * @return
+     */
+    unsigned int GetNormalsSize() const { return m_normals.size(); }
+
+private:
+    SFVEC3F_VECTOR m_vertexs;                                                   ///< vertex array
+    SFVEC3F_VECTOR m_normals;                                                   ///< normals array
+};
+
+
+/**
+ * @brief The CLAYER_TRIANGLES class stores arrays of triangles to be used to
+ * create display lists
+ */
+class CLAYER_TRIANGLES
+{
+public:
+    /**
+     * @brief CLAYER_TRIANGLES - initialize arrays with reserved triangles
+     * @param aNrReservedTriangles: number of pre alloc triangles to reserve
+     */
+    CLAYER_TRIANGLES( unsigned int aNrReservedTriangles );
+
+    /**
+     * @brief ~CLAYER_TRIANGLES - Free containers
+     */
+    ~CLAYER_TRIANGLES();
+
+    /**
+     * @brief IsLayersSizeValid - check if the vertex arrays of the layers are as expected
+     * @return TRUE if layers are correctly setup
+     */
+    bool IsLayersSizeValid();
+
+    CLAYER_TRIANGLE_CONTAINER *m_layer_top_segment_ends;
+    CLAYER_TRIANGLE_CONTAINER *m_layer_top_triangles;
+    CLAYER_TRIANGLE_CONTAINER *m_layer_middle_contourns_quads;
+    CLAYER_TRIANGLE_CONTAINER *m_layer_bot_triangles;
+    CLAYER_TRIANGLE_CONTAINER *m_layer_bot_segment_ends;
+};
+
+
+/**
+ * @brief The CLAYERS_OGL_DISP_LISTS class stores the openGL display lists to
+ * related with a layer
+ */
+class CLAYERS_OGL_DISP_LISTS
+{
+public:
+    /**
+     * @brief CLAYERS_OGL_DISP_LISTS - Creates the display lists for a layer
+     * @param aLayerTriangles: contains the layers array of vertex to render to display lists
+     * @param aTextureIndexForSegEnds: texture index to be used by segment ends. It is a black and white squared texture with a center circle diameter of the size of the texture.
+     */
+    CLAYERS_OGL_DISP_LISTS( const CLAYER_TRIANGLES &aLayerTriangles,
+                            GLuint aTextureIndexForSegEnds,
+                            const SFVEC3F& aLayerColor );
+
+    /**
+     * @brief ~CLAYERS_OGL_DISP_LISTS - Destroy this class while free the display lists from GPU mem
+     */
+    ~CLAYERS_OGL_DISP_LISTS();
+
+    /**
+     * @brief DrawTopAndMiddle - This function calls the display lists for the top elements and middle contourns
+     */
+    void DrawTopAndMiddle() const;
+
+    /**
+     * @brief DrawBotAndMiddle - This function calls the display lists for the botton elements and middle contourns
+     */
+    void DrawBotAndMiddle() const;
+
+    /**
+     * @brief DrawTop - This function calls the display lists for the top elements
+     */
+    void DrawTop() const;
+
+    /**
+     * @brief DrawBot - This function calls the display lists for the botton elements
+     */
+    void DrawBot() const;
+
+    /**
+     * @brief DrawMiddle - This function calls the display lists for the middle elements
+     */
+    void DrawMiddle() const;
+
+    /**
+     * @brief DrawAll - This function calls all the display lists
+     */
+    void DrawAll() const;
+
+private:
+    GLuint generate_top_or_bot_seg_ends(const CLAYER_TRIANGLE_CONTAINER * aTriangleContainer, const SFVEC3F& aLayerColor, bool aIsNormalUp , GLuint aTextureId ) const;
+    GLuint generate_top_or_bot_triangles( const CLAYER_TRIANGLE_CONTAINER * aTriangleContainer, const SFVEC3F& aLayerColor, bool aIsNormalUp ) const;
+    GLuint generate_middle_triangles( const CLAYER_TRIANGLE_CONTAINER * aTriangleContainer, const SFVEC3F& aLayerColor ) const;
+
+private:
+    GLuint m_layer_top_segment_ends;
+    GLuint m_layer_top_triangles;
+    GLuint m_layer_middle_contourns_quads;
+    GLuint m_layer_bot_triangles;
+    GLuint m_layer_bot_segment_ends;
+};
+
+#endif // CLAYER_TRIANGLES_H_
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.cpp b/3d-viewer/3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.cpp
new file mode 100644
index 0000000000..e256e3e388
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.cpp
@@ -0,0 +1,265 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ogl_legacy_utils.cpp
+ * @brief
+ */
+
+
+#include "common_ogl/openGL_includes.h"
+#include "ogl_legacy_utils.h"
+#include <trigo.h>
+#include <wx/debug.h>                                                           // For the wxASSERT
+
+#define RADPERDEG 0.0174533
+
+void OGL_draw_arrow( SFVEC3F aPosition, SFVEC3F aTargetPos, float aSize )
+{
+    wxASSERT( aSize > 0.0f );
+
+    SFVEC3F vec = (aTargetPos - aPosition);
+    float length = glm::length( vec );
+
+    GLUquadricObj *quadObj;
+
+    glPushMatrix ();
+
+      glTranslatef( aPosition.x, aPosition.y, aPosition.z );
+
+      if( ( vec.x != 0.0f ) || ( vec.y != 0.0f ) )
+      {
+        glRotatef( atan2(vec.y, vec.x) / RADPERDEG, 0.0f, 0.0f, 1.0f );
+        glRotatef( atan2(sqrt(vec.x * vec.x + vec.y * vec.y), vec.z) / RADPERDEG, 0.0f, 1.0f, 0.0f );
+      } else if( vec.z < 0.0f )
+      {
+        glRotatef( 180.0f, 1.0f, 0.0f, 0.0f );
+      }
+
+      glTranslatef( 0.0f, 0.0f, length - 4.0f * aSize );
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle( quadObj, GLU_FILL );
+      gluQuadricNormals( quadObj, GLU_SMOOTH );
+      gluCylinder( quadObj, 2.0 * aSize, 0.0, 4.0 * aSize, 12, 1 );
+      gluDeleteQuadric( quadObj );
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle( quadObj, GLU_FILL );
+      gluQuadricNormals( quadObj, GLU_SMOOTH );
+      gluDisk( quadObj, 0.0, 2.0 * aSize, 12, 1 );
+      gluDeleteQuadric( quadObj );
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle( quadObj, GLU_FILL );
+      gluQuadricNormals( quadObj, GLU_SMOOTH );
+      gluDisk( quadObj, 0.0, aSize, 12, 1 );
+      gluDeleteQuadric( quadObj );
+
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle( quadObj, GLU_FILL );
+      gluQuadricNormals( quadObj, GLU_SMOOTH );
+      gluSphere( quadObj, aSize, 24, 24 );
+      gluDeleteQuadric( quadObj );
+
+      glTranslatef( 0.0f , 0.0f ,-length + 4.0f * aSize );
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle(quadObj, GLU_FILL );
+      gluQuadricNormals(quadObj, GLU_SMOOTH );
+      gluCylinder( quadObj, aSize, aSize, length - 4.0 * aSize, 12, 1 );
+      gluDeleteQuadric( quadObj );
+/*
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle( quadObj, GLU_FILL );
+      gluQuadricNormals( quadObj, GLU_SMOOTH );
+      gluSphere( quadObj, aSize, 24, 24 );
+      gluDeleteQuadric( quadObj );
+*/
+
+      quadObj = gluNewQuadric();
+      gluQuadricDrawStyle( quadObj, GLU_FILL );
+      gluQuadricNormals( quadObj, GLU_SMOOTH );
+      gluDisk( quadObj, 0.0, aSize, 12, 1 );
+      gluDeleteQuadric( quadObj );
+
+    glPopMatrix ();
+}
+
+
+void OGL_draw_bbox( const CBBOX &aBBox )
+{
+    wxASSERT( aBBox.IsInitialized() );
+
+    glBegin( GL_LINE_LOOP );
+    glVertex3f( aBBox.Min().x, aBBox.Min().y, aBBox.Min().z );
+    glVertex3f( aBBox.Max().x, aBBox.Min().y, aBBox.Min().z );
+    glVertex3f( aBBox.Max().x, aBBox.Max().y, aBBox.Min().z );
+    glVertex3f( aBBox.Min().x, aBBox.Max().y, aBBox.Min().z );
+    glEnd();
+
+    glBegin( GL_LINE_LOOP );
+    glVertex3f( aBBox.Min().x, aBBox.Min().y, aBBox.Max().z );
+    glVertex3f( aBBox.Max().x, aBBox.Min().y, aBBox.Max().z );
+    glVertex3f( aBBox.Max().x, aBBox.Max().y, aBBox.Max().z );
+    glVertex3f( aBBox.Min().x, aBBox.Max().y, aBBox.Max().z );
+    glEnd();
+
+    glBegin( GL_LINE_STRIP );
+    glVertex3f( aBBox.Min().x, aBBox.Min().y, aBBox.Min().z );
+    glVertex3f( aBBox.Min().x, aBBox.Min().y, aBBox.Max().z );
+    glEnd();
+
+    glBegin( GL_LINE_STRIP );
+    glVertex3f( aBBox.Max().x, aBBox.Min().y, aBBox.Min().z );
+    glVertex3f( aBBox.Max().x, aBBox.Min().y, aBBox.Max().z );
+    glEnd();
+
+    glBegin( GL_LINE_STRIP );
+    glVertex3f( aBBox.Max().x, aBBox.Max().y, aBBox.Min().z );
+    glVertex3f( aBBox.Max().x, aBBox.Max().y, aBBox.Max().z );
+    glEnd();
+
+    glBegin( GL_LINE_STRIP );
+    glVertex3f( aBBox.Min().x, aBBox.Max().y, aBBox.Min().z );
+    glVertex3f( aBBox.Min().x, aBBox.Max().y, aBBox.Max().z );
+    glEnd();
+}
+
+
+void OGL_draw_half_open_cylinder( unsigned int aNrSidesPerCircle )
+{
+    if( aNrSidesPerCircle > 1 )
+    {
+        float radius = 0.5f;
+        int delta = 3600 / aNrSidesPerCircle;
+
+        // Generate bottom
+        glNormal3f( 0.0f, 0.0f,-1.0f );
+        glBegin( GL_TRIANGLE_FAN );
+        glVertex3f( 0.0, 0.0, 0.0 );                                            // This is the V0 of the FAN
+        for( int ii = 0; ii < 1800; ii += delta )
+        {
+            SFVEC2D corner = SFVEC2D( 0.0, radius );
+            RotatePoint( &corner.x, &corner.y, ii );
+            glVertex3f( corner.x, corner.y, 0.0 );
+        }
+        glVertex3d( 0.0, -radius, 0.0 );
+        glEnd();
+
+        // Generate top
+        glNormal3f( 0.0f, 0.0f, 1.0f );
+        glBegin( GL_TRIANGLE_FAN );
+        glVertex3f( 0.0, 0.0, 1.0 );                                            // This is the V0 of the FAN
+        for( int ii = 1800; ii > 0; ii -= delta )
+        {
+            SFVEC2D corner = SFVEC2D( 0.0, radius );
+            RotatePoint( &corner.x, &corner.y, ii );
+            glVertex3f( corner.x, corner.y, 1.0 );
+        }
+        glVertex3f( 0.0, radius, 1.0 );
+        glEnd();
+
+        // Generate contours
+        glBegin( GL_QUAD_STRIP );
+        for( int ii = 1800; ii > 0; ii -= delta )
+        {
+            SFVEC2D corner = SFVEC2D( 0.0, radius );
+            RotatePoint( &corner.x, &corner.y, ii );
+            glNormal3f( corner.x * 2.0f, corner.y * 2.0f, 0.0f );
+            glVertex3f( corner.x, corner.y, 1.0 );
+            glVertex3f( corner.x, corner.y, 0.0 );
+        }
+        glNormal3f( 0.0, 1.0f, 0.0f );
+        glVertex3d( 0.0, radius, 1.0 );
+        glVertex3d( 0.0, radius, 0.0 );
+        glEnd();
+    }
+}
+
+
+void OGL_Draw_segment( const CROUNDSEGMENT2D &aSegment, unsigned int aNrSidesPerCircle )
+{
+    glPushMatrix();
+
+    const SFVEC2F start = aSegment.GetStart();
+    const SFVEC2F end   = aSegment.GetEnd();
+    const SFVEC2F end_minus_start = aSegment.GetEnd_minus_Start();
+    const float radius = aSegment.GetRadius();
+    const float width  = aSegment.GetWidth();
+    const float lenght = aSegment.GetLenght();
+
+    glTranslatef( start.x, start.y, 0.0f );
+
+    if( ( end_minus_start.x != 0.0f ) || ( end_minus_start.y != 0.0f ) )
+    {
+      glRotatef( atan2(end_minus_start.y, end_minus_start.x) / RADPERDEG, 0.0f, 0.0f, 1.0f );
+    }
+
+    glPushMatrix();
+    glTranslatef( lenght, 0.0, 0.0f );
+    glScalef( width, width, 1.0f );
+    OGL_draw_half_open_cylinder( aNrSidesPerCircle );
+    glPopMatrix ();
+
+    glBegin( GL_QUADS );
+    glNormal3f( 0.0,-1.0, 0.0 );
+    glVertex3f( lenght,-radius, 1.0 );
+    glVertex3f( 0.0,   -radius, 1.0 );
+    glVertex3f( 0.0,   -radius, 0.0 );
+    glVertex3f( lenght,-radius, 0.0 );
+    glEnd();
+
+    glBegin( GL_QUADS );
+    glNormal3f( 0.0,  1.0, 0.0 );
+    glVertex3f( lenght, radius, 0.0 );
+    glVertex3f( 0.0,    radius, 0.0 );
+    glVertex3f( 0.0,    radius, 1.0 );
+    glVertex3f( lenght, radius, 1.0 );
+    glEnd();
+
+    glBegin( GL_QUADS );
+    glNormal3f( 0.0, 0.0, 1.0 );
+    glVertex3f( lenght, radius, 1.0 );
+    glVertex3f( 0.0,    radius, 1.0 );
+    glVertex3f( 0.0,   -radius, 1.0 );
+    glVertex3f( lenght,-radius, 1.0 );
+    glEnd();
+
+    glBegin( GL_QUADS );
+    glNormal3f( 0.0, 0.0,-1.0 );
+    glVertex3f( lenght,-radius, 0.0 );
+    glVertex3f( 0.0,   -radius, 0.0 );
+    glVertex3f( 0.0,    radius, 0.0 );
+    glVertex3f( lenght, radius, 0.0 );
+    glEnd();
+
+    glScalef( width, width, 1.0f );
+    glRotatef( 180, 0.0, 0.0, 1.0 );
+    OGL_draw_half_open_cylinder( aNrSidesPerCircle );
+
+    glPopMatrix ();
+}
diff --git a/3d-viewer/3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.h b/3d-viewer/3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.h
new file mode 100644
index 0000000000..cc619b7b69
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.h
@@ -0,0 +1,67 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ogl_legacy_utils.h
+ * @brief
+ */
+
+#ifndef OGL_LEGACY_UTILS_H_
+#define OGL_LEGACY_UTILS_H_
+
+#include "3d_xv3d/xv3d_types.h"
+#include "3d_render_raytracing/shapes3D/cbbox.h"
+#include "3d_render_raytracing/shapes2D/croundsegment2d.h"
+
+/**
+ * @brief OGL_draw_arrow - draw a round arrow
+ * @param aPosition: start position of the arrow
+ * @param aTargetPos: end position of the arror
+ * @param aSize: diameter size
+ */
+void OGL_draw_arrow( SFVEC3F aPosition, SFVEC3F aTargetPos, float aSize );
+
+
+/**
+ * @brief OGL_draw_bbox - draw the bounding box lines
+ * @param aBBox
+ */
+void OGL_draw_bbox( const CBBOX &aBBox );
+
+
+/**
+ * @brief OGL_draw_half_open_cylinder - draws an open half cylinder
+ * with diameter 1.0f and Height 1.0f
+ * the bottom center is at (0,0,0) and top center is at (0,0,1)
+ */
+void OGL_draw_half_open_cylinder( unsigned int aNrSidesPerCircle );
+
+
+/**
+ * @brief OGL_Draw_segment
+ * @param aSegment
+ */
+void OGL_Draw_segment( const CROUNDSEGMENT2D &aSegment, unsigned int aNrSidesPerCircle );
+
+#endif // OGL_LEGACY_UTILS_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/accelerators/ccontainer.h b/3d-viewer/3d_rendering/3d_render_raytracing/accelerators/ccontainer.h
new file mode 100644
index 0000000000..7026d4e746
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/accelerators/ccontainer.h
@@ -0,0 +1,83 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ccontainer.h
+ * @brief
+ */
+
+#ifndef _CCONTAINER_H_
+#define _CCONTAINER_H_
+
+#include "../shapes3D/cobject.h"
+#include <list>
+#include <vector>
+
+typedef std::list<COBJECT *> LIST_OBJECT;
+typedef std::vector<COBJECT *> VECTOR_OBJECT;
+typedef std::vector<const COBJECT *> CONST_VECTOR_OBJECT;
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CGENERICCONTAINER
+{
+protected:
+    CBBOX       m_bbox;
+    LIST_OBJECT m_objects;
+
+public:
+    CGENERICCONTAINER();
+
+    virtual ~CGENERICCONTAINER();
+
+    void Add( COBJECT *aObject )
+    {
+        if( aObject ) // Only add if it is a valid pointer
+        {
+            m_objects.push_back( aObject );
+            m_bbox.Union( aObject->GetBBox() );
+        }
+    }
+
+    void Clear();
+
+    const LIST_OBJECT &GetList() const { return m_objects; }
+
+    const void ConvertTo( CONST_VECTOR_OBJECT &aOutVector ) const;
+
+    const CBBOX &GetBBox() const { return m_bbox; }
+
+    virtual bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const = 0;
+    virtual bool IntersectP( const RAY &aRay, float aMaxDistance ) const = 0;
+
+private:
+};
+
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CCONTAINER : public CGENERICCONTAINER
+{
+public:
+    bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const;
+    bool IntersectP( const RAY &aRay, float aMaxDistance ) const;
+};
+
+#endif // _CCONTAINER_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/accelerators/ccontainer2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/accelerators/ccontainer2d.h
new file mode 100644
index 0000000000..eda1aa94b2
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/accelerators/ccontainer2d.h
@@ -0,0 +1,116 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ccontainer2d.h
+ * @brief
+ */
+
+#ifndef _CCONTAINER2D_H_
+#define _CCONTAINER2D_H_
+
+#include "../shapes2D/cobject2d.h"
+#include <list>
+
+typedef std::list<COBJECT2D *> LIST_OBJECT2D;
+typedef std::list<const COBJECT2D *> CONST_LIST_OBJECT2D;
+
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CGENERICCONTAINER2D
+{
+protected:
+    CBBOX2D m_bbox;
+    LIST_OBJECT2D m_objects;
+
+public:
+    CGENERICCONTAINER2D( OBJECT2D_TYPE aObjType );
+
+    virtual ~CGENERICCONTAINER2D();
+
+    void Add( COBJECT2D *aObject )
+    {
+        if( aObject ) // Only add if it is a valid pointer
+        {
+            m_objects.push_back( aObject );
+            m_bbox.Union( aObject->GetBBox() );
+        }
+    }// automatically releases the lock when lck goes out of scope.
+
+    void Clear();
+
+    const LIST_OBJECT2D &GetList() const { return m_objects; }
+
+    /**
+     * @brief GetListObjectsIntersects - Get a list of objects that intersects a bbox
+     * @param aBBox - a bbox to make the query
+     * @param aOutList - A list of objects that intersects the bbox
+     */
+    virtual void GetListObjectsIntersects( const CBBOX2D & aBBox, CONST_LIST_OBJECT2D &aOutList ) const = 0;
+
+private:
+};
+
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CCONTAINER2D : public CGENERICCONTAINER2D
+{
+public:
+    CCONTAINER2D();
+
+    // Imported from CGENERICCONTAINER2D
+    void GetListObjectsIntersects( const CBBOX2D & aBBox, CONST_LIST_OBJECT2D &aOutList ) const;
+};
+
+
+struct BVH_CONTAINER_NODE_2D
+{
+    CBBOX2D                 m_BBox;
+    BVH_CONTAINER_NODE_2D   *m_Children[2];
+    CONST_LIST_OBJECT2D     m_LeafList;                                         ///< Store the list of objects if that node is a Leaf
+};
+
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CBVHCONTAINER2D : public CGENERICCONTAINER2D
+{
+public:
+    CBVHCONTAINER2D();
+    ~CBVHCONTAINER2D();
+
+    void BuildBVH();
+
+private:
+    bool m_isInitialized;
+    std::list<BVH_CONTAINER_NODE_2D *> m_elements_to_delete;
+    BVH_CONTAINER_NODE_2D   *m_Tree;
+
+    void destroy();
+    void recursiveBuild_MIDDLE_SPLIT( BVH_CONTAINER_NODE_2D *aNodeParent );
+    void recursiveGetListObjectsIntersects( const BVH_CONTAINER_NODE_2D *aNode, const CBBOX2D & aBBox, CONST_LIST_OBJECT2D &aOutList ) const;
+
+public:
+
+    // Imported from CGENERICCONTAINER2D
+    void GetListObjectsIntersects( const CBBOX2D & aBBox, CONST_LIST_OBJECT2D &aOutList ) const;
+};
+
+#endif // _CCONTAINER2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/cfrustum.h b/3d-viewer/3d_rendering/3d_render_raytracing/cfrustum.h
new file mode 100644
index 0000000000..d777f791ea
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/cfrustum.h
@@ -0,0 +1,53 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cfrustum.h
+ * @brief
+ */
+
+#ifndef _CFRUSTUM_H_
+#define _CFRUSTUM_H_
+
+#include "../../3d_xv3d/xv3d_types.h"
+#include "shapes3D/cbbox.h"
+#include "ray.h"
+
+// !TODO: optimize wih SSE
+//#if(GLM_ARCH != GLM_ARCH_PURE)
+#if 0
+#error not implemented
+#else
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) CFRUSTUM
+{
+    SFVEC3F m_normals[4];
+    SFVEC3F m_point[4];
+
+    void GenerateFrustum( const RAY &topLeft, const RAY &topRight, const RAY &bottomLeft, const RAY &bottomRight );
+    bool Intersect( const CBBOX &aBBox ) const;
+};
+#endif
+
+
+#endif // _CFRUSTUM_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/cmaterial.h b/3d-viewer/3d_rendering/3d_render_raytracing/cmaterial.h
new file mode 100644
index 0000000000..8b31b38107
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/cmaterial.h
@@ -0,0 +1,95 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cmaterial.h
+ * @brief
+ */
+
+#ifndef _CMATERIAL_H_
+#define _CMATERIAL_H_
+
+#include "ray.h"
+#include "hitinfo.h"
+
+/// 
+class GLM_ALIGN(CLASS_ALIGNMENT) CMATERIAL
+{
+public:
+    CMATERIAL();
+    CMATERIAL( const SFVEC3F &aAmbient, const SFVEC3F &aEmissive, const SFVEC3F &aSpecular, float aShinness, float aTransparency );
+
+    const SFVEC3F &GetAmbientColor()  const { return m_ambientColor;  }
+    const SFVEC3F &GetEmissiveColor() const { return m_emissiveColor; }
+    const SFVEC3F &GetSpecularColor() const { return m_specularColor; }
+
+    float GetShinness()     const { return m_shinness;     }
+    float GetTransparency() const { return m_transparency; }
+
+    void SetCastShadows( bool aCastShadows ) { m_cast_shadows  = aCastShadows; }
+    bool GetCastShadows() const { return m_cast_shadows; }
+
+    virtual SFVEC3F Shade( const RAY &aRay, const HITINFO &aHitInfo, float NdotL, const SFVEC3F &aDiffuseObjColor, const SFVEC3F &aDirToLight, const SFVEC3F &aLightColor, bool aIsInShadow ) const = 0;
+
+/*
+
+
+    virtual SFVEC3F GetReflect(Vec3f point){ return reflectiveColor;}
+    virtual Vec3f GetTrans(Vec3f point){ return transparentColor;}
+    virtual float getIndexOfRefrac(Vec3f point){ return indexOfRefraction;}
+
+    virtual bool isReflect(Vec3f point){return ((reflectiveColor.x()>0)||(reflectiveColor.y()>0)||(reflectiveColor.z()>0));}
+    virtual bool isTransparent(Vec3f point){return ((transparentColor.x()>0)||(transparentColor.y()>0)||(transparentColor.z()>0));}
+*/
+protected:
+    SFVEC3F m_ambientColor;    
+    // NOTE: we will not use diffuse color material here,
+    // because it will be stored in object, since there are objects (i.e: triangles)
+    // that can have per vertex color
+
+    SFVEC3F m_emissiveColor;
+    SFVEC3F m_specularColor;
+    float   m_shinness;
+    float   m_transparency;     ///< 1.0 is completely transparent, 0.0 completely opaque
+    bool    m_cast_shadows;     ///< true if this object will block the light
+};
+
+
+/// https://en.wikipedia.org/wiki/Blinn%E2%80%93Phong_shading_model
+class GLM_ALIGN(CLASS_ALIGNMENT) CBLINN_PHONG_MATERIAL : public CMATERIAL
+{
+public:
+    CBLINN_PHONG_MATERIAL() : CMATERIAL() {}
+
+    CBLINN_PHONG_MATERIAL( const SFVEC3F &aAmbient,
+                           const SFVEC3F &aEmissive,
+                           const SFVEC3F &aSpecular,
+                           float aShinness,
+                           float aTransparency ) :
+    CMATERIAL( aAmbient, aEmissive, aSpecular, aShinness, aTransparency ) {}
+
+    SFVEC3F Shade( const RAY &aRay, const HITINFO &aHitInfo, float NdotL, const SFVEC3F &aDiffuseObjColor, const SFVEC3F &aDirToLight, const SFVEC3F &aLightColor, bool aIsInShadow ) const;
+};
+
+#endif // _CMATERIAL_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/hitinfo.h b/3d-viewer/3d_rendering/3d_render_raytracing/hitinfo.h
new file mode 100644
index 0000000000..b500fb1cc9
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/hitinfo.h
@@ -0,0 +1,65 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  hitinfo.h
+ * @brief
+ */
+
+#ifndef _HITINFO_H_
+#define _HITINFO_H_
+
+#include "../../3d_xv3d/xv3d_types.h"
+#include "raypacket.h"
+
+//#define RAYTRACING_RAY_STATISTICS
+
+class COBJECT;
+
+/// Stores the hit information of a ray with a point on the surface of a object
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) HITINFO
+{
+    SFVEC3F m_HitNormal;                ///< (12) normal at the hit point
+    float   m_tHit;                     ///< ( 4) distance
+
+    const COBJECT *pHitObject;          ///< ( 4) Object that was hitted
+    SFVEC2F m_UV;                       ///< ( 8) 2-D texture coordinates
+
+    unsigned int m_acc_node_info;       ///< ( 4) The acc should store here information (Ex: the node that it hits)
+
+#ifdef RAYTRACING_RAY_STATISTICS
+    // Statistics
+    unsigned int m_NrRayObjTests;       ///< Number of ray-objects tests
+    unsigned int m_NrTransversedNodes;  ///< Number of transversed nodes in the acc structure
+#endif
+};
+
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) HITINFO_PACKET
+{
+    bool    m_hitresult;
+    HITINFO m_HitInfo;
+
+};
+
+#endif // _HITINFO_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/ray.cpp b/3d-viewer/3d_rendering/3d_render_raytracing/ray.cpp
new file mode 100644
index 0000000000..e8f11a8e95
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/ray.cpp
@@ -0,0 +1,394 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ray.cpp
+ * @brief
+ */
+
+
+#include "ray.h"
+#include "3d_math/3d_fastmath.h"
+#include <stdio.h>
+#include <wx/debug.h>
+
+static unsigned int gs_next_rayID = 0;
+
+void RAY::Init( const SFVEC3F& o, const SFVEC3F& d )
+{
+    m_Origin = o;
+    m_Dir = d;
+    m_InvDir = 1.0f / d;
+
+    if( fabs(m_Dir.x) < FLT_EPSILON )
+        m_InvDir.x = NextFloatDown(FLT_MAX);
+
+    if( fabs(m_Dir.y) < FLT_EPSILON )
+        m_InvDir.y = NextFloatDown(FLT_MAX);
+
+    if( fabs(m_Dir.z) < FLT_EPSILON )
+        m_InvDir.z = NextFloatDown(FLT_MAX);
+
+    rayID = gs_next_rayID;
+    gs_next_rayID++;
+
+    // An Efficient and Robust Ray–Box Intersection Algorithm
+    // Amy Williams Steve Barrus R. Keith Morley Peter Shirley
+    // University of Utah
+    // http://people.csail.mit.edu/amy/papers/box-jgt.pdf
+    m_dirIsNeg[0] = m_Dir.x < 0.0f;
+    m_dirIsNeg[1] = m_Dir.y < 0.0f;
+    m_dirIsNeg[2] = m_Dir.z < 0.0f;
+
+    // ray slope
+
+    // "Fast Ray / Axis-Aligned Bounding Box Overlap Tests using Ray Slopes"
+    // by Martin Eisemann, Thorsten Grosch, Stefan Müller and Marcus Magnor
+    // Computer Graphics Lab, TU Braunschweig, Germany and
+    // University of Koblenz-Landau, Germany
+    // Licence: "This source code is public domain, but please mention us if you use it."
+    //
+    // https://github.com/rjw57/mcvoxel/tree/master/third-party/rayslope
+    // https://github.com/rjw57/mcvoxel/blob/master/third-party/rayslope/ray.cpp
+
+    ibyj = m_Dir.x * m_InvDir.y;
+    jbyi = m_Dir.y * m_InvDir.x;
+    jbyk = m_Dir.y * m_InvDir.z;
+    kbyj = m_Dir.z * m_InvDir.y;
+    ibyk = m_Dir.x * m_InvDir.z;
+    kbyi = m_Dir.z * m_InvDir.x;
+    c_xy = m_Origin.y - jbyi * m_Origin.x;
+    c_xz = m_Origin.z - kbyi * m_Origin.x;
+    c_yx = m_Origin.x - ibyj * m_Origin.y;
+    c_yz = m_Origin.z - kbyj * m_Origin.y;
+    c_zx = m_Origin.x - ibyk * m_Origin.z;
+    c_zy = m_Origin.y - jbyk * m_Origin.z;
+
+    // ray slope classification
+    if( m_Dir.x < 0 )
+    {
+        if( m_Dir.y < 0 )
+        {
+            if( m_Dir.z < 0 )
+            {
+                m_Classification = MMM;
+            }
+            else if( m_Dir.z > 0 ){
+                m_Classification = MMP;
+            }
+            else//( m_Dir.z >= 0 )
+            {
+                m_Classification = MMO;
+            }
+        }
+        else//( m_Dir.y >= 0 )
+        {
+            if( m_Dir.z < 0 )
+            {
+                m_Classification = MPM;
+                if( m_Dir.y == 0 )
+                    m_Classification = MOM;
+            }
+            else//( m_Dir.z >= 0 )
+            {
+                if( ( m_Dir.y == 0 ) && ( m_Dir.z == 0 ) )
+                    m_Classification = MOO;
+                else if( m_Dir.z == 0 )
+                    m_Classification = MPO;
+                else if( m_Dir.y == 0 )
+                    m_Classification = MOP;
+                else
+                    m_Classification = MPP;
+            }
+        }
+    }
+    else//( m_Dir.x >= 0 )
+    {
+        if( m_Dir.y < 0 )
+        {
+            if( m_Dir.z < 0 )
+            {
+                m_Classification = PMM;
+                if( m_Dir.x == 0 )
+                    m_Classification = OMM;
+            }
+            else//( m_Dir.z >= 0 )
+            {
+                if( ( m_Dir.x == 0 ) && ( m_Dir.z == 0 ) )
+                    m_Classification = OMO;
+                else if( m_Dir.z == 0 )
+                    m_Classification = PMO;
+                else if( m_Dir.x == 0 )
+                    m_Classification = OMP;
+                else
+                    m_Classification = PMP;
+            }
+        }
+        else//( m_Dir.y >= 0 )
+        {
+            if( m_Dir.z < 0 )
+            {
+                if( ( m_Dir.x == 0 ) && ( m_Dir.y == 0 ) )
+                    m_Classification = OOM;
+                else if( m_Dir.x == 0 )
+                    m_Classification = OPM;
+                else if( m_Dir.y == 0 )
+                    m_Classification = POM;
+                else
+                    m_Classification = PPM;
+            }
+            else//( m_Dir.z > 0 )
+            {
+                if( m_Dir.x == 0 )
+                {
+                    if( m_Dir.y == 0 )
+                        m_Classification = OOP;
+                    else if( m_Dir.z == 0 )
+                        m_Classification = OPO;
+                    else
+                        m_Classification = OPP;
+                }
+                else
+                {
+                    if( ( m_Dir.y == 0 ) && ( m_Dir.z == 0 ) )
+                        m_Classification = POO;
+                    else if( m_Dir.y == 0 )
+                        m_Classification = POP;
+                    else if( m_Dir.z == 0 )
+                        m_Classification = PPO;
+                    else
+                        m_Classification = PPP;
+                }
+            }
+        }
+    }
+}
+
+
+bool IntersectSegment( const SFVEC2F &aStartA, const SFVEC2F &aEnd_minus_startA,
+                       const SFVEC2F &aStartB, const SFVEC2F &aEnd_minus_startB )
+{
+    float rxs = aEnd_minus_startA.x * aEnd_minus_startB.y - aEnd_minus_startA.y * aEnd_minus_startB.x;
+
+    if( fabs(rxs) >  glm::epsilon<float>() )
+    {
+        float inv_rxs = 1.0f / rxs;
+
+        SFVEC2F pq = aStartB - aStartA;
+
+        float t = (pq.x * aEnd_minus_startB.y - pq.y * aEnd_minus_startB.x) * inv_rxs;
+
+        if( (t < 0.0f) || (t > 1.0f) )
+            return false;
+
+        float u = (pq.x * aEnd_minus_startA.y - pq.y * aEnd_minus_startA.x) * inv_rxs;
+
+        if( (u < 0.0f) || (u > 1.0f) )
+            return false;
+
+        return true;
+    }
+
+    return false;
+}
+
+// !TODO: not tested
+bool RAY::IntersectSphere( const SFVEC3F &aCenter, float aRadius, float &aOutT0, float &aOutT1 ) const
+{
+/*
+    // Ray-sphere intersection: algebraic
+
+    SFVEC3F CO = m_Origin - aCenter;
+
+    float a = glm::dot( m_Dir, m_Dir );
+    float b = 2.0f * glm::dot( CO, m_Dir );
+    float c = glm::dot( CO, CO ) - aRadius*aRadius;
+
+    float discriminant = b * b - 4.0f * a * c;
+
+    if( discriminant < 0.0f )
+        return false;
+
+    aOutT0 = (-b - sqrtf(discriminant)) / (2.0f * a);
+    aOutT1 = (-b + sqrtf(discriminant)) / (2.0f * a);
+
+    if( aOutT0 > aOutT1 )
+    {
+        float temp = aOutT0;
+        aOutT0 = aOutT1;
+        aOutT1 = temp;
+    }
+
+    return true;
+*/
+
+    // Ray-sphere intersection: geometric
+    SFVEC3F OC = aCenter - m_Origin;
+    float p_dot_d = glm::dot( OC, m_Dir );
+
+    if( p_dot_d < 0.0f )
+        return 0.0f;
+
+    float p_dot_p = glm::dot( OC, OC );
+    float discriminant = p_dot_p - p_dot_d * p_dot_d;
+
+    if( discriminant > aRadius*aRadius )
+        return false;
+
+    discriminant = sqrtf( aRadius*aRadius - discriminant );
+
+    aOutT0 = p_dot_d - discriminant;
+    aOutT1 = p_dot_d + discriminant;
+
+    if( aOutT0 > aOutT1 )
+    {
+        float temp = aOutT0;
+        aOutT0 = aOutT1;
+        aOutT1 = temp;
+    }
+
+    return true;
+}
+
+RAYSEG2D::RAYSEG2D( const SFVEC2F& s, const SFVEC2F& e )
+{
+    m_Start = s;
+    m_End = e;
+    m_End_minus_start = e - s;
+    m_Length = glm::length( m_End_minus_start );
+    m_Dir = glm::normalize( m_End_minus_start );
+    m_InvDir = (1.0f / m_Dir);
+
+    if( fabs(m_Dir.x) < FLT_EPSILON )
+        m_InvDir.x = NextFloatDown(FLT_MAX);
+
+    if( fabs(m_Dir.y) < FLT_EPSILON )
+        m_InvDir.y = NextFloatDown(FLT_MAX);
+
+    m_DOT_End_minus_start = glm::dot( m_End_minus_start, m_End_minus_start );
+}
+
+
+bool RAYSEG2D::IntersectSegment( const SFVEC2F &aStart, const SFVEC2F &aEnd_minus_start, float *aOutT ) const
+{
+    float rxs = m_End_minus_start.x * aEnd_minus_start.y - m_End_minus_start.y * aEnd_minus_start.x;
+
+    if( fabs(rxs) >  glm::epsilon<float>() )
+    {
+        float inv_rxs = 1.0f / rxs;
+
+        SFVEC2F pq = aStart - m_Start;
+
+        float t = (pq.x * aEnd_minus_start.y - pq.y * aEnd_minus_start.x) * inv_rxs;
+
+        if( (t < 0.0f) || (t > 1.0f) )
+            return false;
+
+        float u = (pq.x * m_End_minus_start.y - pq.y * m_End_minus_start.x) * inv_rxs;
+
+        if( (u < 0.0f) || (u > 1.0f) )
+            return false;
+
+        *aOutT = t;
+
+        return true;
+    }
+
+    return false;
+}
+
+
+// http://geomalgorithms.com/a02-_lines.html
+float RAYSEG2D::DistanceToPointSquared( const SFVEC2F &aPoint ) const
+{
+    SFVEC2F p = aPoint - m_Start;
+
+    float c1 = glm::dot( p, m_End_minus_start );
+
+    if( c1 < FLT_EPSILON )
+        return glm::dot( p, p );
+
+    if( m_DOT_End_minus_start <= c1 )
+        p = aPoint - m_End;
+    else
+    {
+        float b = c1 / m_DOT_End_minus_start;
+        SFVEC2F pb = m_Start + m_End_minus_start * b;
+        p = aPoint - pb;
+    }
+
+    return glm::dot( p, p );
+}
+
+
+bool RAYSEG2D::IntersectCircle( const SFVEC2F &aCenter, float aRadius, float *aOutT0, float *aOutT1, SFVEC2F *aOutNormalT0, SFVEC2F *aOutNormalT1 ) const
+{
+    // This code used directly from Steve Marschner's CS667 framework
+    // http://cs665pd.googlecode.com/svn/trunk/photon/sphere.cpp
+
+    // Compute some factors used in computation
+    float qx = m_Start.x - aCenter.x;
+    float qy = m_Start.y - aCenter.y;
+
+    float qd = qx * m_Dir.x + qy * m_Dir.y;
+    float qq = qx * qx + qy * qy;
+
+    // solving the quadratic equation for t at the pts of intersection
+    // dd*t^2 + (2*qd)*t + (qq-r^2) = 0
+    float discriminantsqr = (qd * qd - (qq - aRadius * aRadius));
+
+    // If the discriminant is less than zero, there is no intersection
+    if( discriminantsqr < FLT_EPSILON )
+        return false;
+
+
+    // Otherwise check and make sure that the intersections occur on the ray (t
+    // > 0) and return the closer one
+    float discriminant = sqrt(discriminantsqr);
+    float t1 = (-qd - discriminant);
+    float t2 = (-qd + discriminant);
+
+    if( (( t1 < 0.0f ) || ( t1 > m_Length ) ) &&
+        (( t2 < 0.0f ) || ( t2 > m_Length ) ) )
+        return false;// Neither intersection was in the ray's half line.
+
+    // Convert the intersection to a normalized
+    *aOutT0 = t1 / m_Length;
+    *aOutT1 = t2 / m_Length;
+
+    SFVEC2F hitPointT1 = at( t1 );
+    SFVEC2F hitPointT2 = at( t2 );
+
+    *aOutNormalT0 = (hitPointT1 - aCenter) / aRadius;
+    *aOutNormalT1 = (hitPointT2 - aCenter) / aRadius;
+
+    return true;
+}
+
+
+void RAY::debug() const
+{
+    printf("O(%f, %f, %f) D(%f, %f, %f)\n", m_Origin.x, m_Origin.y, m_Origin.z,
+                                            m_Dir.x,    m_Dir.y,    m_Dir.z );
+}
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/ray.h b/3d-viewer/3d_rendering/3d_render_raytracing/ray.h
new file mode 100644
index 0000000000..e7a990ca87
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/ray.h
@@ -0,0 +1,129 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ray.h
+ * @brief
+ */
+
+#ifndef _RAY_H_
+#define _RAY_H_
+
+#include "3d_xv3d/xv3d_types.h"
+
+
+enum RAY_CLASSIFICATION
+{
+    MMM, MMP, MPM, MPP, PMM, PMP, PPM, PPP, POO, MOO, OPO, OMO, OOP, OOM, OMM,
+    OMP,OPM,OPP,MOM,MOP,POM,POP,MMO,MPO,PMO,PPO
+};
+
+
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) RAY
+{
+    SFVEC3F m_Origin;
+    unsigned int rayID; ///< unique ray ID
+
+    SFVEC3F m_Dir;
+    RAY_CLASSIFICATION  m_Classification;
+
+    SFVEC3F m_InvDir;
+
+    float ibyj, jbyi, kbyj, jbyk, ibyk, kbyi;   // slope
+    float c_xy, c_xz, c_yx, c_yz, c_zx, c_zy;
+
+    unsigned int m_dirIsNeg[3];
+
+    void Init( const SFVEC3F& o, const SFVEC3F& d );
+
+    bool IntersectSphere( const SFVEC3F &aCenter, float aRadius, float &aOutT0, float &aOutT1 ) const;
+
+    SFVEC3F at( float t ) const { return m_Origin + m_Dir * t; }
+    SFVEC2F at2D( float t ) const { return SFVEC2F( m_Origin.x + m_Dir.x * t, m_Origin.y + m_Dir.y * t ); }
+
+    void debug() const;
+};
+
+
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) RAY2D
+{
+    SFVEC2F m_Origin;
+    SFVEC2F m_Dir;
+    SFVEC2F m_InvDir;
+
+    RAY2D( const SFVEC2F& o, const SFVEC2F& d ) { m_Origin = o; m_Dir = d; m_InvDir = (1.0f / d); }
+
+    SFVEC2F at( float t ) const { return m_Origin + m_Dir * t; }
+};
+
+
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) RAYSEG2D
+{
+    SFVEC2F m_Start;
+    SFVEC2F m_End;
+    SFVEC2F m_End_minus_start;
+    SFVEC2F m_Dir;
+    SFVEC2F m_InvDir;
+    float   m_Length;
+    float   m_DOT_End_minus_start; ///< dot( m_End_minus_start, m_End_minus_start)
+
+    RAYSEG2D( const SFVEC2F& s, const SFVEC2F& e );
+
+    bool IntersectSegment( const SFVEC2F &aStart, const SFVEC2F &aEnd_minus_start, float *aOutT ) const;
+    bool IntersectCircle( const SFVEC2F &aCenter, float aRadius, float *aOutT0, float *aOutT1, SFVEC2F *aOutNormalT0, SFVEC2F *aOutNormalT1 ) const;
+
+    float DistanceToPointSquared( const SFVEC2F &aPoint ) const;
+    /**
+     * Function atNormalized - returns the position at t
+     * t - value 0.0 ... 1.0
+     */
+    SFVEC2F atNormalized( float t ) const { return m_Start + m_End_minus_start * t; }
+
+    SFVEC2F at( float t ) const { return m_Start + m_Dir * t; }
+};
+
+
+bool IntersectSegment( const SFVEC2F &aStartA, const SFVEC2F &aEnd_minus_startA,
+                       const SFVEC2F &aStartB, const SFVEC2F &aEnd_minus_startB );
+
+#if(GLM_ARCH != GLM_ARCH_PURE)
+/*
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) RAY4
+{
+    glm::simdVec4 m_orgX;   ///< x coordinate of ray origin
+    glm::simdVec4 m_orgy;   ///< y coordinate of ray origin
+    glm::simdVec4 m_orgz;   ///< z coordinate of ray origin
+
+    glm::simdVec4 m_dirX;   ///< x direction of ray
+    glm::simdVec4 m_diry;   ///< y direction of ray
+    glm::simdVec4 m_dirz;   ///< z direction of ray
+
+    glm::simdVec4 m_tnear;  ///< Start of ray segment
+    glm::simdVec4 m_tfar;   ///< End of ray segment
+};*/
+
+#endif
+
+
+#endif // _RAY_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/raypacket.h b/3d-viewer/3d_rendering/3d_render_raytracing/raypacket.h
new file mode 100644
index 0000000000..bc9b2d9e43
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/raypacket.h
@@ -0,0 +1,53 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  raypacket.h
+ * @brief
+ */
+
+#ifndef _RAYPACKET_H_
+#define _RAYPACKET_H_
+
+#include "ray.h"
+#include "cfrustum.h"
+#include "../ccamera.h"
+
+#define RAYPACKET_DIM (1 << 3)
+#define RAYPACKET_MASK    (unsigned int)( (RAYPACKET_DIM - 1))
+#define RAYPACKET_INVMASK (unsigned int)(~(RAYPACKET_DIM - 1))
+#define RAYPACKET_RAYS_PER_PACKET (RAYPACKET_DIM * RAYPACKET_DIM)
+
+
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) RAYPACKET
+{
+    CFRUSTUM    m_Frustum;
+    RAY         m_ray[RAYPACKET_RAYS_PER_PACKET];
+
+    RAYPACKET( const CCAMERA &aCamera, const SFVEC2I &aWindowsPosition );
+    RAYPACKET( const CCAMERA &aCamera, const SFVEC2I &aWindowsPosition, unsigned int aPixelMultiple );
+};
+
+
+#endif // _RAYPACKET_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.cpp b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.cpp
new file mode 100644
index 0000000000..01fa466214
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.cpp
@@ -0,0 +1,307 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+ /**
+ * @file CBBOX2D2d.cpp
+ * @brief Bounding Box class implementation
+ */
+
+#include "3d_math/3d_fastmath.h"
+
+#include "cbbox2d.h"
+#include <fctsys.h>
+#include <wx/debug.h>
+
+
+CBBOX2D::CBBOX2D()
+{
+    Reset();
+}
+
+
+CBBOX2D::CBBOX2D( const SFVEC2F &aPbInit )
+{
+    m_min = aPbInit;
+    m_max = aPbInit;
+}
+
+
+CBBOX2D::CBBOX2D( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax )
+{
+    Set( aPbMin, aPbMax );
+}
+
+
+CBBOX2D::~CBBOX2D()
+{
+}
+
+
+void CBBOX2D::Set( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax )
+{
+    m_min.x =  fminf( aPbMin.x, aPbMax.x );
+    m_min.y =  fminf( aPbMin.y, aPbMax.y );
+
+    m_max.x =  fmaxf( aPbMin.x, aPbMax.x );
+    m_max.y =  fmaxf( aPbMin.y, aPbMax.y );
+}
+
+
+void CBBOX2D::Set( const CBBOX2D &aBBox )
+{
+    wxASSERT( aBBox.IsInitialized() );
+
+    Set( aBBox.Min(), aBBox.Max() );
+}
+
+
+bool CBBOX2D::IsInitialized() const
+{
+    return !( ( FLT_MAX == m_min.x) ||
+              ( FLT_MAX == m_min.y) ||
+              (-FLT_MAX == m_max.x) ||
+              (-FLT_MAX == m_max.y) );
+}
+
+
+void CBBOX2D::Reset()
+{
+    m_min = SFVEC2F( FLT_MAX, FLT_MAX );
+    m_max = SFVEC2F(-FLT_MAX,-FLT_MAX );
+}
+
+
+void CBBOX2D::Union( const SFVEC2F &aPoint )
+{
+    // get the minimun value between the added point and the existent bounding box
+    m_min.x =  fminf( m_min.x, aPoint.x );
+    m_min.y =  fminf( m_min.y, aPoint.y );
+
+    // get the maximun value between the added point and the existent bounding box
+    m_max.x =  fmaxf( m_max.x, aPoint.x );
+    m_max.y =  fmaxf( m_max.y, aPoint.y );
+}
+
+
+void CBBOX2D::Union( const CBBOX2D &aBBox )
+{
+    // get the minimun value between the added bounding box and the existent bounding box
+    m_min.x =  fminf( m_min.x, aBBox.m_min.x );
+    m_min.y =  fminf( m_min.y, aBBox.m_min.y );
+
+    // get the maximun value between the added bounding box and the existent bounding box
+    m_max.x =  fmaxf( m_max.x, aBBox.m_max.x );
+    m_max.y =  fmaxf( m_max.y, aBBox.m_max.y );
+}
+
+
+SFVEC2F CBBOX2D::GetCenter() const
+{
+    return (m_max + m_min) * 0.5f;
+}
+
+
+SFVEC2F CBBOX2D::GetExtent() const
+{
+    return m_max - m_min;
+}
+
+
+unsigned int CBBOX2D::MaxDimension() const
+{
+    unsigned int result = 0;
+    SFVEC2F extent = GetExtent();
+
+    if( extent.y > extent.x ) result = 1;
+
+    return result;
+}
+
+
+float CBBOX2D::Perimeter() const
+{
+    SFVEC2F extent = GetExtent();
+    return 2.0f * ( extent.x + extent.y );
+}
+
+
+void CBBOX2D::Scale( float aScale )
+{
+    wxASSERT( IsInitialized() );
+
+    SFVEC2F scaleV( aScale, aScale );
+    SFVEC2F centerV = GetCenter();
+
+    m_min = (m_min - centerV) * scaleV + centerV;
+    m_max = (m_max - centerV) * scaleV + centerV;
+}
+
+
+void CBBOX2D::ScaleNextUp()
+{
+    m_min.x = NextFloatDown( m_min.x );
+    m_min.y = NextFloatDown( m_min.y );
+
+    m_max.x = NextFloatUp( m_max.x );
+    m_max.y = NextFloatUp( m_max.y );
+}
+
+
+void CBBOX2D::ScaleNextDown()
+{
+    m_min.x = NextFloatUp( m_min.x );
+    m_min.y = NextFloatUp( m_min.y );
+
+    m_max.x = NextFloatDown( m_max.x );
+    m_max.y = NextFloatDown( m_max.y );
+}
+
+
+// http://goanna.cs.rmit.edu.au/~gl/teaching/rtr&3dgp/notes/intersection.pdf
+// http://www.mrtc.mdh.se/projects/3Dgraphics/paperF.pdf
+bool CBBOX2D::Intersects( const SFVEC2F &aCenter, float aRadiusSquared ) const
+{
+    float fDistSq = 0.0f;
+
+    for ( unsigned int i = 0; i < 2; i++ )
+    {
+        if( aCenter[i] < m_min[i] )
+        {
+            float fDist = aCenter[i] - m_min[i];
+            fDistSq += fDist * fDist;
+        }
+        else
+        {
+            if( aCenter[i] > m_max[i] )
+            {
+                float fDist = aCenter[i] - m_max[i];
+                fDistSq += fDist * fDist;
+            }
+        }
+    }
+
+    return ( fDistSq <= aRadiusSquared );
+}
+
+
+bool CBBOX2D::Intersects( const CBBOX2D &aBBox ) const
+{
+    wxASSERT( IsInitialized() );
+    wxASSERT( aBBox.IsInitialized() );
+
+    bool x = ( m_max.x >= aBBox.m_min.x ) && ( m_min.x <= aBBox.m_max.x );
+    bool y = ( m_max.y >= aBBox.m_min.y ) && ( m_min.y <= aBBox.m_max.y );
+
+    return ( x && y );
+}
+
+
+bool CBBOX2D::Inside( const SFVEC2F &aPoint ) const
+{
+    wxASSERT( IsInitialized() );
+
+    return ( ( aPoint.x >= m_min.x ) && ( aPoint.x <= m_max.x ) &&
+             ( aPoint.y >= m_min.y ) && ( aPoint.y <= m_max.y ) );
+}
+
+
+float CBBOX2D::Area() const
+{
+    SFVEC2F extent = GetExtent();
+    return extent.x * extent.y;
+}
+
+
+// http://tavianator.com/fast-branchless-raybounding-box-intersections/
+bool CBBOX2D::Intersect( const RAY2D &aRay, float *t ) const
+{
+    wxASSERT( t );
+
+    float tx1 = (m_min.x - aRay.m_Origin.x) * aRay.m_InvDir.x;
+    float tx2 = (m_max.x - aRay.m_Origin.x) * aRay.m_InvDir.x;
+
+    float tmin = glm::min( tx1, tx2 );
+    float tmax = glm::max( tx1, tx2 );
+
+    float ty1 = (m_min.y - aRay.m_Origin.y) * aRay.m_InvDir.y;
+    float ty2 = (m_max.y - aRay.m_Origin.y) * aRay.m_InvDir.y;
+
+    tmin = glm::max( tmin, glm::min( ty1, ty2 ) );
+    tmax = glm::min( tmax, glm::max( ty1, ty2 ) );
+
+    if( tmin > 0.0f )
+        *t = tmin;
+    else
+        *t = tmax;
+
+    return (tmax >= 0.0f) && (tmax >= tmin);
+}
+
+
+bool CBBOX2D::Intersect( const RAYSEG2D &aRaySeg ) const
+{
+    float tx1 = (m_min.x - aRaySeg.m_Start.x) * aRaySeg.m_InvDir.x;
+    float tx2 = (m_max.x - aRaySeg.m_Start.x) * aRaySeg.m_InvDir.x;
+
+    float tmin = glm::min( tx1, tx2 );
+    float tmax = glm::max( tx1, tx2 );
+
+    float ty1 = (m_min.y - aRaySeg.m_Start.y) * aRaySeg.m_InvDir.y;
+    float ty2 = (m_max.y - aRaySeg.m_Start.y) * aRaySeg.m_InvDir.y;
+
+    tmin = glm::max( tmin, glm::min( ty1, ty2 ) );
+    tmax = glm::min( tmax, glm::max( ty1, ty2 ) );
+
+    if( (tmax >= 0.0f) && (tmax >= tmin) )
+    {
+        float t = (tmin > 0.0f)?tmin:tmax;
+        return ( t < aRaySeg.m_Length );
+    }
+
+    return false;
+}
+
+
+bool CBBOX2D::Intersect( const RAY2D &aRay, float *aOutHitT0, float *aOutHitT1 ) const
+{
+    wxASSERT( aOutHitT0 );
+    wxASSERT( aOutHitT1 );
+
+    float tx1 = (m_min.x - aRay.m_Origin.x) * aRay.m_InvDir.x;
+    float tx2 = (m_max.x - aRay.m_Origin.x) * aRay.m_InvDir.x;
+
+    float tmin = glm::min( tx1, tx2 );
+    float tmax = glm::max( tx1, tx2 );
+
+    float ty1 = (m_min.y - aRay.m_Origin.y) * aRay.m_InvDir.y;
+    float ty2 = (m_max.y - aRay.m_Origin.y) * aRay.m_InvDir.y;
+
+    tmin = glm::max( tmin, glm::min( ty1, ty2 ) );
+    tmax = glm::min( tmax, glm::max( ty1, ty2 ) );
+
+    *aOutHitT0 = (tmin > 0.0f)?tmin:0.0f;
+    *aOutHitT1 = tmax;
+
+    return (tmax >= 0.0f) && (tmax >= tmin);
+}
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.h
new file mode 100644
index 0000000000..4ad88c5ab8
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.h
@@ -0,0 +1,216 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+ /**
+ * @file cbbox2d.h
+ * @brief 2D Bounding Box class definition
+ */
+
+#ifndef _CBBOX2D_H_
+#define _CBBOX2D_H_
+
+#include "3d_xv3d/xv3d_types.h"
+#include "3d_rendering/3d_render_raytracing/ray.h"
+
+
+/**
+ * Class CBBOX
+ * manages a bounding box defined by two SFVEC2F min max points.
+ */
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) CBBOX2D
+{
+
+public:
+
+    /**
+     * Constructor CBBOX2D
+     * Create with default values a bounding box (not inizialized)
+     */
+    CBBOX2D();
+
+    /**
+     * Constructor CBBOX2D
+     * Initialize a bounding box with a given point
+     * @param aPbInit a point for the bounding box initialization
+     */
+    CBBOX2D( const SFVEC2F &aPbInit );
+
+    /**
+     * Constructor CBBOX2D
+     * Initialize a bounding box with a minimon and a maximun point
+     * @param aPbMin the minimun point to initialize the bounding box
+     * @param aPbMax the maximun point to initialize the bounding box
+     */
+    CBBOX2D( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax );
+
+    ~CBBOX2D();
+
+
+    /**
+     * Function Set
+     * Set bounding box with new parameters
+     * @param aPbMin the minimun point to initialize the bounding box
+     * @param aPbMax the maximun point to initialize the bounding box
+     */
+    void Set( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax );
+
+    /**
+     * Function Set
+     * Set bounding box based on another bounding box
+     * @param CBBOX2D a bounding box to initialize this one
+     */
+    void Set( const CBBOX2D &aBBox );
+
+    /**
+     * Function Union
+     * recalculate the bounding box adding a point
+     * @param aPoint the point to be bounded
+     */
+    void Union( const SFVEC2F &aPoint );
+
+    /**
+     * Function Union
+     * recalculate the bounding box adding other bounding box
+     * @param aBBox the bounding box to be bounded
+     */
+    void Union( const CBBOX2D &aBBox );
+
+    /**
+     * Function Scale
+     * scales a bounding box by its center
+     * @param aScale scale factor to apply
+     */
+    void Scale( float aScale );
+
+    /**
+     * Function ScaleNextUp
+     * scales a bounding box to the next float representation making it larger
+     */
+    void ScaleNextUp();
+
+    /**
+     * Function ScaleNextDown
+     * scales a bounding box to the next float representation making it smaller
+     */
+    void ScaleNextDown();
+
+    /**
+     * Function Intersects
+     * test if a bounding box intersects this box
+     * @param aBBox the bounding box to check if it inversects
+     */
+    bool Intersects( const CBBOX2D &aBBox ) const;
+
+    /**
+     * Function Intersects
+     * test if a circle intersects this box
+     * @param aBBox the bounding box to check if it intersects
+     */
+    bool Intersects( const SFVEC2F &aCenter, float aRadiusSquared ) const;
+
+    /**
+     * Function Inside
+     * check is a point is inside this bounding box
+     * @param aPoint point to test
+     */
+    bool Inside( const SFVEC2F &aPoint ) const;
+
+    /**
+     * Function Area
+     * calculate the area of a bounding box
+     * @return float - area of this bounding box
+     */
+    float Area() const;
+
+    /**
+     * Function IsInitialized
+     * check if this bounding box is already initialized
+     * @return bool - return true if it was initialized, false if otherwise
+     */
+    bool IsInitialized() const;
+
+    /**
+     * Function Reset
+     * reset the bounding box to zero and de-initialized it
+     */
+    void Reset();
+
+    /**
+     * Function GetCenter
+     * return the center point of the bounding box
+     * @return SFVEC2F - the position of the center of this bounding box
+     */
+    SFVEC2F GetCenter() const;
+
+    /**
+     * Function GetExtent
+     * @return SFVEC2F - max-min
+     */
+    SFVEC2F GetExtent() const;
+
+    /**
+     * Function Min
+     * return the minimun vertex pointer
+     * @return SFVEC2F - the minimun vertice position
+     */
+    const SFVEC2F &Min() const { return m_min; }
+
+    /**
+     * Function Max
+     * return the maximum vertex pointer
+     * @return SFVEC2F - the maximun vertice position
+     */
+    const SFVEC2F &Max() const { return m_max; }
+
+
+    /**
+     * Function MaxDimension
+     * @return the index of the max dimention (0=x, 1=y)
+     */
+    unsigned int MaxDimension() const;
+
+    /**
+     * Function Perimeter
+     * @return the surface are of the box
+     */
+    float Perimeter() const;
+
+    /**
+     * Function Intersect
+     * @param aRay = ray to intersect the box
+     * @param t = distance point of the ray of the intersection (if true)
+     * @return true if the ray hits the box
+     */
+    bool Intersect( const RAY2D &aRay, float *t ) const;
+
+    bool Intersect( const RAY2D &aRay, float *aOutHitT0, float *aOutHitT1 ) const;
+
+    bool Intersect( const RAYSEG2D &aRaySeg ) const;
+
+private:
+    SFVEC2F m_min;           ///< point of the lower position of the bounding box
+    SFVEC2F m_max;           ///< point of the higher position of the bounding box
+};
+
+#endif // CBBox2d_h
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h
new file mode 100644
index 0000000000..fc1d7ec020
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h
@@ -0,0 +1,59 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cfilledcircle2d.h
+ * @brief
+ */
+
+#ifndef _CFILLEDCIRCLE2D_H_
+#define _CFILLEDCIRCLE2D_H_
+
+#include "cobject2d.h"
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CFILLEDCIRCLE2D : public COBJECT2D
+{
+public:
+    float GetRadius() const { return m_radius; }
+    const SFVEC2F &GetCenter() const { return m_center; }
+    float GetRadiusSquared() const { return m_radius_squared; }
+
+private:
+    SFVEC2F m_center;
+    float   m_radius;
+    float   m_radius_squared;
+
+public:
+    CFILLEDCIRCLE2D( const SFVEC2F &aCenter, float aRadius, const BOARD_ITEM &aBoardItem );
+
+    // Imported from COBJECT2D
+    bool Overlaps( const CBBOX2D &aBBox ) const;
+    bool Intersects( const CBBOX2D &aBBox ) const;
+    bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+    INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+    bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+
+#endif // _CFILLEDCIRCLE2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.cpp b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.cpp
new file mode 100644
index 0000000000..b6418c8e1d
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.cpp
@@ -0,0 +1,68 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cobject2d.cpp
+ * @brief
+ */
+
+#include "cobject2d.h"
+#include <stdio.h>
+
+
+COBJECT2D_STATS *COBJECT2D_STATS::s_instance = 0;
+
+
+COBJECT2D::COBJECT2D( OBJECT2D_TYPE aObjType, const BOARD_ITEM &aBoardItem )
+    : m_boardItem(aBoardItem)
+{
+    m_obj_type = aObjType;
+    COBJECT2D_STATS::Instance().AddOne( aObjType );
+}
+
+
+static const char *OBJECT2D_STR[OBJ2D_MAX] =
+{
+    "OBJ2D_FILLED_CIRCLE",
+    "OBJ2D_CSG",
+    "OBJ2D_POLYGON",
+    "OBJ2D_DUMMYBLOCK",
+    "OBJ2D_POLYGON4PT",
+    "OBJ2D_RING",
+    "OBJ2D_ROUNDSEG",
+    "OBJ2D_TRIANGLE",
+    "OBJ2D_CONTAINER",
+    "OBJ2D_BVHCONTAINER"
+};
+
+
+void COBJECT2D_STATS::PrintStats()
+{
+    printf( "OBJ2D Statistics:\n" );
+
+    for( unsigned int i = 0; i < OBJ2D_MAX; ++i )
+    {
+        printf( "  %20s  %u\n", OBJECT2D_STR[i], m_counter[i] );
+    }
+}
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.h
new file mode 100644
index 0000000000..a129bd04ef
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.h
@@ -0,0 +1,160 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cobject2d.h
+ * @brief
+ */
+
+#ifndef _COBJECT2D_H_
+#define _COBJECT2D_H_
+
+#include "3d_xv3d/xv3d_types.h"
+#include "cbbox2d.h"
+#include <string.h>
+
+#include <class_board_item.h>
+
+enum INTERSECTION_RESULT
+{
+    INTR_MISSES,
+    INTR_INTERSECTS,
+    INTR_FULL_INSIDE
+};
+
+
+enum OBJECT2D_TYPE
+{
+    OBJ2D_FILLED_CIRCLE,
+    OBJ2D_CSG,
+    OBJ2D_POLYGON,
+    OBJ2D_DUMMYBLOCK,
+    OBJ2D_POLYGON4PT,
+    OBJ2D_RING,
+    OBJ2D_ROUNDSEG,
+    OBJ2D_TRIANGLE,
+    OBJ2D_CONTAINER,
+    OBJ2D_BVHCONTAINER,
+    OBJ2D_MAX
+};
+
+
+class GLM_ALIGN(CLASS_ALIGNMENT) COBJECT2D
+{
+protected:
+    CBBOX2D          m_bbox;
+    SFVEC2F          m_centroid;
+    OBJECT2D_TYPE    m_obj_type;
+
+    const BOARD_ITEM &m_boardItem;
+public:
+
+    COBJECT2D( OBJECT2D_TYPE aObjType, const BOARD_ITEM &aBoardItem );
+    virtual ~COBJECT2D() {}
+
+    const BOARD_ITEM &GetBoardItem() const { return m_boardItem; }
+
+    /** Function Overlaps
+     * @brief Test if the box overlaps the object
+     * Conformance
+     * The function overlaps implements function Overlaps from the OGC Simple Feature Specification.
+     * http://www.opengeospatial.org/standards/sfa
+     * a.Overlaps(b) ⇔ ( dim(I(a)) = dim(I(b)) = dim(I(a) ∩ I(b))) ∧ (a ∩ b ≠ a) ∧ (a ∩ b ≠ b)
+     * It means that the result dimension of an overlap is the same dimentions of the bounding box
+     * (so the overlap cannot be a point or a line) and one of the boxes cannot full contain the other
+     * box.
+     * @param aBBox - The bounding box to test
+     * @return true if the BBox intersects the object or is inside it
+     */
+    virtual bool Overlaps( const CBBOX2D &aBBox ) const = 0;
+
+    /** Function Intersects
+     * @brief Intersects - a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅)
+     * It intersects if the result intersection is not null
+     * @param aBBox
+     * @return
+     */
+    virtual bool Intersects( const CBBOX2D &aBBox ) const = 0;
+
+    /** Function Intersect
+     * @brief Intersect
+     * @param aSegRay
+     * @param aOutT a value between 0.0 and 1.0 in relation to the time of the hit of the segment
+     * @param aNormalOut
+     * @return
+     */
+    virtual bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const = 0;
+
+    /** Function IsBBoxInside
+     * @brief Tests if the bouding is out, intersects or is complety inside
+     * @param aBBox - The bounding box to test
+     * @return INTERSECTION_RESULT
+     */
+    virtual INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const = 0;
+
+    virtual bool IsPointInside( const SFVEC2F &aPoint ) const = 0;
+
+    const CBBOX2D &GetBBox() const { return m_bbox; }
+
+    const SFVEC2F &GetCentroid() const { return m_centroid; }
+
+    const OBJECT2D_TYPE GetObjectType() const { return m_obj_type; }
+};
+
+
+
+/// Implements a class for object statistics
+/// using Singleton pattern
+class COBJECT2D_STATS
+{
+public:
+    void ResetStats() { memset( m_counter, 0, sizeof(unsigned int) * OBJ2D_MAX ); }
+
+    unsigned int GetCountOf( OBJECT2D_TYPE aObjType ) const { return m_counter[aObjType]; }
+
+    void AddOne( OBJECT2D_TYPE aObjType ) { m_counter[aObjType]++; }
+
+    void PrintStats();
+
+    static COBJECT2D_STATS &Instance()
+    {
+        if( !s_instance )
+            s_instance = new COBJECT2D_STATS;
+
+        return *s_instance;
+    }
+
+private:
+    COBJECT2D_STATS(){ ResetStats(); }
+    COBJECT2D_STATS( const COBJECT2D_STATS &old );
+    const COBJECT2D_STATS &operator=( const COBJECT2D_STATS &old );
+    ~COBJECT2D_STATS(){}
+
+private:
+    unsigned int m_counter[OBJ2D_MAX];
+
+    static COBJECT2D_STATS *s_instance;
+};
+
+#endif // _COBJECT2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h
new file mode 100644
index 0000000000..e4a7d8cd3e
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h
@@ -0,0 +1,154 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cpolygon2d.h
+ * @brief
+ */
+
+#ifndef _CPOLYGON2D_H_
+#define _CPOLYGON2D_H_
+
+#include "cobject2d.h"
+#include "../accelerators/ccontainer2d.h"
+#include <geometry/shape_poly_set.h>
+#include <polygons_defs.h>
+#include <vector>
+
+
+typedef struct
+{
+    SFVEC2F m_Start;
+    float   m_inv_JY_minus_IY;
+    float   m_JX_minus_IX;
+}POLYSEGMENT;
+
+
+typedef struct
+{
+    SFVEC2F m_Start;
+    SFVEC2F m_End;
+}SEG_NORMALS;
+
+
+typedef struct
+{
+    SFVEC2F     m_Start;
+    SFVEC2F     m_Precalc_slope;
+    SEG_NORMALS m_Normals;
+}SEGMENT_WITH_NORMALS;
+
+
+typedef std::vector< POLYSEGMENT > SEGMENTS;
+
+
+/// This list will be used to test ray2d intersections. It will be a subset
+/// of an original polygon. The normals will be passed already interpolated.
+typedef std::vector< SEGMENT_WITH_NORMALS > SEGMENTS_WIDTH_NORMALS;
+
+
+/// This structured will be used to handle a sub set of a polygon.
+/// It can contain multiple closed polygons and holes.
+/// It will be used to test if points are inside. A point will be inside the
+/// polygon if it is not inside a hole and it is inside a Outer polygon.
+typedef struct
+{
+    std::vector<SEGMENTS> m_Outers;
+    std::vector<SEGMENTS> m_Holes;
+}OUTERS_AND_HOLES;
+
+
+/// This class represents a sub polygon block. This polygon block was created
+/// from a general polygon definition that was sub divided and create blocks of
+/// polygons. This polygon class represent a sub part of that main polygon.
+/// There is information for the contours (used to test the ray2d intersection)
+/// and a close definition of the block polygon to test if a point is inside.
+class GLM_ALIGN(CLASS_ALIGNMENT) CPOLYGONBLOCK2D : public COBJECT2D
+{
+private:
+    /// This is the outter part of the polygon. This list is used to test a ray
+    /// intersection with the boundaries of this sub polygon.
+    /// It contains also the interpolated normals that are passed from the main
+    /// polygon.
+    SEGMENTS_WIDTH_NORMALS m_open_segments;
+
+    /// A polygon block can have multiple polygon and holes
+    OUTERS_AND_HOLES m_outers_and_holes;
+
+public:
+    CPOLYGONBLOCK2D( const SEGMENTS_WIDTH_NORMALS &aOpenSegmentList,
+                     const OUTERS_AND_HOLES &aOuter_and_holes,
+                     const BOARD_ITEM &aBoardItem );
+
+    // Imported from COBJECT2D
+    bool Overlaps( const CBBOX2D &aBBox ) const;
+    bool Intersects( const CBBOX2D &aBBox ) const;
+    bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+    INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+    bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+
+/// This dummy block will be defined by a 2d box size. If the point is inside
+/// the bounding box it will return allways true. However, the intersection with
+/// a ray will return allways false.
+/// This is used as a sub block extrated from polygon (pcb polygon areas) and
+/// represents an area that is full filled.
+class GLM_ALIGN(CLASS_ALIGNMENT) CDUMMYBLOCK2D : public COBJECT2D
+{
+
+public:
+    CDUMMYBLOCK2D(const SFVEC2F &aPbMin, const SFVEC2F &aPbMax , const BOARD_ITEM &aBoardItem );
+    CDUMMYBLOCK2D( const CBBOX2D &aBBox, const BOARD_ITEM &aBoardItem );
+
+     // Imported from COBJECT2D
+     bool Overlaps( const CBBOX2D &aBBox ) const;
+     bool Intersects( const CBBOX2D &aBBox ) const;
+     bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+     INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+     bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+/**
+ * @brief Convert_path_polygon_to_polygon_blocks_and_dummy_blocks
+ * This function will use a polygon in the format of the ClipperLib::Path
+ * will process it and will create multiple 2d objects (CPOLYGONBLOCK2D and
+ * CDUMMYBLOCK2D) that can be used to represent this polygon area.
+ * @param aMainPath - the polygon are that was converted from the pcb board
+ * @param aDstContainer - the destination container to put the created sub blocks
+ * @param aBiuTo3DunitsScale - the rendering target 3d scale
+ * @param aDivFactor - a division factor (in 3Dunits) to divide the polygon plane, 0.0f will use the internal polygon segm statistics
+ */
+void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(const SHAPE_POLY_SET &aMainPath,
+        CGENERICCONTAINER2D &aDstContainer,
+        float aBiuTo3DunitsScale,
+        float aDivFactor,
+        const BOARD_ITEM &aBoardItem );
+
+void Polygon_Calc_BBox_3DU(const SHAPE_POLY_SET &aPolysList, CBBOX2D &aOutBBox , float aBiuTo3DunitsScale );
+void Polygon_Convert( const KI_POLYGON &aPolygon, ClipperLib::Path &aOutPath, CBBOX2D &aOutBBox, float aBiuTo3DunitsScale );
+
+void Polygon2d_TestModule();
+
+#endif // _CPOLYGON2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.h
new file mode 100644
index 0000000000..3ef3396101
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.h
@@ -0,0 +1,73 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cpolygon4pts2d.h
+ * @brief A simplified 4 point polygon
+ */
+
+#ifndef _CPOLYGON4PTS2D_H_
+#define _CPOLYGON4PTS2D_H_
+
+#include "cobject2d.h"
+
+/**
+ *  This handles simple polygons with 4 points. Used for pads.
+ *  (rectangles, trapezoids, with rotation.etc)
+ *  This is a simplified version of the cpolygon2d class
+ */
+class GLM_ALIGN(CLASS_ALIGNMENT) CPOLYGON4PTS2D : public COBJECT2D
+{
+private:
+    SFVEC2F m_segments[4];
+    SFVEC2F m_precalc_slope[4];
+    SFVEC2F m_seg_normal[4];
+
+public:
+    CPOLYGON4PTS2D( const SFVEC2F &v1,
+                    const SFVEC2F &v2,
+                    const SFVEC2F &v3,
+                    const SFVEC2F &v4,
+                    const BOARD_ITEM &aBoardItem );
+
+    const SFVEC2F &GetV0() const { return m_segments[0]; }
+    const SFVEC2F &GetV1() const { return m_segments[1]; }
+    const SFVEC2F &GetV2() const { return m_segments[2]; }
+    const SFVEC2F &GetV3() const { return m_segments[3]; }
+
+    const SFVEC2F &GetN0() const { return m_seg_normal[0]; }
+    const SFVEC2F &GetN1() const { return m_seg_normal[1]; }
+    const SFVEC2F &GetN2() const { return m_seg_normal[2]; }
+    const SFVEC2F &GetN3() const { return m_seg_normal[3]; }
+
+    // Imported from COBJECT2D
+    bool Overlaps( const CBBOX2D &aBBox ) const;
+    bool Intersects( const CBBOX2D &aBBox ) const;
+    bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+    INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+    bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+
+#endif // _CPOLYGON4PTS2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cring2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cring2d.h
new file mode 100644
index 0000000000..7a414b597a
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cring2d.h
@@ -0,0 +1,65 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cring2d.h
+ * @brief
+ */
+
+#ifndef _CRING2D_H_
+#define _CRING2D_H_
+
+#include "cobject2d.h"
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CRING2D : public COBJECT2D
+{
+public:
+    const SFVEC2F &GetCenter() const { return m_center; }
+    float GetInnerRadius() const { return m_inner_radius; }
+    float GetOuterRadius() const { return m_outer_radius; }
+
+    float GetInnerRadiusSquared() const { return m_inner_radius_squared; }
+    float GetOuterRadiusSquared() const { return m_outer_radius_squared; }
+
+private:
+    SFVEC2F m_center;
+    float   m_inner_radius;
+    float   m_outer_radius;
+    float   m_inner_radius_squared;
+    float   m_outer_radius_squared;
+
+public:
+    CRING2D( const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius,
+             const BOARD_ITEM &aBoardItem );
+
+    // Imported from COBJECT2D
+    bool Overlaps( const CBBOX2D &aBBox ) const;
+    bool Intersects( const CBBOX2D &aBBox ) const;
+    bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+    INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+    bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+
+#endif // _CRING2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.cpp b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.cpp
new file mode 100644
index 0000000000..c78a746f05
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.cpp
@@ -0,0 +1,309 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  croundsegment2d.cpp
+ * @brief
+ */
+
+#include "croundsegment2d.h"
+#include <wx/debug.h>
+
+
+CROUNDSEGMENT2D::CROUNDSEGMENT2D( const SFVEC2F &aStart, const SFVEC2F &aEnd, float aWidth,
+                                  const BOARD_ITEM &aBoardItem ) :
+    COBJECT2D( OBJ2D_ROUNDSEG, aBoardItem ),
+    m_segment( aStart, aEnd )
+{
+    m_radius = (aWidth / 2.0f);
+    m_radius_squared = m_radius * m_radius;
+    m_width = aWidth;
+
+    SFVEC2F leftRadiusOffset( -m_segment.m_Dir.y * m_radius, m_segment.m_Dir.x * m_radius);
+    m_leftStart = aStart + leftRadiusOffset;
+    m_leftEnd   = aEnd   + leftRadiusOffset;
+    m_leftEnd_minus_start = m_leftEnd - m_leftStart;
+    m_leftDir   = glm::normalize( m_leftEnd_minus_start );
+
+    SFVEC2F rightRadiusOffset( -leftRadiusOffset.x, -leftRadiusOffset.y );
+    m_rightStart = aEnd   + rightRadiusOffset;
+    m_rightEnd   = aStart + rightRadiusOffset;
+    m_rightEnd_minus_start = m_rightEnd - m_rightStart;
+    m_rightDir   = glm::normalize( m_rightEnd_minus_start );
+
+    m_bbox.Reset();
+    m_bbox.Set( aStart, aEnd );
+    m_bbox.Set( m_bbox.Min() - SFVEC2F( m_radius, m_radius ), m_bbox.Max() + SFVEC2F( m_radius, m_radius ) );
+    m_bbox.ScaleNextUp();
+    m_centroid = m_bbox.GetCenter();
+
+    wxASSERT( m_bbox.IsInitialized() );
+}
+
+
+bool CROUNDSEGMENT2D::Intersects( const CBBOX2D &aBBox ) const
+{
+    if( !m_bbox.Intersects( aBBox ) )
+        return false;
+
+    if( (aBBox.Max().x > m_bbox.Max().x) &&
+        (aBBox.Max().y > m_bbox.Max().x) &&
+        (aBBox.Min().x < m_bbox.Min().x) &&
+        (aBBox.Min().y < m_bbox.Min().y)
+        )
+        return true;
+
+    SFVEC2F v[4];
+
+    v[0] = aBBox.Min();
+    v[1] = SFVEC2F( aBBox.Min().x, aBBox.Max().y );
+    v[2] = aBBox.Max();
+    v[3] = SFVEC2F( aBBox.Max().x, aBBox.Min().y );
+
+    // Test against the main rectangle segment
+    if( IntersectSegment( m_leftStart, m_leftEnd_minus_start, v[0], v[1] - v[0] ) ) return true;
+    if( IntersectSegment( m_leftStart, m_leftEnd_minus_start, v[1], v[2] - v[1] ) ) return true;
+    if( IntersectSegment( m_leftStart, m_leftEnd_minus_start, v[2], v[3] - v[2] ) ) return true;
+    if( IntersectSegment( m_leftStart, m_leftEnd_minus_start, v[3], v[0] - v[3] ) ) return true;
+
+    if( IntersectSegment( m_rightStart, m_rightEnd_minus_start, v[0], v[1] - v[0] ) ) return true;
+    if( IntersectSegment( m_rightStart, m_rightEnd_minus_start, v[1], v[2] - v[1] ) ) return true;
+    if( IntersectSegment( m_rightStart, m_rightEnd_minus_start, v[2], v[3] - v[2] ) ) return true;
+    if( IntersectSegment( m_rightStart, m_rightEnd_minus_start, v[3], v[0] - v[3] ) ) return true;
+
+    // Test the two circles
+    if( aBBox.Intersects( m_segment.m_Start, m_radius_squared ) ) return true;
+    if( aBBox.Intersects( m_segment.m_End,   m_radius_squared ) ) return true;
+
+    return false;
+}
+
+
+bool CROUNDSEGMENT2D::Overlaps( const CBBOX2D &aBBox ) const
+{
+    // NOT IMPLEMENTED
+    return false;
+}
+
+
+bool CROUNDSEGMENT2D::Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const
+{
+    wxASSERT( aOutT );
+    wxASSERT( aNormalOut );
+
+    bool start_is_inside = IsPointInside( aSegRay.m_Start );
+    bool end_is_inside = IsPointInside( aSegRay.m_End );
+
+    // If segment if inside there are no hits
+    if( start_is_inside && end_is_inside )
+        return false;
+
+    bool hitted = false;
+
+    float closerHitT = FLT_MAX;
+    float farHitT = FLT_MAX;
+
+    SFVEC2F closerHitNormal;
+    SFVEC2F farHitNormal;
+
+    float leftSegT;
+    bool leftSegmentHit = aSegRay.IntersectSegment( m_leftStart, m_leftEnd_minus_start, &leftSegT );
+
+    if( leftSegmentHit )
+    {
+        hitted = true;
+        closerHitT = leftSegT;
+        farHitT    = leftSegT;
+
+        closerHitNormal = SFVEC2F( -m_leftDir.y,  m_leftDir.x );
+        farHitNormal    = SFVEC2F( -m_leftDir.y,  m_leftDir.x );
+    }
+
+    float rightSegT;
+    bool rightSegmentHit = aSegRay.IntersectSegment( m_rightStart, m_rightEnd_minus_start, &rightSegT );
+
+    if( rightSegmentHit )
+    {
+        if( !start_is_inside )
+        if( (hitted == false) || (rightSegT < closerHitT) )
+        {
+            closerHitT = rightSegT;
+            closerHitNormal = SFVEC2F( -m_rightDir.y,  m_rightDir.x );
+        }
+
+        if( start_is_inside )
+        if( (hitted == false) || (rightSegT > farHitT) )
+        {
+            farHitT = rightSegT;
+            farHitNormal = SFVEC2F( -m_rightDir.y,  m_rightDir.x );
+        }
+
+        hitted = true;
+    }
+
+    float   circleStart_T0;
+    float   circleStart_T1;
+    SFVEC2F circleStart_N0;
+    SFVEC2F circleStart_N1;
+
+    bool startCircleHit = aSegRay.IntersectCircle( m_segment.m_Start, m_radius,
+                                                   &circleStart_T0, &circleStart_T1,
+                                                   &circleStart_N0, &circleStart_N1 );
+
+    if( startCircleHit )
+    {
+        if( circleStart_T0 > 0.0f )
+        {
+            if( !start_is_inside )
+            if( (hitted == false) || (circleStart_T0 < closerHitT) )
+            {
+                closerHitT = circleStart_T0;
+                closerHitNormal = circleStart_N0;
+            }
+
+            if( start_is_inside )
+            if( (hitted == false) || (circleStart_T1 > farHitT) )
+            {
+                farHitT = circleStart_T1;
+                farHitNormal = circleStart_N1;
+            }
+        }
+        else
+        {
+            // This can only happen if the ray starts inside
+            if( (hitted == false) || (circleStart_T1 > farHitT) )
+            {
+                farHitT = circleStart_T1;
+                farHitNormal = circleStart_N1;
+            }
+        }
+
+        hitted = true;
+    }
+
+    float   circleEnd_T0;
+    float   circleEnd_T1;
+    SFVEC2F circleEnd_N0;
+    SFVEC2F circleEnd_N1;
+
+    bool rightCircleHit = aSegRay.IntersectCircle( m_segment.m_End, m_radius,
+                                                   &circleEnd_T0, &circleEnd_T1,
+                                                   &circleEnd_N0, &circleEnd_N1 );
+    if( rightCircleHit )
+    {
+        if( circleEnd_T0 > 0.0f )
+        {
+            if( !start_is_inside )
+            if( (hitted == false) || (circleEnd_T0 < closerHitT) )
+            {
+                closerHitT = circleEnd_T0;
+                closerHitNormal = circleEnd_N0;
+            }
+
+            if( start_is_inside )
+            if( (hitted == false) || (circleEnd_T1 > farHitT) )
+            {
+                farHitT = circleEnd_T1;
+                farHitNormal = circleEnd_N1;
+            }
+        }
+        else
+        {
+            // This can only happen if the ray starts inside
+            if( (hitted == false) || (circleEnd_T1 > farHitT) )
+            {
+                farHitT = circleEnd_T1;
+                farHitNormal = circleEnd_N1;
+            }
+        }
+
+        hitted = true;
+    }
+
+    if( hitted )
+    {
+        if( !start_is_inside )
+        {
+            *aOutT = closerHitT;
+            //wxASSERT( (closerHitT > 0.0f) && (closerHitT <= 1.0f) );
+            *aNormalOut = closerHitNormal;
+        }
+        else
+        {
+            wxASSERT( (farHitT > 0.0f) && (farHitT <= 1.0f) );
+            *aOutT = farHitT;
+            *aNormalOut = farHitNormal;
+        }
+    }
+
+    return hitted;
+}
+
+
+INTERSECTION_RESULT CROUNDSEGMENT2D::IsBBoxInside( const CBBOX2D &aBBox ) const
+{
+    if( !m_bbox.Intersects( aBBox ) )
+        return INTR_MISSES;
+
+    SFVEC2F v[4];
+
+    v[0] = aBBox.Min();
+    v[1] = aBBox.Max();
+    v[2] = SFVEC2F( aBBox.Min().x, aBBox.Max().y );
+    v[3] = SFVEC2F( aBBox.Max().x, aBBox.Min().y );
+
+    bool isInside[4];
+
+    isInside[0] = IsPointInside( v[0] );
+    isInside[1] = IsPointInside( v[1] );
+    isInside[2] = IsPointInside( v[2] );
+    isInside[3] = IsPointInside( v[3] );
+
+    // Check if all points are inside the circle
+    if( isInside[0] &&
+        isInside[1] &&
+        isInside[2] &&
+        isInside[3] )
+        return INTR_FULL_INSIDE;
+
+    // Check if any point is inside the circle
+    if( isInside[0] ||
+        isInside[1] ||
+        isInside[2] ||
+        isInside[3] )
+        return INTR_INTERSECTS;
+
+    return INTR_MISSES;
+}
+
+
+bool CROUNDSEGMENT2D::IsPointInside( const SFVEC2F &aPoint ) const
+{
+    float dSquared = m_segment.DistanceToPointSquared( aPoint );
+
+    if( dSquared <= m_radius_squared )
+        return true;
+
+    return false;
+}
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h
new file mode 100644
index 0000000000..7431b00cbc
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h
@@ -0,0 +1,89 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  croundsegment2d.h
+ * @brief
+ */
+
+#ifndef _CROUNDSEGMENT2D_H_
+#define _CROUNDSEGMENT2D_H_
+
+#include "cobject2d.h"
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CROUNDSEGMENT2D : public COBJECT2D
+{
+
+friend class CROUNDSEG;
+
+private:
+    RAYSEG2D m_segment;
+
+    SFVEC2F  m_leftStart;
+    SFVEC2F  m_leftEnd;
+    SFVEC2F  m_leftEnd_minus_start;
+    SFVEC2F  m_leftDir;
+
+    SFVEC2F  m_rightStart;
+    SFVEC2F  m_rightEnd;
+    SFVEC2F  m_rightEnd_minus_start;
+    SFVEC2F  m_rightDir;
+
+    float    m_radius;
+    float    m_radius_squared;
+    float    m_width;
+
+public:
+    CROUNDSEGMENT2D( const SFVEC2F &aStart, const SFVEC2F &aEnd, float aWidth,
+                     const BOARD_ITEM &aBoardItem );
+
+    float GetRadius() const { return m_radius; }
+    float GetRadiusSquared() const { return m_radius_squared; }
+    float GetWidth()  const { return m_width; }
+    float GetLenght() const { return m_segment.m_Length; }
+
+    const SFVEC2F &GetStart() const { return m_segment.m_Start; }
+    const SFVEC2F &GetEnd() const { return m_segment.m_End; }
+    const SFVEC2F &GetEnd_minus_Start() const { return m_segment.m_End_minus_start; }
+
+    const SFVEC2F &GetLeftStar() const { return m_leftStart; }
+    const SFVEC2F &GetLeftEnd()  const { return m_leftEnd; }
+    const SFVEC2F &GetLeftEnd_minus_Start() const { return m_leftEnd_minus_start; }
+    const SFVEC2F &GetLeftDir()  const { return m_leftDir; }
+
+    const SFVEC2F &GetRightStar() const { return m_rightStart; }
+    const SFVEC2F &GetRightEnd()  const { return m_rightEnd; }
+    const SFVEC2F &GetRightEnd_minus_Start() const { return m_rightEnd_minus_start; }
+    const SFVEC2F &GetRightDir()  const { return m_rightDir; }
+
+    // Imported from COBJECT2D
+    bool Overlaps( const CBBOX2D &aBBox ) const;
+    bool Intersects( const CBBOX2D &aBBox ) const;
+    bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+    INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+    bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+
+#endif // _CROUNDSEGMENT2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.h
new file mode 100644
index 0000000000..34769fc020
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.h
@@ -0,0 +1,75 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ctriangle2d.h
+ * @brief
+ */
+
+#ifndef _CTRIANGLE2D_H_
+#define _CTRIANGLE2D_H_
+
+#include "cobject2d.h"
+#include "../accelerators/ccontainer2d.h"
+#include <geometry/shape_line_chain.h>
+#include <geometry/shape_poly_set.h>
+#include <clipper.hpp>
+
+class GLM_ALIGN(CLASS_ALIGNMENT) CTRIANGLE2D : public COBJECT2D
+{
+private:
+    SFVEC2F p1;
+    SFVEC2F p2;
+    SFVEC2F p3;
+
+    float m_inv_denominator;
+    float m_p2y_minus_p3y;
+    float m_p3x_minus_p2x;
+    float m_p3y_minus_p1y;
+    float m_p1x_minus_p3x;
+
+public:
+    CTRIANGLE2D ( const SFVEC2F &aV1,
+                  const SFVEC2F &aV2,
+                  const SFVEC2F &aV3,
+                  const BOARD_ITEM &aBoardItem );
+
+    const SFVEC2F &GetP1() const { return p1; }
+    const SFVEC2F &GetP2() const { return p2; }
+    const SFVEC2F &GetP3() const { return p3; }
+
+    // Imported from COBJECT2D
+    bool Overlaps( const CBBOX2D &aBBox ) const;
+    bool Intersects( const CBBOX2D &aBBox ) const;
+    bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const;
+    INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const;
+    bool IsPointInside( const SFVEC2F &aPoint ) const;
+};
+
+
+void Convert_shape_line_polygon_to_triangles(  const SHAPE_POLY_SET &aPolyList,
+                                               CGENERICCONTAINER2D &aDstContainer,
+                                               float aBiuTo3DunitsScale,
+                                               const BOARD_ITEM &aBoardItem );
+#endif // _CTRIANGLE2D_H_
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.cpp b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.cpp
new file mode 100644
index 0000000000..f771e95c94
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.cpp
@@ -0,0 +1,373 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+ /**
+ * @file cbbox.cpp
+ * @brief Bounding Box class implementation
+ */
+#include "3d_math/3d_fastmath.h"
+
+#include "cbbox.h"
+#include <stdio.h>
+#include <wx/debug.h>                                                           // For the wxASSERT
+
+
+CBBOX::CBBOX()
+{
+    Reset();
+}
+
+
+CBBOX::CBBOX( const SFVEC3F &aPbInit )
+{
+    m_min = aPbInit;
+    m_max = aPbInit;
+}
+
+
+CBBOX::CBBOX( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax )
+{
+    Set( aPbMin, aPbMax );
+}
+
+
+CBBOX::~CBBOX()
+{
+}
+
+
+void CBBOX::Set( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax )
+{
+    m_min.x =  fminf( aPbMin.x, aPbMax.x );
+    m_min.y =  fminf( aPbMin.y, aPbMax.y );
+    m_min.z =  fminf( aPbMin.z, aPbMax.z );
+
+    m_max.x =  fmaxf( aPbMin.x, aPbMax.x );
+    m_max.y =  fmaxf( aPbMin.y, aPbMax.y );
+    m_max.z =  fmaxf( aPbMin.z, aPbMax.z );
+}
+
+
+void CBBOX::Set( const CBBOX &aBBox )
+{
+    wxASSERT( aBBox.IsInitialized() );
+
+    Set( aBBox.Min(), aBBox.Max() );
+}
+
+
+bool CBBOX::IsInitialized() const
+{
+    return !( ( FLT_MAX == m_min.x) ||
+              ( FLT_MAX == m_min.y) ||
+              ( FLT_MAX == m_min.z) ||
+              (-FLT_MAX == m_max.x) ||
+              (-FLT_MAX == m_max.y) ||
+              (-FLT_MAX == m_max.z) );
+}
+
+
+void CBBOX::Reset()
+{
+    m_min = SFVEC3F( FLT_MAX, FLT_MAX, FLT_MAX );
+    m_max = SFVEC3F(-FLT_MAX,-FLT_MAX,-FLT_MAX );
+}
+
+
+void CBBOX::Union( const SFVEC3F &aPoint )
+{
+    // get the minimun value between the added point and the existent bounding box
+    m_min.x =  fminf( m_min.x, aPoint.x );
+    m_min.y =  fminf( m_min.y, aPoint.y );
+    m_min.z =  fminf( m_min.z, aPoint.z );
+
+    // get the maximun value between the added point and the existent bounding box
+    m_max.x =  fmaxf( m_max.x, aPoint.x );
+    m_max.y =  fmaxf( m_max.y, aPoint.y );
+    m_max.z =  fmaxf( m_max.z, aPoint.z );
+}
+
+
+void CBBOX::Union( const CBBOX &aBBox )
+{
+    wxASSERT( aBBox.IsInitialized() );
+
+    // get the minimun value between the added bounding box and the existent bounding box
+    m_min.x =  fmin( m_min.x, aBBox.m_min.x );
+    m_min.y =  fmin( m_min.y, aBBox.m_min.y );
+    m_min.z =  fmin( m_min.z, aBBox.m_min.z );
+
+    // get the maximun value between the added bounding box and the existent bounding box
+    m_max.x =  fmax( m_max.x, aBBox.m_max.x );
+    m_max.y =  fmax( m_max.y, aBBox.m_max.y );
+    m_max.z =  fmax( m_max.z, aBBox.m_max.z );
+}
+
+
+SFVEC3F CBBOX::GetCenter() const
+{
+    return (m_max + m_min) * 0.5f;
+}
+
+
+float CBBOX::GetCenter( unsigned int aAxis ) const
+{
+    wxASSERT( aAxis < 3 );
+    return (m_max[aAxis] + m_min[aAxis]) * 0.5f;
+}
+
+
+const SFVEC3F CBBOX::GetExtent() const
+{
+    return m_max - m_min;
+}
+
+
+unsigned int CBBOX::MaxDimension() const
+{
+    unsigned int result = 0;
+
+    SFVEC3F extent = GetExtent();
+
+    if( extent.y > extent.x ) result = 1;
+    if( extent.z > extent.y ) result = 2;
+
+    return result;
+}
+
+
+float CBBOX::GetMaxDimension() const
+{
+    unsigned int max_dimensions_idx = 0;
+
+    SFVEC3F extent = GetExtent();
+
+    if( extent.y > extent.x ) max_dimensions_idx = 1;
+    if( extent.z > extent.y ) max_dimensions_idx = 2;
+
+    return extent[max_dimensions_idx];
+}
+
+
+float CBBOX::SurfaceArea() const
+{
+    SFVEC3F extent = GetExtent();
+
+    return 2.0f * ( extent.x * extent.z +
+                    extent.x * extent.y +
+                    extent.y * extent.z );
+}
+
+
+void CBBOX::Scale( float aScale )
+{
+    wxASSERT( IsInitialized() );
+
+    SFVEC3F scaleV  = SFVEC3F( aScale, aScale, aScale );
+    SFVEC3F centerV = GetCenter();
+
+    m_min = (m_min - centerV) * scaleV + centerV;
+    m_max = (m_max - centerV) * scaleV + centerV;
+}
+
+
+void CBBOX::ScaleNextUp()
+{
+    m_min.x = NextFloatDown( m_min.x );
+    m_min.y = NextFloatDown( m_min.y );
+    m_min.z = NextFloatDown( m_min.z );
+
+    m_max.x = NextFloatUp( m_max.x );
+    m_max.y = NextFloatUp( m_max.y );
+    m_max.z = NextFloatUp( m_max.z );
+}
+
+
+void CBBOX::ScaleNextDown()
+{
+    m_min.x = NextFloatUp( m_min.x );
+    m_min.y = NextFloatUp( m_min.y );
+    m_min.z = NextFloatUp( m_min.z );
+
+    m_max.x = NextFloatDown( m_max.x );
+    m_max.y = NextFloatDown( m_max.y );
+    m_max.z = NextFloatDown( m_max.z );
+}
+
+
+bool CBBOX::Intersects( const CBBOX &aBBox ) const
+{
+    wxASSERT( IsInitialized() );
+    wxASSERT( aBBox.IsInitialized() );
+
+    bool x = ( m_max.x >= aBBox.m_min.x ) && ( m_min.x <= aBBox.m_max.x );
+    bool y = ( m_max.y >= aBBox.m_min.y ) && ( m_min.y <= aBBox.m_max.y );
+    bool z = ( m_max.z >= aBBox.m_min.z ) && ( m_min.z <= aBBox.m_max.z );
+
+    return ( x && y && z );
+}
+
+
+bool CBBOX::Inside( const SFVEC3F &aPoint ) const
+{
+    wxASSERT( IsInitialized() );
+
+    return (( aPoint.x >= m_min.x ) && ( aPoint.x <= m_max.x ) &&
+            ( aPoint.y >= m_min.y ) && ( aPoint.y <= m_max.y ) &&
+            ( aPoint.z >= m_min.z ) && ( aPoint.z <= m_max.z ));
+}
+
+
+float CBBOX::Volume() const
+{
+    wxASSERT( IsInitialized() );
+
+    SFVEC3F extent = GetExtent();
+
+    return extent.x * extent.y * extent.z;
+}
+
+
+SFVEC3F CBBOX::Offset( const SFVEC3F &p ) const
+{
+    return (p - m_min) / (m_max - m_min);
+}
+
+
+// Intersection code based on the book:
+// "Physical Based Ray Tracing" (by Matt Pharr and Greg Humphrey)
+// https://github.com/mmp/pbrt-v2/blob/master/src/core/geometry.cpp#L68
+// /////////////////////////////////////////////////////////////////////////
+#if 0
+bool CBBOX::Intersect( const RAY &aRay, float *aOutHitt0, float *aOutHitt1 )
+{
+    float t0 = 0.0f;
+    float t1 = FLT_MAX;
+
+    for( unsigned int i = 0; i < 3; ++i )
+    {
+        // Update interval for _i_th bounding box slab
+        float tNear = (m_min[i] - aRay.m_Origin[i]) * aRay.m_InvDir[i];
+        float tFar  = (m_max[i] - aRay.m_Origin[i]) * aRay.m_InvDir[i];
+
+        // Update parametric interval from slab intersection
+        if( tNear > tFar )
+        {
+            // Swap
+            float ftemp = tNear;
+            tNear = tFar;
+            tFar = ftemp;
+        }
+
+        t0 = tNear > t0 ? tNear : t0;
+        t1 = tFar  < t1 ? tFar  : t1;
+
+        if( t0 > t1 )
+            return false;
+    }
+
+    if( aOutHitt0 ) *aOutHitt0 = t0;
+    if( aOutHitt1 ) *aOutHitt1 = t1;
+
+    return true;
+}
+#else
+// https://github.com/mmp/pbrt-v2/blob/master/src/accelerators/bvh.cpp#L126
+bool CBBOX::Intersect( const RAY &aRay, float *aOutHitt0, float *aOutHitt1 ) const
+{
+    wxASSERT( aOutHitt0 );
+    wxASSERT( aOutHitt1 );
+
+    const SFVEC3F bounds[2] = {m_min, m_max};
+
+    // Check for ray intersection against x and y slabs
+    float tmin =  (bounds[    aRay.m_dirIsNeg[0]].x - aRay.m_Origin.x) * aRay.m_InvDir.x;
+    float tmax =  (bounds[1 - aRay.m_dirIsNeg[0]].x - aRay.m_Origin.x) * aRay.m_InvDir.x;
+    float tymin = (bounds[    aRay.m_dirIsNeg[1]].y - aRay.m_Origin.y) * aRay.m_InvDir.y;
+    float tymax = (bounds[1 - aRay.m_dirIsNeg[1]].y - aRay.m_Origin.y) * aRay.m_InvDir.y;
+
+    if( (tmin > tymax) || (tymin > tmax) )
+        return false;
+
+    tmin = (tymin > tmin)? tymin : tmin;
+    tmax = (tymax < tmax)? tymax : tmax;
+
+    // Check for ray intersection against z slab
+    float tzmin = (bounds[    aRay.m_dirIsNeg[2]].z - aRay.m_Origin.z) * aRay.m_InvDir.z;
+    float tzmax = (bounds[1 - aRay.m_dirIsNeg[2]].z - aRay.m_Origin.z) * aRay.m_InvDir.z;
+
+    if( (tmin > tzmax) || (tzmin > tmax) )
+        return false;
+
+    tmin = (tzmin > tmin)? tzmin : tmin;
+    tmin = ( tmin < 0.0f)? 0.0f  : tmin;
+
+    tmax = (tzmax < tmax)? tzmax : tmax;
+
+    *aOutHitt0 = tmin;
+    *aOutHitt1 = tmax;
+
+    return true;
+}
+#endif
+
+
+void CBBOX::ApplyTransformation( glm::mat4 aTransformMatrix )
+{
+    wxASSERT( IsInitialized() );
+
+    SFVEC3F v1 = SFVEC3F( aTransformMatrix * glm::vec4( m_min.x, m_min.y, m_min.z, 1.0f ) );
+    SFVEC3F v2 = SFVEC3F( aTransformMatrix * glm::vec4( m_max.x, m_max.y, m_max.z, 1.0f ) );
+
+    Reset();
+    Union( v1 );
+    Union( v2 );
+}
+
+
+void CBBOX::ApplyTransformationAA( glm::mat4 aTransformMatrix )
+{
+    wxASSERT( IsInitialized() );
+
+    // apply the transformation matrix for each of vertices of the bounding box
+    // and make a union with all vertices
+    CBBOX tmpBBox = CBBOX(  SFVEC3F( aTransformMatrix * glm::vec4( m_min.x, m_min.y, m_min.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_max.x, m_min.y, m_min.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_min.x, m_max.y, m_min.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_min.x, m_min.y, m_max.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_min.x, m_max.y, m_max.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_max.x, m_max.y, m_min.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_max.x, m_min.y, m_max.z, 1.0f ) ) );
+    tmpBBox.Union(          SFVEC3F( aTransformMatrix * glm::vec4( m_max.x, m_max.y, m_max.z, 1.0f ) ) );
+
+    m_min = tmpBBox.m_min;
+    m_max = tmpBBox.m_max;
+}
+
+
+void CBBOX::debug() const
+{
+    printf( "min(%f, %f, %f) - max(%f, %f, %f)\n", m_min.x, m_min.y, m_min.z,
+                                                   m_max.x, m_max.y, m_max.z );
+}
diff --git a/3d-viewer/CBBox.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.h
similarity index 54%
rename from 3d-viewer/CBBox.h
rename to 3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.h
index f883cb6ba0..ccd2840185 100644
--- a/3d-viewer/CBBox.h
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.h
@@ -23,23 +23,22 @@
  */
 
  /**
- * @file CBBox.h
+ * @file cbbox.h
  * @brief Bounding Box class definition
  */
 
-#ifndef CBBox_h
-#define CBBox_h
-
-#define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/glm.hpp>
-#include <3d_types.h>
+#ifndef _CBBOX_H_
+#define _CBBOX_H_
 
+#include "3d_xv3d/xv3d_types.h"
+#include "3d_rendering/3d_render_raytracing/ray.h"
+#include <fctsys.h>                                                             // For the DBG(
 
 /**
  * Class CBBOX
- * manages a bounding box defined by two S3D_VERTEX points.
+ * manages a bounding box defined by two SFVEC3F min max points.
  */
-class CBBOX
+GLM_ALIGNED_STRUCT(CLASS_ALIGNMENT) CBBOX
 {
 
 public:
@@ -55,7 +54,7 @@ public:
      * Initialize a bounding box with a given point
      * @param aPbInit a point for the bounding box initialization
      */
-    CBBOX( const S3D_VERTEX &aPbInit );
+    CBBOX( const SFVEC3F &aPbInit );
 
     /**
      * Constructor CBBOX
@@ -63,7 +62,7 @@ public:
      * @param aPbMin the minimun point to initialize the bounding box
      * @param aPbMax the maximun point to initialize the bounding box
      */
-    CBBOX( const S3D_VERTEX &aPbMin, const S3D_VERTEX &aPbMax );
+    CBBOX( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax );
 
     ~CBBOX();
 
@@ -74,14 +73,16 @@ public:
      * @param aPbMin the minimun point to initialize the bounding box
      * @param aPbMax the maximun point to initialize the bounding box
      */
-    void Set( const S3D_VERTEX &aPbMin, const S3D_VERTEX &aPbMax );
+    void Set( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax );
+
+    void Set( const CBBOX &aBBox );
 
     /**
      * Function Union
      * recalculate the bounding box adding a point
      * @param aPoint the point to be bounded
      */
-    void Union( const S3D_VERTEX &aPoint );
+    void Union( const SFVEC3F &aPoint );
 
     /**
      * Function Union
@@ -98,18 +99,30 @@ public:
     void Scale( float aScale );
 
     /**
-     * Function OverlapsBox
-     * test if a bounding box overlaps this box
-     * @param aBBox the bounding box to check if it overlaps
+     * Function ScaleNextUp
+     * scales a bounding box to the next float representation making it larger
      */
-    bool OverlapsBox( const CBBOX &aBBox ) const;
+    void ScaleNextUp();
+
+    /**
+     * Function ScaleNextDown
+     * scales a bounding box to the next float representation making it smaller
+     */
+    void ScaleNextDown();
+
+    /**
+     * Function Intersects
+     * test if a bounding box intersects this box
+     * @param aBBox the bounding box to check if it intersects
+     */
+    bool Intersects( const CBBOX &aBBox ) const;
 
     /**
      * Function Inside
      * check is a point is inside this bounding box
      * @param aPoint point to test
      */
-    bool Inside( const S3D_VERTEX &aPoint ) const;
+    bool Inside( const SFVEC3F &aPoint ) const;
 
     /**
      * Function ApplyTransformation
@@ -134,10 +147,10 @@ public:
     float Volume() const;
 
     /**
-     * Function GLdebug
-     * render a wired bounding box using openGL
+     * Function debug
+     * output to stdout
      */
-    void GLdebug() const;
+    void debug() const;
 
     /**
      * Function IsInitialized
@@ -155,28 +168,86 @@ public:
     /**
      * Function GetCenter
      * return the center point of the bounding box
-     * @return S3D_VERTEX - the position of the center of this bounding box
+     * @return SFVEC3F - the position of the center of this bounding box
      */
-    S3D_VERTEX GetCenter() const;
+    SFVEC3F GetCenter() const;
+
+    /**
+     * Function GetCenter
+     * return the center point of the bounding box for one Axis (0, 1 or 2)
+     * @return float - the position of the center of this bounding box for the axis
+     */
+    float GetCenter( unsigned int aAxis ) const;
+
+    /** Function Offset
+     *
+     * @return SFVEC3F - return the offset relative to max-min
+     */
+    SFVEC3F Offset( const SFVEC3F &p ) const;
+
+    /**
+     * Function GetExtent
+     * @return SFVEC3F - max-min
+     */
+    const SFVEC3F GetExtent() const;
 
     /**
      * Function Min
      * return the minimun vertex pointer
-     * @return S3D_VERTEX - the minimun vertice position
+     * @return SFVEC3F - the minimun vertice position
      */
-    S3D_VERTEX Min() const;
+    const SFVEC3F &Min() const { return m_min; }
 
     /**
      * Function Max
      * return the maximum vertex pointer
-     * @return S3D_VERTEX - the maximun vertice position
+     * @return SFVEC3F - the maximun vertice position
      */
-    S3D_VERTEX Max() const;
+    const SFVEC3F &Max() const { return m_max; }
+
+
+    /**
+     * Function MaxDimension
+     * @return the index of the max dimention (0=x, 1=y, 2=z)
+     */
+    unsigned int MaxDimension() const;
+
+    /**
+     * @brief GetMaxDimension
+     * @return the max dimension
+     */
+    float GetMaxDimension() const;
+
+    /**
+     * Function SurfaceArea
+     * @return the surface are of the box
+     */
+    float SurfaceArea() const;
+
+    /**
+     * Function Intersect
+     * @param aRay = ray to intersect the box
+     * @param t = distance point of the ray of the intersection (if true)
+     * @return true if the ray hits the box
+     */
+    bool Intersect( const RAY &aRay, float *t ) const;
+
+    bool Intersect( const RAY &aRay ) const;
+
+    /**
+     * Function Intersect - Useful for get the enter and exit position
+     * If the ray starts inside the bbox, it will return aOutHitt0 = 0.0
+     * @param aRay = ray to intersect the box
+     * @param aOutHitt0 = distance point of the ray of the intersection (if true)
+     * @param aOutHitt1 = distance point of the ray of the exit (if true)
+     * @return true if the ray hits the box
+     */
+    bool Intersect( const RAY &aRay, float *aOutHitt0, float *aOutHitt1 ) const;
 
 private:
-    S3D_VERTEX m_min;           ///< point of the lower position of the bounding box
-    S3D_VERTEX m_max;           ///< point of the higher position of the bounding box
-    bool m_initialized;         ///< initialization status of the bounding box. true - if initialized, false otherwise
+
+    SFVEC3F m_min;           ///< (12) point of the lower position of the bounding box
+    SFVEC3F m_max;           ///< (12) point of the higher position of the bounding box
 };
 
 #endif // CBBox_h
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox_ray.cpp b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox_ray.cpp
new file mode 100644
index 0000000000..7e45a94c4b
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox_ray.cpp
@@ -0,0 +1,905 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+ /**
+ * @file cbbox_ray.cpp
+ * @brief Bounding Box - Ray test intersection
+ */
+
+#include "cbbox.h"
+#include <fctsys.h>
+#include <wx/debug.h>
+
+// This BBOX Ray intersection test have the following credits:
+
+// "This source code accompanies the Journal of Graphics Tools paper:
+//
+//  "Fast Ray / Axis-Aligned Bounding Box Overlap Tests using Ray Slopes"
+//  by Martin Eisemann, Thorsten Grosch, Stefan Müller and Marcus Magnor
+//  Computer Graphics Lab, TU Braunschweig, Germany and
+//  University of Koblenz-Landau, Germany
+//
+//  This source code is public domain, but please mention us if you use it."
+
+
+bool CBBOX::Intersect( const RAY &aRay, float *t ) const
+{
+    switch ( aRay.m_Classification )
+    {
+    case MMM:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_min.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_min.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_min.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+
+            // compute the intersection distance
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+
+    case MMP:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_min.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_max.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_min.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case MPM:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_min.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_min.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_min.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case MPP:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_min.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_max.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_min.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case PMM:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_max.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_min.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_max.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+
+    case PMP:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_max.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_max.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_max.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case PPM:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_max.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_min.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_max.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case PPP:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_max.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_max.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_max.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case OMM:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyk * m_min.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_max.z +  aRay.c_yz > 0)
+            )
+            return false;
+
+            *t = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case OMP:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyk * m_max.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_min.z +  aRay.c_yz < 0)
+            )
+            return false;
+
+            *t = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case OPM:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyk * m_min.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_max.z +  aRay.c_yz > 0)
+            )
+            return false;
+
+            *t = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case OPP:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyk * m_max.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_min.z +  aRay.c_yz < 0)
+            )
+            return false;
+
+            *t = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+
+    case MOM:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.kbyi * m_min.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+
+    case MOP:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.kbyi * m_min.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case POM:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.kbyi * m_max.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t2 = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+
+    case POP:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.kbyi * m_max.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t2 = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            if(t2 > *t)
+                *t = t2;
+
+            return true;
+        }
+
+    case MMO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y < m_min.y)
+            || ( aRay.jbyi * m_min.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_max.x +  aRay.c_yx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            return true;
+        }
+
+    case MPO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.jbyi * m_min.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_max.x +  aRay.c_yx > 0)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            return true;
+        }
+
+
+    case PMO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y < m_min.y)
+            || ( aRay.jbyi * m_max.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_min.x +  aRay.c_yx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            return true;
+        }
+
+    case PPO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.jbyi * m_max.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_min.x +  aRay.c_yx < 0)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            float t1 = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            if(t1 > *t)
+                *t = t1;
+
+            return true;
+        }
+
+
+    case MOO:
+        {
+        if(( aRay.m_Origin.x < m_min.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+
+            *t = (m_max.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            return true;
+        }
+
+    case POO:
+        {
+        if(( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+
+            *t = (m_min.x -  aRay.m_Origin.x) *  aRay.m_InvDir.x;
+
+            return true;
+        }
+
+    case OMO:
+        {
+        if(( aRay.m_Origin.y < m_min.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+
+            *t = (m_max.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            return true;
+        }
+
+    case OPO:
+        {
+        if(( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+
+            *t = (m_min.y -  aRay.m_Origin.y) *  aRay.m_InvDir.y;
+
+            return true;
+        }
+
+
+    case OOM:
+        {
+        if(( aRay.m_Origin.z < m_min.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            )
+            return false;
+
+            *t = (m_max.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            return true;
+        }
+
+    case OOP:
+        {
+        if(( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            )
+            return false;
+
+            *t = (m_min.z -  aRay.m_Origin.z) *  aRay.m_InvDir.z;
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+bool CBBOX::Intersect( const RAY &aRay ) const
+{
+    switch ( aRay.m_Classification )
+    {
+    case MMM:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_min.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_min.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_min.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case MMP:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_min.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_max.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_min.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case MPM:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_min.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_min.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_min.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case MPP:
+        {
+        if (( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_min.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_max.x +  aRay.c_yx > 0)
+            || ( aRay.jbyk * m_max.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_min.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case PMM:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_max.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_min.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_max.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case PMP:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_max.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_max.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_max.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+            return true;
+        }
+
+    case PPM:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyi * m_max.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_min.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_max.z +  aRay.c_yz > 0)
+            || ( aRay.kbyi * m_max.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+            return true;
+        }
+
+    case PPP:
+        {
+        if (( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyi * m_max.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_min.x +  aRay.c_yx < 0)
+            || ( aRay.jbyk * m_max.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_min.z +  aRay.c_yz < 0)
+            || ( aRay.kbyi * m_max.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+            return true;
+        }
+
+    case OMM:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyk * m_min.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_max.z +  aRay.c_yz > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case OMP:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyk * m_max.z - m_max.y +  aRay.c_zy > 0)
+            || ( aRay.kbyj * m_min.y - m_min.z +  aRay.c_yz < 0)
+            )
+            return false;
+            return true;
+        }
+
+    case OPM:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.jbyk * m_min.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_max.z +  aRay.c_yz > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case OPP:
+        {
+        if(( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y > m_max.y) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.jbyk * m_max.z - m_min.y +  aRay.c_zy < 0)
+            || ( aRay.kbyj * m_max.y - m_min.z +  aRay.c_yz < 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case MOM:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.kbyi * m_min.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case MOP:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.kbyi * m_min.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_max.x +  aRay.c_zx > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case POM:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.z < m_min.z)
+            || ( aRay.kbyi * m_max.x - m_max.z +  aRay.c_xz > 0)
+            || ( aRay.ibyk * m_min.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case POP:
+        {
+        if(( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.kbyi * m_max.x - m_min.z +  aRay.c_xz < 0)
+            || ( aRay.ibyk * m_max.z - m_min.x +  aRay.c_zx < 0)
+            )
+            return false;
+            return true;
+        }
+
+    case MMO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y < m_min.y)
+            || ( aRay.jbyi * m_min.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_max.x +  aRay.c_yx > 0)
+            )
+            return false;
+            return true;
+        }
+
+    case MPO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.jbyi * m_min.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_max.x +  aRay.c_yx > 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case PMO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y < m_min.y)
+            || ( aRay.jbyi * m_max.x - m_max.y +  aRay.c_xy > 0)
+            || ( aRay.ibyj * m_min.y - m_min.x +  aRay.c_yx < 0)
+            )
+            return false;
+            return true;
+        }
+
+    case PPO:
+        {
+        if(( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x > m_max.x) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.jbyi * m_max.x - m_min.y +  aRay.c_xy < 0)
+            || ( aRay.ibyj * m_max.y - m_min.x +  aRay.c_yx < 0)
+            )
+            return false;
+            return true;
+        }
+
+
+    case MOO:
+        {
+        if(( aRay.m_Origin.x < m_min.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+            return true;
+        }
+
+    case POO:
+        {
+        if(( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+            return true;
+        }
+
+    case OMO:
+        {
+        if(( aRay.m_Origin.y < m_min.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+            return true;
+        }
+
+    case OPO:
+        {
+        if(( aRay.m_Origin.y > m_max.y)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.z < m_min.z) || ( aRay.m_Origin.z > m_max.z)
+            )
+            return false;
+            return true;
+        }
+
+
+    case OOM:
+        {
+        if(( aRay.m_Origin.z < m_min.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            )
+            return false;
+            return true;
+        }
+
+    case OOP:
+        {
+        if(( aRay.m_Origin.z > m_max.z)
+            || ( aRay.m_Origin.x < m_min.x) || ( aRay.m_Origin.x > m_max.x)
+            || ( aRay.m_Origin.y < m_min.y) || ( aRay.m_Origin.y > m_max.y)
+            )
+            return false;
+            return true;
+        }
+    }
+
+    return false;
+}
diff --git a/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cobject.h b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cobject.h
new file mode 100644
index 0000000000..897a914905
--- /dev/null
+++ b/3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cobject.h
@@ -0,0 +1,135 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cobject.h
+ * @brief
+ */
+
+#ifndef _COBJECT_H_
+#define _COBJECT_H_
+
+#include "../../../3d_xv3d/xv3d_types.h"
+#include "cbbox.h"
+#include "../hitinfo.h"
+#include "../cmaterial.h"
+
+
+enum OBJECT3D_TYPE
+{
+    OBJ3D_CYLINDER,
+    OBJ3D_DUMMYBLOCK,
+    OBJ3D_LAYERITEM,
+    OBJ3D_XYPLANE,
+    OBJ3D_ROUNDSEG,
+    OBJ3D_TRIANGLE,
+    OBJ3D_MAX
+};
+
+class GLM_ALIGN(CLASS_ALIGNMENT) COBJECT
+{
+protected:
+    CBBOX   m_bbox;
+    SFVEC3F m_centroid;
+    OBJECT3D_TYPE m_obj_type;
+    const CMATERIAL *m_material;
+
+public:
+
+    COBJECT( OBJECT3D_TYPE aObjType );
+
+    void SetMaterial( const CMATERIAL *aMaterial ) { m_material = aMaterial; }
+    const CMATERIAL *GetMaterial() const { return m_material; }
+
+    virtual SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const = 0;
+
+    virtual ~COBJECT() {}
+
+    /** Function Intersects
+     * @brief Intersects - a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅)
+     * It intersects if the result intersection is not null
+     * @param aBBox
+     * @return
+     */
+    virtual bool Intersects( const CBBOX &aBBox ) const = 0;
+
+
+    /** Functions Intersect
+     * @brief Intersect
+     * @param aRay
+     * @param aHitInfo
+     * @return TRUE if the aRay intersects the object
+     */
+    virtual bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const = 0;
+
+    /** Functions Intersect for shadow test
+     * @brief Intersect
+     * @param aRay
+     * @param aDistance - max distance of the test
+     * @return TRUE if the aRay intersects the object
+     */
+    virtual bool IntersectP( const RAY &aRay, float aMaxDistance ) const = 0;
+
+    const CBBOX &GetBBox() const { return m_bbox; }
+
+    const SFVEC3F &GetCentroid() const { return m_centroid; }
+};
+
+
+/// Implements a class for object statistics
+/// using Singleton pattern
+class COBJECT3D_STATS
+{
+public:
+
+    void ResetStats() { memset( m_counter, 0, sizeof(unsigned int) * OBJ3D_MAX ); }
+
+    unsigned int GetCountOf( OBJECT3D_TYPE aObjType ) const { return m_counter[aObjType]; }
+
+    void AddOne( OBJECT3D_TYPE aObjType ) { m_counter[aObjType]++; }
+
+    void PrintStats();
+
+    static COBJECT3D_STATS &Instance()
+    {
+        if( !s_instance )
+            s_instance = new COBJECT3D_STATS;
+
+        return *s_instance;
+    }
+
+private:
+    COBJECT3D_STATS(){ ResetStats(); }
+    COBJECT3D_STATS( const COBJECT3D_STATS &old );
+    const COBJECT3D_STATS &operator=( const COBJECT3D_STATS &old );
+    ~COBJECT3D_STATS(){}
+
+private:
+    unsigned int m_counter[OBJ3D_MAX];
+
+    static COBJECT3D_STATS *s_instance;
+};
+
+
+#endif // _COBJECT_H_
diff --git a/3d-viewer/3d_rendering/c3d_render_base.h b/3d-viewer/3d_rendering/c3d_render_base.h
new file mode 100644
index 0000000000..7182d0f4f7
--- /dev/null
+++ b/3d-viewer/3d_rendering/c3d_render_base.h
@@ -0,0 +1,82 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3d_render_base.h
+ * @brief
+ */
+
+#ifndef C3D_RENDER_BASE_H
+#define C3D_RENDER_BASE_H
+
+
+#include <wxBasePcbFrame.h>
+#include "../3d_canvas/cinfo3d_visu.h"
+#include "3d_cache/3d_cache.h"
+
+/**
+ *  This is a base class to hold data and functions for render targets.
+ */
+class C3D_RENDER_BASE
+{
+
+
+    // Operations
+public:
+
+    C3D_RENDER_BASE( CINFO3D_VISU &aSettings,
+                     S3D_CACHE *a3DModelManager );
+
+    virtual ~C3D_RENDER_BASE() = 0;
+
+    virtual void SetCurWindowSize( const wxSize &aSize ) = 0;
+
+    virtual void Redraw( bool aIsMoving ) = 0;
+
+    void ReloadRequest() { m_reloadRequested = true; }
+
+    // Attributes
+
+protected:
+    CINFO3D_VISU &m_settings;
+    S3D_CACHE *m_3d_model_manager;
+
+    bool m_is_opengl_initialized;
+    bool m_reloadRequested;
+
+    /**
+     *  The window size that this camera is working.
+     */
+    wxSize m_windowSize;
+
+    /**
+     *  Trace mask used to enable or disable the trace output of this class.
+     *  The debug output can be turned on by setting the WXTRACE environment variable to
+     *  "KI_TRACE_3D_RENDER".  See the wxWidgets documentation on wxLogTrace for
+     *  more information.
+     */
+    static const wxChar *m_logTrace;
+};
+
+#endif // C3D_RENDER_BASE_H
diff --git a/3d-viewer/3d_rendering/c3dmodel.h b/3d-viewer/3d_rendering/c3dmodel.h
new file mode 100644
index 0000000000..e17af15dbf
--- /dev/null
+++ b/3d-viewer/3d_rendering/c3dmodel.h
@@ -0,0 +1,106 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  c3dmodel.h
+ * @brief define an internal structure to be used by the 3D renders
+ */
+
+
+#ifndef C3DMODEL_H
+#define C3DMODEL_H
+
+#include "3d_xv3d/xv3d_types.h"
+#include <base_units.h>
+//#include <wx/string.h>
+
+/**
+  * Scale convertion from 3d model units to pcb units
+  */
+#define UNITS3D_TO_UNITSPCB (IU_PER_MM)
+
+
+typedef struct
+{
+    SFVEC3F m_Ambient;          //
+    SFVEC3F m_Diffuse;          ///< Default diffuse color if m_Color is NULL
+    SFVEC3F m_Emissive;         //
+    SFVEC3F m_Specular;         //
+    float   m_Shininess;        //
+    float   m_Transparency;     ///< 1.0 is completely transparent, 0.0 completely opaque
+
+    // !TODO: to be implemented
+    /*struct textures
+    {
+        wxString m_Ambient;            // map_Ka
+        wxString m_Diffuse;            // map_Kd
+        wxString m_Specular;           // map_Ks
+        wxString m_Specular_highlight; // map_Ns
+        wxString m_Bump;               // map_bump, bump
+        wxString m_Displacement;       // disp
+        wxString m_Alpha;              // map_d
+    };*/
+} SMATERIAL;
+
+
+/// Per-vertex normal/color/texcoors structure.
+/// CONDITIONS:
+///     m_Positions size == m_Normals size == m_Texcoords size == m_Color size
+///     m_Texcoords can be NULL, textures will not be applied in that case
+///     m_Color can be NULL, it will use the m_Diffuse color for every triangle
+///     any m_FaceIdx must be an index of a the element lists
+///     m_MaterialIdx must be an existent material index stored in the parent model
+/// SCALES:
+/// m_Positions units are in mm, example:
+///  0.1 unit ==  0.1 mm
+///  1.0 unit ==  1.0 mm
+/// 10.0 unit == 10.0 mm
+///
+/// To convert this units to pcbunits, use the convertion facto UNITS3D_TO_UNITSPCB
+///
+/// m_Normals, m_Color and m_Texcoords are beween 0.0f and 1.0f
+typedef struct
+{
+    unsigned int    m_VertexSize;   ///< Number of vertex in the arrays
+    SFVEC3F        *m_Positions;    ///< Vertex position array
+    SFVEC3F        *m_Normals;      ///< Vertex normals array
+    SFVEC2F        *m_Texcoords;    ///< Vertex texture coordinates array, can be NULL
+    SFVEC3F        *m_Color;        ///< Vertex color array, can be NULL
+    unsigned int    m_FaceIdxSize;  ///< Number of elements of the m_FaceIdx array
+    unsigned int   *m_FaceIdx;      ///< Triangle Face Indexes
+    unsigned int    m_MaterialIdx;  ///< Material Index to be used in this mesh (must be < m_MaterialsSize )
+} SMESH;
+
+
+/// Store the a model based on meshes and materials
+typedef struct
+{
+    unsigned int    m_MeshesSize;       ///< Number of meshes in the array
+    SMESH          *m_Meshes;           ///< The meshes list of this model
+
+    unsigned int    m_MaterialsSize;    ///< Number of materials in the material array
+    SMATERIAL      *m_Materials;        ///< The materials list of this model
+} S3DMODEL;
+
+#endif // C3DMODEL_H
diff --git a/3d-viewer/3d_rendering/ccamera.cpp b/3d-viewer/3d_rendering/ccamera.cpp
new file mode 100644
index 0000000000..3749ac80ad
--- /dev/null
+++ b/3d-viewer/3d_rendering/ccamera.cpp
@@ -0,0 +1,493 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ccamera.cpp
+ * @brief
+ */
+
+#include "../common_ogl/openGL_includes.h"
+#include "ccamera.h"
+#include <wx/log.h>
+
+
+/**
+ *  Trace mask used to enable or disable the trace output of this class.
+ *  The debug output can be turned on by setting the WXTRACE environment variable to
+ *  "KI_TRACE_CCAMERA".  See the wxWidgets documentation on wxLogTrace for
+ *  more information.
+ */
+const wxChar *CCAMERA::m_logTrace = wxT( "KI_TRACE_CCAMERA" );
+
+
+CCAMERA::CCAMERA( float aRangeScale )
+{
+    wxLogTrace( m_logTrace, wxT( "CCAMERA::CCAMERA" ) );
+
+    m_parametersChanged    = true;
+    m_projectionType       = PROJECTION_PERSPECTIVE;
+    m_projectionMatrix     = glm::mat4( 1.0f );
+    m_projectionMatrix_inv = glm::mat4( 1.0f );
+    m_rotationMatrix       = glm::mat4( 1.0f );
+    m_lastPosition         = wxPoint( 0, 0 );
+    m_windowSize           = wxSize( 0, 0 );
+    m_zoom                 = 1.0f;
+    m_range_scale          = aRangeScale;
+    m_camera_pos_init      = SFVEC3F( 0.0f, 0.0f, -aRangeScale );
+    m_camera_pos           = m_camera_pos_init;
+    m_boardLookAt_pos      = SFVEC3F( 0.0, 0.0, 0.0 );
+    updateViewMatrix();
+    m_viewMatrix_inverse   = glm::inverse( m_viewMatrix );
+    m_scr_nX.clear();
+    m_scr_nY.clear();
+}
+
+
+void CCAMERA::updateViewMatrix()
+{
+    m_viewMatrix = glm::translate( glm::mat4( 1.0f ), m_camera_pos ) *
+                   m_rotationMatrix * glm::translate( glm::mat4( 1.0f ), m_boardLookAt_pos );
+}
+
+
+const glm::mat4 &CCAMERA::GetRotationMatrix() const
+{
+    return m_rotationMatrix;
+}
+
+
+void CCAMERA::rebuildProjection()
+{
+    m_frustum.ratio = (float) m_windowSize.x / m_windowSize.y;
+    m_frustum.nearD = 0.01f;
+    m_frustum.farD = glm::length( m_camera_pos_init ) * 2.0f;                   // Consider that we can render double the lenght, review if that is OK...
+
+    switch( m_projectionType )
+    {
+    case PROJECTION_PERSPECTIVE:
+        // Ratio width / height of the window display
+        m_frustum.angle = 45.0f * m_zoom;
+
+
+        m_projectionMatrix = glm::perspective( m_frustum.angle * ( glm::pi<float>() / 180.0f ),
+                                               m_frustum.ratio,
+                                               m_frustum.nearD,
+                                               m_frustum.farD );
+
+        m_projectionMatrix_inv = glm::inverse( m_projectionMatrix );
+
+        m_frustum.tang = (float)tan( m_frustum.angle * ( glm::pi<float>() / 180.0f ) * 0.5f ) ;
+
+        m_focalLen.x = ( (float)m_windowSize.y / (float)m_windowSize.x ) / m_frustum.tang;
+        m_focalLen.y = 1.0f / m_frustum.tang;
+
+        m_frustum.nh = m_frustum.nearD * m_frustum.tang;
+        m_frustum.nw = m_frustum.nh * m_frustum.ratio;
+        m_frustum.fh = m_frustum.farD * m_frustum.tang;
+        m_frustum.fw = m_frustum.fh * m_frustum.ratio;
+        break;
+
+    case PROJECTION_ORTHO:
+        const float orthoReductionFactor = m_zoom / 400.0f;
+
+        // Initialize Projection Matrix for Ortographic View
+        m_projectionMatrix = glm::ortho( -m_windowSize.x * orthoReductionFactor,
+                                          m_windowSize.x * orthoReductionFactor,
+                                         -m_windowSize.y * orthoReductionFactor,
+                                          m_windowSize.y * orthoReductionFactor,
+                                          m_frustum.nearD,
+                                          m_frustum.farD );
+
+        m_projectionMatrix_inv = glm::inverse( m_projectionMatrix );
+
+        m_frustum.nw = m_windowSize.x * orthoReductionFactor * 2.0f;
+        m_frustum.nh = m_windowSize.y * orthoReductionFactor * 2.0f;
+        m_frustum.fw = m_frustum.nw;
+        m_frustum.fh = m_frustum.nh;
+
+        break;
+    }
+
+    m_scr_nX.resize( m_windowSize.x );
+    m_scr_nY.resize( m_windowSize.y );
+
+    // Precalc X values for camera -> ray generation
+    for( unsigned int x = 0; x < (unsigned int)m_windowSize.x; x++ )
+    {
+        // Converts 0.0 .. 1.0
+        float xNormalizedDeviceCoordinates = ( ( (float)x + 0.5f ) / (m_windowSize.x - 0.0f) );
+
+        // Converts -1.0 .. 1.0
+        m_scr_nX[x] = 2.0f * xNormalizedDeviceCoordinates - 1.0f;
+    }
+
+    // Precalc Y values for camera -> ray generation
+    for( unsigned int y = 0; y < (unsigned int)m_windowSize.y; y++ )
+    {
+        // Converts 0.0 .. 1.0
+        float yNormalizedDeviceCoordinates = ( ( (float)y + 0.5f ) / (m_windowSize.y - 0.0f) );
+
+        // Converts -1.0 .. 1.0
+        m_scr_nY[y] = 2.0f * yNormalizedDeviceCoordinates - 1.0f;
+    }
+
+    updateFrustum();
+}
+
+
+void CCAMERA::updateFrustum()
+{
+    // Update matrix and vectors
+    m_viewMatrix_inverse = glm::inverse( m_viewMatrix );
+
+    m_right = glm::normalize( SFVEC3F( m_viewMatrix_inverse * glm::vec4( SFVEC3F( 1.0, 0.0, 0.0 ), 0.0 ) ) );
+    m_up    = glm::normalize( SFVEC3F( m_viewMatrix_inverse * glm::vec4( SFVEC3F( 0.0, 1.0, 0.0 ), 0.0 ) ) );
+    m_dir   = glm::normalize( SFVEC3F( m_viewMatrix_inverse * glm::vec4( SFVEC3F( 0.0, 0.0, 1.0 ), 0.0 ) ) );
+    m_pos   = SFVEC3F( m_viewMatrix_inverse * glm::vec4( SFVEC3F( 0.0, 0.0, 0.0 ), 1.0 ) );
+
+
+    /*
+     * Frustum is a implementation based on a tutorial by
+     * http://www.lighthouse3d.com/tutorials/view-frustum-culling/
+     */
+
+    // compute the centers of the near and far planes
+    m_frustum.nc = m_pos - m_dir * m_frustum.nearD;
+    m_frustum.fc = m_pos - m_dir * m_frustum.farD;
+
+    // compute the 4 corners of the frustum on the near plane
+    m_frustum.ntl = m_frustum.nc + m_up * m_frustum.nh - m_right * m_frustum.nw;
+    m_frustum.ntr = m_frustum.nc + m_up * m_frustum.nh + m_right * m_frustum.nw;
+    m_frustum.nbl = m_frustum.nc - m_up * m_frustum.nh - m_right * m_frustum.nw;
+    m_frustum.nbr = m_frustum.nc - m_up * m_frustum.nh + m_right * m_frustum.nw;
+
+    // compute the 4 corners of the frustum on the far plane
+    m_frustum.ftl = m_frustum.fc + m_up * m_frustum.fh - m_right * m_frustum.fw;
+    m_frustum.ftr = m_frustum.fc + m_up * m_frustum.fh + m_right * m_frustum.fw;
+    m_frustum.fbl = m_frustum.fc - m_up * m_frustum.fh - m_right * m_frustum.fw;
+    m_frustum.fbr = m_frustum.fc - m_up * m_frustum.fh + m_right * m_frustum.fw;
+
+    // Reserve size for precalc values
+    m_right_nX.resize( m_windowSize.x );
+    m_up_nY.resize( m_windowSize.y );
+
+    // Precalc X values for camera -> ray generation
+    SFVEC3F right_nw = m_right * m_frustum.nw;
+
+    for( unsigned int x = 0; x < (unsigned int)m_windowSize.x; x++ )
+        m_right_nX[x] = right_nw * m_scr_nX[x];
+
+    // Precalc Y values for camera -> ray generation
+    SFVEC3F up_nh = m_up * m_frustum.nh;
+
+    for( unsigned int y = 0; y < (unsigned int)m_windowSize.y; y++ )
+        m_up_nY[y] = m_frustum.nc + (up_nh * m_scr_nY[y]);
+}
+
+
+void CCAMERA::MakeRay( const SFVEC2I &aWindowPos, SFVEC3F &aOutOrigin, SFVEC3F &aOutDirection ) const
+{
+    aOutOrigin = m_up_nY[aWindowPos.y] +
+                 m_right_nX[aWindowPos.x];
+
+    aOutDirection = glm::normalize( aOutOrigin - m_pos );
+}
+
+
+void CCAMERA::GLdebug_Lines()
+{
+    SFVEC3F ntl = m_frustum.ntl;
+    SFVEC3F ntr = m_frustum.ntr;
+    SFVEC3F nbl = m_frustum.nbl;
+    SFVEC3F nbr = m_frustum.nbr;
+
+    SFVEC3F ftl = m_frustum.ftl;
+    SFVEC3F ftr = m_frustum.ftr;
+    SFVEC3F fbl = m_frustum.fbl;
+    SFVEC3F fbr = m_frustum.fbr;
+
+    glColor4f( 1.0, 1.0, 1.0, 0.7 );
+
+    glBegin(GL_LINE_LOOP);
+    //near plane
+        glVertex3f(ntl.x,ntl.y,ntl.z);
+        glVertex3f(ntr.x,ntr.y,ntr.z);
+        glVertex3f(nbr.x,nbr.y,nbr.z);
+        glVertex3f(nbl.x,nbl.y,nbl.z);
+    glEnd();
+
+    glBegin(GL_LINE_LOOP);
+    //far plane
+        glVertex3f(ftr.x,ftr.y,ftr.z);
+        glVertex3f(ftl.x,ftl.y,ftl.z);
+        glVertex3f(fbl.x,fbl.y,fbl.z);
+        glVertex3f(fbr.x,fbr.y,fbr.z);
+    glEnd();
+
+    glBegin(GL_LINE_LOOP);
+    //bottom plane
+        glVertex3f(nbl.x,nbl.y,nbl.z);
+        glVertex3f(nbr.x,nbr.y,nbr.z);
+        glVertex3f(fbr.x,fbr.y,fbr.z);
+        glVertex3f(fbl.x,fbl.y,fbl.z);
+    glEnd();
+
+    glBegin(GL_LINE_LOOP);
+    //top plane
+        glVertex3f(ntr.x,ntr.y,ntr.z);
+        glVertex3f(ntl.x,ntl.y,ntl.z);
+        glVertex3f(ftl.x,ftl.y,ftl.z);
+        glVertex3f(ftr.x,ftr.y,ftr.z);
+    glEnd();
+
+    glBegin(GL_LINE_LOOP);
+    //left plane
+        glVertex3f(ntl.x,ntl.y,ntl.z);
+        glVertex3f(nbl.x,nbl.y,nbl.z);
+        glVertex3f(fbl.x,fbl.y,fbl.z);
+        glVertex3f(ftl.x,ftl.y,ftl.z);
+    glEnd();
+
+    glBegin(GL_LINE_LOOP);
+    // right plane
+        glVertex3f(nbr.x,nbr.y,nbr.z);
+        glVertex3f(ntr.x,ntr.y,ntr.z);
+        glVertex3f(ftr.x,ftr.y,ftr.z);
+        glVertex3f(fbr.x,fbr.y,fbr.z);
+    glEnd();
+}
+
+
+void CCAMERA::GLdebug_Vectors()
+{
+    SFVEC3F right = m_pos + m_right * m_frustum.nearD;
+    SFVEC3F up    = m_pos + m_up    * m_frustum.nearD;
+    SFVEC3F dir   = m_pos - m_dir   * m_frustum.nearD;
+
+    glColor4f( 1.0, 0.0, 0.0, 1.0 );
+    glBegin( GL_LINES );
+    glVertex3fv( &m_pos.x );
+    glVertex3fv( &right.x );
+    glEnd();
+
+    glColor4f( 0.0, 1.0, 0.0, 1.0 );
+    glBegin( GL_LINES );
+    glVertex3fv( &m_pos.x );
+    glVertex3fv( &up.x );
+    glEnd();
+
+    glColor4f( 0.0, 0.0, 1.0, 1.0 );
+    glBegin( GL_LINES );
+    glVertex3fv( &m_pos.x );
+    glVertex3fv( &dir.x );
+    glEnd();
+}
+
+
+void CCAMERA::GLdebug_Planes()
+{
+    SFVEC3F ntl = m_frustum.ntl;
+    SFVEC3F ntr = m_frustum.ntr;
+    SFVEC3F nbl = m_frustum.nbl;
+    SFVEC3F nbr = m_frustum.nbr;
+
+    SFVEC3F ftl = m_frustum.ftl;
+    SFVEC3F ftr = m_frustum.ftr;
+    SFVEC3F fbl = m_frustum.fbl;
+    SFVEC3F fbr = m_frustum.fbr;
+
+    // Initialize alpha blending function.
+    glEnable( GL_BLEND );
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+
+    glBegin(GL_QUADS);
+
+    //near plane
+        glColor4f( 0.0, 0.0, 0.5, 0.6 );
+        glVertex3f(ntl.x,ntl.y,ntl.z);
+        glVertex3f(ntr.x,ntr.y,ntr.z);
+        glVertex3f(nbr.x,nbr.y,nbr.z);
+        glVertex3f(nbl.x,nbl.y,nbl.z);
+
+    //far plane
+        glColor4f( 0.0, 0.0, 0.5, 0.6 );
+        glVertex3f(ftr.x,ftr.y,ftr.z);
+        glVertex3f(ftl.x,ftl.y,ftl.z);
+        glVertex3f(fbl.x,fbl.y,fbl.z);
+        glVertex3f(fbr.x,fbr.y,fbr.z);
+
+    //bottom plane
+        glColor4f( 0.0, 0.5, 0.0, 0.6 );
+        glVertex3f(nbl.x,nbl.y,nbl.z);
+        glVertex3f(nbr.x,nbr.y,nbr.z);
+        glVertex3f(fbr.x,fbr.y,fbr.z);
+        glVertex3f(fbl.x,fbl.y,fbl.z);
+
+    //top plane
+        glColor4f( 0.0, 0.5, 0.0, 0.6 );
+        glVertex3f(ntr.x,ntr.y,ntr.z);
+        glVertex3f(ntl.x,ntl.y,ntl.z);
+        glVertex3f(ftl.x,ftl.y,ftl.z);
+        glVertex3f(ftr.x,ftr.y,ftr.z);
+
+    //left plane
+        glColor4f( 0.5, 0.0, 0.0, 0.6 );
+        glVertex3f(ntl.x,ntl.y,ntl.z);
+        glVertex3f(nbl.x,nbl.y,nbl.z);
+        glVertex3f(fbl.x,fbl.y,fbl.z);
+        glVertex3f(ftl.x,ftl.y,ftl.z);
+
+    // right plane
+        glColor4f( 0.5, 0.0, 0.0, 0.6 );
+        glVertex3f(nbr.x,nbr.y,nbr.z);
+        glVertex3f(ntr.x,ntr.y,ntr.z);
+        glVertex3f(ftr.x,ftr.y,ftr.z);
+        glVertex3f(fbr.x,fbr.y,fbr.z);
+
+    glEnd();
+
+    glDisable( GL_BLEND );
+/*
+    glColor3f( 0.0, 0.0, 1.0 );
+    OGL_draw_arrow( m_pos,
+                    m_frustum.nc,
+                    0.1);*/
+
+
+}
+
+
+const glm::mat4 &CCAMERA::GetProjectionMatrix() const
+{
+    return m_projectionMatrix;
+}
+
+
+const glm::mat4 &CCAMERA::GetProjectionMatrixInv() const
+{
+    return m_projectionMatrix_inv;
+}
+
+
+const glm::mat4 &CCAMERA::GetViewMatrix() const
+{
+    return m_viewMatrix;
+}
+
+
+const glm::mat4 &CCAMERA::GetViewMatrix_Inv() const
+{
+    return m_viewMatrix_inverse;
+}
+
+
+void CCAMERA::SetCurMousePosition( const wxPoint &aNewMousePosition )
+{
+    m_lastPosition = aNewMousePosition;
+}
+
+
+void CCAMERA::SetProjection( PROJECTION_TYPE aProjectionType )
+{
+    if( m_projectionType != aProjectionType )
+    {
+        m_projectionType = aProjectionType;
+        rebuildProjection();
+    }
+}
+
+
+void CCAMERA::SetCurWindowSize( const wxSize &aSize )
+{
+    if( m_windowSize != aSize )
+    {
+        m_windowSize = aSize;
+        rebuildProjection();
+    }
+}
+
+
+void CCAMERA::ZoomReset()
+{
+    m_zoom = 1.0f;
+
+    m_camera_pos.z = m_camera_pos_init.z;
+
+    updateViewMatrix();
+    rebuildProjection();
+}
+
+
+void CCAMERA::ZoomIn( float aFactor )
+{
+    float old_zoom = m_zoom;
+
+    m_zoom /= aFactor;
+
+    if( m_zoom <= 0.05f )
+        m_zoom = 0.05f;
+
+    m_camera_pos.z = m_zoom * m_camera_pos_init.z;
+
+    if( old_zoom != m_zoom )
+    {
+        updateViewMatrix();
+        rebuildProjection();
+    }
+}
+
+
+void CCAMERA::ZoomOut( float aFactor )
+{
+    float old_zoom = m_zoom;
+
+    m_zoom *= aFactor;
+
+    if( m_zoom >= 1.5f )
+        m_zoom = 1.5f;
+
+    m_camera_pos.z = m_zoom * m_camera_pos_init.z;
+
+    if( old_zoom != m_zoom )
+    {
+        updateViewMatrix();
+        rebuildProjection();
+    }
+}
+
+
+float CCAMERA::ZoomGet() const
+{
+    return m_zoom;
+}
+
+
+bool CCAMERA::ParametersChanged()
+{
+    bool parametersChanged = m_parametersChanged;
+
+    m_parametersChanged = false;
+
+    return parametersChanged;
+}
diff --git a/3d-viewer/3d_rendering/ccamera.h b/3d-viewer/3d_rendering/ccamera.h
new file mode 100644
index 0000000000..32436a187d
--- /dev/null
+++ b/3d-viewer/3d_rendering/ccamera.h
@@ -0,0 +1,229 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ccamera.h
+ * @brief Define an abstract camera
+ */
+
+#ifndef CCAMERA_H
+#define CCAMERA_H
+
+#include "../3d_xv3d/xv3d_types.h"
+#include "../3d_rendering/3d_render_raytracing/ray.h"
+#include <wx/gdicmn.h>                                                          // for wxSize
+#include <vector>
+
+enum PROJECTION_TYPE
+{
+    PROJECTION_ORTHO,
+    PROJECTION_PERSPECTIVE
+};
+
+/**
+ * Frustum structure
+ * Frustum is a implementation based on a tutorial by
+ * http://www.lighthouse3d.com/tutorials/view-frustum-culling/
+ */
+struct FRUSTUM
+{
+    SFVEC3F nc;
+    SFVEC3F fc;
+    SFVEC3F ntl; ///< Near Top Left
+    SFVEC3F ntr; ///< Near Top Right
+    SFVEC3F nbl; ///< Near Bottom Left
+    SFVEC3F nbr; ///< Near Bottom Right
+    SFVEC3F ftl; ///< Far Top Left
+    SFVEC3F ftr; ///< Far Top Right
+    SFVEC3F fbl; ///< Far Bottom Left
+    SFVEC3F fbr; ///< Far Bottom Right
+    float nearD, farD, ratio, angle, tang;
+    float nw, nh, fw, fh;
+};
+
+/**
+ *  Class CCAMERA
+ *  is a virtual class used to derive CCAMERA objects from.
+ *
+ *  It must be derived to other classes to implement a real camera object.
+ */
+class CCAMERA
+{
+
+ public:
+
+    /**
+     * @brief CCAMERA initialize a camera
+     * @param aRangeScale: it will be expected that the board will have a -aRangeScale/2 to +aRangeScale/2
+     * it will initialize the initial Z position with aRangeScale
+     */
+    CCAMERA( float aRangeScale );
+
+
+    /**
+     *  Function GetRotationMatrix
+     *  Get the rotation matrix to be applied in a transformation camera
+     *  @return the rotation matrix of the camera
+     */
+    const glm::mat4 &GetRotationMatrix() const;
+
+    const glm::mat4 &GetViewMatrix() const;
+    const glm::mat4 &GetViewMatrix_Inv() const;
+
+    const glm::mat4 &GetProjectionMatrix() const;
+    const glm::mat4 &GetProjectionMatrixInv() const;
+
+    const SFVEC3F &GetRight()    const { return m_right; }
+    const SFVEC3F &GetUp()       const { return m_up; }
+    const SFVEC3F &GetDir()      const { return m_dir; }
+    const SFVEC3F &GetPos()      const { return m_pos; }
+    const SFVEC2F &GetFocalLen() const { return m_focalLen; }
+    float GetNear() const { return m_frustum.nearD; }
+    float GetFar() const { return m_frustum.farD; }
+
+    virtual void SetBoardLookAtPos( const SFVEC3F &aBoardPos ) = 0;
+
+    /**
+     *  Calculate a new mouse drag position
+     */
+    virtual void Drag( const wxPoint &aNewMousePosition )  = 0;
+
+    virtual void Pan( const wxPoint &aNewMousePosition )  = 0;
+
+    virtual void Pan( const SFVEC3F &aDeltaOffsetInc )  = 0;
+
+
+    /**
+     *  Reset the camera to initial state
+     */
+    virtual void Reset()  = 0;
+
+
+    /**
+     *  It updates the current mouse position without make any new recalculations on camera.
+     */
+    void SetCurMousePosition( const wxPoint &aPosition );
+
+    void SetProjection( PROJECTION_TYPE aProjectionType );
+
+    void SetCurWindowSize( const wxSize &aSize );
+
+    void ZoomReset();
+
+    void ZoomIn( float aFactor );
+
+    void ZoomOut( float aFactor );
+
+    float ZoomGet() const ;
+
+    /**
+     *  Function ParametersChanged
+     *  @return true if some of the parameters in camera was changed, it will reset the flag
+     */
+    bool ParametersChanged();
+
+    void MakeRay( const SFVEC2I &aWindowPos, SFVEC3F &aOutOrigin, SFVEC3F &aOutDirection ) const;
+
+    void GLdebug_Lines();
+
+    void GLdebug_Planes();
+
+    void GLdebug_Vectors();
+
+ protected:
+
+    void rebuildProjection();
+    void updateFrustum();
+    void updateViewMatrix();
+
+    /**
+     * @brief m_range_scale - the nominal range expected to be used in the camera.
+     * It will be used to initialize the Z position
+     */
+    float m_range_scale;
+
+    /**
+     *  3D zoom value (Min 0.0 ... Max 1.0)
+     */
+    float m_zoom;
+
+    /**
+     *  The window size that this camera is working.
+     */
+    wxSize m_windowSize;
+
+    /**
+     *  The last mouse position in the screen
+     */
+    wxPoint m_lastPosition;
+
+    glm::mat4 m_rotationMatrix;
+    glm::mat4 m_viewMatrix;
+    glm::mat4 m_viewMatrix_inverse;
+    glm::mat4 m_projectionMatrix;
+    glm::mat4 m_projectionMatrix_inv;
+    PROJECTION_TYPE m_projectionType;
+
+    FRUSTUM m_frustum;
+
+    SFVEC3F m_right;
+    SFVEC3F m_up;
+    SFVEC3F m_dir;
+    SFVEC3F m_pos;
+
+    SFVEC2F m_focalLen;
+
+    SFVEC3F m_camera_pos_init;
+    SFVEC3F m_camera_pos;
+
+    SFVEC3F m_boardLookAt_pos;
+
+    /**
+     *  Precalc values array used to calc ray for each pixel (constant for the same window size)
+     */
+    std::vector< float > m_scr_nX;
+    std::vector< float > m_scr_nY;
+
+    /**
+     *  Precalc values array used to calc ray for each pixel, for X and Y axis of each new camera position
+     */
+    std::vector< SFVEC3F > m_right_nX;
+    std::vector< SFVEC3F > m_up_nY;
+
+
+    /**
+     *  Set to true if any of the parameters in the camera was changed
+     */
+    bool m_parametersChanged;
+
+    /**
+     *  Trace mask used to enable or disable the trace output of this class.
+     *  The debug output can be turned on by setting the WXTRACE environment variable to
+     *  "KI_TRACE_CCAMERA".  See the wxWidgets documentation on wxLogTrace for
+     *  more information.
+     */
+    static const wxChar *m_logTrace;
+};
+
+#endif // CCAMERA_H
diff --git a/3d-viewer/3d_rendering/cimage.cpp b/3d-viewer/3d_rendering/cimage.cpp
new file mode 100644
index 0000000000..627706acee
--- /dev/null
+++ b/3d-viewer/3d_rendering/cimage.cpp
@@ -0,0 +1,519 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+ /**
+ * @file cimage.cpp
+ * @brief one 8bit-channel image implementation
+ */
+
+#include "cimage.h"
+#include <wx/image.h>                                                           // Used for save an image to disk
+#include <string.h>                                                             // For memcpy
+
+#ifndef CLAMP
+#define CLAMP(n, min, max) {if (n < min) n=min; else if (n > max) n = max;}
+#endif
+
+
+CIMAGE::CIMAGE( unsigned int aXsize, unsigned int aYsize )
+{
+    m_wxh     = aXsize * aYsize;
+    m_pixels  = (unsigned char*)malloc( m_wxh );
+    memset( m_pixels, 0, m_wxh );
+    m_width   = aXsize;
+    m_height  = aYsize;
+    m_wraping = (E_WRAP)WRAP_CLAMP;
+}
+
+
+CIMAGE::CIMAGE( const CIMAGE &aSrcImage )
+{
+    m_wxh     = aSrcImage.GetWidth() * aSrcImage.GetHeight();
+    m_pixels  = (unsigned char*)malloc( m_wxh );
+    memcpy( m_pixels, aSrcImage.GetBuffer(), m_wxh );
+    m_width   = aSrcImage.GetWidth();
+    m_height  = aSrcImage.GetHeight();
+    m_wraping = (E_WRAP)WRAP_CLAMP;
+}
+
+
+CIMAGE::~CIMAGE()
+{
+    free( m_pixels );
+}
+
+
+unsigned char* CIMAGE::GetBuffer() const
+{
+    return m_pixels;
+}
+
+
+bool CIMAGE::wrapCoords( int *aXo, int *aYo ) const
+{
+    int x = *aXo;
+    int y = *aYo;
+
+    switch(m_wraping)
+    {
+    case WRAP_CLAMP:
+        x =  (x < 0 )?0:x;
+        x =  (x >= (int)(m_width - 1))?(m_width - 1):x;
+        y =  (y < 0)?0:y;
+        y =  (y >= (int)(m_height - 1))?(m_height - 1):y;
+        break;
+    case WRAP_WRAP:
+        x = (x < 0)?((m_width - 1)+x):x;
+        x = (x >= (int)(m_width - 1))?(x - m_width):x;
+        y = (y < 0)?((m_height - 1)+y):y;
+        y = (y >= (int)(m_height - 1))?(y - m_height):y;
+        break;
+    default:
+        break;
+    }
+    
+    if( (x < 0) || (x >= (int)m_width) ||
+        (y < 0) || (y >= (int)m_height) )
+        return false;
+    
+    *aXo = x;
+    *aYo = y;
+
+    return true;
+}
+
+void CIMAGE::plot8CircleLines( int aCx, int aCy, int aX, int aY, unsigned char aValue )
+{
+    Hline( aCx - aX, aCx + aX, aCy + aY, aValue );
+    Hline( aCx - aX, aCx + aX, aCy - aY, aValue );
+    Hline( aCx - aY, aCx + aY, aCy + aX, aValue );
+    Hline( aCx - aY, aCx + aY, aCy - aX, aValue );
+}
+
+
+void CIMAGE::Setpixel( int aX, int aY, unsigned char aValue )
+{
+    if( wrapCoords( &aX, &aY ) )
+        m_pixels[aX + aY * m_width] = aValue;
+}
+
+
+unsigned char CIMAGE::Getpixel( int aX, int aY ) const
+{
+    if( wrapCoords( &aX, &aY ) )
+        return m_pixels[aX + aY * m_width];
+    else
+        return 0;
+}
+
+
+void CIMAGE::Hline( int aXStart, int aXEnd, int aY, unsigned char aValue )
+{
+    if( ( aY < 0 ) ||
+        ( aY >= (int)m_height ) ||
+        ( ( aXStart < 0 ) && ( aXEnd < 0) ) ||
+        ( ( aXStart >= (int)m_width ) && ( aXEnd >= (int)m_width) ) )
+        return;
+
+    if( aXStart > aXEnd )
+    {
+        int swap = aXStart;
+        aXStart = aXEnd;
+        aXEnd = swap;
+    }
+
+    // Clamp line
+    if( aXStart < 0 )
+        aXStart = 0;
+
+    if( aXEnd >= (int)m_width )
+        aXEnd = m_width - 1;
+
+    unsigned char* pixelPtr = &m_pixels[aXStart + aY * m_width];
+    unsigned char* pixelPtrEnd = pixelPtr + (unsigned int)((aXEnd - aXStart) + 1);
+
+    while( pixelPtr < pixelPtrEnd )
+    {
+        *pixelPtr = aValue;
+        pixelPtr++;
+    }
+}
+
+// Based on paper
+// http://web.engr.oregonstate.edu/~sllu/bcircle.pdf
+void CIMAGE::CircleFilled(int aCx, int aCy, int aRadius, unsigned char aValue)
+{
+    int x = aRadius;
+    int y = 0;
+    int xChange = 1 - 2 * aRadius;
+    int yChange = 0;
+    int radiusError = 0;
+
+    while( x >= y )
+    {
+        plot8CircleLines( aCx, aCy, x, y, aValue );
+        y++;
+        radiusError += yChange;
+        yChange += 2;
+
+        if( (2 * radiusError + xChange) > 0 )
+        {
+            x--;
+            radiusError += xChange;
+            xChange += 2;
+        }
+    }
+}
+
+
+void CIMAGE::Invert()
+{
+    for( unsigned int it = 0; it < m_wxh; it++ )
+        m_pixels[it] = 255 - m_pixels[it];
+}
+
+
+void CIMAGE::CopyFull( const CIMAGE *aImgA, const CIMAGE *aImgB, E_IMAGE_OP aOperation )
+{
+    int aV, bV;
+
+    if( aOperation == COPY_RAW )
+    {
+        if ( aImgA == NULL )
+            return;
+    }
+    else
+    {
+        if ( (aImgA == NULL) || (aImgB == NULL) )
+            return; 
+    }
+
+    switch(aOperation)
+    {
+    case COPY_RAW:
+        memcpy( m_pixels, aImgA->m_pixels, m_wxh );
+    break;
+
+    case COPY_ADD:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            aV = (aV + bV);
+            aV = (aV > 255)?255:aV;
+
+            m_pixels[it] = aV;
+        }
+    break;
+
+    case COPY_SUB:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            aV = (aV - bV);
+            aV = (aV < 0)?0:aV;
+
+            m_pixels[it] = aV;
+        }
+    break;
+
+    case COPY_DIF:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            m_pixels[it] = abs(aV - bV);
+        }
+    break;
+
+    case COPY_MUL:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            m_pixels[it] = (unsigned char)((((float)aV / 255.0f) * ((float)bV / 255.0f)) * 255);
+        }
+    break;
+
+    case COPY_AND:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            m_pixels[it] = aImgA->m_pixels[it] & aImgB->m_pixels[it];
+        }
+    break;
+
+    case COPY_OR:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            m_pixels[it] = aImgA->m_pixels[it] | aImgB->m_pixels[it];
+        }
+    break;
+
+    case COPY_XOR:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            m_pixels[it] = aImgA->m_pixels[it] ^ aImgB->m_pixels[it];
+        }
+    break;
+    
+    case COPY_BLEND50:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            m_pixels[it] = (aV + bV) / 2;
+        }
+    break;
+
+    case COPY_MIN:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            m_pixels[it] = (aV < bV)?aV:bV;
+        }
+    break;
+
+    case COPY_MAX:
+        for( unsigned int it = 0;it < m_wxh; it++ )
+        {
+            aV = aImgA->m_pixels[it];
+            bV = aImgB->m_pixels[it];
+
+            m_pixels[it] = (aV > bV)?aV:bV;
+        }
+    break;
+
+    default:
+    break;
+    }
+}
+
+// TIP: If you want create or test filters you can use GIMP
+// with a generic convolution matrix and get the values from there.
+// http://docs.gimp.org/nl/plug-in-convmatrix.html
+static const S_FILTER FILTERS[] =   {
+    // Hi Pass
+    {
+    {   { 0, -1, -1, -1,  0},
+        {-1,  2, -4,  2, -1},
+        {-1, -4, 13, -4, -1},
+        {-1,  2, -4,  2, -1},
+        { 0, -1, -1, -1,  0}
+    },
+        7,
+        255
+    },
+    
+    // Blur
+    {
+    {   { 3,  5,  7,  5,  3},
+        { 5,  9, 12,  9,  5},
+        { 7, 12, 20, 12,  7},
+        { 5,  9, 12,  9,  5},
+        { 3,  5,  7,  5,  3}
+    },
+        182,
+        0
+    },
+
+    // Blur Invert
+    {
+    {   { 0,  0,  0,  0,  0},
+        { 0,  0, -1,  0,  0},
+        { 0, -1,  0, -1,  0},
+        { 0,  0, -1,  0,  0},
+        { 0,  0,  0,  0,  0}
+    },
+        4,
+        255
+    },
+
+    // Blur
+    {
+    {   { 1,  4,  7,  4,  1},
+        { 4, 16, 26, 16,  4},
+        { 7, 26, 41, 26,  7},
+        { 4, 16, 26, 16,  4},
+        { 1,  4,  7,  4,  1}
+    },
+        273,
+        0
+    },
+
+    // Cartoon
+    {
+    {   {-1, -1, -1, -1,  0},
+        {-1,  0,  0,  0,  0},
+        {-1,  0,  4,  0,  0},
+        { 0,  0,  0,  1,  0},
+        { 0,  0,  0,  0,  4}
+    },
+        3,
+        0
+    },
+
+    // Emboss
+    {
+    {   {-1, -1, -1, -1,  0},
+        {-1, -1, -1,  0,  1},
+        {-1, -1,  0,  1,  1},
+        {-1,  0,  1,  1,  1},
+        { 0,  1,  1,  1,  1}
+    },
+        1,
+        128
+    },
+
+    // Sharpen
+    {
+    {   {-1, -1, -1, -1, -1},
+        {-1,  2,  2,  2, -1},
+        {-1,  2,  8,  2, -1},
+        {-1,  2,  2,  2, -1},
+        {-1, -1, -1, -1, -1}
+    },
+        8,
+        0
+    },
+
+    // Melt
+    {
+    {   { 4,  2,  6,  8,  1},
+        { 1,  2,  5,  4,  2},
+        { 0, -1,  1, -1,  0},
+        { 0,  0, -2,  0,  0},
+        { 0,  0,  0,  0,  0}
+    },
+        32,
+        0
+    },
+
+    // Sobel Gx
+    {
+    {   { 0,  0,  0,  0,  0},
+        { 0, -1,  0,  1,  0},
+        { 0, -2,  0,  2,  0},
+        { 0, -1,  0,  1,  0},
+        { 0,  0,  0,  0,  0}
+    },
+        1,
+        0
+    },
+
+    // Sobel Gy
+    {
+    {   { 1,  2,  4,  2,  1},
+        {-1, -1,  0,  1,  1},
+        {-2, -2,  0,  2,  2},
+        {-1, -1,  0,  1,  1},
+        {-1, -2, -4, -2, -1},
+    },
+        1,
+        0
+    }
+};// Filters
+
+
+//!TODO: This functions can be optimized slipting it between the edges and
+//       do it without use the getpixel function.
+//       Optimization can be done to m_pixels[ix + iy * m_width]
+//       but keep in mind the parallel process of the algorithm
+void CIMAGE::EfxFilter( CIMAGE *aInImg, E_FILTER aFilterType )
+{
+    S_FILTER filter = FILTERS[aFilterType];
+
+    aInImg->m_wraping = WRAP_CLAMP;
+    m_wraping = WRAP_CLAMP;
+
+    #ifdef USE_OPENMP
+    #pragma omp parallel for
+    #endif /* USE_OPENMP */
+    
+    for( int iy = 0; iy < (int)m_height; iy++)
+    {
+        for( int ix = 0; ix < (int)m_width; ix++ )
+        {
+            int v = 0;
+
+            for( int sy = 0; sy < 5; sy++ )
+            {
+                for( int sx = 0; sx < 5; sx++ )
+                {
+                    int factor = filter.kernel[sx][sy];
+                    unsigned char pixelv = aInImg->Getpixel( ix + sx - 2, iy + sy - 2 );
+                    v += pixelv * factor;
+                }
+            }
+            
+            v /= filter.div;
+
+            v += filter.offset;
+
+            CLAMP(v, 0, 255);
+
+            m_pixels[ix + iy * m_width] = v;
+        }
+    }
+}
+
+
+void CIMAGE::SetPixelsFromNormalizedFloat( const float * aNormalizedFloatArray )
+{
+    for( unsigned int i = 0; i < m_wxh; i++ )
+    {
+        int v = aNormalizedFloatArray[i] * 255;
+        CLAMP(v, 0, 255);
+        m_pixels[i] = v;
+    }
+}
+
+
+void CIMAGE::SaveAsPNG( wxString aFileName ) const
+{
+    unsigned char* pixelbuffer = (unsigned char*) malloc( m_wxh * 3 );
+   
+    wxImage image( m_width, m_height );
+
+    for( unsigned int i = 0; i < m_wxh; i++)
+    {
+        unsigned char v = m_pixels[i];
+        // Set RGB value with all same values intensities
+        pixelbuffer[i * 3 + 0] = v;
+        pixelbuffer[i * 3 + 1] = v;
+        pixelbuffer[i * 3 + 2] = v;
+    }
+
+    image.SetData( pixelbuffer );
+    image = image.Mirror( false );
+    image.SaveFile( aFileName + ".png", wxBITMAP_TYPE_PNG );
+    image.Destroy();
+}
diff --git a/3d-viewer/3d_rendering/cimage.h b/3d-viewer/3d_rendering/cimage.h
new file mode 100644
index 0000000000..88e6f8de3e
--- /dev/null
+++ b/3d-viewer/3d_rendering/cimage.h
@@ -0,0 +1,221 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+ /**
+ * @file cimage.h
+ * @brief one 8bit-channel image definition
+ */
+
+#ifndef CIMAGE_H
+#define CIMAGE_H
+
+#include <wx/string.h>
+
+/// Image operation type
+enum E_IMAGE_OP {
+    COPY_RAW,
+    COPY_ADD,
+    COPY_SUB,
+    COPY_DIF,
+    COPY_MUL,
+    COPY_AND,
+    COPY_OR,
+    COPY_XOR,
+    COPY_BLEND50,
+    COPY_MIN,
+    COPY_MAX
+};
+
+
+/// Image wrap type enumeration
+enum E_WRAP {
+    WRAP_ZERO,      ///< Coords that wraps are not evaluated
+    WRAP_CLAMP,     ///< Coords are clamped to image size
+    WRAP_WRAP       ///< Coords are wrapped arround
+};
+
+
+/// Filter type enumeration
+enum E_FILTER {
+    FILTER_HIPASS,
+    FILTER_GAUSSIAN_BLUR,
+    FILTER_INVERT_BLUR,
+    FILTER_GAUSSIAN_BLUR2,
+};
+
+/// 5x5 Filter struct parameters
+typedef struct {
+    signed char    kernel[5][5];
+    unsigned char  div;
+    unsigned char  offset;
+}S_FILTER;
+
+
+/**
+ * Class CIMAGE
+ * manages a 8-bit channel image
+ */
+class CIMAGE
+{
+
+public:
+
+    /**
+     * Constructor CIMAGE
+     * constructs a CIMAGE based on image size
+     * @param aXsize x size
+     * @param aYsize y size
+     */
+    CIMAGE( unsigned int aXsize, unsigned int aYsize );
+
+    /**
+     * @brief CIMAGE
+     * constructs a CIMAGE based on an existent image. It will copy the image to
+     * the new
+     * @param aSrcImage
+     */
+    CIMAGE( const CIMAGE &aSrcImage );
+
+    ~CIMAGE();
+
+    /**
+     * Function Setpixel
+     * set a value in a pixel position, position is clamped in accord with the
+     * current clamp settings
+     * @param aX x position
+     * @param aY y position
+     * @param aValue value to set the pixel
+     */
+    void Setpixel( int aX, int aY, unsigned char aValue );
+    
+    /**
+     * Function Getpixel
+     * get the pixel value from pixel position, position is clamped in accord with the
+     * current clamp settings
+     * @param aX x position
+     * @param aY y position
+     * @return unsigned char - pixel value
+     */
+    unsigned char Getpixel( int aX, int aY ) const;
+
+    /**
+     * @brief hline - Draws an horizontal line
+     * @param aXStart - x start position
+     * @param aXEnd - x end position
+     * @param aY - y positoin
+     * @param aValue - value to add
+     */
+    void Hline( int aXStart, int aXEnd, int aY, unsigned char aValue );
+
+    /**
+     * @brief CircleFilled
+     * @param aCx
+     * @param aCy
+     * @param aRadius
+     * @param aValue
+     */
+    void CircleFilled( int aCx, int aCy, int aRadius, unsigned char aValue );
+
+    /**
+     * Function CopyFull
+     * perform a copy operation, based on operation type. The result destination is the self image class
+     * @param aImgA an image input
+     * @param aImgB an image input
+     * @param aOperation operation to perform
+     *  COPY_RAW        this <- aImgA
+     *  COPY_ADD        this <- CLAMP(aImgA + aImgB)
+     *  COPY_SUB        this <- CLAMP(aImgA - aImgB)
+     *  COPY_DIF        this <- abs(aImgA - aImgB)
+     *  COPY_MUL        this <- aImgA * aImgB
+     *  COPY_AND        this <- aImgA & aImgB
+     *  COPY_OR         this <- aImgA | aImgB
+     *  COPY_XOR        this <- aImgA ^ aImgB
+     *  COPY_BLEND50    this <- (aImgA + aImgB) / 2
+     *  COPY_MIN        this <- (aImgA < aImgB)?aImgA:aImgB
+     *  COPY_MAX        this <- (aImgA > aImgB)?aImgA:aImgB
+     */
+    void CopyFull( const CIMAGE *aImgA, const CIMAGE *aImgB, E_IMAGE_OP aOperation );
+
+    /**
+     * Function Invert
+     * invert the values of image this <- (255 - this)
+     */
+    void Invert();
+
+    /**
+     * Function EfxFilter
+     * apply a filter to the input image and stores it in the image class
+     * this <- FilterType(aInImg)
+     * @param aInImg input image
+     * @param aFilterType filter type to apply
+     */
+    void EfxFilter( CIMAGE *aInImg, E_FILTER aFilterType );
+
+    /**
+     * Function SaveAsPNG
+     * save image buffer to a PNG file into the working folder.
+     * each of RGB channel will have the 8bit-channel from the image.
+     * @param aFileName fime name (without extension)
+     */
+    void SaveAsPNG( wxString aFileName ) const;
+
+    /**
+     * Function SetPixelsFromNormalizedFloat
+     * set the current channel from a float normalized (0.0 - 1.0) buffer
+     * this <- CLAMP(NormalizedFloat * 255)
+     * @param aNormalizedFloatArray a float array with the same size of the image
+     */
+    void SetPixelsFromNormalizedFloat( const float * aNormalizedFloatArray );
+
+    /**
+     * Function GetBuffer
+     * get the image buffer pointer
+     * @return unsigned char * - the pointer of the buffer 8bit channel
+     */
+    unsigned char* GetBuffer() const;
+
+    unsigned int GetWidth() const { return m_width; }
+    unsigned int GetHeight() const { return m_height; }
+private:
+
+    /**
+     * Function wrapCoords
+     * calculate the coordinates points in accord with the current clamping settings
+     * @param aXo X coordinate to be converted (output)
+     * @param aXo Y coordinate to be converted (output)
+     * @return bool - true if the coordinates are inside the image, false otherwise
+     */
+    bool wrapCoords( int *aXo, int *aYo ) const;
+
+    void plot8CircleLines( int aCx, int aCy, int aX, int aY, unsigned char aValue );
+
+private:
+    unsigned char*  m_pixels;           ///< buffer to store the image 8bit-channel
+    unsigned int    m_width;            ///< width of the image
+    unsigned int    m_height;           ///< height of the image
+    unsigned int    m_wxh;              ///< width * height precalc value
+    E_WRAP          m_wraping;          ///< current wrapping type
+};
+
+#endif   // CIMAGE_H
diff --git a/3d-viewer/3d_rendering/ctrack_ball.cpp b/3d-viewer/3d_rendering/ctrack_ball.cpp
new file mode 100644
index 0000000000..517116bab3
--- /dev/null
+++ b/3d-viewer/3d_rendering/ctrack_ball.cpp
@@ -0,0 +1,117 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ctrack_ball.cpp
+ * @brief
+ */
+
+#include "common_ogl/openGL_includes.h"
+#include "ctrack_ball.h"
+#include "trackball.h"
+#include <wx/log.h>
+
+
+CTRACK_BALL::CTRACK_BALL( float aRangeScale ) : CCAMERA( aRangeScale )
+{
+    wxLogTrace( m_logTrace, wxT( "CTRACK_BALL::CTRACK_BALL" ) );
+
+    memset( m_quat, 0, sizeof( m_quat ) );
+    trackball( m_quat, 0.0, 0.0, 0.0, 0.0 );
+}
+
+
+void CTRACK_BALL::Drag( const wxPoint &aNewMousePosition )
+{
+    m_parametersChanged = true;
+
+    double spin_quat[4];
+
+    // "Pass the x and y coordinates of the last and current positions of
+    //  the mouse, scaled so they are from (-1.0 ... 1.0)."
+    float zoom = std::min( m_zoom, 1.0f );
+    trackball( spin_quat,
+               zoom * (2.0 * m_lastPosition.x - m_windowSize.x) / m_windowSize.x,
+               zoom * (m_windowSize.y - 2.0 * m_lastPosition.y) / m_windowSize.y,
+               zoom * (2.0 * aNewMousePosition.x - m_windowSize.x) / m_windowSize.x,
+               zoom * ( m_windowSize.y - 2.0 * aNewMousePosition.y ) / m_windowSize.y);
+
+    add_quats( spin_quat, m_quat, m_quat );
+
+    GLfloat rotationMatrix[4][4];
+
+    build_rotmatrix( rotationMatrix, m_quat );
+
+    m_rotationMatrix = glm::make_mat4( &rotationMatrix[0][0] );
+
+    updateViewMatrix();
+
+    updateFrustum();
+}
+
+void CTRACK_BALL::SetBoardLookAtPos( const SFVEC3F &aBoardPos )
+{
+    if( m_boardLookAt_pos != aBoardPos )
+    {
+        m_boardLookAt_pos = -aBoardPos;
+
+        updateViewMatrix();
+        updateFrustum();
+        m_parametersChanged = true;
+    }
+}
+
+void CTRACK_BALL::Pan( const wxPoint &aNewMousePosition )
+{
+    m_parametersChanged = true;
+
+    // Current zoom and an additional factor are taken into account
+    // for the amount of panning.
+
+    float zoom = std::min( m_zoom, 1.0f );
+    float panFactor = m_range_scale * zoom * (zoom * 4.0f);
+    m_camera_pos.x -= panFactor * ( m_lastPosition.x - aNewMousePosition.x ) / m_windowSize.x;
+    m_camera_pos.y -= panFactor * (aNewMousePosition.y - m_lastPosition.y ) / m_windowSize.y;
+
+    updateViewMatrix();
+    updateFrustum();
+}
+
+
+void CTRACK_BALL::Pan( const SFVEC3F &aDeltaOffsetInc )
+{
+    m_parametersChanged = true;
+
+    m_camera_pos += aDeltaOffsetInc;
+
+    updateViewMatrix();
+    updateFrustum();
+}
+
+
+void CTRACK_BALL::Reset()
+{
+    m_parametersChanged = true;
+}
+
diff --git a/3d-viewer/3d_rendering/ctrack_ball.h b/3d-viewer/3d_rendering/ctrack_ball.h
new file mode 100644
index 0000000000..435af66a3d
--- /dev/null
+++ b/3d-viewer/3d_rendering/ctrack_ball.h
@@ -0,0 +1,63 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ctrack_ball.h
+ * @brief
+ */
+
+#ifndef CTRACK_BALL_H
+#define CTRACK_BALL_H
+
+#include "ccamera.h"
+
+
+class CTRACK_BALL : public CCAMERA
+{
+
+ public:
+
+    CTRACK_BALL( float aRangeScale );
+
+    void Drag( const wxPoint &aNewMousePosition );
+
+    void Pan( const wxPoint &aNewMousePosition );
+
+    void Pan( const SFVEC3F &aDeltaOffsetInc );
+
+    void SetBoardLookAtPos( const SFVEC3F &aBoardPos );
+
+    void Reset();
+
+
+ private:
+
+    /**
+     *  quarternion of the trackball
+     */
+    double m_quat[4];
+
+};
+
+#endif // CTRACK_BALL_H
diff --git a/3d-viewer/3d_rendering/trackball.cpp b/3d-viewer/3d_rendering/trackball.cpp
new file mode 100644
index 0000000000..b70ef438fe
--- /dev/null
+++ b/3d-viewer/3d_rendering/trackball.cpp
@@ -0,0 +1,323 @@
+/*
+ * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
+ * ALL RIGHTS RESERVED
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose and without fee is hereby granted, provided that the above
+ * copyright notice appear in all copies and that both the copyright notice
+ * and this permission notice appear in supporting documentation, and that
+ * the name of Silicon Graphics, Inc. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.
+ *
+ * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
+ * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
+ * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
+ * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
+ * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
+ * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
+ * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
+ * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
+ * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * US Government Users Restricted Rights
+ * Use, duplication, or disclosure by the Government is subject to
+ * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+ * (c)(1)(ii) of the Rights in Technical Data and Computer Software
+ * clause at DFARS 252.227-7013 and/or in similar or successor
+ * clauses in the FAR or the DOD or NASA FAR Supplement.
+ * Unpublished-- rights reserved under the copyright laws of the
+ * United States.  Contractor/manufacturer is Silicon Graphics,
+ * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
+ *
+ * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+ */
+/*
+ * Trackball code:
+ *
+ * Implementation of a virtual trackball.
+ * Implemented by Gavin Bell, lots of ideas from Thant Tessman and
+ *   the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129.
+ *
+ * Vector manip code:
+ *
+ * Original code from:
+ * David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli
+ *
+ * Much mucking with by:
+ * Gavin Bell
+ */
+#include <cmath>
+#include <wx/glcanvas.h>     // used only to define GLfloat
+#include <trackball.h>
+
+/*
+ * This size should really be based on the distance from the center of
+ * rotation to the point on the object underneath the mouse.  That
+ * point would then track the mouse as closely as possible.  This is a
+ * simple example, though, so that is left as an Exercise for the
+ * Programmer.
+ */
+#define TRACKBALLSIZE  (0.8f)
+
+/*
+ * Local function prototypes (not defined in trackball.h)
+ */
+static double tb_project_to_sphere(double, double, double);
+static void normalize_quat(double [4]);
+
+void
+vzero(double *v)
+{
+    v[0] = 0.0;
+    v[1] = 0.0;
+    v[2] = 0.0;
+}
+
+void
+vset(double *v, double x, double y, double z)
+{
+    v[0] = x;
+    v[1] = y;
+    v[2] = z;
+}
+
+void
+vsub(const double *src1, const double *src2, double *dst)
+{
+    dst[0] = src1[0] - src2[0];
+    dst[1] = src1[1] - src2[1];
+    dst[2] = src1[2] - src2[2];
+}
+
+void
+vcopy(const double *v1, double *v2)
+{
+    register int i;
+    for (i = 0 ; i < 3 ; i++)
+        v2[i] = v1[i];
+}
+
+void
+vcross(const double *v1, const double *v2, double *cross)
+{
+    double temp[3];
+
+    temp[0] = (v1[1] * v2[2]) - (v1[2] * v2[1]);
+    temp[1] = (v1[2] * v2[0]) - (v1[0] * v2[2]);
+    temp[2] = (v1[0] * v2[1]) - (v1[1] * v2[0]);
+    vcopy(temp, cross);
+}
+
+double
+vlength(const double *v)
+{
+    return (double) sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+
+void
+vscale(double *v, double div)
+{
+    v[0] *= div;
+    v[1] *= div;
+    v[2] *= div;
+}
+
+void
+vnormal(double *v)
+{
+    vscale(v, 1.0f/vlength(v));
+}
+
+double
+vdot(const double *v1, const double *v2)
+{
+    return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+}
+
+void
+vadd(const double *src1, const double *src2, double *dst)
+{
+    dst[0] = src1[0] + src2[0];
+    dst[1] = src1[1] + src2[1];
+    dst[2] = src1[2] + src2[2];
+}
+
+/*
+ * Ok, simulate a track-ball.  Project the points onto the virtual
+ * trackball, then figure out the axis of rotation, which is the cross
+ * product of P1 P2 and O P1 (O is the center of the ball, 0,0,0)
+ * Note:  This is a deformed trackball-- is a trackball in the center,
+ * but is deformed into a hyperbolic sheet of rotation away from the
+ * center.  This particular function was chosen after trying out
+ * several variations.
+ *
+ * It is assumed that the arguments to this routine are in the range
+ * (-1.0 ... 1.0)
+ */
+void
+trackball(double q[4], double p1x, double p1y, double p2x, double p2y)
+{
+    double a[3]; /* Axis of rotation */
+    double phi;  /* how much to rotate about axis */
+    double p1[3], p2[3], d[3];
+    double t;
+
+    if (p1x == p2x && p1y == p2y) {
+        /* Zero rotation */
+        vzero(q);
+        q[3] = 1.0;
+        return;
+    }
+
+    /*
+     * First, figure out z-coordinates for projection of P1 and P2 to
+     * deformed sphere
+     */
+    vset(p1, p1x, p1y, tb_project_to_sphere(TRACKBALLSIZE, p1x, p1y));
+    vset(p2, p2x, p2y, tb_project_to_sphere(TRACKBALLSIZE, p2x, p2y));
+
+    /*
+     *  Now, we want the cross product of P1 and P2
+     */
+    vcross(p2,p1,a);
+
+    /*
+     *  Figure out how much to rotate around that axis.
+     */
+    vsub(p1, p2, d);
+    t = vlength(d) / (2.0f*TRACKBALLSIZE);
+
+    /*
+     * Avoid problems with out-of-control values...
+     */
+    if (t > 1.0) t = 1.0;
+    if (t < -1.0) t = -1.0;
+    phi = 2.0f * (double) asin(t);
+
+    axis_to_quat(a,phi,q);
+}
+
+/*
+ *  Given an axis and angle, compute quaternion.
+ */
+void
+axis_to_quat(double a[3], double phi, double q[4])
+{
+    vnormal(a);
+    vcopy(a, q);
+    vscale(q, (double) sin(phi/2.0));
+    q[3] = (double) cos(phi/2.0);
+}
+
+/*
+ * Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
+ * if we are away from the center of the sphere.
+ */
+static double
+tb_project_to_sphere(double r, double x, double y)
+{
+    double d, t, z;
+
+    d = (double) sqrt(x*x + y*y);
+    if (d < r * 0.70710678118654752440) {    /* Inside sphere */
+        z = (double) sqrt(r*r - d*d);
+    } else {           /* On hyperbola */
+        t = r / 1.41421356237309504880f;
+        z = t*t / d;
+    }
+    return z;
+}
+
+/*
+ * Given two rotations, e1 and e2, expressed as quaternion rotations,
+ * figure out the equivalent single rotation and stuff it into dest.
+ *
+ * This routine also normalizes the result every RENORMCOUNT times it is
+ * called, to keep error from creeping in.
+ *
+ * NOTE: This routine is written so that q1 or q2 may be the same
+ * as dest (or each other).
+ */
+
+#define RENORMCOUNT 97
+
+void
+add_quats(double q1[4], double q2[4], double dest[4])
+{
+    static int count=0;
+    double t1[4], t2[4], t3[4];
+    double tf[4];
+
+    vcopy(q1,t1);
+    vscale(t1,q2[3]);
+
+    vcopy(q2,t2);
+    vscale(t2,q1[3]);
+
+    vcross(q2,q1,t3);
+    vadd(t1,t2,tf);
+    vadd(t3,tf,tf);
+    tf[3] = q1[3] * q2[3] - vdot(q1,q2);
+
+    dest[0] = tf[0];
+    dest[1] = tf[1];
+    dest[2] = tf[2];
+    dest[3] = tf[3];
+
+    if (++count > RENORMCOUNT) {
+        count = 0;
+        normalize_quat(dest);
+    }
+}
+
+/*
+ * Quaternions always obey:  a^2 + b^2 + c^2 + d^2 = 1.0
+ * If they don't add up to 1.0, dividing by their magnitued will
+ * renormalize them.
+ *
+ * Note: See the following for more information on quaternions:
+ *
+ * - Shoemake, K., Animating rotation with quaternion curves, Computer
+ *   Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254, 1985.
+ * - Pletinckx, D., Quaternion calculus as a basic tool in computer
+ *   graphics, The Visual Computer 5, 2-13, 1989.
+ */
+static void normalize_quat(double q[4])
+{
+    int i;
+    double mag;
+
+    mag = (q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
+    for (i = 0; i < 4; i++) q[i] /= mag;
+}
+
+/*
+ * Build a rotation matrix, given a quaternion rotation.
+ *
+ */
+void build_rotmatrix(GLfloat m[4][4], double q[4])
+{
+    m[0][0] = 1.0f - 2.0f * (q[1] * q[1] + q[2] * q[2]);
+    m[0][1] = 2.0f * (q[0] * q[1] - q[2] * q[3]);
+    m[0][2] = 2.0f * (q[2] * q[0] + q[1] * q[3]);
+    m[0][3] = 0.0f;
+
+    m[1][0] = 2.0f * (q[0] * q[1] + q[2] * q[3]);
+    m[1][1]= 1.0f - 2.0f * (q[2] * q[2] + q[0] * q[0]);
+    m[1][2] = 2.0f * (q[1] * q[2] - q[0] * q[3]);
+    m[1][3] = 0.0f;
+
+    m[2][0] = 2.0f * (q[2] * q[0] - q[1] * q[3]);
+    m[2][1] = 2.0f * (q[1] * q[2] + q[0] * q[3]);
+    m[2][2] = 1.0f - 2.0f * (q[1] * q[1] + q[0] * q[0]);
+    m[2][3] = 0.0f;
+
+    m[3][0] = 0.0f;
+    m[3][1] = 0.0f;
+    m[3][2] = 0.0f;
+    m[3][3] = 1.0f;
+}
+
diff --git a/3d-viewer/3d_rendering/trackball.h b/3d-viewer/3d_rendering/trackball.h
new file mode 100644
index 0000000000..a860dff673
--- /dev/null
+++ b/3d-viewer/3d_rendering/trackball.h
@@ -0,0 +1,74 @@
+/*
+ * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
+ * ALL RIGHTS RESERVED
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose and without fee is hereby granted, provided that the above
+ * copyright notice appear in all copies and that both the copyright notice
+ * and this permission notice appear in supporting documentation, and that
+ * the name of Silicon Graphics, Inc. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.
+ *
+ * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
+ * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
+ * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
+ * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
+ * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
+ * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
+ * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
+ * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
+ * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * US Government Users Restricted Rights
+ * Use, duplication, or disclosure by the Government is subject to
+ * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+ * (c)(1)(ii) of the Rights in Technical Data and Computer Software
+ * clause at DFARS 252.227-7013 and/or in similar or successor
+ * clauses in the FAR or the DOD or NASA FAR Supplement.
+ * Unpublished-- rights reserved under the copyright laws of the
+ * United States.  Contractor/manufacturer is Silicon Graphics,
+ * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
+ *
+ * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+ */
+/*
+ * trackball.h
+ * A virtual trackball implementation
+ * Written by Gavin Bell for Silicon Graphics, November 1988.
+ */
+
+/*
+ * Pass the x and y coordinates of the last and current positions of
+ * the mouse, scaled so they are from (-1.0 ... 1.0).
+ *
+ * The resulting rotation is returned as a quaternion rotation in the
+ * first paramater.
+ */
+void trackball(double q[4], double p1x, double p1y, double p2x, double p2y);
+
+/*
+ * Given two quaternions, add them together to get a third quaternion.
+ * Adding quaternions to get a compound rotation is analagous to adding
+ * translations to get a compound translation.  When incrementally
+ * adding rotations, the first argument here should be the new
+ * rotation, the second and third the total rotation (which will be
+ * over-written with the resulting new total rotation).
+ */
+void add_quats(double *q1, double *q2, double *dest);
+
+/*
+ * A useful function, builds a rotation matrix in Matrix based on
+ * given quaternion.
+ */
+void build_rotmatrix(GLfloat m[4][4], double q[4]);
+
+/*
+ * This function computes a quaternion based on an axis (defined by
+ * the given vector) and an angle about which to rotate.  The angle is
+ * expressed in radians.  The result is put into the third argument.
+ */
+void axis_to_quat(double a[3], double phi, double q[4]);
+
diff --git a/3d-viewer/3d_struct.h b/3d-viewer/3d_struct.h
index bd8a9345be..fc855672dc 100644
--- a/3d-viewer/3d_struct.h
+++ b/3d-viewer/3d_struct.h
@@ -35,7 +35,7 @@
 #include <base_struct.h>
 #include <3d_material.h>
 #include <3d_types.h>
-#include <CBBox.h>
+#include "3d_rendering/3d_render_raytracing/shapes3D/cbbox.h"
 
 
 class S3D_MASTER;
diff --git a/3d-viewer/3d_types.h b/3d-viewer/3d_types.h
index 9301cb69d2..d49ab66334 100644
--- a/3d-viewer/3d_types.h
+++ b/3d-viewer/3d_types.h
@@ -30,7 +30,7 @@
 #define _3D_TYPES_H_
 
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/glm.hpp>
+#include <glm/glm.hpp>
 #include <base_units.h>     // for IU_PER_MILS
 
 
diff --git a/3d-viewer/3d_xv3d/xv3d_types.h b/3d-viewer/3d_xv3d/xv3d_types.h
new file mode 100644
index 0000000000..24325ed7fc
--- /dev/null
+++ b/3d-viewer/3d_xv3d/xv3d_types.h
@@ -0,0 +1,56 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  xv3d_types.h
+ * @brief
+ */
+
+#ifndef XV3D_TYPES_H
+#define XV3D_TYPES_H
+
+#define GLM_FORCE_RADIANS
+#include <glm.hpp>
+#include <gtc/matrix_transform.hpp>
+#include <gtc/type_ptr.hpp>
+#include <gtx/matrix_major_storage.hpp>
+#include <gtx/matrix_decompose.hpp>
+#include <gtx/quaternion.hpp>
+#include <gtx/fast_square_root.hpp>
+#include <gtx/rotate_vector.hpp>
+//#include <gtx/simd_vec4.hpp>
+
+typedef glm::uvec2  SFVEC2UI;
+typedef glm::ivec2  SFVEC2I;
+typedef glm::vec2   SFVEC2F;
+typedef glm::dvec2  SFVEC2D;
+typedef glm::vec3   SFVEC3F;
+typedef glm::dvec3  SFVEC3D;
+typedef glm::vec4   SFVEC4F;
+typedef glm::uvec3  SFVEC3UI;
+typedef glm::dvec3  SFVEC3D;
+
+#define CLASS_ALIGNMENT 16
+
+#endif // XV3D_TYPES_H
diff --git a/3d-viewer/CBBox.cpp b/3d-viewer/CBBox.cpp
deleted file mode 100644
index 23c1856a99..0000000000
--- a/3d-viewer/CBBox.cpp
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- * This program source code file is part of KiCad, a free EDA CAD application.
- *
- * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
- * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, you may find one here:
- * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
- * or you may search the http://www.gnu.org website for the version 2 license,
- * or you may write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
- */
-
- /**
- * @file CBBox.cpp
- * @brief Bounding Box class implementation
- */
-
-#include "CBBox.h"
-
-
-// openGL includes used for debug the bounding box
-#ifdef __WXMAC__
-#  ifdef __DARWIN__
-#    include <OpenGL/glu.h>
-#  else
-#    include <glu.h>
-#  endif
-#else
-#  include <GL/glu.h>
-#endif
-
-CBBOX::CBBOX()
-{
-    Reset();
-}
-
-CBBOX::CBBOX( const S3D_VERTEX &aPbInit )
-{
-    m_min = aPbInit;
-    m_max = aPbInit;
-
-    m_initialized = true;
-}
-
-CBBOX::CBBOX( const S3D_VERTEX &aPbMin, const S3D_VERTEX &aPbMax )
-{
-    Set( aPbMin, aPbMax );
-}
-
-CBBOX::~CBBOX()
-{
-}
-
-void CBBOX::Set( const S3D_VERTEX &aPbMin, const S3D_VERTEX &aPbMax )
-{
-    m_min.x =  glm::min( aPbMin.x, aPbMax.x );
-    m_min.y =  glm::min( aPbMin.y, aPbMax.y );
-    m_min.z =  glm::min( aPbMin.z, aPbMax.z );
-
-    m_max.x =  glm::max( aPbMin.x, aPbMax.x );
-    m_max.y =  glm::max( aPbMin.y, aPbMax.y );
-    m_max.z =  glm::max( aPbMin.z, aPbMax.z );
-
-    m_initialized = true;
-}
-
-bool CBBOX::IsInitialized() const
-{
-    return m_initialized;
-}
-
-void CBBOX::Reset()
-{
-    m_min = S3D_VERTEX( 0.0f, 0.0f, 0.0f );
-    m_max = S3D_VERTEX( 0.0f, 0.0f, 0.0f );
-
-    m_initialized = false;
-}
-
-void CBBOX::Union( const S3D_VERTEX &aPoint )
-{
-    if( !m_initialized )
-    {
-        m_initialized = true;
-        // Initialize the bounding box with the given point
-        m_min = aPoint;
-        m_max = aPoint;
-    }
-    else
-    {
-        // get the minimun value between the added point and the existent bounding box
-        m_min.x =  glm::min( m_min.x, aPoint.x );
-        m_min.y =  glm::min( m_min.y, aPoint.y );
-        m_min.z =  glm::min( m_min.z, aPoint.z );
-
-        // get the maximun value between the added point and the existent bounding box
-        m_max.x =  glm::max( m_max.x, aPoint.x );
-        m_max.y =  glm::max( m_max.y, aPoint.y );
-        m_max.z =  glm::max( m_max.z, aPoint.z );
-    }   
-}
-
-
-void CBBOX::Union( const CBBOX &aBBox )
-{
-    if( aBBox.m_initialized == false )
-        return;
-    
-    if( !m_initialized )
-    {
-        // Initialize the bounding box with the given bounding box
-        m_initialized = true;
-        m_min = aBBox.m_min;
-        m_max = aBBox.m_max;
-    }
-    else
-    {
-        // get the minimun value between the added bounding box and the existent bounding box
-        m_min.x =  glm::min( m_min.x, aBBox.m_min.x );
-        m_min.y =  glm::min( m_min.y, aBBox.m_min.y );
-        m_min.z =  glm::min( m_min.z, aBBox.m_min.z );
-
-        // get the maximun value between the added bounding box and the existent bounding box
-        m_max.x =  glm::max( m_max.x, aBBox.m_max.x );
-        m_max.y =  glm::max( m_max.y, aBBox.m_max.y );
-        m_max.z =  glm::max( m_max.z, aBBox.m_max.z );
-    }
-}
-
-
-S3D_VERTEX CBBOX::GetCenter() const
-{
-    return (m_max + m_min) * 0.5f;
-}
-
-S3D_VERTEX CBBOX::Min() const
-{
-    return m_min;
-}
-
-S3D_VERTEX CBBOX::Max() const
-{
-    return m_max;
-}
-
-void CBBOX::Scale( float aScale )
-{
-    if( m_initialized == false )
-        return;
-    
-    S3D_VERTEX scaleV  = S3D_VERTEX( aScale, aScale, aScale );
-    S3D_VERTEX centerV = GetCenter();
-
-    m_min = (m_min - centerV) * scaleV + centerV;
-    m_max = (m_max - centerV) * scaleV + centerV;
-}
-
-
-bool CBBOX::OverlapsBox( const CBBOX &aBBox ) const 
-{
-    if( aBBox.m_initialized == false )
-        return false;
-
-    bool x = ( m_max.x >= aBBox.m_min.x ) && ( m_min.x <= aBBox.m_max.x );
-    bool y = ( m_max.y >= aBBox.m_min.y ) && ( m_min.y <= aBBox.m_max.y );
-    bool z = ( m_max.z >= aBBox.m_min.z ) && ( m_min.z <= aBBox.m_max.z );
-
-    return ( x && y && z );
-}
-
-
-bool CBBOX::Inside( const S3D_VERTEX &aPoint ) const 
-{
-    if( m_initialized == false )
-        return false;
-
-    return (( aPoint.x >= m_min.x ) && ( aPoint.x <= m_max.x ) &&
-            ( aPoint.y >= m_min.y ) && ( aPoint.y <= m_max.y ) &&
-            ( aPoint.z >= m_min.z ) && ( aPoint.z <= m_max.z ));
-}
-
-
-float CBBOX::Volume() const 
-{
-    if( m_initialized == false )
-        return 0.0f;
-
-    S3D_VERTEX d = m_max - m_min;
-    return d.x * d.y * d.z;
-}
-
-
-void CBBOX::ApplyTransformation( glm::mat4 aTransformMatrix )
-{
-    if( m_initialized == false )
-        return;
-    
-    S3D_VERTEX v1 = S3D_VERTEX( aTransformMatrix * glm::vec4( m_min.x, m_min.y, m_min.z, 1.0f ) );
-    S3D_VERTEX v2 = S3D_VERTEX( aTransformMatrix * glm::vec4( m_max.x, m_max.y, m_max.z, 1.0f ) );
-
-    Reset();
-    Union( v1 );
-    Union( v2 );
-}
-
-
-void CBBOX::ApplyTransformationAA( glm::mat4 aTransformMatrix )
-{
-    if( m_initialized == false )
-        return;
-
-    // apply the transformation matrix for each of vertices of the bounding box
-    // and make a union with all vertices
-    CBBOX tmpBBox = CBBOX(  S3D_VERTEX( aTransformMatrix * glm::vec4( m_min.x, m_min.y, m_min.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_max.x, m_min.y, m_min.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_min.x, m_max.y, m_min.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_min.x, m_min.y, m_max.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_min.x, m_max.y, m_max.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_max.x, m_max.y, m_min.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_max.x, m_min.y, m_max.z, 1.0f ) ) );
-    tmpBBox.Union(          S3D_VERTEX( aTransformMatrix * glm::vec4( m_max.x, m_max.y, m_max.z, 1.0f ) ) );
-
-    m_min = tmpBBox.m_min;
-    m_max = tmpBBox.m_max;
-}
-
-
-void CBBOX::GLdebug() const 
-{
-    if( m_initialized == false )
-        return;
-
-    glBegin( GL_LINE_LOOP );
-    glVertex3f( m_min.x, m_min.y, m_min.z );
-    glVertex3f( m_max.x, m_min.y, m_min.z );
-    glVertex3f( m_max.x, m_max.y, m_min.z );
-    glVertex3f( m_min.x, m_max.y, m_min.z );
-    glEnd();
-
-    glBegin( GL_LINE_LOOP );
-    glVertex3f( m_min.x, m_min.y, m_max.z );
-    glVertex3f( m_max.x, m_min.y, m_max.z );
-    glVertex3f( m_max.x, m_max.y, m_max.z );
-    glVertex3f( m_min.x, m_max.y, m_max.z );
-    glEnd();
-
-    glBegin( GL_LINE_STRIP );
-    glVertex3f( m_min.x, m_min.y, m_min.z );
-    glVertex3f( m_min.x, m_min.y, m_max.z );
-    glEnd();
-
-    glBegin( GL_LINE_STRIP );
-    glVertex3f( m_max.x, m_min.y, m_min.z );
-    glVertex3f( m_max.x, m_min.y, m_max.z );
-    glEnd();
-
-    glBegin( GL_LINE_STRIP );
-    glVertex3f( m_max.x, m_max.y, m_min.z );
-    glVertex3f( m_max.x, m_max.y, m_max.z );
-    glEnd();
-
-    glBegin( GL_LINE_STRIP );
-    glVertex3f( m_min.x, m_max.y, m_min.z );
-    glVertex3f( m_min.x, m_max.y, m_max.z );
-    glEnd();
-}
diff --git a/3d-viewer/CMakeLists.txt b/3d-viewer/CMakeLists.txt
index b48e505d67..435995c58c 100644
--- a/3d-viewer/CMakeLists.txt
+++ b/3d-viewer/CMakeLists.txt
@@ -5,10 +5,23 @@ include_directories(
     textures
     ../pcbnew
     ../polygon
+    3d_canvas
+    3d_cache
+    3d_rendering
+    3d_viewer
+    ${CMAKE_SOURCE_DIR}/include/gal/opengl
     ${GLEW_INCLUDE_DIR}
+    ${GLM_INCLUDE_DIR}
     ${INC_AFTER}
     )
 
+# directories
+set( DIR_DLG 3d_cache/dialogs )
+set( DIR_RAY 3d_rendering/3d_render_raytracing )
+set( DIR_RAY_ACC ${DIR_RAY}/accelerators )
+set( DIR_RAY_2D ${DIR_RAY}/shapes2D )
+set( DIR_RAY_3D ${DIR_RAY}/shapes3D )
+
 set(3D-VIEWER_SRCS
     dialogs/dialog_3D_view_option_base.cpp
     dialogs/dialog_3D_view_option.cpp
@@ -32,8 +45,107 @@ set(3D-VIEWER_SRCS
     vrml_v2_modelparser.cpp
     x3dmodelparser.cpp
     CImage.cpp
-    CBBox.cpp
+    3d_cache/3d_cache_wrapper.cpp
+    3d_cache/3d_cache.cpp
+    3d_cache/3d_plugin_manager.cpp
+    3d_cache/3d_filename_resolver.cpp
+    3d_cache/md5.cpp
+    ${DIR_DLG}/3d_cache_dialogs.cpp
+    ${DIR_DLG}/dialog_config_3dpath.cpp
+    ${DIR_DLG}/dialog_select_3dmodel.cpp
+    ${DIR_DLG}/panel_prev_model.cpp
+    3d_model_viewer/c3d_model_viewer.cpp
+    3d_rendering/3d_render_ogl_legacy/c_ogl_3dmodel.cpp
+    3d_rendering/3d_render_ogl_legacy/ogl_legacy_utils.cpp
+    3d_rendering/3d_render_ogl_legacy/c3d_render_createscene_ogl_legacy.cpp
+    3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.cpp
+    3d_rendering/3d_render_ogl_legacy/clayer_triangles.cpp
+    ${DIR_RAY}/ray.cpp
+    ${DIR_RAY_2D}/cbbox2d.cpp
+    ${DIR_RAY_2D}/cobject2d.cpp
+    ${DIR_RAY_2D}/croundsegment2d.cpp
+    ${DIR_RAY_3D}/cbbox.cpp
+    ${DIR_RAY_3D}/cbbox_ray.cpp
+    3d_rendering/ccamera.cpp
+    3d_rendering/cimage.cpp
+    3d_rendering/ctrack_ball.cpp
+    3d_rendering/trackball.cpp
+    common_ogl/cogl_att_list.cpp
+    common_ogl/ogl_utils.cpp
     )
 
 add_library(3d-viewer STATIC ${3D-VIEWER_SRCS})
 add_dependencies( 3d-viewer pcbcommon )
+
+option( GLM_ENABLE_SIMD_SSE2 "Enable SSE2 optimizations" OFF )
+option( GLM_ENABLE_SIMD_SSE3 "Enable SSE3 optimizations" OFF )
+option( GLM_ENABLE_SIMD_AVX "Enable AVX optimizations" OFF )
+option( GLM_ENABLE_SIMD_AVX2 "Enable AVX2 optimizations" OFF )
+option( GLM_FORCE_PURE "Force 'pure' instructions" OFF )
+
+if(GLM_FORCE_PURE)
+    add_definitions(-DGLM_FORCE_PURE)
+
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        add_definitions(-mfpmath=387)
+    endif()
+elseif(GLM_ENABLE_SIMD_AVX2)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        add_definitions(-mavx2)
+    elseif(GLM_USE_INTEL)
+        add_definitions(/QxAVX2)
+    elseif(MSVC)
+        add_definitions(/arch:AVX2)
+    endif()
+elseif(GLM_ENABLE_SIMD_AVX)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        add_definitions(-mavx)
+    elseif(GLM_USE_INTEL)
+        add_definitions(/QxAVX)
+    elseif(MSVC)
+        add_definitions(/arch:AVX)
+    endif()
+elseif(GLM_ENABLE_SIMD_SSE3)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        add_definitions(-msse3)
+    elseif(GLM_USE_INTEL)
+        add_definitions(/QxSSE3)
+    elseif(MSVC)
+        add_definitions(/arch:SSE2) # VC doesn't support /arch:SSE3
+    endif()
+elseif(GLM_ENABLE_SIMD_SSE2)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        add_definitions(-msse2)
+    elseif(GLM_USE_INTEL)
+        add_definitions(/QxSSE2)
+    elseif(MSVC)
+        if(NOT CMAKE_CL_64)
+            add_definitions(/arch:SSE2)
+        endif()
+    endif()
+endif()
+
+
+option( GLM_ENABLE_FAST_MATH "Enable fast math optimizations" OFF )
+
+if(GLM_ENABLE_FAST_MATH)
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        add_definitions(-ffast-math)
+    endif()
+
+    if(MSVC)
+        add_definitions(/fp:fast)
+    endif()
+elseif(NOT GLM_ENABLE_FAST_MATH)
+    if(MSVC)
+        add_definitions(/fp:precise)
+    endif()
+endif()
+
+if( WIN32 )
+    target_link_libraries( 3d-viewer ${Boost_} ${wxWidgets_LIBRARIES} ${OPENGL_LIBRARIES} s3d_sg )
+else()
+    target_link_libraries( 3d-viewer ${Boost_} ${wxWidgets_LIBRARIES} ${OPENGL_LIBRARIES} s3d_sg dl )
+endif()
+
+add_subdirectory( 3d_cache )
diff --git a/3d-viewer/common_ogl/cogl_att_list.cpp b/3d-viewer/common_ogl/cogl_att_list.cpp
new file mode 100644
index 0000000000..abae8ffe35
--- /dev/null
+++ b/3d-viewer/common_ogl/cogl_att_list.cpp
@@ -0,0 +1,118 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cogl_att_list.cpp
+ * @brief Implements a attribute list support for openGL
+ */
+
+#include "cogl_att_list.h"
+
+
+/**
+ *  Attributes list to be passed to a wxGLCanvas creation.
+ *
+ *  This array should be 2*n+1
+ *  Sadly wxwidgets / glx < 13 allowed
+ *  a thing named "boolean attributes" that don't take a value.
+ *  (See src/unix/glx11.cpp -> wxGLCanvasX11::ConvertWXAttrsToGL() ).
+ *  To avoid problems due to this, just specify those attributes twice.
+ *  Only WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_STEREO are such boolean
+ *  attributes.
+ */
+const int COGL_ATT_LIST::m_openGL_AttributesList[] = {
+    // Boolean attributes (using itself at padding):
+    WX_GL_RGBA,             WX_GL_RGBA,
+    WX_GL_DOUBLEBUFFER,     WX_GL_DOUBLEBUFFER,
+
+    // Normal attributes with values:
+    WX_GL_DEPTH_SIZE,       16,
+    WX_GL_STENCIL_SIZE,     1,
+    WX_GL_SAMPLE_BUFFERS,   1,  // Enable multisampling support (antialiasing).
+    WX_GL_SAMPLES,          0,  // Disable AA for the start.
+    0                           // NULL termination
+};
+
+
+int COGL_ATT_LIST::m_openGL_AttributesList_toUse[
+                      sizeof( COGL_ATT_LIST::m_openGL_AttributesList )] = { 0 };
+
+
+const int *COGL_ATT_LIST::GetAttributesList( bool aUseAntiAliasing )
+{
+    memcpy( m_openGL_AttributesList_toUse,
+            m_openGL_AttributesList,
+            sizeof( m_openGL_AttributesList_toUse ) );
+
+    if( aUseAntiAliasing )
+    {
+        // Check if the canvas supports multisampling.
+        if( wxGLCanvas::IsDisplaySupported( m_openGL_AttributesList_toUse ) )
+        {
+            // Check for possible sample sizes, start form the top.
+            int maxSamples = 8; // Any higher doesn't change anything.
+            int samplesOffset = 0;
+
+            for( unsigned int ii = 0;
+                 ii < DIM( m_openGL_AttributesList_toUse );
+                 ii += 2 )
+            {
+                if( m_openGL_AttributesList_toUse[ii] == WX_GL_SAMPLES )
+                {
+                    samplesOffset = ii + 1;
+                    break;
+                }
+            }
+
+            m_openGL_AttributesList_toUse[samplesOffset] = maxSamples;
+
+            for( ; maxSamples > 0 &&
+                   !wxGLCanvas::IsDisplaySupported( m_openGL_AttributesList_toUse );
+                maxSamples = maxSamples >> 1 )
+            {
+                m_openGL_AttributesList_toUse[samplesOffset] = maxSamples;
+            }
+        }
+        else
+            aUseAntiAliasing = false;
+    }
+
+    // Disable antialising if it failed or was not requested
+    if( !aUseAntiAliasing )
+    {
+        // Disable multisampling
+        for( unsigned int ii = 0;
+             ii < DIM( m_openGL_AttributesList_toUse );
+             ii += 2 )
+        {
+            if( m_openGL_AttributesList_toUse[ii] == WX_GL_SAMPLE_BUFFERS )
+            {
+                m_openGL_AttributesList_toUse[ii + 1] = 0;
+                break;
+            }
+        }
+    }
+
+    return m_openGL_AttributesList_toUse;
+}
diff --git a/3d-viewer/common_ogl/cogl_att_list.h b/3d-viewer/common_ogl/cogl_att_list.h
new file mode 100644
index 0000000000..88e97a9a9c
--- /dev/null
+++ b/3d-viewer/common_ogl/cogl_att_list.h
@@ -0,0 +1,74 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  cogl_att_list.h
+ * @brief Declaration of the cogl_att_list class
+ */
+
+#ifndef _COGL_ATT_LIST_H
+#define _COGL_ATT_LIST_H
+
+//#include <3d_xv3d/xv3d_types.h>
+#include <macros.h>
+#include <wx/glcanvas.h>
+
+
+
+/**
+ *  Class COGL_ATT_LIST
+ *  Helper class to create an attribute list
+ */
+class COGL_ATT_LIST
+{
+
+public:
+    /**
+     *  Get a list of attributes to pass to wxGLCanvas
+     *  @param aUseAntiAliasing = if true try to initialize (if is supported) the list with anti aliasing capabilities
+     *  @return a list of options to be passed in the creation of a EDA_3D_CANVAS class
+     */
+    static const int *GetAttributesList( bool aUseAntiAliasing );
+
+private:
+    /**
+     *  Attributes list to be passed to a wxGLCanvas creation.
+     *
+     *  This array should be 2*n+1
+     *  Sadly wxwidgets / glx < 13 allowed
+     *  a thing named "boolean attributes" that don't take a value.
+     *  (See src/unix/glx11.cpp -> wxGLCanvasX11::ConvertWXAttrsToGL() ).
+     *  To avoid problems due to this, just specify those attributes twice.
+     *  Only WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_STEREO are such boolean
+     *  attributes.
+     */
+    static const int m_openGL_AttributesList[];
+
+    /**
+     * Attributes list that was (eventualy) changed and are passed to creation
+     */
+    static int m_openGL_AttributesList_toUse[];
+};
+
+#endif // _COGL_ATT_LIST_H
diff --git a/3d-viewer/common_ogl/ogl_utils.cpp b/3d-viewer/common_ogl/ogl_utils.cpp
new file mode 100644
index 0000000000..db20392222
--- /dev/null
+++ b/3d-viewer/common_ogl/ogl_utils.cpp
@@ -0,0 +1,129 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ogl_utils.cpp
+ * @brief implements generic openGL functions that are common to any openGL target
+ */
+
+
+#include "openGL_includes.h"
+#include "ogl_utils.h"
+
+void OGL_GetScreenshot( wxImage &aDstImage )
+{
+    struct viewport_params
+    {
+        GLint originX;
+        GLint originY;
+        GLint x;
+        GLint y;
+    } viewport;
+
+    glGetIntegerv( GL_VIEWPORT, (GLint*) &viewport );
+
+    unsigned char* pixelbuffer = (unsigned char*) malloc( viewport.x * viewport.y * 3 );
+    unsigned char* alphabuffer = (unsigned char*) malloc( viewport.x * viewport.y );
+
+    glPixelStorei( GL_PACK_ALIGNMENT, 1 );
+    glReadBuffer( GL_BACK_LEFT );
+
+    glReadPixels( viewport.originX, viewport.originY,
+                  viewport.x, viewport.y,
+                  GL_RGB, GL_UNSIGNED_BYTE, pixelbuffer );
+
+    glReadPixels( viewport.originX, viewport.originY,
+                  viewport.x, viewport.y,
+                  GL_ALPHA, GL_UNSIGNED_BYTE, alphabuffer );
+
+    // "Sets the image data without performing checks.
+    //  The data given must have the size (width*height*3)
+    //  The data must have been allocated with malloc()
+    //  If static_data is false, after this call the pointer to the data is owned
+    //  by the wxImage object, that will be responsible for deleting it."
+    aDstImage.SetData( pixelbuffer, viewport.x, viewport.y, false );
+    aDstImage.SetAlpha( alphabuffer, false );
+
+    aDstImage = aDstImage.Mirror( false );
+}
+
+
+GLuint OGL_LoadTexture( const CIMAGE &aImage )
+{
+    unsigned char* rgbaBuffer = (unsigned char*) malloc( aImage.GetWidth() * aImage.GetHeight() * 4 );
+
+    unsigned char* dst = rgbaBuffer;
+    unsigned char* ori = aImage.GetBuffer();
+    for( unsigned int i = 0; i < (aImage.GetWidth() * aImage.GetHeight()); ++i )
+    {
+        unsigned char v = *ori;
+        ori++;
+
+        dst[0] = v;
+        dst[1] = v;
+        dst[2] = v;
+        dst[3] = v;
+        dst+= 4;
+    }
+
+    GLuint texture;
+    glPixelStorei (GL_UNPACK_ALIGNMENT, 4);
+    glPixelStorei (GL_PACK_ALIGNMENT, 4);
+
+    glGenTextures( 1, &texture );
+    glBindTexture( GL_TEXTURE_2D, texture );
+
+    //gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, aImage.GetWidth(), aImage.GetHeight(), GL_RGBA, GL_UNSIGNED_BYTE, rgbaBuffer );
+
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, aImage.GetWidth(), aImage.GetHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbaBuffer );
+
+    //glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+
+    glBindTexture( GL_TEXTURE_2D, 0 );
+
+    free( rgbaBuffer );
+
+    return texture;
+}
+
+
+void OGL_SetMaterial( const SMATERIAL & aMaterial )
+{
+    const SFVEC4F ambient  = SFVEC4F( aMaterial.m_Ambient,  1.0f );
+    const SFVEC4F diffuse  = SFVEC4F( aMaterial.m_Diffuse,  1.0f );
+    const SFVEC4F specular = SFVEC4F( aMaterial.m_Specular, 1.0f );
+    const SFVEC4F emissive = SFVEC4F( aMaterial.m_Emissive, 1.0f );
+
+    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT,  &ambient.r );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE,  &diffuse.r );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r );
+    glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, (aMaterial.m_Shininess > 128.0f)?128.0f:aMaterial.m_Shininess );
+}
diff --git a/3d-viewer/common_ogl/ogl_utils.h b/3d-viewer/common_ogl/ogl_utils.h
new file mode 100644
index 0000000000..560ddde516
--- /dev/null
+++ b/3d-viewer/common_ogl/ogl_utils.h
@@ -0,0 +1,44 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@ua.pt>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  ogl_utils.h
+ * @brief
+ */
+
+#ifndef OGL_UTILS_H_
+#define OGL_UTILS_H_
+
+#include <wx/image.h>
+#include "3d_rendering/cimage.h"
+#include "3d_rendering/c3dmodel.h"
+
+void OGL_SetMaterial(const SMATERIAL & aMaterial);
+
+GLuint OGL_LoadTexture( const CIMAGE &aImage );
+
+void OGL_GetScreenshot( wxImage &aDstImage );
+
+
+#endif // OGL_UTILS_H_
diff --git a/3d-viewer/common_ogl/openGL_includes.h b/3d-viewer/common_ogl/openGL_includes.h
new file mode 100644
index 0000000000..a4810e9f60
--- /dev/null
+++ b/3d-viewer/common_ogl/openGL_includes.h
@@ -0,0 +1,48 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file  openGL_includes.h
+ * @brief includes in a proper way the openGL related includes
+ */
+
+#ifndef OPENGL_INCLUDES_H
+#define OPENGL_INCLUDES_H
+
+#include <GL/glew.h>
+
+#include <GL/gl.h>
+
+#ifdef __WXMAC__
+#  ifdef __DARWIN__
+#    include <OpenGL/glu.h>
+#  else
+#    include <glu.h>
+#  endif
+#else
+#  include <GL/glu.h>
+#endif
+
+
+#endif // OPENGL_INCLUDES_H
diff --git a/3d-viewer/vrml_aux.h b/3d-viewer/vrml_aux.h
index 2350a44e17..e3c40ccbdb 100644
--- a/3d-viewer/vrml_aux.h
+++ b/3d-viewer/vrml_aux.h
@@ -35,7 +35,7 @@
 #include <macros.h>
 #include <base_struct.h>
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/glm.hpp>
+#include <glm/glm.hpp>
 #include <vector>
 #include <kicad_string.h>
 #include <info3d_visu.h>
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9ff922cae3..fd07c9f104 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -448,17 +448,16 @@ check_find_package_result( OPENGL_FOUND "OpenGL" )
 # Always defined, empty if no libraries are to be built
 add_custom_target( lib-dependencies )
 
-#####################
-# Find GLEW library #
-#####################
+# Find GLEW library
 if( NOT GLEW_FOUND )
     find_package( GLEW )
     check_find_package_result( GLEW_FOUND "GLEW" )
 endif()
 
-######################
-# Find Cairo library #
-######################
+# Find GLM library
+find_package( GLM 0.9.5.4 REQUIRED )
+
+# Find Cairo library
 if( NOT CAIRO_FOUND )
     find_package( Cairo 1.8.1 QUIET )
     check_find_package_result( CAIRO_FOUND "Cairo" )
@@ -813,3 +812,6 @@ if( UNIX AND NOT APPLE )
     include( CPack )
 
 endif()
+
+# 3D plugins
+add_subdirectory( plugins )
diff --git a/CMakeModules/FindGLM.cmake b/CMakeModules/FindGLM.cmake
new file mode 100644
index 0000000000..6a289ae803
--- /dev/null
+++ b/CMakeModules/FindGLM.cmake
@@ -0,0 +1,68 @@
+if( ${CMAKE_MAJOR_VERSION} STREQUAL "2" AND ${CMAKE_MINOR_VERSION} STREQUAL "8"
+    AND ( ${CMAKE_PATCH_VERSION} STREQUAL "2" OR ${CMAKE_PATCH_VERSION} STREQUAL "7"
+    OR ${CMAKE_PATCH_VERSION} STREQUAL "10" ) )
+    
+    message( FATAL_ERROR "\nThis version of CMake is known to not work\n"
+        "Known bad versions: 2.8.2, 2.8.7, 2.8.10\n" )
+    
+endif()
+
+
+find_path( GLM_INCLUDE_DIR glm.hpp PATH_SUFFIXES glm )
+
+
+if( NOT ${GLM_INCLUDE_DIR} STREQUAL "" )
+   
+    # attempt to extract the GLM Version information from setup.hpp
+    find_file( GLM_SETUP setup.hpp PATHS ${GLM_INCLUDE_DIR} PATH_SUFFIXES core detail NO_DEFAULT_PATH )
+
+    if( GLM_SETUP )
+        # extract the "#define GLM_VERSION*" lines
+        file( STRINGS ${GLM_SETUP} _version REGEX "^#define.*GLM_VERSION.*" )
+        
+        foreach( SVAR ${_version} )
+            string( REGEX MATCH GLM_VERSION_[M,A,J,O,R,I,N,P,T,C,H,E,V,I,S]* _VARNAME ${SVAR} )
+            string( REGEX MATCH [0-9]+ _VALUE ${SVAR} )
+            
+            if( NOT ${_VARNAME} STREQUAL "" AND NOT ${_VALUE} STREQUAL "" )
+                set( _${_VARNAME} ${_VALUE} )
+            endif()
+            
+        endforeach()
+        
+        #ensure that NOT GLM_VERSION* will evaluate to '0'
+        if( NOT _GLM_VERSION_MAJOR )
+            set( _GLM_VERSION_MAJOR 0 )
+        endif()
+
+        if( NOT _GLM_VERSION_MINOR )
+            set( _GLM_VERSION_MINOR 0 )
+        endif()
+
+        if( NOT _GLM_VERSION_PATCH )
+            set( _GLM_VERSION_PATCH 0 )
+        endif()
+
+        if( NOT _GLM_VERSION_REVISION )
+            set( _GLM_VERSION_REVISION 0 )
+        endif()
+
+        set( GLM_VERSION ${_GLM_VERSION_MAJOR}.${_GLM_VERSION_MINOR}.${_GLM_VERSION_PATCH}.${_GLM_VERSION_REVISION} )
+        unset( GLM_SETUP CACHE )
+        
+    endif( GLM_SETUP )
+    
+endif( NOT ${GLM_INCLUDE_DIR} STREQUAL "" )
+
+
+include( FindPackageHandleStandardArgs )
+FIND_PACKAGE_HANDLE_STANDARD_ARGS( GLM
+    REQUIRED_VARS GLM_INCLUDE_DIR
+    VERSION_VAR GLM_VERSION )
+
+    
+mark_as_advanced( GLM_INCLUDE_DIR )
+set( GLM_VERSION_MAJOR ${_GLM_VERSION_MAJOR} CACHE INTERNAL "" )
+set( GLM_VERSION_MINOR ${_GLM_VERSION_MINOR} CACHE INTERNAL "" )
+set( GLM_VERSION_PATCH ${_GLM_VERSION_PATCH} CACHE INTERNAL "" )
+set( GLM_VERSION_TWEAK ${_GLM_VERSION_REVISION} CACHE INTERNAL "" )
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 46708f7a84..27267186ef 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -4,6 +4,7 @@ include_directories(
     ./dialog_about
     ${CAIRO_INCLUDE_DIR}
     ${GLEW_INCLUDE_DIR}
+    ${GLM_INCLUDE_DIR}
     ../3d-viewer
     ../pcbnew
     ../polygon
diff --git a/cvpcb/CMakeLists.txt b/cvpcb/CMakeLists.txt
index 5a00f2c569..3a106825b5 100644
--- a/cvpcb/CMakeLists.txt
+++ b/cvpcb/CMakeLists.txt
@@ -16,6 +16,7 @@ include_directories(
     ../pcbnew/dialogs
     ../polygon
     ../common
+    ${GLM_INCLUDE_DIR}
     ${INC_AFTER}
     )
 
diff --git a/include/gal/opengl/glm/core/_detail.hpp b/include/gal/opengl/glm/core/_detail.hpp
deleted file mode 100644
index e6b42c26ed..0000000000
--- a/include/gal/opengl/glm/core/_detail.hpp
+++ /dev/null
@@ -1,482 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/_detail.hpp
-/// @date 2008-07-24 / 2011-06-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_detail
-#define glm_core_detail
-
-#include "setup.hpp"
-#include <cassert>
-#if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))
-#include <cstdint>
-#endif
-
-namespace glm{
-namespace detail
-{
-	class half;
-
-#if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
-	typedef int64_t								sint64;
-	typedef uint64_t							uint64;
-#elif(GLM_COMPILER & GLM_COMPILER_VC)
-	typedef signed __int64						sint64;
-	typedef unsigned __int64					uint64;
-#elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC | GLM_COMPILER_CLANG))
-	__extension__ typedef signed long long		sint64;
-	__extension__ typedef unsigned long long	uint64;
-#elif(GLM_COMPILER & GLM_COMPILER_BC)
-	typedef Int64								sint64;
-	typedef Uint64								uint64;
-#else//unknown compiler
-	typedef signed long	long					sint64;
-	typedef unsigned long long					uint64;
-#endif//GLM_COMPILER
-
-	template<bool C>
-	struct If
-	{
-		template<typename F, typename T>
-		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
-		{
-			return functor(val);
-		}
-	};
-
-	template<>
-	struct If<false>
-	{
-		template<typename F, typename T>
-		static GLM_FUNC_QUALIFIER T apply(F, const T& val)
-		{
-			return val;
-		}
-	};
-
-	//template <typename T>
-	//struct traits
-	//{
-	//	static const bool is_signed = false;
-	//	static const bool is_float = false;
-	//	static const bool is_vector = false;
-	//	static const bool is_matrix = false;
-	//	static const bool is_genType = false;
-	//	static const bool is_genIType = false;
-	//	static const bool is_genUType = false;
-	//};
-
-	//template <>
-	//struct traits<half>
-	//{
-	//	static const bool is_float = true;
-	//	static const bool is_genType = true;
-	//};
-
-	//template <>
-	//struct traits<float>
-	//{
-	//	static const bool is_float = true;
-	//	static const bool is_genType = true;
-	//};
-
-	//template <>
-	//struct traits<double>
-	//{
-	//	static const bool is_float = true;
-	//	static const bool is_genType = true;
-	//};
-
-	//template <typename genType>
-	//struct desc
-	//{
-	//	typedef genType							type;
-	//	typedef genType *						pointer;
-	//	typedef genType const*					const_pointer;
-	//	typedef genType const *const			const_pointer_const;
-	//	typedef genType *const					pointer_const;
-	//	typedef genType &						reference;
-	//	typedef genType const&					const_reference;
-	//	typedef genType const&					param_type;
-
-	//	typedef typename genType::value_type	value_type;
-	//	typedef typename genType::size_type		size_type;
-	//	static const typename size_type			value_size;
-	//};
-
-	//template <typename genType>
-	//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
-
-	union uif32
-	{
-		GLM_FUNC_QUALIFIER uif32() :
-			i(0)
-		{}
-
-		GLM_FUNC_QUALIFIER uif32(float f) :
-			f(f)
-		{}
-
-		GLM_FUNC_QUALIFIER uif32(unsigned int i) :
-			i(i)
-		{}
-
-		float f;
-		unsigned int i;
-	};
-
-	union uif64
-	{
-		GLM_FUNC_QUALIFIER uif64() :
-			i(0)
-		{}
-
-		GLM_FUNC_QUALIFIER uif64(double f) :
-			f(f)
-		{}
-
-		GLM_FUNC_QUALIFIER uif64(uint64 i) :
-			i(i)
-		{}
-
-		double f;
-		uint64 i;
-	};
-
-	typedef uif32 uif;
-
-	//////////////////
-	// int
-
-	template <typename T>
-	struct is_int
-	{
-		enum is_int_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_INT(T)	\
-	template <>					\
-	struct is_int<T>			\
-	{							\
-		enum is_int_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	//////////////////
-	// uint
-
-	template <typename T>
-	struct is_uint
-	{
-		enum is_uint_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_UINT(T)	\
-	template <>					\
-	struct is_uint<T>			\
-	{							\
-		enum is_uint_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	//GLM_DETAIL_IS_UINT(unsigned long long)
-
-	//////////////////
-	// float
-
-	template <typename T>
-	struct is_float
-	{
-		enum is_float_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_FLOAT(T)	\
-	template <>					\
-	struct is_float<T>			\
-	{							\
-		enum is_float_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	GLM_DETAIL_IS_FLOAT(detail::half);
-	GLM_DETAIL_IS_FLOAT(float);
-	GLM_DETAIL_IS_FLOAT(double);
-	GLM_DETAIL_IS_FLOAT(long double);
-
-	//////////////////
-	// bool
-
-	template <typename T>
-	struct is_bool
-	{
-		enum is_bool_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-	
-	template <>
-	struct is_bool<bool>
-	{
-		enum is_bool_enum
-		{
-			_YES = 1,
-			_NO = 0
-		};
-	};
-	
-	//////////////////
-	// vector
-
-	template <typename T>
-	struct is_vector
-	{
-		enum is_vector_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#	define GLM_DETAIL_IS_VECTOR(TYPE) \
-		template <typename T> \
-		struct is_vector<TYPE<T> > \
-		{ \
-			enum is_vector_enum \
-			{ \
-				_YES = 1, \
-				_NO = 0 \
-			}; \
-		}
-
-	//////////////////
-	// matrix
-
-	template <typename T>
-	struct is_matrix
-	{
-		enum is_matrix_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_MATRIX(T)	\
-	template <>					\
-	struct is_matrix			\
-	{							\
-		enum is_matrix_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	//////////////////
-	// type
-
-	template <typename T>
-	struct type
-	{
-		enum type_enum
-		{
-			is_float = is_float<T>::_YES,
-			is_int = is_int<T>::_YES,
-			is_uint = is_uint<T>::_YES,
-			is_bool = is_bool<T>::_YES
-		};
-	};
-	
-	//////////////////
-	// type
-	
-	typedef signed char							int8;
-	typedef signed short						int16;
-	typedef signed int							int32;
-	typedef detail::sint64						int64;
-	
-	typedef unsigned char						uint8;
-	typedef unsigned short						uint16;
-	typedef unsigned int						uint32;
-	typedef detail::uint64						uint64;
-	
-	typedef detail::half						float16;
-	typedef float								float32;
-	typedef double								float64;
-	
-	//////////////////
-	// float_or_int_trait 
-
-	struct float_or_int_value
-	{
-		enum
-		{
-			GLM_ERROR,
-			GLM_FLOAT,
-			GLM_INT
-		};
-	};
-
-	template <typename T>
-	struct float_or_int_trait
-	{
-		enum{ID = float_or_int_value::GLM_ERROR};
-	};
-
-	template <>
-	struct float_or_int_trait<int8>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<int16>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<int32>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<int64>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint8>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint16>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint32>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint64>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<float16>
-	{
-		enum{ID = float_or_int_value::GLM_FLOAT};
-	};
-
-	template <>
-	struct float_or_int_trait<float32>
-	{
-		enum{ID = float_or_int_value::GLM_FLOAT};
-	};
-
-	template <>
-	struct float_or_int_trait<float64>
-	{
-		enum{ID = float_or_int_value::GLM_FLOAT};
-	};
-
-}//namespace detail
-}//namespace glm
-
-#if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
-#	define GLM_DEPRECATED __declspec(deprecated)
-#	define GLM_ALIGN(x) __declspec(align(x)) 
-#	define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct 
-#	define GLM_RESTRICT __declspec(restrict)
-#	define GLM_RESTRICT_VAR __restrict
-#	define GLM_CONSTEXPR 
-#elif(GLM_COMPILER & GLM_COMPILER_INTEL)
-#	define GLM_DEPRECATED
-#	define GLM_ALIGN(x) __declspec(align(x))
-#	define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
-#	define GLM_RESTRICT
-#	define GLM_RESTRICT_VAR __restrict
-#	define GLM_CONSTEXPR
-#elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31)) || (GLM_COMPILER & GLM_COMPILER_CLANG))
-#	define GLM_DEPRECATED __attribute__((__deprecated__))
-#	define GLM_ALIGN(x) __attribute__((aligned(x)))
-#	define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
-#	if(GLM_COMPILER >= GLM_COMPILER_GCC33)
-#		define GLM_RESTRICT __restrict__
-#		define GLM_RESTRICT_VAR __restrict__
-#	else
-#		define GLM_RESTRICT
-#		define GLM_RESTRICT_VAR
-#	endif
-#	define GLM_RESTRICT __restrict__
-#	define GLM_RESTRICT_VAR __restrict__
-#	if((GLM_COMPILER >= GLM_COMPILER_GCC47) && ((GLM_LANG & GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
-#		define GLM_CONSTEXPR constexpr 
-#	else
-#		define GLM_CONSTEXPR 
-#	endif
-#else
-#	define GLM_DEPRECATED
-#	define GLM_ALIGN
-#	define GLM_ALIGNED_STRUCT(x) 
-#	define GLM_RESTRICT
-#	define GLM_RESTRICT_VAR
-#	define GLM_CONSTEXPR 
-#endif//GLM_COMPILER
-
-#endif//glm_core_detail
diff --git a/include/gal/opengl/glm/core/_fixes.hpp b/include/gal/opengl/glm/core/_fixes.hpp
deleted file mode 100644
index b4cec5f259..0000000000
--- a/include/gal/opengl/glm/core/_fixes.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/_fixes.hpp
-/// @date 2011-02-21 / 2011-11-22
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include <cmath>
-
-//! Workaround for compatibility with other libraries
-#ifdef max
-#undef max
-#endif
-
-//! Workaround for compatibility with other libraries
-#ifdef min
-#undef min
-#endif
-
-//! Workaround for Android
-#ifdef isnan
-#undef isnan
-#endif
-
-//! Workaround for Android
-#ifdef isinf
-#undef isinf
-#endif
-
-//! Workaround for Chrone Native Client
-#ifdef log2
-#undef log2
-#endif
-
diff --git a/include/gal/opengl/glm/core/_swizzle.hpp b/include/gal/opengl/glm/core/_swizzle.hpp
deleted file mode 100644
index dc069443f7..0000000000
--- a/include/gal/opengl/glm/core/_swizzle.hpp
+++ /dev/null
@@ -1,861 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/_swizzle.hpp
-/// @date 2006-04-20 / 2011-02-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_swizzle
-#define glm_core_swizzle
-
-#include "_swizzle_func.hpp"
-
-namespace glm
-{
-	enum comp
-	{
-		X = 0,
-		R = 0,
-		S = 0,
-		Y = 1,
-		G = 1,
-		T = 1,
-		Z = 2,
-		B = 2,
-		P = 2,
-		W = 3,
-		A = 3,
-		Q = 3
-	};
-}//namespace glm
-
-namespace glm{
-namespace detail
-{
-	// Internal class for implementing swizzle operators
-	template <typename T, int N>
-	struct _swizzle_base0
-	{
-		typedef T       value_type;
-
-	protected:
-		GLM_FUNC_QUALIFIER value_type&         elem   (size_t i)       { return (reinterpret_cast<value_type*>(_buffer))[i]; }
-		GLM_FUNC_QUALIFIER const value_type&   elem   (size_t i) const { return (reinterpret_cast<const value_type*>(_buffer))[i]; }
-
-		// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
-		// The size 1 buffer is assumed to aligned to the actual members so that the
-		// elem() 
-		char    _buffer[1];
-	};
-
-	template <typename T, typename V, int E0, int E1, int E2, int E3, int N>
-	struct _swizzle_base1 : public _swizzle_base0<T,N>
-	{
-	};
-
-	template <typename T, typename V, int E0, int E1>
-	struct _swizzle_base1<T,V,E0,E1,-1,-2,2> : public _swizzle_base0<T,2>
-	{
-		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1)); }
-	};
-
-	template <typename T, typename V, int E0, int E1, int E2>
-	struct _swizzle_base1<T,V,E0,E1,E2,-1,3> : public _swizzle_base0<T,3>
-	{
-		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
-	};
-
-	template <typename T, typename V, int E0, int E1, int E2, int E3>
-	struct _swizzle_base1<T,V,E0,E1,E2,E3,4> : public _swizzle_base0<T,4>
-	{ 
-		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
-	};
-
-	// Internal class for implementing swizzle operators
-	/*
-		Template parameters:
-
-		ValueType = type of scalar values (e.g. float, double)
-		VecType   = class the swizzle is applies to (e.g. tvec3<float>)
-		N         = number of components in the vector (e.g. 3)
-		E0...3    = what index the n-th element of this swizzle refers to in the unswizzled vec
-
-		DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
-			containing duplicate elements so that they cannot be used as r-values).            
-	*/
-	template <typename ValueType, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
-	struct _swizzle_base2 : public _swizzle_base1<ValueType,VecType,E0,E1,E2,E3,N>
-	{
-		typedef VecType vec_type;
-		typedef ValueType value_type;
-
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
-		{
-			for (int i = 0; i < N; ++i)
-				(*this)[i] = t;
-			return *this;
-		}
-
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; } 
-			};
-			_apply_op(that, op());
-			return *this;
-		}
-
-		GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER void operator += (const VecType& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER value_type& operator[]  (size_t i)
-		{
-#ifndef __CUDA_ARCH__
-			static
-#endif
-				const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-		GLM_FUNC_QUALIFIER value_type  operator[]  (size_t i) const
-		{
-#ifndef __CUDA_ARCH__
-			static
-#endif
-				const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-	protected:
-		template <typename T>
-		GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
-		{
-			// Make a copy of the data in this == &that.
-			// The copier should optimize out the copy in cases where the function is
-			// properly inlined and the copy is not necessary.
-			ValueType t[N];
-			for (int i = 0; i < N; ++i)
-				t[i] = that[i];
-			for (int i = 0; i < N; ++i)
-				op( (*this)[i], t[i] );
-		}
-	};
-
-	// Specialization for swizzles containing duplicate elements.  These cannot be modified.
-	template <typename ValueType, typename VecType, int N, int E0, int E1, int E2, int E3>
-	struct _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType,VecType,E0,E1,E2,E3,N>
-	{
-		typedef VecType         vec_type;        
-		typedef ValueType       value_type;
-
-		struct Stub {};
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
-
-		GLM_FUNC_QUALIFIER value_type  operator[]  (size_t i) const
-		{
-#ifndef __CUDA_ARCH__
-			static
-#endif
-				const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-	};
-
-	template <int N,typename ValueType, typename VecType, int E0,int E1,int E2,int E3>
-	struct swizzle : public _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
-	{
-		typedef _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
-
-		using base_type::operator=;
-
-		GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
-	};
-
-//
-// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
-//
-#define _GLM_SWIZZLE_TEMPLATE1   template <int N, typename T, typename V, int E0, int E1, int E2, int E3>
-#define _GLM_SWIZZLE_TEMPLATE2   template <int N, typename T, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
-#define _GLM_SWIZZLE_TYPE1       glm::detail::swizzle<N,T,V,E0,E1,E2,E3>
-#define _GLM_SWIZZLE_TYPE2       glm::detail::swizzle<N,T,V,F0,F1,F2,F3>
-
-//
-// Wrapper for a binary operator (e.g. u.yy + v.zy)
-//
-#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
-	_GLM_SWIZZLE_TEMPLATE2                                                          \
-	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
-	{                                                                               \
-		return a() OPERAND b();                                                     \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b)                   \
-	{                                                                               \
-		return a() OPERAND b;                                                       \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b)                   \
-	{                                                                               \
-		return a OPERAND b();                                                       \
-	}
-
-//
-// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
-//
-#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
-	{                                                                               \
-		return a() OPERAND b;                                                       \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b)                   \
-	{                                                                               \
-		return a OPERAND b();                                                       \
-	}
-
-//
-// Macro for wrapping a function taking one argument (e.g. abs())
-//
-#define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION)                          \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a)  \
-	{                                                                               \
-		return FUNCTION(a());                                                       \
-	}
-
-//
-// Macro for wrapping a function taking two vector arguments (e.g. dot()).
-//
-#define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION)                                                      \
-	_GLM_SWIZZLE_TEMPLATE2                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
-	{                                                                                                           \
-		return FUNCTION(a(), b());                                                                              \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
-	{                                                                                                           \
-		return FUNCTION(a(), b());                                                                              \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
-	{                                                                                                           \
-		return FUNCTION(a(), b);                                                                                \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b)                  \
-	{                                                                                                           \
-		return FUNCTION(a, b());                                                                                \
-	} 
-
-//
-// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
-//
-#define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION)                                                             \
-	_GLM_SWIZZLE_TEMPLATE2                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c)   \
-	{                                                                                                                         \
-		return FUNCTION(a(), b(), c);                                                                                         \
-	}                                                                                                                         \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)   \
-	{                                                                                                                         \
-		return FUNCTION(a(), b(), c);                                                                                         \
-	}                                                                                                                         \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
-	{                                                                                                                         \
-		return FUNCTION(a(), b, c);                                                                                           \
-	}                                                                                                                         \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)           \
-	{                                                                                                                         \
-		return FUNCTION(a, b(), c);                                                                                           \
-	} 
- 
-}//namespace detail 
-}//namespace glm
-
-namespace glm
-{
-	namespace detail
-	{
-		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
-		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
-	}
-
-	//
-	// Swizzles are distinct types from the unswizzled type.  The below macros will
-	// provide template specializations for the swizzle types for the given functions
-	// so that the compiler does not have any ambiguity to choosing how to handle
-	// the function.
-	//
-	// The alternative is to use the operator()() when calling the function in order
-	// to explicitly convert the swizzled type to the unswizzled type.
-	//
-
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    abs);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acos);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acosh);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    all);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    any);
-
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type,  dot);
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    cross);
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    step);    
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
-}
-
-#define _GLM_SWIZZLE2_2_MEMBERS(T,P,E0,E1) \
-	struct { glm::detail::swizzle<2,T,P,0,0,-1,-2> E0 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,0,1,-1,-2> E0 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,1,0,-1,-2> E1 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,1,1,-1,-2> E1 ## E1; }; 
-
-#define _GLM_SWIZZLE2_3_MEMBERS(T,P2,E0,E1) \
-	struct { glm::detail::swizzle<3,T,P2,0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P2,0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,1,1,-1> E1 ## E1 ## E1; };  
-
-#define _GLM_SWIZZLE2_4_MEMBERS(T,P2,E0,E1) \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,1> E1 ## E1 ## E1 ## E1; };  
-
-#define _GLM_SWIZZLE3_2_MEMBERS(T,P2,E0,E1,E2) \
-	struct { glm::detail::swizzle<2,T,P2,0,0,-1,-2> E0 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P2,0,1,-1,-2> E0 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P2,0,2,-1,-2> E0 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P2,1,0,-1,-2> E1 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P2,1,1,-1,-2> E1 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P2,1,2,-1,-2> E1 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P2,2,0,-1,-2> E2 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P2,2,1,-1,-2> E2 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P2,2,2,-1,-2> E2 ## E2; }; 
-
-#define _GLM_SWIZZLE3_3_MEMBERS(T,P,E0,E1,E2) \
-	struct { glm::detail::swizzle<3,T,P,0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,2,-1> E2 ## E2 ## E2; };
-
-#define _GLM_SWIZZLE3_4_MEMBERS(T,P2,E0,E1,E2) \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
-
-#define _GLM_SWIZZLE4_2_MEMBERS(T,P,E0,E1,E2,E3) \
-	struct { glm::detail::swizzle<2,T,P,0,0,-1,-2> E0 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,0,1,-1,-2> E0 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,0,2,-1,-2> E0 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,0,3,-1,-2> E0 ## E3; }; \
-	struct { glm::detail::swizzle<2,T,P,1,0,-1,-2> E1 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,1,1,-1,-2> E1 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,1,2,-1,-2> E1 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,1,3,-1,-2> E1 ## E3; }; \
-	struct { glm::detail::swizzle<2,T,P,2,0,-1,-2> E2 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,2,1,-1,-2> E2 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,2,2,-1,-2> E2 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,2,3,-1,-2> E2 ## E3; }; \
-	struct { glm::detail::swizzle<2,T,P,3,0,-1,-2> E3 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,3,1,-1,-2> E3 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,3,2,-1,-2> E3 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,3,3,-1,-2> E3 ## E3; }; 
-
-#define _GLM_SWIZZLE4_3_MEMBERS(T,P,E0,E1,E2,E3) \
-	struct { glm::detail::swizzle<3,T,P,0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,3,-1> E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,3,-1> E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,3,-1> E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,0,-1> E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,1,-1> E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,2,-1> E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,3,-1> E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,3,-1> E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,3,-1> E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,3,-1> E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,0,-1> E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,1,-1> E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,2,-1> E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,3,-1> E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,3,-1> E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,3,-1> E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,2,-1> E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,3,-1> E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,0,-1> E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,1,-1> E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,2,-1> E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,3,-1> E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,0,-1> E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,1,-1> E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,2,-1> E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,3,-1> E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,0,-1> E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,1,-1> E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,2,-1> E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,3,-1> E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,0,-1> E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,1,-1> E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,2,-1> E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,3,-1> E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,0,-1> E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,1,-1> E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,2,-1> E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,3,-1> E3 ## E3 ## E3; };  
-
-#define _GLM_SWIZZLE4_4_MEMBERS(T,P,E0,E1,E2,E3) \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,3> E3 ## E3 ## E3 ## E3; }; 
-
-#endif//glm_core_swizzle
diff --git a/include/gal/opengl/glm/core/_swizzle_func.hpp b/include/gal/opengl/glm/core/_swizzle_func.hpp
deleted file mode 100644
index be66784373..0000000000
--- a/include/gal/opengl/glm/core/_swizzle_func.hpp
+++ /dev/null
@@ -1,787 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/_swizzle_func.hpp
-/// @date 2011-10-16 / 2011-10-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_swizzle_func
-#define glm_core_swizzle_func
-
-#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
-	SWIZZLED_TYPE<TMPL_TYPE> A ## B() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
-	SWIZZLED_TYPE<TMPL_TYPE> A ## B ## C() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
-	SWIZZLED_TYPE<TMPL_TYPE> A ## B ## C ## D() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C, this->D); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
-	template <typename TMPL_TYPE> \
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
-	template <typename TMPL_TYPE> \
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B ## C() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
-	template <typename TMPL_TYPE> \
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B ## C ## D() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C, this->D); \
-	}
-
-#define GLM_MUTABLE
-
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
-
-//GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
-
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
-
-#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, q)
-
-//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
-
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
-
-#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
-
-#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q, p)
-
-//GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
-
-#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
-
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
-
-#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q)
-
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
-
-#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q, p)
-
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
-
-#endif//glm_core_swizzle_func
diff --git a/include/gal/opengl/glm/core/_vectorize.hpp b/include/gal/opengl/glm/core/_vectorize.hpp
deleted file mode 100644
index 9984014fa8..0000000000
--- a/include/gal/opengl/glm/core/_vectorize.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/_vectorize.hpp
-/// @date 2011-10-14 / 2011-10-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#define VECTORIZE2_VEC(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec2<T> func( \
-		detail::tvec2<T> const & v) \
-	{ \
-		return detail::tvec2<T>( \
-			func(v.x), \
-			func(v.y)); \
-	}
-
-#define VECTORIZE3_VEC(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec3<T> func( \
-		detail::tvec3<T> const & v) \
-	{ \
-		return detail::tvec3<T>( \
-			func(v.x), \
-			func(v.y), \
-			func(v.z)); \
-	}
-
-#define VECTORIZE4_VEC(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec4<T> func( \
-		detail::tvec4<T> const & v) \
-	{ \
-		return detail::tvec4<T>( \
-			func(v.x), \
-			func(v.y), \
-			func(v.z), \
-			func(v.w)); \
-	}
-
-#define VECTORIZE_VEC(func) \
-	VECTORIZE2_VEC(func) \
-	VECTORIZE3_VEC(func) \
-	VECTORIZE4_VEC(func)
-
-#define VECTORIZE2_VEC_SCA(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec2<T> func \
-	( \
-		detail::tvec2<T> const & x,  \
-		typename detail::tvec2<T>::value_type const & y \
-	) \
-	{ \
-		return detail::tvec2<T>( \
-			func(x.x, y), \
-			func(x.y, y)); \
-	}
-
-#define VECTORIZE3_VEC_SCA(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec3<T> func \
-	( \
-		detail::tvec3<T> const & x,  \
-		typename detail::tvec3<T>::value_type const & y \
-	) \
-	{ \
-		return detail::tvec3<T>( \
-			func(x.x, y), \
-			func(x.y, y), \
-			func(x.z, y)); \
-	}
-
-#define VECTORIZE4_VEC_SCA(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec4<T> func \
-	( \
-		detail::tvec4<T> const & x,  \
-		typename detail::tvec4<T>::value_type const & y \
-	) \
-	{ \
-		return detail::tvec4<T>( \
-			func(x.x, y), \
-			func(x.y, y), \
-			func(x.z, y), \
-			func(x.w, y)); \
-	}
-
-#define VECTORIZE_VEC_SCA(func) \
-	VECTORIZE2_VEC_SCA(func) \
-	VECTORIZE3_VEC_SCA(func) \
-	VECTORIZE4_VEC_SCA(func)
-
-#define VECTORIZE2_VEC_VEC(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec2<T> func \
-	( \
-		detail::tvec2<T> const & x,  \
-		detail::tvec2<T> const & y \
-	) \
-	{ \
-		return detail::tvec2<T>( \
-			func(x.x, y.x), \
-			func(x.y, y.y)); \
-	}
-
-#define VECTORIZE3_VEC_VEC(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec3<T> func \
-	( \
-		detail::tvec3<T> const & x,  \
-		detail::tvec3<T> const & y \
-	) \
-	{ \
-		return detail::tvec3<T>( \
-			func(x.x, y.x), \
-			func(x.y, y.y), \
-			func(x.z, y.z)); \
-	}
-
-#define VECTORIZE4_VEC_VEC(func) \
-	template <typename T> \
-	GLM_FUNC_QUALIFIER detail::tvec4<T> func \
-	( \
-		detail::tvec4<T> const & x,  \
-		detail::tvec4<T> const & y \
-	) \
-	{ \
-		return detail::tvec4<T>( \
-			func(x.x, y.x), \
-			func(x.y, y.y), \
-			func(x.z, y.z), \
-			func(x.w, y.w)); \
-	}
-
-#define VECTORIZE_VEC_VEC(func) \
-	VECTORIZE2_VEC_VEC(func) \
-	VECTORIZE3_VEC_VEC(func) \
-	VECTORIZE4_VEC_VEC(func)
diff --git a/include/gal/opengl/glm/core/dummy.cpp b/include/gal/opengl/glm/core/dummy.cpp
deleted file mode 100644
index 38fcca0206..0000000000
--- a/include/gal/opengl/glm/core/dummy.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/dummy.cpp
-/// @date 2011-01-19 / 2011-06-15
-/// @author Christophe Riccio
-///
-/// GLM is a header only library. There is nothing to compile. 
-/// dummy.cpp exist only a wordaround for CMake file.
-///////////////////////////////////////////////////////////////////////////////////
-
-#define GLM_MESSAGES
-#include "../glm.hpp"
-
-//#error "GLM is a header only library"
-
-int main()
-{
-
-}
diff --git a/include/gal/opengl/glm/core/func_common.hpp b/include/gal/opengl/glm/core/func_common.hpp
deleted file mode 100644
index fcf7eb7619..0000000000
--- a/include/gal/opengl/glm/core/func_common.hpp
+++ /dev/null
@@ -1,430 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_common.hpp
-/// @date 2008-03-08 / 2010-01-26
-/// @author Christophe Riccio
-/// 
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-///
-/// @defgroup core_func_common Common functions
-/// @ingroup core
-/// 
-/// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_common
-#define GLM_CORE_func_common GLM_VERSION
-
-#include "_fixes.hpp"
-
-namespace glm
-{
-	/// @addtogroup core_func_common
-	/// @{
-
-	/// Returns x if x >= 0; otherwise, it returns -x.
-	/// 
-	/// @tparam genType floating-point or signed integer; scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType abs(genType const & x);
-
-	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
-	/// 
-	/// @tparam genType Floating-point or signed integer; scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType sign(genType const & x);
-
-	/// Returns a value equal to the nearest integer that is less then or equal to x. 
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType floor(genType const & x);
-
-	/// Returns a value equal to the nearest integer to x 
-	/// whose absolute value is not larger than the absolute value of x. 
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType trunc(genType const & x);
-
-	/// Returns a value equal to the nearest integer to x. 
-	/// The fraction 0.5 will round in a direction chosen by the 
-	/// implementation, presumably the direction that is fastest. 
-	/// This includes the possibility that round(x) returns the 
-	/// same value as roundEven(x) for all values of x. 
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType round(genType const & x);
-
-	/// Returns a value equal to the nearest integer to x.
-	/// A fractional part of 0.5 will round toward the nearest even
-	/// integer. (Both 3.5 and 4.5 for x will return 4.0.) 
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType roundEven(genType const & x);
-
-	/// Returns a value equal to the nearest integer 
-	/// that is greater than or equal to x. 
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType ceil(genType const & x);
-
-	/// Return x - floor(x).
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType fract(genType const & x);
-
-	/// Modulus. Returns x - y * floor(x / y) 
-	/// for each component in x using the floating point value y.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType mod(
-		genType const & x, 
-		genType const & y);
-
-	/// Modulus. Returns x - y * floor(x / y) 
-	/// for each component in x using the floating point value y.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType mod(
-		genType const & x, 
-		typename genType::value_type const & y);
-
-	/// Returns the fractional part of x and sets i to the integer
-	/// part (as a whole number floating point value). Both the
-	/// return value and the output parameter will have the same
-	/// sign as x.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType modf(
-		genType const & x, 
-		genType & i);
-
-	/// Returns y if y < x; otherwise, it returns x.
-	///
-	/// @tparam genType Floating-point or integer; scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType min(
-		genType const & x, 
-		genType const & y);
-
-	template <typename genType> 
-	GLM_FUNC_DECL genType min(
-		genType const & x, 
-		typename genType::value_type const & y);
-
-	/// Returns y if x < y; otherwise, it returns x.
-	/// 
-	/// @tparam genType Floating-point or integer; scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType max(
-		genType const & x, 
-		genType const & y);
-
-	template <typename genType> 
-	GLM_FUNC_DECL genType max(
-		genType const & x, 
-		typename genType::value_type const & y);
-
-	/// Returns min(max(x, minVal), maxVal) for each component in x 
-	/// using the floating-point values minVal and maxVal.
-	///
-	/// @tparam genType Floating-point or integer; scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType clamp(
-		genType const & x, 
-		genType const & minVal, 
-		genType const & maxVal); 
-
-	template <typename genType> 
-	GLM_FUNC_DECL genType clamp(
-		genType const & x, 
-		typename genType::value_type const & minVal, 
-		typename genType::value_type const & maxVal); 
-
-	/// If genTypeU is a floating scalar or vector: 
-	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
-	/// x and y using the floating-point value a. 
-	/// The value for a is not restricted to the range [0, 1].
-	/// 
-	/// If genTypeU is a boolean scalar or vector: 
-	/// Selects which vector each returned component comes
-	/// from. For a component of <a> that is false, the
-	/// corresponding component of x is returned. For a
-	/// component of a that is true, the corresponding
-	/// component of y is returned. Components of x and y that
-	/// are not selected are allowed to be invalid floating point
-	/// values and will have no effect on the results. Thus, this
-	/// provides different functionality than
-	/// genType mix(genType x, genType y, genType(a))
-	/// where a is a Boolean vector.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	/// 
-	/// @param[in]  x Value to interpolate.
-	/// @param[in]  y Value to interpolate.
-	/// @param[in]  a Interpolant.
-	/// 
-	/// @tparam	genTypeT Floating point scalar or vector.
-	/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
-	/// 
-	/// @code
-	/// #include <glm/glm.hpp>
-	/// ...
-	/// float a;
-	/// bool b;
-	/// glm::dvec3 e;
-	/// glm::dvec3 f;
-	/// glm::vec4 g;
-	/// glm::vec4 h;
-	/// ...
-	/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors. 
-	/// glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
-	/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
-	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
-	/// @endcode
-	template <typename genTypeT, typename genTypeU> 
-	GLM_FUNC_DECL genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a);
-
-	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType step(
-		genType const & edge, 
-		genType const & x);
-
-	template <typename genType> 
-	GLM_FUNC_DECL genType step(
-		typename genType::value_type const & edge, 
-		genType const & x);
-
-	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
-	/// performs smooth Hermite interpolation between 0 and 1
-	/// when edge0 < x < edge1. This is useful in cases where
-	/// you would want a threshold function with a smooth
-	/// transition. This is equivalent to:
-	/// genType t;
-	/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
-	/// return t * t * (3 - 2 * t);
-	/// Results are undefined if edge0 >= edge1.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType smoothstep(
-		genType const & edge0, 
-		genType const & edge1, 
-		genType const & x);
-
-	template <typename genType> 
-	GLM_FUNC_DECL genType smoothstep(
-		typename genType::value_type const & edge0, 
-		typename genType::value_type const & edge1, 
-		genType const & x);
-
-	/// Returns true if x holds a NaN (not a number)
-	/// representation in the underlying implementation's set of
-	/// floating point representations. Returns false otherwise,
-	/// including for implementations with no NaN
-	/// representations.
-	/// 
-	/// /!\ When using compiler fast math, this function may fail.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
-
-	/// Returns true if x holds a positive infinity or negative
-	/// infinity representation in the underlying implementation's
-	/// set of floating point representations. Returns false
-	/// otherwise, including for implementations with no infinity
-	/// representations.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
-
-	/// Returns a signed integer value representing
-	/// the encoding of a floating-point value. The floatingpoint
-	/// value's bit-level representation is preserved.
-	///
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genIType Signed integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType, typename genIType>
-	GLM_FUNC_DECL genIType floatBitsToInt(genType const & value);
-
-	/// Returns a unsigned integer value representing
-	/// the encoding of a floating-point value. The floatingpoint
-	/// value's bit-level representation is preserved.
-	///
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genUType Unsigned integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType, typename genUType>
-	GLM_FUNC_DECL genUType floatBitsToUint(genType const & value);
-
-	/// Returns a floating-point value corresponding to a signed
-	/// integer encoding of a floating-point value.
-	/// If an inf or NaN is passed in, it will not signal, and the
-	/// resulting floating point value is unspecified. Otherwise,
-	/// the bit-level representation is preserved.
-	/// 
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genIType Signed integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	/// 
-	/// @todo Clarify this declaration, we don't need to actually specify the return type
-	template <typename genType, typename genIType>
-	GLM_FUNC_DECL genType intBitsToFloat(genIType const & value);
-
-	/// Returns a floating-point value corresponding to a
-	/// unsigned integer encoding of a floating-point value.
-	/// If an inf or NaN is passed in, it will not signal, and the
-	/// resulting floating point value is unspecified. Otherwise,
-	/// the bit-level representation is preserved.
-	/// 
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genUType Unsigned integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	/// 
-	/// @todo Clarify this declaration, we don't need to actually specify the return type
-	template <typename genType, typename genUType>
-	GLM_FUNC_DECL genType uintBitsToFloat(genUType const & value);
-
-	/// Computes and returns a * b + c.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
-
-	/// Splits x into a floating-point significand in the range
-	/// [0.5, 1.0) and an integral exponent of two, such that:
-	/// x = significand * exp(2, exponent)
-	/// 
-	/// The significand is returned by the function and the
-	/// exponent is returned in the parameter exp. For a
-	/// floating-point value of zero, the significant and exponent
-	/// are both zero. For a floating-point value that is an
-	/// infinity or is not a number, the results are undefined.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType, typename genIType>
-	GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
-
-	/// Builds a floating-point number from x and the
-	/// corresponding integral exponent of two in exp, returning:
-	/// significand * exp(2, exponent)
-	/// 
-	/// If this product is too large to be represented in the
-	/// floating-point type, the result is undefined.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///  
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType, typename genIType>
-	GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
-
-	/// @}
-}//namespace glm
-
-#include "func_common.inl"
-
-#endif//GLM_CORE_func_common
diff --git a/include/gal/opengl/glm/core/func_common.inl b/include/gal/opengl/glm/core/func_common.inl
deleted file mode 100644
index 1c0d9df979..0000000000
--- a/include/gal/opengl/glm/core/func_common.inl
+++ /dev/null
@@ -1,1226 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_common.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename genFIType, bool /*signed*/>
-	struct Abs_
-	{};
-
-	template <typename genFIType>
-	struct Abs_<genFIType, true>
-	{
-		GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
-		{
-			GLM_STATIC_ASSERT(
-				detail::type<genFIType>::is_float || 
-				detail::type<genFIType>::is_int, "'abs' only accept floating-point and integer inputs");
-			return x >= genFIType(0) ? x : -x;
-			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
-		}
-	};
-
-	template <typename genFIType>
-	struct Abs_<genFIType, false>
-	{
-		GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
-		{
-			GLM_STATIC_ASSERT(
-					detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs");
-			return x;
-		}
-	};
-}//namespace detail
-
-	// abs
-	template <typename genFIType>
-	GLM_FUNC_QUALIFIER genFIType abs
-	(
-		genFIType const & x
-	)
-	{
-		return detail::Abs_<genFIType, std::numeric_limits<genFIType>::is_signed>::get(x);
-	}
-
-	VECTORIZE_VEC(abs)
-
-	// sign
-	//Try something like based on x >> 31 to get the sign bit
-	template <typename genFIType> 
-	GLM_FUNC_QUALIFIER genFIType sign
-	(
-		genFIType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(
-			detail::type<genFIType>::is_float || 
-			detail::type<genFIType>::is_int, "'sign' only accept signed inputs");
-
-		genFIType result;
-		if(x > genFIType(0))
-			result = genFIType(1);
-		else if(x < genFIType(0))
-			result = genFIType(-1);
-		else
-			result = genFIType(0);
-		return result;
-	}
-	
-	VECTORIZE_VEC(sign)
-
-	// floor
-	template <>
-	GLM_FUNC_QUALIFIER detail::half floor<detail::half>(detail::half const & x)
-	{
-		return detail::half(::std::floor(float(x)));
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType floor(genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'floor' only accept floating-point inputs");
-
-		return ::std::floor(x);
-	}
-
-	VECTORIZE_VEC(floor)
-
-	// trunc
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType trunc(genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'trunc' only accept floating-point inputs");
-		return x < 0 ? -floor(-x) : floor(x);
-	}
-
-	VECTORIZE_VEC(trunc)
-
-	// round
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType round(genType const& x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'round' only accept floating-point inputs");
-
-		if(x < 0)
-			return genType(int(x - genType(0.5)));
-		return genType(int(x + genType(0.5)));
-	}
-
-	VECTORIZE_VEC(round)
-
-/*
-	// roundEven
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs");
-
-		return genType(int(x + genType(int(x) % 2)));
-	}
-*/
-	
-	// roundEven
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType roundEven(genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs");
-		
-		int Integer = int(x);
-		genType IntegerPart = genType(Integer);
-		genType FractionalPart = fract(x);
-
-		if(FractionalPart > genType(0.5) || FractionalPart < genType(0.5))
-		{
-			return round(x);
-		}
-		else if((Integer % 2) == 0)
-		{
-			return IntegerPart;
-		}
-		else if(x <= genType(0)) // Work around... 
-		{
-			return IntegerPart - 1;
-		}
-		else
-		{
-			return IntegerPart + 1;
-		}
-		//else // Bug on MinGW 4.5.2
-		//{
-		//	return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
-		//}
-	}
-	
-	VECTORIZE_VEC(roundEven)
-
-	// ceil
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ceil(genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'ceil' only accept floating-point inputs");
-
-		return ::std::ceil(x);
-	}
-
-	VECTORIZE_VEC(ceil)
-
-	// fract
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fract
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'fract' only accept floating-point inputs");
-
-		return x - ::std::floor(x);
-	}
-
-	VECTORIZE_VEC(fract)
-
-	// mod
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType mod
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mod' only accept floating-point inputs");
-
-		return x - y * floor(x / y);
-	}
-
-	VECTORIZE_VEC_SCA(mod)
-	VECTORIZE_VEC_VEC(mod)
-
-	// modf
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType modf
-	(
-		genType const & x, 
-		genType & i
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'modf' only accept floating-point inputs");
-
-		return std::modf(x, &i);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> modf
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> & i
-	)
-	{
-		return detail::tvec2<valType>(
-			modf(x.x, i.x),
-			modf(x.y, i.y));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> modf
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> & i
-	)
-	{
-		return detail::tvec3<valType>(
-			modf(x.x, i.x),
-			modf(x.y, i.y),
-			modf(x.z, i.z));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> modf
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> & i
-	)
-	{
-		return detail::tvec4<valType>(
-			modf(x.x, i.x),
-			modf(x.y, i.y),
-			modf(x.z, i.z),
-			modf(x.w, i.w));
-	}
-
-	//// Only valid if (INT_MIN <= x-y <= INT_MAX)
-	//// min(x,y)
-	//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
-	//CHAR_BIT - 1)));
-	//// max(x,y)
-	//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
-	//CHAR_BIT - 1)));
-
-	// min
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType min
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(
-			detail::type<genType>::is_float || 
-			detail::type<genType>::is_int ||
-			detail::type<genType>::is_uint, "'min' only accept numbers");
-
-		return x < y ? x : y;
-	}
-
-	VECTORIZE_VEC_SCA(min)
-	VECTORIZE_VEC_VEC(min)
-
-	// max
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType max
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(
-			detail::type<genType>::is_float || 
-			detail::type<genType>::is_int ||
-			detail::type<genType>::is_uint, "'max' only accept numbers");
-
-		return x > y ? x : y;
-	}
-
-	VECTORIZE_VEC_SCA(max)
-	VECTORIZE_VEC_VEC(max)
-
-	// clamp
-	template <typename valType>
-	GLM_FUNC_QUALIFIER valType clamp
-	(
-		valType const & x, 
-		valType const & minVal, 
-		valType const & maxVal
-	)
-	{
-		GLM_STATIC_ASSERT(
-			detail::type<valType>::is_float || 
-			detail::type<valType>::is_int ||
-			detail::type<valType>::is_uint, "'clamp' only accept numbers");
-		
-		return min(maxVal, max(minVal, x));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
-	(
-		detail::tvec2<T> const & x, 
-		typename detail::tvec2<T>::value_type const & minVal, 
-		typename detail::tvec2<T>::value_type const & maxVal
-	)
-	{
-		return detail::tvec2<T>(
-			clamp(x.x, minVal, maxVal),
-			clamp(x.y, minVal, maxVal));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
-	(
-		detail::tvec3<T> const & x, 
-		typename detail::tvec3<T>::value_type const & minVal, 
-		typename detail::tvec3<T>::value_type const & maxVal
-	)
-	{
-		return detail::tvec3<T>(
-			clamp(x.x, minVal, maxVal),
-			clamp(x.y, minVal, maxVal),
-			clamp(x.z, minVal, maxVal));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
-	(
-		detail::tvec4<T> const & x, 
-		typename detail::tvec4<T>::value_type const & minVal, 
-		typename detail::tvec4<T>::value_type const & maxVal
-	)
-	{
-		return detail::tvec4<T>(
-			clamp(x.x, minVal, maxVal),
-			clamp(x.y, minVal, maxVal),
-			clamp(x.z, minVal, maxVal),
-			clamp(x.w, minVal, maxVal));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & minVal, 
-		detail::tvec2<T> const & maxVal
-	)
-	{
-		return detail::tvec2<T>(
-			clamp(x.x, minVal.x, maxVal.x),
-			clamp(x.y, minVal.y, maxVal.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & minVal, 
-		detail::tvec3<T> const & maxVal
-	)
-	{
-		return detail::tvec3<T>(
-			clamp(x.x, minVal.x, maxVal.x),
-			clamp(x.y, minVal.y, maxVal.y),
-			clamp(x.z, minVal.z, maxVal.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & minVal, 
-		detail::tvec4<T> const & maxVal
-	)
-	{
-		return detail::tvec4<T>(
-			clamp(x.x, minVal.x, maxVal.x),
-			clamp(x.y, minVal.y, maxVal.y),
-			clamp(x.z, minVal.z, maxVal.z),
-			clamp(x.w, minVal.w, maxVal.w));
-	}
-
-	// mix
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType mix
-	(
-		genType const & x, 
-		genType const & y, 
-		genType const & a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float , "'genType' is not floating-point type");
-
-		return x + a * (y - x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> mix
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y, 
-		valType const & a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float , "'genType' is not floating-point type");
-
-		return x + a * (y - x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> mix
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y, 
-		valType const & a
-	)
-	{
-		return x + a * (y - x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> mix
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y, 
-		valType const & a
-	)
-	{
-		return x + a * (y - x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> mix
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y, 
-		detail::tvec2<valType> const & a
-	)
-	{
-		return x + a * (y - x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> mix
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y, 
-		detail::tvec3<valType> const & a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float , "'genType' is not floating-point type");
-
-		return x + a * (y - x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> mix
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y, 
-		detail::tvec4<valType> const & a
-	)
-	{
-		return x + a * (y - x);
-	}
-
-	//template <typename genTypeT>
-	//GLM_FUNC_QUALIFIER genTypeT mix
-	//(
-	//	genTypeT const & x, 
-	//	genTypeT const & y, 
-	//	float const & a
-	//)
-	//{
-	//	// It could be a vector too
-	//	//GLM_STATIC_ASSERT(
-	//	//	detail::type<genTypeT>::is_float && 
-	//	//	detail::type<genTypeU>::is_float);
-
-	//	return x + a * (y - x);
-	//}
-
-	template <>
-	GLM_FUNC_QUALIFIER float mix
-	(
-		float const & x, 
-		float const & y, 
-		bool const & a
-	)
-	{
-		return a ? y : x;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER double mix
-	(
-		double const & x, 
-		double const & y, 
-		bool const & a
-	)
-	{
-		return a ? y : x;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> mix
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		bool a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		return a ? y : x;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> mix
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		bool a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		return a ? y : x;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> mix
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		bool a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		return a ? y : x;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> mix
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		typename detail::tvec2<T>::bool_type a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		detail::tvec2<T> result;
-		for
-		(
-			typename detail::tvec2<T>::size_type i = 0; 
-			i < x.length(); ++i
-		)
-		{
-			result[i] = a[i] ? y[i] : x[i];
-		}
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> mix
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		typename detail::tvec3<T>::bool_type a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		detail::tvec3<T> result;
-		for
-		(
-			typename detail::tvec3<T>::size_type i = 0; 
-			i < x.length(); ++i
-		)
-		{
-			result[i] = a[i] ? y[i] : x[i];
-		}
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> mix
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		typename detail::tvec4<T>::bool_type a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		detail::tvec4<T> result;
-		for
-		(
-			typename detail::tvec4<T>::size_type i = 0; 
-			i < x.length(); ++i
-		)
-		{
-			result[i] = a[i] ? y[i] : x[i];
-		}
-		return result;
-	}
-
-	// step
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType step
-	(
-		genType const & edge, 
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'step' only accept floating-point inputs");
-
-		return x < edge ? genType(0) : genType(1);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> step
-	(
-		typename detail::tvec2<T>::value_type const & edge, 
-		detail::tvec2<T> const & x
-	)
-	{
-		return detail::tvec2<T>(
-			x.x < edge ? T(0) : T(1),
-			x.y < edge ? T(0) : T(1));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> step
-	(
-		typename detail::tvec3<T>::value_type const & edge, 
-		detail::tvec3<T> const & x
-	)
-	{
-		return detail::tvec3<T>(
-			x.x < edge ? T(0) : T(1),
-			x.y < edge ? T(0) : T(1),
-			x.z < edge ? T(0) : T(1));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> step
-	(
-		typename detail::tvec4<T>::value_type const & edge, 
-		detail::tvec4<T> const & x
-	)
-	{
-		return detail::tvec4<T>(
-			x.x < edge ? T(0) : T(1),
-			x.y < edge ? T(0) : T(1),
-			x.z < edge ? T(0) : T(1),
-			x.w < edge ? T(0) : T(1));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> step
-	(
-		detail::tvec2<T> const & edge, 
-		detail::tvec2<T> const & x
-	)
-	{
-		return detail::tvec2<T>(
-			x.x < edge.x ? T(0) : T(1),
-			x.y < edge.y ? T(0) : T(1));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> step
-	(
-		detail::tvec3<T> const & edge, 
-		detail::tvec3<T> const & x
-	)
-	{
-		return detail::tvec3<T>(
-			x.x < edge.x ? T(0) : T(1),
-			x.y < edge.y ? T(0) : T(1),
-			x.z < edge.z ? T(0) : T(1));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> step
-	(
-		detail::tvec4<T> const & edge, 
-		detail::tvec4<T> const & x
-	)
-	{
-		return detail::tvec4<T>(
-			x.x < edge.x ? T(0) : T(1),
-			x.y < edge.y ? T(0) : T(1),
-			x.z < edge.z ? T(0) : T(1),
-			x.w < edge.w ? T(0) : T(1));
-	}
-
-	// smoothstep
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType smoothstep
-	(
-		genType const & edge0, 
-		genType const & edge1, 
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'smoothstep' only accept floating-point inputs");
-
-		genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1));
-		return tmp * tmp * (genType(3) - genType(2) * tmp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep
-	(
-		typename detail::tvec2<T>::value_type const & edge0, 
-		typename detail::tvec2<T>::value_type const & edge1, 
-		detail::tvec2<T> const & x
-	)
-	{
-		return detail::tvec2<T>(
-			smoothstep(edge0, edge1, x.x),
-			smoothstep(edge0, edge1, x.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep
-	(
-		typename detail::tvec3<T>::value_type const & edge0, 
-		typename detail::tvec3<T>::value_type const & edge1, 
-		detail::tvec3<T> const & x
-	)
-	{
-		return detail::tvec3<T>(
-			smoothstep(edge0, edge1, x.x),
-			smoothstep(edge0, edge1, x.y),
-			smoothstep(edge0, edge1, x.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep
-	(
-		typename detail::tvec4<T>::value_type const & edge0, 
-		typename detail::tvec4<T>::value_type const & edge1, 
-		detail::tvec4<T> const & x
-	)
-	{
-		return detail::tvec4<T>(
-			smoothstep(edge0, edge1, x.x),
-			smoothstep(edge0, edge1, x.y),
-			smoothstep(edge0, edge1, x.z),
-			smoothstep(edge0, edge1, x.w));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep
-	(
-		detail::tvec2<T> const & edge0, 
-		detail::tvec2<T> const & edge1, 
-		detail::tvec2<T> const & x
-	)
-	{
-		return detail::tvec2<T>(
-			smoothstep(edge0.x, edge1.x, x.x),
-			smoothstep(edge0.y, edge1.y, x.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep
-	(
-		detail::tvec3<T> const & edge0, 
-		detail::tvec3<T> const & edge1, 
-		detail::tvec3<T> const & x
-	)
-	{
-		return detail::tvec3<T>(
-			smoothstep(edge0.x, edge1.x, x.x),
-			smoothstep(edge0.y, edge1.y, x.y),
-			smoothstep(edge0.z, edge1.z, x.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep
-	(
-		detail::tvec4<T> const & edge0, 
-		detail::tvec4<T> const & edge1, 
-		detail::tvec4<T> const & x
-	)
-	{
-		return detail::tvec4<T>(
-			smoothstep(edge0.x, edge1.x, x.x),
-			smoothstep(edge0.y, edge1.y, x.y),
-			smoothstep(edge0.z, edge1.z, x.z),
-			smoothstep(edge0.w, edge1.w, x.w));
-	}
-
-	// TODO: Not working on MinGW...
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER bool isnan(genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isnan' only accept floating-point inputs");
-
-#		if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL))
-			return _isnan(x) != 0;
-#		elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG))
-#			if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-				return _isnan(x) != 0;
-#			else
-				return std::isnan(x);
-#			endif
-#		elif(GLM_COMPILER & GLM_COMPILER_CUDA)
-			return isnan(x) != 0;
-#		else
-			return std::isnan(x);
-#		endif
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isnan
-	(
-		detail::tvec2<T> const & x
-	)
-	{
-		return typename detail::tvec2<T>::bool_type(
-			isnan(x.x),
-			isnan(x.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isnan
-	(
-		detail::tvec3<T> const & x
-	)
-	{
-		return typename detail::tvec3<T>::bool_type(
-			isnan(x.x),
-			isnan(x.y),
-			isnan(x.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isnan
-	(
-		detail::tvec4<T> const & x
-	)
-	{
-		return typename detail::tvec4<T>::bool_type(
-			isnan(x.x),
-			isnan(x.y),
-			isnan(x.z),
-			isnan(x.w));
-	}
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER bool isinf(
-		genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isinf' only accept floating-point inputs");
-
-#		if(GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC))
-			return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
-#		elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG))
-#			if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-				return _isinf(x) != 0;
-#			else
-				return std::isinf(x);
-#			endif
-#		elif(GLM_COMPILER & GLM_COMPILER_CUDA)
-			// http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab
-			return isinf(double(x)) != 0;
-#		else
-			return std::isinf(x);
-#		endif
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isinf
-	(
-		detail::tvec2<T> const & x
-	)
-	{
-		return typename detail::tvec2<T>::bool_type(
-			isinf(x.x),
-			isinf(x.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isinf
-	(
-		detail::tvec3<T> const & x
-	)
-	{
-		return typename detail::tvec3<T>::bool_type(
-			isinf(x.x),
-			isinf(x.y),
-			isinf(x.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isinf
-	(
-		detail::tvec4<T> const & x
-	)
-	{
-		return typename detail::tvec4<T>::bool_type(
-			isinf(x.x),
-			isinf(x.y),
-			isinf(x.z),
-			isinf(x.w));
-	}
-
-	GLM_FUNC_QUALIFIER int floatBitsToInt(float const & value)
-	{
-		union
-		{
-			float f;
-			int i;
-		} fi;
-
-		fi.f = value;
-		return fi.i;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<int> floatBitsToInt
-	(
-		detail::tvec2<float> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			floatBitsToInt(value.x),
-			floatBitsToInt(value.y));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec3<int> floatBitsToInt
-	(
-		detail::tvec3<float> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			floatBitsToInt(value.x),
-			floatBitsToInt(value.y),
-			floatBitsToInt(value.z));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<int> floatBitsToInt
-	(
-		detail::tvec4<float> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			floatBitsToInt(value.x),
-			floatBitsToInt(value.y),
-			floatBitsToInt(value.z),
-			floatBitsToInt(value.w));
-	}
-
-	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & value)
-	{
-		union
-		{
-			float f;
-			uint u;
-		} fu;
-
-		fu.f = value;
-		return fu.u;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<uint> floatBitsToUint
-	(
-		detail::tvec2<float> const & value
-	)
-	{
-		return detail::tvec2<uint>(
-			floatBitsToUint(value.x),
-			floatBitsToUint(value.y));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec3<uint> floatBitsToUint
-	(
-		detail::tvec3<float> const & value
-	)
-	{
-		return detail::tvec3<uint>(
-			floatBitsToUint(value.x),
-			floatBitsToUint(value.y),
-			floatBitsToUint(value.z));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<uint> floatBitsToUint
-	(
-		detail::tvec4<float> const & value
-	)
-	{
-		return detail::tvec4<uint>(
-			floatBitsToUint(value.x),
-			floatBitsToUint(value.y),
-			floatBitsToUint(value.z),
-			floatBitsToUint(value.w));
-	}
-
-	GLM_FUNC_QUALIFIER float intBitsToFloat(int const & value)
-	{
-		union
-		{
-			float f;
-			int i;
-		} fi;
-
-		fi.i = value;
-		return fi.f;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<float> intBitsToFloat
-
-	(
-		detail::tvec2<int> const & value
-	)
-	{
-		return detail::tvec2<float>(
-			intBitsToFloat(value.x),
-			intBitsToFloat(value.y));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec3<float> intBitsToFloat
-	(
-		detail::tvec3<int> const & value
-	)
-	{
-		return detail::tvec3<float>(
-			intBitsToFloat(value.x),
-			intBitsToFloat(value.y),
-			intBitsToFloat(value.z));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<float> intBitsToFloat
-	(
-		detail::tvec4<int> const & value
-	)
-	{
-		return detail::tvec4<float>(
-			intBitsToFloat(value.x),
-			intBitsToFloat(value.y),
-			intBitsToFloat(value.z),
-			intBitsToFloat(value.w));
-	}
-
-	GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & value)
-	{
-		union
-		{
-			float f;
-			uint u;
-		} fu;
-
-		fu.u = value;
-		return fu.f;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<float> uintBitsToFloat
-	(
-		detail::tvec2<uint> const & value
-	)
-	{
-		return detail::tvec2<float>(
-			uintBitsToFloat(value.x),
-			uintBitsToFloat(value.y));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec3<float> uintBitsToFloat
-	(
-		detail::tvec3<uint> const & value
-	)
-	{
-		return detail::tvec3<float>(
-			uintBitsToFloat(value.x),
-			uintBitsToFloat(value.y),
-			uintBitsToFloat(value.z));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<float> uintBitsToFloat
-	(
-		detail::tvec4<uint> const & value
-	)
-	{
-		return detail::tvec4<float>(
-			uintBitsToFloat(value.x),
-			uintBitsToFloat(value.y),
-			uintBitsToFloat(value.z),
-			uintBitsToFloat(value.w));
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fma
-	(
-		genType const & a, 
-		genType const & b, 
-		genType const & c
-	)
-	{
-		return a * b + c;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType frexp
-	(
-		genType const & x, 
-		int & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> frexp
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<int> & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> frexp
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<int> & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> frexp
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<int> & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ldexp
-	(
-		genType const & x, 
-		int const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> ldexp
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<int> const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> ldexp
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<int> const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> ldexp
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<int> const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_exponential.hpp b/include/gal/opengl/glm/core/func_exponential.hpp
deleted file mode 100644
index dc76fcbb93..0000000000
--- a/include/gal/opengl/glm/core/func_exponential.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_exponential.hpp
-/// @date 2008-08-08 / 2011-06-14
-/// @author Christophe Riccio
-/// 
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-///
-/// @defgroup core_func_exponential Exponential functions
-/// @ingroup core
-/// 
-/// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_exponential
-#define glm_core_func_exponential GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_exponential
-	/// @{
-
-	/// Returns 'base' raised to the power 'exponent'. 
-	///
-	/// @param base Floating point value. pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
-	/// @param exponent Floating point value representing the 'exponent'.
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
-
-	/// Returns the natural exponentiation of x, i.e., e^x.
-	///
-	/// @param x exp function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType exp(genType const & x);
-
-	/// Returns the natural logarithm of x, i.e., 
-	/// returns the value y which satisfies the equation x = e^y. 
-	/// Results are undefined if x <= 0.
-	///
-	/// @param x log function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType log(genType const & x);
-
-	/// Returns 2 raised to the x power.
-	/// 
-	/// @param x exp2 function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType exp2(genType const & x);
-
-	/// Returns the base 2 log of x, i.e., returns the value y, 
-	/// which satisfies the equation x = 2 ^ y.
-	/// 
-	/// @param x log2 function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType log2(genType const & x);
-
-	/// Returns the positive square root of x.
-	/// 
-	/// @param x sqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType sqrt(genType const & x);
-    
-	/// Returns the reciprocal of the positive square root of x.
-	/// 
-	/// @param x inversesqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType inversesqrt(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_exponential.inl"
-
-#endif//glm_core_func_exponential
diff --git a/include/gal/opengl/glm/core/func_exponential.inl b/include/gal/opengl/glm/core/func_exponential.inl
deleted file mode 100644
index 1b08786df6..0000000000
--- a/include/gal/opengl/glm/core/func_exponential.inl
+++ /dev/null
@@ -1,156 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_exponential.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// pow
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType pow
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'pow' only accept floating-point input");
-
-		return genType(::std::pow(x, y));
-	}
-
-	VECTORIZE_VEC_VEC(pow)
-
-	// exp
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp' only accept floating-point input");
-
-		return genType(::std::exp(x));
-	}
-
-	VECTORIZE_VEC(exp)
-
-	// log
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log' only accept floating-point input");
-
-		return genType(::std::log(x));
-	}
-
-	VECTORIZE_VEC(log)
-
-	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp2
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp2' only accept floating-point input");
-
-		return genType(::std::exp(genType(0.69314718055994530941723212145818) * x));
-	}
-
-	VECTORIZE_VEC(exp2)
-
-namespace _detail
-{
-	template <int _PATH = detail::float_or_int_value::GLM_ERROR>
-	struct _compute_log2
-	{
-		template <typename T>
-		T operator() (T const & Value) const;
-/*
-		{
-			GLM_STATIC_ASSERT(0, "'log2' parameter has an invalid template parameter type. GLM core features only supports floating-point types, include <glm/gtx/integer.hpp> for integer types support. Others types are not supported.");
-			return Value;
-		}
-*/
-	};
-
-	template <>
-	struct _compute_log2<detail::float_or_int_value::GLM_FLOAT>
-	{
-		template <typename T>
-		T operator() (T const & Value) const
-		{
-			return T(::std::log(Value)) / T(0.69314718055994530941723212145818);
-		}
-	};
-
-}//namespace _detail
-
-	// log2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log2
-	(
-		genType const & x
-	)
-	{
-		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
-		return _detail::_compute_log2<detail::float_or_int_trait<genType>::ID>()(x);
-	}
-
-	VECTORIZE_VEC(log2)
-
-	// sqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sqrt
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sqrt' only accept floating-point input");
-
-		return genType(::std::sqrt(x));
-	}
-
-	VECTORIZE_VEC(sqrt)
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType inversesqrt
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'inversesqrt' only accept floating-point input");
-		assert(x > genType(0));
-
-		return genType(1) / ::std::sqrt(x);
-	}
-
-	VECTORIZE_VEC(inversesqrt)
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_geometric.hpp b/include/gal/opengl/glm/core/func_geometric.hpp
deleted file mode 100644
index c221084f14..0000000000
--- a/include/gal/opengl/glm/core/func_geometric.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_geometric.hpp
-/// @date 2008-08-03 / 2011-06-14
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-/// 
-/// @defgroup core_func_geometric Geometric functions
-/// @ingroup core
-/// 
-/// These operate on vectors as vectors, not component-wise.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_geometric
-#define glm_core_func_geometric GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_geometric
-	/// @{
-
-	/// Returns the length of x, i.e., sqrt(x * x).
-	/// 
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::value_type length(
-		genType const & x); 
-
-	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::value_type distance(
-		genType const & p0, 
-		genType const & p1);
-
-	/// Returns the dot product of x and y, i.e., result = x * y.
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::value_type dot(
-		genType const & x, 
-		genType const & y);
-
-	/// Returns the cross product of x and y.
-	///
-	/// @tparam valType Floating-point scalar types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename valType> 
-	GLM_FUNC_DECL detail::tvec3<valType> cross(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y);
-
-	/// Returns a vector in the same direction as x but with length of 1.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType normalize(
-		genType const & x);
-
-	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType faceforward(
-		genType const & N, 
-		genType const & I, 
-		genType const & Nref);
-
-	/// For the incident vector I and surface orientation N, 
-	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType reflect(
-		genType const & I, 
-		genType const & N);
-
-	/// For the incident vector I and surface normal N, 
-	/// and the ratio of indices of refraction eta, 
-	/// return the refraction vector.
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType refract(
-		genType const & I, 
-		genType const & N, 
-		typename genType::value_type const & eta);
-
-	/// @}
-}//namespace glm
-
-#include "func_geometric.inl"
-
-#endif//glm_core_func_geometric
diff --git a/include/gal/opengl/glm/core/func_geometric.inl b/include/gal/opengl/glm/core/func_geometric.inl
deleted file mode 100644
index 259a0ffdf9..0000000000
--- a/include/gal/opengl/glm/core/func_geometric.inl
+++ /dev/null
@@ -1,321 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_geometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// length
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType length
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'length' only accept floating-point inputs");
-
-		genType sqr = x * x;
-		return sqrt(sqr);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type length
-	(
-		detail::tvec2<T> const & v
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
-
-		typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
-		return sqrt(sqr);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type length
-	(
-		detail::tvec3<T> const & v
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
-
-		typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
-		return sqrt(sqr);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type length
-	(
-		detail::tvec4<T> const & v
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
-
-		typename detail::tvec4<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
-		return sqrt(sqr);
-	}
-
-	// distance
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType distance
-	(
-		genType const & p0, 
-		genType const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
- 
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type distance
-	(
-		detail::tvec2<T> const & p0,
-		detail::tvec2<T> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type distance
-	(
-		detail::tvec3<T> const & p0,
-		detail::tvec3<T> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type distance
-	(
-		detail::tvec4<T> const & p0,
-		detail::tvec4<T> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	// dot
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType dot
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'dot' only accept floating-point inputs");
-
-		return x * y;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type dot
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
-
-		return x.x * y.x + x.y * y.y;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T dot
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
-
-		return x.x * y.x + x.y * y.y + x.z * y.z;
-	}
-/* // SSE3
-	GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
-	{
-		float Result;
-		__asm
-		{
-			mov		esi, x
-			mov		edi, y
-			movaps	xmm0, [esi]
-			mulps	xmm0, [edi]
-			haddps(	_xmm0, _xmm0 )
-			haddps(	_xmm0, _xmm0 )
-			movss	Result, xmm0
-		}
-		return Result;
-	}
-*/
-	template <typename T>
-	GLM_FUNC_QUALIFIER T dot
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
-
-		return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w;
-	}
-
-	// cross
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> cross
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'cross' only accept floating-point inputs");
-
-		return detail::tvec3<T>(
-			x.y * y.z - y.y * x.z,
-			x.z * y.x - y.z * x.x,
-			x.x * y.y - y.x * x.y);
-	}
-
-	// normalize
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType normalize
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'normalize' only accept floating-point inputs");
-
-		return x < genType(0) ? genType(-1) : genType(1);
-	}
-
-	// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> normalize
-	(
-		detail::tvec2<T> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
-		
-		typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
-		return x * inversesqrt(sqr);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> normalize
-	(
-		detail::tvec3<T> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
-
-		typename detail::tvec3<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-		return x * inversesqrt(sqr);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> normalize
-	(
-		detail::tvec4<T> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
-		
-		typename detail::tvec4<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return x * inversesqrt(sqr);
-	}
-
-	// faceforward
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward
-	(
-		genType const & N, 
-		genType const & I, 
-		genType const & Nref
-	)
-	{
-		return dot(Nref, I) < 0 ? N : -N;
-	}
-
-	// reflect
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType reflect
-	(
-		genType const & I, 
-		genType const & N
-	)
-	{
-		return I - N * dot(N, I) * genType(2);
-	}
-
-	// refract
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract
-	(
-		genType const & I, 
-		genType const & N, 
-		genType const & eta
-	)
-	{
-		//It could be a vector
-		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
-
-		genType dotValue = dot(N, I);
-		genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
-		if(k < genType(0))
-			return genType(0);
-		else
-			return eta * I - (eta * dotValue + sqrt(k)) * N;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract
-	(
-		genType const & I, 
-		genType const & N, 
-		typename genType::value_type const & eta
-	)
-	{
-		//It could be a vector
-		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
-
-		typename genType::value_type dotValue = dot(N, I);
-		typename genType::value_type k = typename genType::value_type(1) - eta * eta * (typename genType::value_type(1) - dotValue * dotValue);
-		if(k < typename genType::value_type(0))
-			return genType(0);
-		else
-			return eta * I - (eta * dotValue + sqrt(k)) * N;
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_integer.hpp b/include/gal/opengl/glm/core/func_integer.hpp
deleted file mode 100644
index df9a401591..0000000000
--- a/include/gal/opengl/glm/core/func_integer.hpp
+++ /dev/null
@@ -1,201 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_integer.hpp
-/// @date 2010-03-17 / 2011-06-18
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-/// 
-/// @defgroup core_func_integer Integer functions
-/// @ingroup core
-/// 
-/// These all operate component-wise. The description is per component. 
-/// The notation [a, b] means the set of bits from bit-number a through bit-number 
-/// b, inclusive. The lowest-order bit is bit 0.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_integer
-#define glm_core_func_integer GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_integer
-	/// @{
-
-	/// Adds 32-bit unsigned integer x and y, returning the sum
-	/// modulo pow(2, 32). The value carry is set to 0 if the sum was
-	/// less than pow(2, 32), or to 1 otherwise.
-	///
-	/// @tparam genUType Unsigned integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
-	GLM_FUNC_DECL genUType uaddCarry(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & carry);
-
-	/// Subtracts the 32-bit unsigned integer y from x, returning
-	/// the difference if non-negative, or pow(2, 32) plus the difference
-	/// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
-	///
-	/// @tparam genUType Unsigned integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
-	GLM_FUNC_DECL genUType usubBorrow(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & borrow);
-		
-	/// Multiplies 32-bit integers x and y, producing a 64-bit
-	/// result. The 32 least-significant bits are returned in lsb.
-	/// The 32 most-significant bits are returned in msb.
-	///
-	/// @tparam genUType Unsigned integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
-	GLM_FUNC_DECL void umulExtended(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & msb, 
-		genUType & lsb);
-		
-	/// Multiplies 32-bit integers x and y, producing a 64-bit
-	/// result. The 32 least-significant bits are returned in lsb.
-	/// The 32 most-significant bits are returned in msb.
-	/// 
-	/// @tparam genIType Signed integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIType>
-	GLM_FUNC_DECL void imulExtended(
-		genIType const & x, 
-		genIType const & y, 
-		genIType & msb, 
-		genIType & lsb);
-
-	/// Extracts bits [offset, offset + bits - 1] from value,
-	/// returning them in the least significant bits of the result.
-	/// For unsigned data types, the most significant bits of the
-	/// result will be set to zero. For signed data types, the
-	/// most significant bits will be set to the value of bit offset + base - 1.
-	///
-	/// If bits is zero, the result will be zero. The result will be
-	/// undefined if offset or bits is negative, or if the sum of
-	/// offset and bits is greater than the number of bits used
-	/// to store the operand.
-	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType bitfieldExtract(
-		genIUType const & Value, 
-		int const & Offset, 
-		int const & Bits);
-
-	/// Returns the insertion the bits least-significant bits of insert into base.
-	///
-	/// The result will have bits [offset, offset + bits - 1] taken
-	/// from bits [0, bits - 1] of insert, and all other bits taken
-	/// directly from the corresponding bits of base. If bits is
-	/// zero, the result will simply be base. The result will be
-	/// undefined if offset or bits is negative, or if the sum of
-	/// offset and bits is greater than the number of bits used to
-	/// store the operand.
-	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType bitfieldInsert(
-		genIUType const & Base, 
-		genIUType const & Insert, 
-		int const & Offset, 
-		int const & Bits);
-
-	/// Returns the reversal of the bits of value. 
-	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
-	/// where bits is the total number of bits used to represent value.
-	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
-		
-	/// Returns the number of bits set to 1 in the binary representation of value.
-	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
-
-	/// Returns the bit number of the least significant bit set to
-	/// 1 in the binary representation of value. 
-	/// If value is zero, -1 will be returned.
-	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
-
-	/// Returns the bit number of the most significant bit in the binary representation of value.
-	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
-	/// For negative integers, the result will be the bit number of the most significant
-	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
-	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
-
-	/// @}
-}//namespace glm
-
-#include "func_integer.inl"
-
-#endif//glm_core_func_integer
-
diff --git a/include/gal/opengl/glm/core/func_integer.inl b/include/gal/opengl/glm/core/func_integer.inl
deleted file mode 100644
index ad8b1fe83c..0000000000
--- a/include/gal/opengl/glm/core/func_integer.inl
+++ /dev/null
@@ -1,648 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_integer.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(GLM_ARCH != GLM_ARCH_PURE)
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#	include <intrin.h>
-#	pragma intrinsic(_BitScanReverse)
-#endif//(GLM_COMPILER & GLM_COMPILER_VC)
-#endif//(GLM_ARCH != GLM_ARCH_PURE)
-
-namespace glm
-{
-	// uaddCarry
-	template <typename genUType>
-	GLM_FUNC_QUALIFIER genUType uaddCarry
-	(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & Carry
-	)
-	{
-		detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
-		genUType Result = genUType(Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
-		Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32))) > 1 ? 1 : 0;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> uaddCarry
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & Carry
-	)
-	{
-		return detail::tvec2<T>(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> uaddCarry
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & Carry
-	)
-	{
-		return detail::tvec3<T>(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> uaddCarry
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & Carry
-	)
-	{
-		return detail::tvec4<T>(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]),
-			uaddCarry(x[3], y[3], Carry[3]));
-	}
-
-	// usubBorrow
-	template <typename genUType>
-	GLM_FUNC_QUALIFIER genUType usubBorrow
-	(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & Borrow
-	)
-	{
-		Borrow = x >= y ? 0 : 1;
-		if(x > y)
-			return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
-		else
-			return genUType((detail::highp_int_t(1) << detail::highp_int_t(32)) + detail::highp_int_t(x) - detail::highp_int_t(y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> usubBorrow
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & Borrow
-	)
-	{
-		return detail::tvec2<T>(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> usubBorrow
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & Borrow
-	)
-	{
-		return detail::tvec3<T>(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> usubBorrow
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & Borrow
-	)
-	{
-		return detail::tvec4<T>(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]),
-			usubBorrow(x[3], y[3], Borrow[3]));
-	}
-
-	// umulExtended
-	template <typename genUType>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & msb, 
-		genUType & lsb
-	)
-	{
-		detail::highp_uint_t ValueX64 = x;
-		detail::highp_uint_t ValueY64 = y;
-		detail::highp_uint_t Value64 = ValueX64 * ValueY64;
-		msb = *(genUType*)&genUType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
-		lsb = *(genUType*)&genUType(Value64 >> detail::highp_uint_t(32));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> umulExtended
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & msb, 
-		detail::tvec2<T> & lsb
-	)
-	{
-		return detail::tvec2<T>(
-			umulExtended(x[0], y[0], msb, lsb),
-			umulExtended(x[1], y[1], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> umulExtended
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & msb, 
-		detail::tvec3<T> & lsb
-	)
-	{
-		return detail::tvec3<T>(
-			umulExtended(x[0], y[0], msb, lsb),
-			umulExtended(x[1], y[1], msb, lsb),
-			umulExtended(x[2], y[2], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> umulExtended
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & msb, 
-		detail::tvec4<T> & lsb
-	)
-	{
-		return detail::tvec4<T>(
-			umulExtended(x[0], y[0], msb, lsb),
-			umulExtended(x[1], y[1], msb, lsb),
-			umulExtended(x[2], y[2], msb, lsb),
-			umulExtended(x[3], y[3], msb, lsb));
-	}
-
-	// imulExtended
-	template <typename genIType>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		genIType const & x, 
-		genIType const & y, 
-		genIType & msb, 
-		genIType & lsb
-	)
-	{
-		detail::highp_int_t ValueX64 = x;
-		detail::highp_int_t ValueY64 = y;
-		detail::highp_int_t Value64 = ValueX64 * ValueY64;
-		msb = *(genIType*)&genIType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
-		lsb = *(genIType*)&genIType(Value64 >> detail::highp_uint_t(32));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> imulExtended
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & msb, 
-		detail::tvec2<T> & lsb
-	)
-	{
-		return detail::tvec2<T>(
-			imulExtended(x[0], y[0], msb, lsb),
-			imulExtended(x[1], y[1], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> imulExtended
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & msb, 
-		detail::tvec3<T> & lsb
-	)
-	{
-		return detail::tvec3<T>(
-			imulExtended(x[0], y[0], msb, lsb),
-			imulExtended(x[1], y[1], msb, lsb),
-			imulExtended(x[2], y[2], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> imulExtended
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & msb, 
-		detail::tvec4<T> & lsb
-	)
-	{
-		return detail::tvec4<T>(
-			imulExtended(x[0], y[0], msb, lsb),
-			imulExtended(x[1], y[1], msb, lsb),
-			imulExtended(x[2], y[2], msb, lsb),
-			imulExtended(x[3], y[3], msb, lsb));
-	}
-
-	// bitfieldExtract
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
-	(
-		genIUType const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		int GenSize = int(sizeof(genIUType)) << int(3);
-
-		assert(Offset + Bits <= GenSize);
-
-		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
-		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
-
-		return ShiftBack;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldExtract
-	(
-		detail::tvec2<T> const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec2<T>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldExtract
-	(
-		detail::tvec3<T> const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldExtract
-	(
-		detail::tvec4<T> const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits),
-			bitfieldExtract(Value[3], Offset, Bits));
-	}
-
-	// bitfieldInsert
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
-	(
-		genIUType const & Base, 
-		genIUType const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
-		assert(Offset + Bits <= sizeof(genIUType));
-
-		if(Bits == 0)
-			return Base;
-
-		genIUType Mask = 0;
-		for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
-			Mask |= (1 << Bit);
-
-		return (Base & ~Mask) | (Insert & Mask);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldInsert
-	(
-		detail::tvec2<T> const & Base, 
-		detail::tvec2<T> const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec2<T>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldInsert
-	(
-		detail::tvec3<T> const & Base, 
-		detail::tvec3<T> const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldInsert
-	(
-		detail::tvec4<T> const & Base, 
-		detail::tvec4<T> const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
-			bitfieldInsert(Base[3], Insert[3], Offset, Bits));
-	}
-
-	// bitfieldReverse
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
-
-		genIUType Out = 0;
-		std::size_t BitSize = sizeof(genIUType) * 8;
-		for(std::size_t i = 0; i < BitSize; ++i)
-			if(Value & (genIUType(1) << i))
-				Out |= genIUType(1) << (BitSize - 1 - i);
-		return Out;
-	}	
-
-	VECTORIZE_VEC(bitfieldReverse)
-
-	// bitCount
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
-
-		int Count = 0;
-		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
-		{
-			if(Value & (1 << i))
-				++Count;
-		}
-		return Count;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> bitCount
-	(
-		detail::tvec2<T> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			bitCount(value[0]),
-			bitCount(value[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> bitCount
-	(
-		detail::tvec3<T> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> bitCount
-	(
-		detail::tvec4<T> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]),
-			bitCount(value[3]));
-	}
-
-	// findLSB
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findLSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		genIUType Bit;
-		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
-		return Bit;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> findLSB
-	(
-		detail::tvec2<T> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			findLSB(value[0]),
-			findLSB(value[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> findLSB
-	(
-		detail::tvec3<T> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> findLSB
-	(
-		detail::tvec4<T> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]),
-			findLSB(value[3]));
-	}
-
-	// findMSB
-#if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC))
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		unsigned long Result(0);
-		_BitScanReverse(&Result, Value); 
-		return int(Result);
-	}
-/*
-// __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000
-#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		// clz returns the number or trailing 0-bits; see
-		// http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Other-Builtins.html
-		//
-		// NoteBecause __builtin_clz only works for unsigned ints, this
-		// implementation will not work for 64-bit integers.
-		//
-		return 31 - __builtin_clzl(Value);
-	}
-*/
-#else
-
-/* SSE implementation idea
-
-		__m128i const Zero = _mm_set_epi32( 0,  0,  0,  0);
-		__m128i const One = _mm_set_epi32( 1,  1,  1,  1);
-		__m128i Bit = _mm_set_epi32(-1, -1, -1, -1);
-		__m128i Tmp = _mm_set_epi32(Value, Value, Value, Value);
-		__m128i Mmi = Zero;
-		for(int i = 0; i < 32; ++i)
-		{
-			__m128i Shilt = _mm_and_si128(_mm_cmpgt_epi32(Tmp, One), One);
-			Tmp = _mm_srai_epi32(Tmp, One);
-			Bit = _mm_add_epi32(Bit, _mm_and_si128(Shilt, i));
-			Mmi = _mm_and_si128(Mmi, One);
-		}
-		return Bit;
-
-*/
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		
-		if(Value == genIUType(0) || Value == genIUType(-1))
-			return -1;
-		else if(Value > 0)
-		{
-			genIUType Bit = genIUType(-1);
-			for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
-			return Bit;
-		}
-		else //if(Value < 0)
-		{
-			int const BitCount(sizeof(genIUType) * 8);
-			int MostSignificantBit(-1);
-			for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
-				MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
-			assert(MostSignificantBit >= 0);
-			return MostSignificantBit;
-		}
-	}
-#endif//(GLM_COMPILER)
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
-	(
-		detail::tvec2<T> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			findMSB(value[0]),
-			findMSB(value[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> findMSB
-	(
-		detail::tvec3<T> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> findMSB
-	(
-		detail::tvec4<T> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]),
-			findMSB(value[3]));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_matrix.hpp b/include/gal/opengl/glm/core/func_matrix.hpp
deleted file mode 100644
index 3c92cbbaba..0000000000
--- a/include/gal/opengl/glm/core/func_matrix.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_matrix.hpp
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-/// 
-/// @defgroup core_func_matrix Matrix functions
-/// @ingroup core
-/// 
-/// For each of the following built-in matrix functions, there is both a 
-/// single-precision floating point version, where all arguments and return values 
-/// are single precision, and a double-precision floating version, where all 
-/// arguments and return values are double precision. Only the single-precision 
-/// floating point version is shown.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_matrix
-#define GLM_CORE_func_matrix GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_matrix
-	/// @{
-
-	/// Multiply matrix x by matrix y component-wise, i.e., 
-	/// result[i][j] is the scalar product of x[i][j] and y[i][j].
-	/// 
-	/// @tparam matType Floating-point matrix types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	template <typename matType> 
-	GLM_FUNC_DECL matType matrixCompMult(
-		matType const & x, 
-		matType const & y);
-
-	/// Treats the first parameter c as a column vector 
-	/// and the second parameter r as a row vector
-	/// and does a linear algebraic matrix multiply c * r.
-	/// 
-	/// @tparam matType Floating-point matrix types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	/// 
-	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
-	template <typename vecType, typename matType> 
-	GLM_FUNC_DECL matType outerProduct(
-		vecType const & c, 
-		vecType const & r);
-
-	/// Returns the transposed matrix of x
-	/// 
-	/// @tparam matType Floating-point matrix types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
-	template <typename matType> 
-	GLM_FUNC_DECL typename matType::transpose_type transpose(
-		matType const & x);
-	
-	/// Return the determinant of a mat2 matrix. 
-	/// 
-	/// @tparam valType Floating-point scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
-	template <typename valType> 
-	GLM_FUNC_DECL typename detail::tmat2x2<valType>::value_type determinant(
-		detail::tmat2x2<valType> const & m);
-
-	/// Return the determinant of a mat3 matrix. 
-	/// 
-	/// @tparam valType Floating-point scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
-	template <typename valType> 
-	GLM_FUNC_DECL typename detail::tmat3x3<valType>::value_type determinant(
-		detail::tmat3x3<valType> const & m);
-
-	/// Return the determinant of a mat4 matrix. 
-	/// 
-	/// @tparam valType Floating-point scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>		
-	template <typename valType> 
-	GLM_FUNC_DECL typename detail::tmat4x4<valType>::value_type determinant(
-		detail::tmat4x4<valType> const & m);
-
-	/// Return the inverse of a mat2 matrix. 
-	/// 
-	/// @tparam valType Floating-point scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	 
-	template <typename valType> 
-	GLM_FUNC_DECL detail::tmat2x2<valType> inverse(
-		detail::tmat2x2<valType> const & m);
-
-	/// Return the inverse of a mat3 matrix. 
-	/// 
-	/// @tparam valType Floating-point scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> 
-	template <typename valType> 
-	GLM_FUNC_DECL detail::tmat3x3<valType> inverse(
-		detail::tmat3x3<valType> const & m);
-
-	/// Return the inverse of a mat4 matrix. 
-	/// 
-	/// @tparam valType Floating-point scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	template <typename valType> 
-	GLM_FUNC_DECL detail::tmat4x4<valType> inverse(
-		detail::tmat4x4<valType> const & m);
-
-	/// @}
-}//namespace glm
-
-#include "func_matrix.inl"
-
-#endif//GLM_CORE_func_matrix
diff --git a/include/gal/opengl/glm/core/func_matrix.inl b/include/gal/opengl/glm/core/func_matrix.inl
deleted file mode 100644
index d89d5d4b16..0000000000
--- a/include/gal/opengl/glm/core/func_matrix.inl
+++ /dev/null
@@ -1,582 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_matrix.inl
-/// @date 2008-03-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// matrixCompMult
-	template <typename matType>
-	GLM_FUNC_QUALIFIER matType matrixCompMult
-	(
-		matType const & x, 
-		matType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float, "'matrixCompMult' only accept floating-point inputs");
-
-		matType result(matType::null);
-		for(typename matType::size_type i = 0; i < matType::row_size(); ++i)
-			result[i] = x[i] * y[i];
-		return result;
-	}
-
-	// outerProduct
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> outerProduct
-	(
-		detail::tvec2<T> const & c, 
-		detail::tvec2<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat2x2<T> m(detail::tmat2x2<T>::null);
-		m[0][0] = c[0] * r[0];
-		m[0][1] = c[1] * r[0];
-		m[1][0] = c[0] * r[1];
-		m[1][1] = c[1] * r[1];
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> outerProduct
-	(
-		detail::tvec3<T> const & c, 
-		detail::tvec3<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
-		for(typename detail::tmat3x3<T>::size_type i(0); i < m.length(); ++i)
-			m[i] = c * r[i];
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> outerProduct
-	(
-		detail::tvec4<T> const & c, 
-		detail::tvec4<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
-		for(typename detail::tmat4x4<T>::size_type i(0); i < m.length(); ++i)
-			m[i] = c * r[i];
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T> outerProduct
-	(
-		detail::tvec3<T> const & c, 
-		detail::tvec2<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat2x3<T> m(detail::tmat2x3<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T> outerProduct
-	(
-		detail::tvec2<T> const & c, 
-		detail::tvec3<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat3x2<T> m(detail::tmat3x2<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T> outerProduct
-	(
-		detail::tvec4<T> const & c, 
-		detail::tvec2<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat2x4<T> m(detail::tmat2x4<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[0][3] = c.w * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		m[1][3] = c.w * r.y;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T> outerProduct
-	(
-		detail::tvec2<T> const & c, 
-		detail::tvec4<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat4x2<T> m(detail::tmat4x2<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		m[3][0] = c.x * r.w;
-		m[3][1] = c.y * r.w;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T> outerProduct
-	(
-		detail::tvec4<T> const & c, 
-		detail::tvec3<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat3x4<T> m(detail::tmat3x4<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[0][3] = c.w * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		m[1][3] = c.w * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		m[2][2] = c.z * r.z;
-		m[2][3] = c.w * r.z;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T> outerProduct
-	(
-		detail::tvec3<T> const & c, 
-		detail::tvec4<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat4x3<T> m(detail::tmat4x3<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		m[2][2] = c.z * r.z;
-		m[3][0] = c.x * r.w;
-		m[3][1] = c.y * r.w;
-		m[3][2] = c.z * r.w;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> transpose
-	(
-		detail::tmat2x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> transpose
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[0][2] = m[2][0];
-
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[1][2] = m[2][1];
-
-		result[2][0] = m[0][2];
-		result[2][1] = m[1][2];
-		result[2][2] = m[2][2];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> transpose
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[0][2] = m[2][0];
-		result[0][3] = m[3][0];
-
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[1][2] = m[2][1];
-		result[1][3] = m[3][1];
-
-		result[2][0] = m[0][2];
-		result[2][1] = m[1][2];
-		result[2][2] = m[2][2];
-		result[2][3] = m[3][2];
-
-		result[3][0] = m[0][3];
-		result[3][1] = m[1][3];
-		result[3][2] = m[2][3];
-		result[3][3] = m[3][3];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T> transpose
-	(
-		detail::tmat3x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[0][2] = m[2][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[1][2] = m[2][1];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T> transpose
-	(
-		detail::tmat2x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[2][0] = m[0][2];
-		result[2][1] = m[1][2];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T> transpose
-	(
-		detail::tmat4x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat2x4<T> result(detail::tmat2x4<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[0][2] = m[2][0];
-		result[0][3] = m[3][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[1][2] = m[2][1];
-		result[1][3] = m[3][1];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T> transpose
-	(
-		detail::tmat2x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[2][0] = m[0][2];
-		result[2][1] = m[1][2];
-		result[3][0] = m[0][3];
-		result[3][1] = m[1][3];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T> transpose
-	(
-		detail::tmat4x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat3x4<T> result(detail::tmat3x4<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[0][2] = m[2][0];
-		result[0][3] = m[3][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[1][2] = m[2][1];
-		result[1][3] = m[3][1];
-		result[2][0] = m[0][2];
-		result[2][1] = m[1][2];
-		result[2][2] = m[2][2];
-		result[2][3] = m[3][2];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T> transpose
-	(
-		detail::tmat3x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
-		result[0][0] = m[0][0];
-		result[0][1] = m[1][0];
-		result[0][2] = m[2][0];
-		result[1][0] = m[0][1];
-		result[1][1] = m[1][1];
-		result[1][2] = m[2][1];
-		result[2][0] = m[0][2];
-		result[2][1] = m[1][2];
-		result[2][2] = m[2][2];
-		result[3][0] = m[0][3];
-		result[3][1] = m[1][3];
-		result[3][2] = m[2][3];
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tmat2x2<T>::value_type determinant
-	(
-		detail::tmat2x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
-
-		return m[0][0] * m[1][1] - m[1][0] * m[0][1];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tmat3x3<T>::value_type determinant
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
-
-		return 
-			+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
-			- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
-			+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tmat4x4<T>::value_type determinant
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
-
-		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-
-		detail::tvec4<T> DetCof(
-			+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
-			- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
-			+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
-			- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
-
-		return m[0][0] * DetCof[0]
-				+ m[0][1] * DetCof[1]
-				+ m[0][2] * DetCof[2]
-				+ m[0][3] * DetCof[3];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> inverse
-	(
-		detail::tmat2x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
-			
-		//valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
-		T Determinant = determinant(m);
-
-		detail::tmat2x2<T> Inverse(
-			+ m[1][1] / Determinant,
-			- m[0][1] / Determinant, 
-			- m[1][0] / Determinant,
-			+ m[0][0] / Determinant);
-
-		return Inverse;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> inverse
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
-
-		//valType Determinant = m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
-		//					- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
-		//					+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-
-		T Determinant = determinant(m);
-
-		detail::tmat3x3<T> Inverse(detail::tmat3x3<T>::null);
-		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
-		Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
-		Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
-		Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
-		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
-		Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
-		Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-		Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
-		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
-		Inverse /= Determinant;
-
-		return Inverse;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> inverse
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
-
-		T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		detail::tvec4<T> const SignA(+1, -1, +1, -1);
-		detail::tvec4<T> const SignB(-1, +1, -1, +1);
-
-		detail::tvec4<T> Fac0(Coef00, Coef00, Coef02, Coef03);
-		detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
-		detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
-		detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
-		detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
-		detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
-
-		detail::tvec4<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-		detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-		detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-		detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
-
-		detail::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-		detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-		detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-		detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
-
-		detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
-
-		detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
-
-		T Determinant = glm::dot(m[0], Row0);
-
-		Inverse /= Determinant;
-
-		return Inverse;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_noise.hpp b/include/gal/opengl/glm/core/func_noise.hpp
deleted file mode 100644
index 3e5f874187..0000000000
--- a/include/gal/opengl/glm/core/func_noise.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_noise.hpp
-/// @date 2008-08-01 / 2011-06-18
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-/// 
-/// @defgroup core_func_noise Noise functions
-/// @ingroup core
-/// 
-/// Noise functions are stochastic functions that can be used to increase visual 
-/// complexity. Values returned by the following noise functions give the 
-/// appearance of randomness, but are not truly random.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_noise
-#define glm_core_func_noise GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_noise
-	/// @{
-
-	/// Returns a 1D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
-
-	/// Returns a 2D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL detail::tvec2<typename genType::value_type> noise2(genType const & x);
-
-	/// Returns a 3D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL detail::tvec3<typename genType::value_type> noise3(genType const & x);
-
-	/// Returns a 4D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL detail::tvec4<typename genType::value_type> noise4(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_noise.inl"
-
-#endif//glm_core_func_noise
diff --git a/include/gal/opengl/glm/core/func_noise.inl b/include/gal/opengl/glm/core/func_noise.inl
deleted file mode 100644
index 68a19333f1..0000000000
--- a/include/gal/opengl/glm/core/func_noise.inl
+++ /dev/null
@@ -1,364 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_noise.inl
-/// @date 2008-08-01 / 2011-09-27
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(T const & x)
-	{
-		return noise1(glm::detail::tvec2<T>(x, T(0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(T const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(T const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - T(1.0)),
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(T const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - T(1.0)),
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)),
-			noise1(x + T(2.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(glm::detail::tvec2<T> const & v)
-	{
-		detail::tvec4<T> const C = detail::tvec4<T>(
-													T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
-													T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
-													T(-0.577350269189626),	// -1.0 + 2.0 * C.x
-													T( 0.024390243902439)); //  1.0 / 41.0
-		
-		// First corner
-		detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
-		detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
-		
-		// Other corners
-		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
-		//i1.y = 1.0 - i1.x;
-		detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
-		// x0 = x0 - 0.0 + 0.0 * C.xx ;
-		// x1 = x0 - i1 + 1.0 * C.xx ;
-		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
-		x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
-		
-		// Permutations
-		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		detail::tvec3<T> p = permute(
-									 permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
-									 + i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
-		
-		detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
-														   dot(x0, x0), 
-														   dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
-														   dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
-		m = m * m ;
-		m = m * m ;
-		
-		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
-		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
-		
-		detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
-		detail::tvec3<T> h = abs(x) - T(0.5);
-		detail::tvec3<T> ox = floor(x + T(0.5));
-		detail::tvec3<T> a0 = x - ox;
-		
-		// Normalise gradients implicitly by scaling m
-		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
-		m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
-		
-		// Compute final noise value at P
-		detail::tvec3<T> g;
-		g.x  = a0.x  * x0.x  + h.x  * x0.y;
-		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-		g.y = a0.y * x12.x + h.y * x12.y;
-		g.z = a0.z * x12.z + h.z * x12.w;
-		return T(130) * dot(m, g);
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T> const & v)
-	{ 
-		detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
-		detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
-		
-		// First corner
-		detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
-		detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
-		
-		// Other corners
-		detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
-		detail::tvec3<T> l(T(1) - g);
-		detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
-		detail::tvec3<T> i2(max(g, detail::tvec3<T>(l.z, l.x, l.y)));
-		
-		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
-		//   x1 = x0 - i1  + 1.0 * C.xxx;
-		//   x2 = x0 - i2  + 2.0 * C.xxx;
-		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
-		detail::tvec3<T> x1(x0 - i1 + C.x);
-		detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
-		detail::tvec3<T> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
-		
-		// Permutations
-		i = mod289(i); 
-		detail::tvec4<T> p(permute(permute(permute( 
-												   i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) + 
-										   i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) + 
-								   i.x + detail::tvec4<T>(T(0), i1.x, i2.x, T(1))));
-		
-		// Gradients: 7x7 points over a square, mapped onto an octahedron.
-		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
-		T n_ = T(0.142857142857); // 1.0/7.0
-		detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
-		
-		detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
-		
-		detail::tvec4<T> x_(floor(j * ns.z));
-		detail::tvec4<T> y_(floor(j - T(7) * x_));    // mod(j,N)
-		
-		detail::tvec4<T> x(x_ * ns.x + ns.y);
-		detail::tvec4<T> y(y_ * ns.x + ns.y);
-		detail::tvec4<T> h(T(1) - abs(x) - abs(y));
-		
-		detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
-		detail::tvec4<T> b1(x.z, x.w, y.z, y.w);
-		
-		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
-		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
-		detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
-		detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
-		
-		detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
-		detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
-		
-		detail::tvec3<T> p0(a0.x, a0.y, h.x);
-		detail::tvec3<T> p1(a0.z, a0.w, h.y);
-		detail::tvec3<T> p2(a1.x, a1.y, h.z);
-		detail::tvec3<T> p3(a1.z, a1.w, h.w);
-		
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-		
-		// Mix final noise value
-		detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
-		m = m * m;
-		return T(42) * dot(m * m, detail::tvec4<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T> const & v)
-	{
-		detail::tvec4<T> const C(
-								 0.138196601125011,  // (5 - sqrt(5))/20  G4
-								 0.276393202250021,  // 2 * G4
-								 0.414589803375032,  // 3 * G4
-								 -0.447213595499958); // -1 + 4 * G4
-		
-		// (sqrt(5) - 1)/4 = F4, used once below
-		T const F4 = T(0.309016994374947451);
-		
-		// First corner
-		detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
-		detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
-		
-		// Other corners
-		
-		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		detail::tvec4<T> i0;
-		detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
-		detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
-		//  i0.x = dot(isX, vec3(1.0));
-		//i0.x = isX.x + isX.y + isX.z;
-		//i0.yzw = T(1) - isX;
-		i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
-		//  i0.y += dot(isYZ.xy, vec2(1.0));
-		i0.y += isYZ.x + isYZ.y;
-		//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
-		i0.z += T(1) - isYZ.x;
-		i0.w += T(1) - isYZ.y;
-		i0.z += isYZ.z;
-		i0.w += T(1) - isYZ.z;
-		
-		// i0 now contains the unique values 0,1,2,3 in each channel
-		detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
-		detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
-		detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
-		
-		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
-		//  x1 = x0 - i1  + 0.0 * C.xxxx
-		//  x2 = x0 - i2  + 0.0 * C.xxxx
-		//  x3 = x0 - i3  + 0.0 * C.xxxx
-		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		detail::tvec4<T> x1 = x0 - i1 + C.x;
-		detail::tvec4<T> x2 = x0 - i2 + C.y;
-		detail::tvec4<T> x3 = x0 - i3 + C.z;
-		detail::tvec4<T> x4 = x0 + C.w;
-		
-		// Permutations
-		i = mod(i, T(289)); 
-		T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
-		detail::tvec4<T> j1 = permute(permute(permute(permute(
-															  i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
-													  + i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
-											  + i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
-									  + i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
-		
-		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
-		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
-		
-		detail::tvec4<T> p0 = grad4(j0,   ip);
-		detail::tvec4<T> p1 = grad4(j1.x, ip);
-		detail::tvec4<T> p2 = grad4(j1.y, ip);
-		detail::tvec4<T> p3 = grad4(j1.z, ip);
-		detail::tvec4<T> p4 = grad4(j1.w, ip);
-		
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-		p4 *= taylorInvSqrt(dot(p4, p4));
-		
-		// Mix contributions from the five corners
-		detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
-		m0 = m0 * m0;
-		m1 = m1 * m1;
-		return T(49) * 
-		(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
-		 dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec2<T> const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + glm::detail::tvec2<T>(0.0)),
-			noise1(glm::detail::tvec2<T>(0.0) - x));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec3<T> const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + glm::detail::tvec3<T>(0.0)),
-			noise1(glm::detail::tvec3<T>(0.0) - x));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec4<T> const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + glm::detail::tvec4<T>(0.0)),
-			noise1(glm::detail::tvec4<T>(0.0) - x));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec2<T> const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - glm::detail::tvec2<T>(1.0)),
-			noise1(x + glm::detail::tvec2<T>(0.0)),
-			noise1(x + glm::detail::tvec2<T>(1.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec3<T> const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - glm::detail::tvec3<T>(1.0)),
-			noise1(x + glm::detail::tvec3<T>(0.0)),
-			noise1(x + glm::detail::tvec3<T>(1.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec4<T> const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - glm::detail::tvec4<T>(1.0)),
-			noise1(x + glm::detail::tvec4<T>(0.0)),
-			noise1(x + glm::detail::tvec4<T>(1.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec2<T> const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - glm::detail::tvec2<T>(1.0)),
-			noise1(x + glm::detail::tvec2<T>(0.0)),
-			noise1(x + glm::detail::tvec2<T>(1.0)),
-			noise1(x + glm::detail::tvec2<T>(2.0)));
-	}
-
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec3<T> const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - glm::detail::tvec3<T>(1.0)),
-			noise1(x + glm::detail::tvec3<T>(0.0)),
-			noise1(x + glm::detail::tvec3<T>(1.0)),
-			noise1(x + glm::detail::tvec3<T>(2.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec4<T> const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - glm::detail::tvec4<T>(1.0)),
-			noise1(x + glm::detail::tvec4<T>(0.0)),
-			noise1(x + glm::detail::tvec4<T>(1.0)),
-			noise1(x + glm::detail::tvec4<T>(2.0)));
-	}
-	
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_packing.hpp b/include/gal/opengl/glm/core/func_packing.hpp
deleted file mode 100644
index b4312e12b4..0000000000
--- a/include/gal/opengl/glm/core/func_packing.hpp
+++ /dev/null
@@ -1,193 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_packing.hpp
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-/// 
-/// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
-/// @ingroup core
-/// 
-/// These functions do not operate component-wise, rather as described in each case.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_packing
-#define GLM_CORE_func_packing GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_packing
-	/// @{
-
-	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
-	//! Then, the results are packed into the returned 32-bit unsigned integer.
-	//! 
-	//! The conversion for component c of v to fixed point is done as follows:
-	//! packUnorm2x16: round(clamp(c, 0, +1) * 65535.0) 
-	//! 
-	//! The first component of the vector will be written to the least significant bits of the output; 
-	//! the last component will be written to the most significant bits.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
-
-	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
-	//! Then, the results are packed into the returned 32-bit unsigned integer.
-	//! 
-	//! The conversion for component c of v to fixed point is done as follows:
-	//! packSnorm2x16: round(clamp(v, -1, +1) * 32767.0)
-	//! 
-	//! The first component of the vector will be written to the least significant bits of the output; 
-	//! the last component will be written to the most significant bits.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> const & v);
-
-	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
-	//! Then, the results are packed into the returned 32-bit unsigned integer.
-	//! 
-	//! The conversion for component c of v to fixed point is done as follows:
-	//! packUnorm4x8:	round(clamp(c, 0, +1) * 255.0)
-	//! 
-	//! The first component of the vector will be written to the least significant bits of the output; 
-	//! the last component will be written to the most significant bits.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
-
-	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
-	//! Then, the results are packed into the returned 32-bit unsigned integer.
-	//! 
-	//! The conversion for component c of v to fixed point is done as follows:
-	//! packSnorm4x8:	round(clamp(c, -1, +1) * 127.0) 
-	//! 
-	//! The first component of the vector will be written to the least significant bits of the output; 
-	//! the last component will be written to the most significant bits.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
-
-	//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
-	//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
-	//! 
-	//! The conversion for unpacked fixed-point value f to floating point is done as follows:
-	//! unpackUnorm2x16: f / 65535.0 
-	//! 
-	//! The first component of the returned vector will be extracted from the least significant bits of the input; 
-	//! the last component will be extracted from the most significant bits.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p);
-
-	//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
-	//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
-	//! 
-	//! The conversion for unpacked fixed-point value f to floating point is done as follows:
-	//! unpackSnorm2x16: clamp(f / 32767.0, -1, +1)
-	//! 
-	//! The first component of the returned vector will be extracted from the least significant bits of the input; 
-	//! the last component will be extracted from the most significant bits.
-	//! 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & p);
-
-	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
-	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
-	/// 
-	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
-	/// unpackUnorm4x8: f / 255.0
-	/// 
-	/// The first component of the returned vector will be extracted from the least significant bits of the input; 
-	/// the last component will be extracted from the most significant bits.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p);
-
-	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
-	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
-	/// 
-	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
-	/// unpackSnorm4x8: clamp(f / 127.0, -1, +1)
-	/// 
-	/// The first component of the returned vector will be extracted from the least significant bits of the input; 
-	/// the last component will be extracted from the most significant bits.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p);
-
-	/// Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
-	/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
-	/// Otherwise, the bit- level representation of v is preserved. 
-	/// The first vector component specifies the 32 least significant bits; 
-	/// the second component specifies the 32 most significant bits.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL double packDouble2x32(detail::tvec2<detail::uint32> const & v);
-
-	/// Returns a two-component unsigned integer vector representation of v. 
-	/// The bit-level representation of v is preserved. 
-	/// The first component of the vector contains the 32 least significant bits of the double; 
-	/// the second component consists the 32 most significant bits.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
-
-	/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector 
-	/// to the 16-bit floating-point representation found in the OpenGL Specification, 
-	/// and then packing these two 16- bit integers into a 32-bit unsigned integer.
-	/// The first vector component specifies the 16 least-significant bits of the result; 
-	/// the second component specifies the 16 most-significant bits.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL uint packHalf2x16(vec2 const & v);
-	
-	/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, 
-	/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, 
-	/// and converting them to 32-bit floating-point values.
-	/// The first component of the vector is obtained from the 16 least-significant bits of v; 
-	/// the second component is obtained from the 16 most-significant bits of v.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL vec2 unpackHalf2x16(uint const & v);
-	
-	/// @}
-}//namespace glm
-
-#include "func_packing.inl"
-
-#endif//GLM_CORE_func_packing
-
diff --git a/include/gal/opengl/glm/core/func_packing.inl b/include/gal/opengl/glm/core/func_packing.inl
deleted file mode 100644
index e10e161840..0000000000
--- a/include/gal/opengl/glm/core/func_packing.inl
+++ /dev/null
@@ -1,208 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_packing.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	GLM_FUNC_QUALIFIER detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v)
-	{
-		detail::uint16 A(detail::uint16(round(clamp(v.x, 0.0f, 1.0f) * 65535.0f)));
-		detail::uint16 B(detail::uint16(round(clamp(v.y, 0.0f, 1.0f) * 65535.0f)));
-		return detail::uint32((B << 16) | A);
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p)
-	{
-		detail::uint32 Mask16((1 << 16) - 1);
-		detail::uint32 A((p >>  0) & Mask16);
-		detail::uint32 B((p >> 16) & Mask16);
-		return detail::tvec2<detail::float32>(
-			A * 1.0f / 65535.0f, 
-			B * 1.0f / 65535.0f);
-	}
-	
-	GLM_FUNC_QUALIFIER detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> const & v)
-	{
-		union iu
-		{
-			detail::int16 i;
-			detail::uint16 u;
-		} A, B;
-		
-		detail::tvec2<detail::float32> Unpack = clamp(v ,-1.0f, 1.0f) * 32767.0f;
-		A.i = detail::int16(round(Unpack.x));
-		B.i = detail::int16(round(Unpack.y));
-		detail::uint32 Pack = (detail::uint32(B.u) << 16) | (detail::uint32(A.u) << 0);
-		return Pack;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & p)
-	{
-		union iu
-		{
-			detail::int16 i;
-			detail::uint16 u;
-		} A, B;
-		
-		detail::uint32 Mask16((1 << 16) - 1);
-		A.u = detail::uint16((p >>  0) & Mask16);
-		B.u = detail::uint16((p >> 16) & Mask16);
-		detail::tvec2<detail::float32> Pack(A.i, B.i);
-		
-		return clamp(Pack * 1.0f / 32767.0f, -1.0f, 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v)
-	{
-		detail::uint8 A((detail::uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
-		detail::uint8 B((detail::uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
-		detail::uint8 C((detail::uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
-		detail::uint8 D((detail::uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
-		return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
-	{	
-		detail::uint32 Mask8((1 << 8) - 1);
-		detail::uint32 A((p >>  0) & Mask8);
-		detail::uint32 B((p >>  8) & Mask8);
-		detail::uint32 C((p >> 16) & Mask8);
-		detail::uint32 D((p >> 24) & Mask8);
-		return detail::tvec4<detail::float32>(
-			A * 1.0f / 255.0f, 
-			B * 1.0f / 255.0f, 
-			C * 1.0f / 255.0f, 
-			D * 1.0f / 255.0f);
-	}
-	
-	GLM_FUNC_QUALIFIER detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v)
-	{
-		union iu
-		{
-			detail::int8 i;
-			detail::uint8 u;
-		} A, B, C, D;
-	
-		detail::tvec4<detail::float32> Unpack = clamp(v ,-1.0f, 1.0f) * 127.0f;
-		A.i = detail::int8(round(Unpack.x));
-		B.i = detail::int8(round(Unpack.y));
-		C.i = detail::int8(round(Unpack.z));
-		D.i = detail::int8(round(Unpack.w));
-		detail::uint32 Pack = (detail::uint32(D.u) << 24) | (detail::uint32(C.u) << 16) | (detail::uint32(B.u) << 8) | (detail::uint32(A.u) << 0);
-		return Pack;
-	}
-	
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p)
-	{	
-		union iu
-		{
-			detail::int8 i;
-			detail::uint8 u;
-		} A, B, C, D;
-	
-		detail::uint32 Mask8((1 << 8) - 1);
-		A.u = detail::uint8((p >>  0) & Mask8);
-		B.u = detail::uint8((p >>  8) & Mask8);
-		C.u = detail::uint8((p >> 16) & Mask8);
-		D.u = detail::uint8((p >> 24) & Mask8);
-		detail::tvec4<detail::float32> Pack(A.i, B.i, C.i, D.i);
-	
-		return clamp(Pack * 1.0f / 127.0f, -1.0f, 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v)
-	{
-		struct uint32_pair
-		{
-			detail::uint32 x;
-			detail::uint32 y;
-		};
-
-		union helper
-		{
-			uint32_pair input;
-			double output;
-		} Helper;
-
-		Helper.input.x = v.x;
-		Helper.input.y = v.y;
-
-		return Helper.output;
-		//return *(double*)&v;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<uint> unpackDouble2x32(double const & v)
-	{
-		struct uint32_pair
-		{
-			detail::uint32 x;
-			detail::uint32 y;
-		};
-
-		union helper
-		{
-			double input;
-			uint32_pair output;
-		} Helper;
-
-		Helper.input = v;
-
-		return detail::tvec2<uint>(Helper.output.x, Helper.output.y);
-	}
-
-	GLM_FUNC_QUALIFIER uint packHalf2x16(detail::tvec2<float> const & v)
-	{
-		union helper
-		{ 
-			uint other; 
-			struct 
-			{ 
-				detail::hdata a, b; 
-			} orig; 
-		} Pack; 
-
-		Pack.orig.a = detail::toFloat16(v.x); 
-		Pack.orig.b = detail::toFloat16(v.y); 
-		return Pack.other;
-	}
-
-	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v)
-	{
-		union helper
-		{ 
-			uint other; 
-			struct 
-			{ 
-				detail::hdata a, b; 
-			} orig; 
-		} Unpack; 
-		Unpack.other = v;
-
-		return vec2(detail::toFloat32(Unpack.orig.a), detail::toFloat32(Unpack.orig.b));
-	}
-}//namespace glm
-
diff --git a/include/gal/opengl/glm/core/func_trigonometric.hpp b/include/gal/opengl/glm/core/func_trigonometric.hpp
deleted file mode 100644
index 9954d9cea6..0000000000
--- a/include/gal/opengl/glm/core/func_trigonometric.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_trigonometric.hpp
-/// @date 2008-08-01 / 2011-06-15
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-/// 
-/// @defgroup core_func_trigonometric Angle and Trigonometry Functions
-/// @ingroup core
-/// 
-/// Function parameters specified as angle are assumed to be in units of radians. 
-/// In no case will any of these functions result in a divide by zero error. If 
-/// the divisor of a ratio is 0, then results will be undefined.
-/// 
-/// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_trigonometric
-#define GLM_CORE_func_trigonometric GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_trigonometric
-	/// @{
-
-	/// Converts degrees to radians and returns the result.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType radians(genType const & degrees);
-
-	/// Converts radians to degrees and returns the result.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType degrees(genType const & radians);
-
-	/// The standard trigonometric sine function. 
-	/// The values returned by this function will range from [-1, 1].
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType sin(genType const & angle);
-
-	/// The standard trigonometric cosine function. 
-	/// The values returned by this function will range from [-1, 1].
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType cos(genType const & angle);
-
-	/// The standard trigonometric tangent function.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType tan(genType const & angle); 
-
-	/// Arc sine. Returns an angle whose sine is x. 
-	/// The range of values returned by this function is [-PI/2, PI/2]. 
-	/// Results are undefined if |x| > 1.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType asin(genType const & x);
-
-	/// Arc cosine. Returns an angle whose sine is x. 
-	/// The range of values returned by this function is [0, PI]. 
-	/// Results are undefined if |x| > 1.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType acos(genType const & x);
-
-	/// Arc tangent. Returns an angle whose tangent is y/x. 
-	/// The signs of x and y are used to determine what 
-	/// quadrant the angle is in. The range of values returned 
-	/// by this function is [-PI, PI]. Results are undefined 
-	/// if x and y are both 0. 
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType atan(genType const & y, genType const & x);
-
-	/// Arc tangent. Returns an angle whose tangent is y_over_x. 
-	/// The range of values returned by this function is [-PI/2, PI/2].
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType atan(genType const & y_over_x);
-
-	/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType sinh(genType const & angle);
-
-	/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType cosh(genType const & angle);
-
-	/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType tanh(genType const & angle);
-
-	/// Arc hyperbolic sine; returns the inverse of sinh.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType asinh(genType const & x);
-	
-	/// Arc hyperbolic cosine; returns the non-negative inverse
-	/// of cosh. Results are undefined if x < 1.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType acosh(genType const & x);
-
-	/// Arc hyperbolic tangent; returns the inverse of tanh.
-	/// Results are undefined if abs(x) >= 1.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType atanh(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_trigonometric.inl"
-
-#endif//GLM_CORE_func_trigonometric
-
-
diff --git a/include/gal/opengl/glm/core/func_trigonometric.inl b/include/gal/opengl/glm/core/func_trigonometric.inl
deleted file mode 100644
index bd59cd73d4..0000000000
--- a/include/gal/opengl/glm/core/func_trigonometric.inl
+++ /dev/null
@@ -1,244 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_trigonometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// radians
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType radians
-	(
-		genType const & degrees
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
-
-		genType const pi = genType(3.1415926535897932384626433832795);
-		return degrees * (pi / genType(180));
-	}
-
-	VECTORIZE_VEC(radians)
-	
-	// degrees
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType degrees
-	(
-		genType const & radians
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'degrees' only accept floating-point input");
-
-		const genType pi = genType(3.1415926535897932384626433832795);
-		return radians * (genType(180) / pi);
-	}
-
-	VECTORIZE_VEC(degrees)
-
-	// sin
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sin
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sin' only accept floating-point input");
-
-		return genType(::std::sin(angle));
-	}
-
-	VECTORIZE_VEC(sin)
-
-	// cos
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType cos(genType const & angle)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cos' only accept floating-point input");
-
-		return genType(::std::cos(angle));
-	}
-
-	VECTORIZE_VEC(cos)
-
-	// tan
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType tan
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tan' only accept floating-point input");
-
-		return genType(::std::tan(angle));
-	}
-
-	VECTORIZE_VEC(tan)
-
-	// asin
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType asin
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asin' only accept floating-point input");
-
-		return genType(::std::asin(x));
-	}
-
-	VECTORIZE_VEC(asin)
-
-	// acos
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType acos
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acos' only accept floating-point input");
-
-		return genType(::std::acos(x));
-	}
-
-	VECTORIZE_VEC(acos)
-
-	// atan
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atan
-	(
-		genType const & y, 
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
-
-		return genType(::std::atan2(y, x));
-	}
-
-	VECTORIZE_VEC_VEC(atan)
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atan
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
-
-		return genType(::std::atan(x));
-	}
-
-	VECTORIZE_VEC(atan)
-
-	// sinh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType sinh
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sinh' only accept floating-point input");
-
-		return genType(std::sinh(angle));
-	}
-
-	VECTORIZE_VEC(sinh)
-
-	// cosh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType cosh
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cosh' only accept floating-point input");
-
-		return genType(std::cosh(angle));
-	}
-
-	VECTORIZE_VEC(cosh)
-
-	// tanh
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType tanh
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tanh' only accept floating-point input");
-
-		return genType(std::tanh(angle));
-	}
-
-	VECTORIZE_VEC(tanh)
-
-	// asinh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType asinh
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asinh' only accept floating-point input");
-		
-		return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
-	}
-
-	VECTORIZE_VEC(asinh)
-
-	// acosh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType acosh
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acosh' only accept floating-point input");
-
-		if(x < genType(1))
-			return genType(0);
-		return log(x + sqrt(x * x - genType(1)));
-	}
-
-	VECTORIZE_VEC(acosh)
-
-	// atanh
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atanh
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atanh' only accept floating-point input");
-		
-		if(abs(x) >= genType(1))
-			return 0;
-		return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
-	}
-
-	VECTORIZE_VEC(atanh)
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/func_vector_relational.hpp b/include/gal/opengl/glm/core/func_vector_relational.hpp
deleted file mode 100644
index 4ffe14eab7..0000000000
--- a/include/gal/opengl/glm/core/func_vector_relational.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_vector_relational.hpp
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-/// 
-/// @defgroup core_func_vector_relational Vector Relational Functions
-/// @ingroup core
-/// 
-/// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to 
-/// operate on scalars and produce scalar Boolean results. For vector results, 
-/// use the following built-in functions. 
-/// 
-/// In all cases, the sizes of all the input and return vectors for any particular 
-/// call must match.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_vector_relational
-#define GLM_CORE_func_vector_relational GLM_VERSION
-
-#include "_detail.hpp"
-
-namespace glm
-{
-	/// @addtogroup core_func_vector_relational
-	/// @{
-
-	/// Returns the component-wise comparison result of x < y.
-	/// 
-	/// @tparam vecType Floating-point or integer vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename vecType> 
-	GLM_FUNC_DECL typename vecType::bool_type lessThan(vecType const & x, vecType const & y);
-
-	/// Returns the component-wise comparison of result x <= y.
-	///
-	/// @tparam vecType Floating-point or integer vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename vecType> 
-	GLM_FUNC_DECL typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y);
-
-	/// Returns the component-wise comparison of result x > y.
-	///
-	/// @tparam vecType Floating-point or integer vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename vecType> 
-	GLM_FUNC_DECL typename vecType::bool_type greaterThan(vecType const & x, vecType const & y);
-
-	/// Returns the component-wise comparison of result x >= y.
-	///
-	/// @tparam vecType Floating-point or integer vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename vecType> 
-	GLM_FUNC_DECL typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y);
-
-	/// Returns the component-wise comparison of result x == y.
-	///
-	/// @tparam vecType Floating-point, integer or boolean vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename vecType> 
-	GLM_FUNC_DECL typename vecType::bool_type equal(vecType const & x, vecType const & y);
-
-	/// Returns the component-wise comparison of result x != y.
-	/// 
-	/// @tparam vecType Floating-point, integer or boolean vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename vecType> 
-	GLM_FUNC_DECL typename vecType::bool_type notEqual(vecType const & x, vecType const & y);
-
-	/// Returns true if any component of x is true.
-	///
-	/// @tparam vecType Boolean vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <template <typename> class vecType> 
-	GLM_FUNC_DECL bool any(vecType<bool> const & v);
-
-	/// Returns true if all components of x are true.
-	///
-	/// @tparam vecType Boolean vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <template <typename> class vecType> 
-	GLM_FUNC_DECL bool all(vecType<bool> const & v);
-
-	/// Returns the component-wise logical complement of x.
-	/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
-	///
-	/// @tparam vecType Boolean vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <template <typename> class vecType> 
-	GLM_FUNC_DECL vecType<bool> not_(vecType<bool> const & v);
-
-	/// @}
-}//namespace glm
-
-#include "func_vector_relational.inl"
-
-#endif//GLM_CORE_func_vector_relational
diff --git a/include/gal/opengl/glm/core/func_vector_relational.inl b/include/gal/opengl/glm/core/func_vector_relational.inl
deleted file mode 100644
index 7fb4f43005..0000000000
--- a/include/gal/opengl/glm/core/func_vector_relational.inl
+++ /dev/null
@@ -1,178 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_vector_relational.inl
-/// @date 2008-08-03 / 2011-09-09
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThan
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'lessThan', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
-			"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] < y[i];
-
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThanEqual
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'lessThanEqual', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
-			"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] <= y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThan
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'greaterThan', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
-			"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] > y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThanEqual
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'greaterThanEqual', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
-			"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] >= y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'equal', GLM vector types required");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] == y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type notEqual
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'notEqual', GLM vector types required");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] != y[i];
-		return Result;
-	}
-
-	template <template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER bool any(vecType<bool> const & v)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
-			"Invalid template instantiation of 'any', GLM boolean vector types required");
-
-		bool Result = false;
-		for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
-			Result = Result || v[i];
-		return Result;
-	}
-
-	template <template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER bool all(vecType<bool> const & v)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
-			"Invalid template instantiation of 'all', GLM boolean vector types required");
-
-		bool Result = true;
-		for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
-			Result = Result && v[i];
-		return Result;
-	}
-
-	template <template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER vecType<bool> not_(vecType<bool> const & v)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
-			"Invalid template instantiation of 'not_', GLM vector types required");
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
-			Result[i] = !v[i];
-		return Result;
-	}
-}//namespace glm
-
diff --git a/include/gal/opengl/glm/core/hint.hpp b/include/gal/opengl/glm/core/hint.hpp
deleted file mode 100644
index 79433a1318..0000000000
--- a/include/gal/opengl/glm/core/hint.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/hint.hpp
-/// @date 2008-08-14 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type
-#define glm_core_type
-
-namespace glm
-{
-	// Use dont_care, nicest and fastest to optimize implementations.
-	class dont_care {};
-	class nicest {};
-	class fastest {};
-}//namespace glm
-
-#endif//glm_core_type
diff --git a/include/gal/opengl/glm/core/intrinsic_common.hpp b/include/gal/opengl/glm/core/intrinsic_common.hpp
deleted file mode 100644
index a4355229f4..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_common.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_common.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_common
-#define glm_detail_intrinsic_common
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-	__m128 sse_abs_ps(__m128 x);
-
-	__m128 sse_sgn_ps(__m128 x);
-
-	//floor
-	__m128 sse_flr_ps(__m128 v);
-
-	//trunc
-	__m128 sse_trc_ps(__m128 v);
-
-	//round
-	__m128 sse_nd_ps(__m128 v);
-
-	//roundEven
-	__m128 sse_rde_ps(__m128 v);
-
-	__m128 sse_rnd_ps(__m128 x);
-
-	__m128 sse_ceil_ps(__m128 v);
-
-	__m128 sse_frc_ps(__m128 x);
-
-	__m128 sse_mod_ps(__m128 x, __m128 y);
-
-	__m128 sse_modf_ps(__m128 x, __m128i & i);
-
-	//GLM_FUNC_QUALIFIER __m128 sse_min_ps(__m128 x, __m128 y)
-
-	//GLM_FUNC_QUALIFIER __m128 sse_max_ps(__m128 x, __m128 y)
-
-	__m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
-
-	__m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a);
-
-	__m128 sse_stp_ps(__m128 edge, __m128 x);
-
-	__m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
-
-	__m128 sse_nan_ps(__m128 x);
-
-	__m128 sse_inf_ps(__m128 x);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_common.inl"
-
-#endif//GLM_ARCH
-#endif//glm_detail_intrinsic_common
diff --git a/include/gal/opengl/glm/core/intrinsic_common.inl b/include/gal/opengl/glm/core/intrinsic_common.inl
deleted file mode 100644
index ba7ac94875..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_common.inl
+++ /dev/null
@@ -1,313 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_common.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#pragma warning(push)
-#pragma warning(disable : 4510 4512 4610)
-#endif
-
-	union ieee754_QNAN
-	{
-	   const float f;
-	   struct i
-	   {
-		  const unsigned int mantissa:23, exp:8, sign:1;
-	   };
-	   
-	   ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
-	};
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#pragma warning(pop)
-#endif
-
-	static const __m128 GLM_VAR_USED zero = _mm_setzero_ps();
-	static const __m128 GLM_VAR_USED one = _mm_set_ps1(1.0f);
-	static const __m128 GLM_VAR_USED minus_one = _mm_set_ps1(-1.0f);
-	static const __m128 GLM_VAR_USED two = _mm_set_ps1(2.0f);
-	static const __m128 GLM_VAR_USED three = _mm_set_ps1(3.0f);
-	static const __m128 GLM_VAR_USED pi = _mm_set_ps1(3.1415926535897932384626433832795f);
-	static const __m128 GLM_VAR_USED hundred_eighty = _mm_set_ps1(180.f);
-	static const __m128 GLM_VAR_USED pi_over_hundred_eighty = _mm_set_ps1(0.017453292519943295769236907684886f);
-	static const __m128 GLM_VAR_USED hundred_eighty_over_pi = _mm_set_ps1(57.295779513082320876798154814105f);
-
-	static const ieee754_QNAN absMask;
-	static const __m128 GLM_VAR_USED abs4Mask = _mm_set_ps1(absMask.f);
-
-	static const __m128 GLM_VAR_USED _epi32_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(static_cast<int>(0x80000000)));
-        //static const __m128 GLM_VAR_USED _epi32_inv_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF));
-        //static const __m128 GLM_VAR_USED _epi32_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
-        //static const __m128 GLM_VAR_USED _epi32_inv_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x807FFFFF));
-        //static const __m128 GLM_VAR_USED _epi32_min_norm_pos = _mm_castsi128_ps(_mm_set1_epi32(0x00800000));
-	static const __m128 GLM_VAR_USED _epi32_0 = _mm_set_ps1(0);
-	static const __m128 GLM_VAR_USED _epi32_1 = _mm_set_ps1(1);
-	static const __m128 GLM_VAR_USED _epi32_2 = _mm_set_ps1(2);
-	static const __m128 GLM_VAR_USED _epi32_3 = _mm_set_ps1(3);
-	static const __m128 GLM_VAR_USED _epi32_4 = _mm_set_ps1(4);
-	static const __m128 GLM_VAR_USED _epi32_5 = _mm_set_ps1(5);
-	static const __m128 GLM_VAR_USED _epi32_6 = _mm_set_ps1(6);
-	static const __m128 GLM_VAR_USED _epi32_7 = _mm_set_ps1(7);
-	static const __m128 GLM_VAR_USED _epi32_8 = _mm_set_ps1(8);
-	static const __m128 GLM_VAR_USED _epi32_9 = _mm_set_ps1(9);
-	static const __m128 GLM_VAR_USED _epi32_127 = _mm_set_ps1(127);
-        //static const __m128 GLM_VAR_USED _epi32_ninf = _mm_castsi128_ps(_mm_set1_epi32(0xFF800000));
-        //static const __m128 GLM_VAR_USED _epi32_pinf = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
-
-	static const __m128 GLM_VAR_USED _ps_1_3 = _mm_set_ps1(0.33333333333333333333333333333333f);
-	static const __m128 GLM_VAR_USED _ps_0p5 = _mm_set_ps1(0.5f);
-	static const __m128 GLM_VAR_USED _ps_1 = _mm_set_ps1(1.0f);
-	static const __m128 GLM_VAR_USED _ps_m1 = _mm_set_ps1(-1.0f);
-	static const __m128 GLM_VAR_USED _ps_2 = _mm_set_ps1(2.0f);
-	static const __m128 GLM_VAR_USED _ps_3 = _mm_set_ps1(3.0f);
-	static const __m128 GLM_VAR_USED _ps_127 = _mm_set_ps1(127.0f);
-	static const __m128 GLM_VAR_USED _ps_255 = _mm_set_ps1(255.0f);
-	static const __m128 GLM_VAR_USED _ps_2pow23 = _mm_set_ps1(8388608.0f);
-
-	static const __m128 GLM_VAR_USED _ps_1_0_0_0 = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
-	static const __m128 GLM_VAR_USED _ps_0_1_0_0 = _mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f);
-	static const __m128 GLM_VAR_USED _ps_0_0_1_0 = _mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f);
-	static const __m128 GLM_VAR_USED _ps_0_0_0_1 = _mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f);
-
-	static const __m128 GLM_VAR_USED _ps_pi = _mm_set_ps1(3.1415926535897932384626433832795f);
-	static const __m128 GLM_VAR_USED _ps_pi2 = _mm_set_ps1(6.283185307179586476925286766560f);
-	static const __m128 GLM_VAR_USED _ps_2_pi = _mm_set_ps1(0.63661977236758134307553505349006f);
-	static const __m128 GLM_VAR_USED _ps_pi_2 = _mm_set_ps1(1.5707963267948966192313216916398f);
-	static const __m128 GLM_VAR_USED _ps_4_pi = _mm_set_ps1(1.2732395447351626861510701069801f);
-	static const __m128 GLM_VAR_USED _ps_pi_4 = _mm_set_ps1(0.78539816339744830961566084581988f);
-
-	static const __m128 GLM_VAR_USED _ps_sincos_p0 = _mm_set_ps1(0.15707963267948963959e1f);
-	static const __m128 GLM_VAR_USED _ps_sincos_p1 = _mm_set_ps1(-0.64596409750621907082e0f);
-	static const __m128 GLM_VAR_USED _ps_sincos_p2 = _mm_set_ps1(0.7969262624561800806e-1f);
-	static const __m128 GLM_VAR_USED _ps_sincos_p3 = _mm_set_ps1(-0.468175413106023168e-2f);
-	static const __m128 GLM_VAR_USED _ps_tan_p0 = _mm_set_ps1(-1.79565251976484877988e7f);
-	static const __m128 GLM_VAR_USED _ps_tan_p1 = _mm_set_ps1(1.15351664838587416140e6f);
-	static const __m128 GLM_VAR_USED _ps_tan_p2 = _mm_set_ps1(-1.30936939181383777646e4f);
-	static const __m128 GLM_VAR_USED _ps_tan_q0 = _mm_set_ps1(-5.38695755929454629881e7f);
-	static const __m128 GLM_VAR_USED _ps_tan_q1 = _mm_set_ps1(2.50083801823357915839e7f);
-	static const __m128 GLM_VAR_USED _ps_tan_q2 = _mm_set_ps1(-1.32089234440210967447e6f);
-	static const __m128 GLM_VAR_USED _ps_tan_q3 = _mm_set_ps1(1.36812963470692954678e4f);
-	static const __m128 GLM_VAR_USED _ps_tan_poleval = _mm_set_ps1(3.68935e19f);
-	static const __m128 GLM_VAR_USED _ps_atan_t0 = _mm_set_ps1(-0.91646118527267623468e-1f);
-	static const __m128 GLM_VAR_USED _ps_atan_t1 = _mm_set_ps1(-0.13956945682312098640e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_t2 = _mm_set_ps1(-0.94393926122725531747e2f);
-	static const __m128 GLM_VAR_USED _ps_atan_t3 = _mm_set_ps1(0.12888383034157279340e2f);
-	static const __m128 GLM_VAR_USED _ps_atan_s0 = _mm_set_ps1(0.12797564625607904396e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_s1 = _mm_set_ps1(0.21972168858277355914e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_s2 = _mm_set_ps1(0.68193064729268275701e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_s3 = _mm_set_ps1(0.28205206687035841409e2f);
-
-	static const __m128 GLM_VAR_USED _ps_exp_hi = _mm_set_ps1(88.3762626647949f);
-	static const __m128 GLM_VAR_USED _ps_exp_lo = _mm_set_ps1(-88.3762626647949f);
-	static const __m128 GLM_VAR_USED _ps_exp_rln2 = _mm_set_ps1(1.4426950408889634073599f);
-	static const __m128 GLM_VAR_USED _ps_exp_p0 = _mm_set_ps1(1.26177193074810590878e-4f);
-	static const __m128 GLM_VAR_USED _ps_exp_p1 = _mm_set_ps1(3.02994407707441961300e-2f);
-	static const __m128 GLM_VAR_USED _ps_exp_q0 = _mm_set_ps1(3.00198505138664455042e-6f);
-	static const __m128 GLM_VAR_USED _ps_exp_q1 = _mm_set_ps1(2.52448340349684104192e-3f);
-	static const __m128 GLM_VAR_USED _ps_exp_q2 = _mm_set_ps1(2.27265548208155028766e-1f);
-	static const __m128 GLM_VAR_USED _ps_exp_q3 = _mm_set_ps1(2.00000000000000000009e0f);
-	static const __m128 GLM_VAR_USED _ps_exp_c1 = _mm_set_ps1(6.93145751953125e-1f);
-	static const __m128 GLM_VAR_USED _ps_exp_c2 = _mm_set_ps1(1.42860682030941723212e-6f);
-	static const __m128 GLM_VAR_USED _ps_exp2_hi = _mm_set_ps1(127.4999961853f);
-	static const __m128 GLM_VAR_USED _ps_exp2_lo = _mm_set_ps1(-127.4999961853f);
-	static const __m128 GLM_VAR_USED _ps_exp2_p0 = _mm_set_ps1(2.30933477057345225087e-2f);
-	static const __m128 GLM_VAR_USED _ps_exp2_p1 = _mm_set_ps1(2.02020656693165307700e1f);
-	static const __m128 GLM_VAR_USED _ps_exp2_p2 = _mm_set_ps1(1.51390680115615096133e3f);
-	static const __m128 GLM_VAR_USED _ps_exp2_q0 = _mm_set_ps1(2.33184211722314911771e2f);
-	static const __m128 GLM_VAR_USED _ps_exp2_q1 = _mm_set_ps1(4.36821166879210612817e3f);
-	static const __m128 GLM_VAR_USED _ps_log_p0 = _mm_set_ps1(-7.89580278884799154124e-1f);
-	static const __m128 GLM_VAR_USED _ps_log_p1 = _mm_set_ps1(1.63866645699558079767e1f);
-	static const __m128 GLM_VAR_USED _ps_log_p2 = _mm_set_ps1(-6.41409952958715622951e1f);
-	static const __m128 GLM_VAR_USED _ps_log_q0 = _mm_set_ps1(-3.56722798256324312549e1f);
-	static const __m128 GLM_VAR_USED _ps_log_q1 = _mm_set_ps1(3.12093766372244180303e2f);
-	static const __m128 GLM_VAR_USED _ps_log_q2 = _mm_set_ps1(-7.69691943550460008604e2f);
-	static const __m128 GLM_VAR_USED _ps_log_c0 = _mm_set_ps1(0.693147180559945f);
-	static const __m128 GLM_VAR_USED _ps_log2_c0 = _mm_set_ps1(1.44269504088896340735992f);
-
-GLM_FUNC_QUALIFIER __m128 sse_abs_ps(__m128 x)
-{
-	return _mm_and_ps(glm::detail::abs4Mask, x);
-} 
-
-GLM_FUNC_QUALIFIER __m128 sse_sgn_ps(__m128 x)
-{
-	__m128 Neg = _mm_set1_ps(-1.0f);
-	__m128 Pos = _mm_set1_ps(1.0f);
-
-	__m128 Cmp0 = _mm_cmplt_ps(x, zero);
-	__m128 Cmp1 = _mm_cmpgt_ps(x, zero);
-
-	__m128 And0 = _mm_and_ps(Cmp0, Neg);
-	__m128 And1 = _mm_and_ps(Cmp1, Pos);
-
-	return _mm_or_ps(And0, And1);
-}
-
-//floor
-GLM_FUNC_QUALIFIER __m128 sse_flr_ps(__m128 x)
-{
-	__m128 rnd0 = sse_rnd_ps(x);
-	__m128 cmp0 = _mm_cmplt_ps(x, rnd0);
-	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
-	__m128 sub0 = _mm_sub_ps(rnd0, and0);
-	return sub0;
-}
-
-//trunc
-/*
-GLM_FUNC_QUALIFIER __m128 _mm_trc_ps(__m128 v)
-{
-	return __m128();
-}
-*/
-//round
-GLM_FUNC_QUALIFIER __m128 sse_rnd_ps(__m128 x)
-{
-	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
-	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
-	__m128 add0 = _mm_add_ps(x, or0);
-	__m128 sub0 = _mm_sub_ps(add0, or0);
-	return sub0;
-}
-
-//roundEven
-GLM_FUNC_QUALIFIER __m128 sse_rde_ps(__m128 x)
-{
-	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
-	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
-	__m128 add0 = _mm_add_ps(x, or0);
-	__m128 sub0 = _mm_sub_ps(add0, or0);
-	return sub0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_ceil_ps(__m128 x)
-{
-	__m128 rnd0 = sse_rnd_ps(x);
-	__m128 cmp0 = _mm_cmpgt_ps(x, rnd0);
-	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
-	__m128 add0 = _mm_add_ps(rnd0, and0);
-	return add0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_frc_ps(__m128 x)
-{
-	__m128 flr0 = sse_flr_ps(x);
-	__m128 sub0 = _mm_sub_ps(x, flr0);
-	return sub0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mod_ps(__m128 x, __m128 y)
-{
-	__m128 div0 = _mm_div_ps(x, y);
-	__m128 flr0 = sse_flr_ps(div0);
-	__m128 mul0 = _mm_mul_ps(y, flr0);
-	__m128 sub0 = _mm_sub_ps(x, mul0);
-	return sub0;
-}
-
-/// TODO
-/*
-GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
-{
-	__m128 empty;
-    return empty;
-}
-*/
-
-//GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
-
-//GLM_FUNC_QUALIFIER __m128 _mm_max_ps(__m128 x, __m128 y)
-
-GLM_FUNC_QUALIFIER __m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal)
-{
-	__m128 min0 = _mm_min_ps(v, maxVal);
-	__m128 max0 = _mm_max_ps(min0, minVal);
-	return max0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a)
-{
-	__m128 sub0 = _mm_sub_ps(glm::detail::one, a);
-	__m128 mul0 = _mm_mul_ps(v1, sub0);
-	__m128 mul1 = _mm_mul_ps(v2, a);
-	__m128 add0 = _mm_add_ps(mul0, mul1);
-	return add0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_stp_ps(__m128 edge, __m128 x)
-{
-	__m128 cmp = _mm_cmple_ps(x, edge);
-	if(_mm_movemask_ps(cmp) == 0)
-		return glm::detail::one;
-	else
-		return glm::detail::zero;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
-{
-	__m128 sub0 = _mm_sub_ps(x, edge0);
-	__m128 sub1 = _mm_sub_ps(edge1, edge0);
-	__m128 div0 = _mm_sub_ps(sub0, sub1);
-	__m128 clp0 = sse_clp_ps(div0, glm::detail::zero, glm::detail::one);
-	__m128 mul0 = _mm_mul_ps(glm::detail::two, clp0);
-	__m128 sub2 = _mm_sub_ps(glm::detail::three, mul0);
-	__m128 mul1 = _mm_mul_ps(clp0, clp0);
-	__m128 mul2 = _mm_mul_ps(mul1, sub2);
-	return mul2;
-}
-
-/// \todo
-//GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
-//{
-//	__m128 empty;
-//    return empty;
-//}
-
-/// \todo
-//GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
-//{
-//	__m128 empty;
-//    return empty;
-//}
-
-// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
-// By Elan Ruskin, http://assemblyrequired.crashworks.org/
-GLM_FUNC_QUALIFIER __m128 sse_sqrt_wip_ss(__m128 const & x)
-{
-	__m128 recip = _mm_rsqrt_ss(x);  // "estimate" opcode
-	const static __m128 three = {3, 3, 3, 3}; // aligned consts for fast load
-	const static __m128 half = {0.5,0.5,0.5,0.5};
-	__m128 halfrecip = _mm_mul_ss(half, recip);
-	__m128 threeminus_xrr = _mm_sub_ss(three, _mm_mul_ss(x, _mm_mul_ss (recip, recip)));
-	return _mm_mul_ss( halfrecip, threeminus_xrr);
-}
-
-}//namespace detail
-}//namespace glms
diff --git a/include/gal/opengl/glm/core/intrinsic_exponential.hpp b/include/gal/opengl/glm/core/intrinsic_exponential.hpp
deleted file mode 100644
index 785527a08b..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_exponential.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_exponential.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_exponential
-#define glm_detail_intrinsic_exponential
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-/*
-GLM_FUNC_QUALIFIER __m128 sse_rsqrt_nr_ss(__m128 const x)
-{
-	__m128 recip = _mm_rsqrt_ss( x );  // "estimate" opcode
-	const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
-	const static __m128 half = { 0.5,0.5,0.5,0.5 };
-	__m128 halfrecip = _mm_mul_ss( half, recip );
-	__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
-	return _mm_mul_ss( halfrecip, threeminus_xrr );
-}
- 
-GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps(  float * RESTRICT vOut, float * RESTRICT vIn )
-{
-        __m128 x = _mm_load_ss(&vIn[0]);
-        __m128 y = _mm_load_ss(&vIn[1]);
-        __m128 z = _mm_load_ss(&vIn[2]);
- 
-        const __m128 l =  // compute x*x + y*y + z*z
-                _mm_add_ss(
-                 _mm_add_ss( _mm_mul_ss(x,x),
-                             _mm_mul_ss(y,y)
-                            ),
-                 _mm_mul_ss( z, z )
-                );
- 
- 
-        const __m128 rsqt = _mm_rsqrt_nr_ss( l );
-        _mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
-        _mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
-        _mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
- 
-        return _mm_mul_ss( l , rsqt );
-}
-*/
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH
-#endif//glm_detail_intrinsic_exponential
diff --git a/include/gal/opengl/glm/core/intrinsic_exponential.inl b/include/gal/opengl/glm/core/intrinsic_exponential.inl
deleted file mode 100644
index 8023e0be7c..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_exponential.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_exponential.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/core/intrinsic_geometric.hpp b/include/gal/opengl/glm/core/intrinsic_geometric.hpp
deleted file mode 100644
index ff60c48fbd..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_geometric.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_geometric.hpp
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_intrinsic_geometric
-#define glm_core_intrinsic_geometric
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-#include "intrinsic_common.hpp"
-
-namespace glm{
-namespace detail
-{
-	//length
-	__m128 sse_len_ps(__m128 x);
-
-	//distance
-	__m128 sse_dst_ps(__m128 p0, __m128 p1);
-
-	//dot
-	__m128 sse_dot_ps(__m128 v1, __m128 v2);
-
-	// SSE1
-	__m128 sse_dot_ss(__m128 v1, __m128 v2);
-
-	//cross
-	__m128 sse_xpd_ps(__m128 v1, __m128 v2);
-
-	//normalize
-	__m128 sse_nrm_ps(__m128 v);
-
-	//faceforward
-	__m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref);
-
-	//reflect
-	__m128 sse_rfe_ps(__m128 I, __m128 N);
-
-	//refract
-	__m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_geometric.inl"
-
-#endif//GLM_ARCH
-#endif//glm_core_intrinsic_geometric
diff --git a/include/gal/opengl/glm/core/intrinsic_geometric.inl b/include/gal/opengl/glm/core/intrinsic_geometric.inl
deleted file mode 100644
index 9411e908c1..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_geometric.inl
+++ /dev/null
@@ -1,146 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_geometric.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-//length
-GLM_FUNC_QUALIFIER __m128 sse_len_ps(__m128 x)
-{
-    __m128 dot0 = sse_dot_ps(x, x);
-	__m128 sqt0 = _mm_sqrt_ps(dot0);
-    return sqt0;
-}
-
-//distance
-GLM_FUNC_QUALIFIER __m128 sse_dst_ps(__m128 p0, __m128 p1)
-{
-	__m128 sub0 = _mm_sub_ps(p0, p1);
-    __m128 len0 = sse_len_ps(sub0);
-    return len0;
-}
-
-//dot
-GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
-{
-#   if((GLM_ARCH & GLM_ARCH_SSE4) == GLM_ARCH_SSE4)
-        return _mm_dp_ps(v1, v2, 0xff);
-#   else
-        __m128 mul0 = _mm_mul_ps(v1, v2);
-        __m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
-        __m128 add0 = _mm_add_ps(mul0, swp0);
-        __m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
-        __m128 add1 = _mm_add_ps(add0, swp1);
-        return add1;
-#   endif
-}
-
-// SSE1
-GLM_FUNC_QUALIFIER __m128 sse_dot_ss(__m128 v1, __m128 v2)
-{
-	__m128 mul0 = _mm_mul_ps(v1, v2);
-	__m128 mov0 = _mm_movehl_ps(mul0, mul0);
-	__m128 add0 = _mm_add_ps(mov0, mul0);
-	__m128 swp1 = _mm_shuffle_ps(add0, add0, 1);
-	__m128 add1 = _mm_add_ss(add0, swp1);
-	return add1;
-}
-
-//cross
-GLM_FUNC_QUALIFIER __m128 sse_xpd_ps(__m128 v1, __m128 v2)
-{
-	__m128 swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
-	__m128 swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
-	__m128 swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
-	__m128 swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
-	__m128 mul0 = _mm_mul_ps(swp0, swp3);
-	__m128 mul1 = _mm_mul_ps(swp1, swp2);
-	__m128 sub0 = _mm_sub_ps(mul0, mul1);
-	return sub0;
-}
-
-//normalize
-GLM_FUNC_QUALIFIER __m128 sse_nrm_ps(__m128 v)
-{
-	__m128 dot0 = sse_dot_ps(v, v);
-	__m128 isr0 = _mm_rsqrt_ps(dot0);
-	__m128 mul0 = _mm_mul_ps(v, isr0);
-	return mul0;
-}
-
-//faceforward
-GLM_FUNC_QUALIFIER __m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref)
-{
-	//__m128 dot0 = _mm_dot_ps(v, v);
-	//__m128 neg0 = _mm_neg_ps(N);
-	//__m128 sgn0 = _mm_sgn_ps(dot0);
-	//__m128 mix0 = _mm_mix_ps(N, neg0, sgn0);
-	//return mix0;
-
-	__m128 dot0 = sse_dot_ps(Nref, I);
-	__m128 sgn0 = sse_sgn_ps(dot0);
-	__m128 mul0 = _mm_mul_ps(sgn0, glm::detail::minus_one);
-	__m128 mul1 = _mm_mul_ps(N, mul0);
-	return mul1;
-}
-
-//reflect
-GLM_FUNC_QUALIFIER __m128 sse_rfe_ps(__m128 I, __m128 N)
-{
-	__m128 dot0 = sse_dot_ps(N, I);
-	__m128 mul0 = _mm_mul_ps(N, dot0);
-	__m128 mul1 = _mm_mul_ps(mul0, glm::detail::two);
-	__m128 sub0 = _mm_sub_ps(I, mul1);
-	return sub0;
-}
-
-//refract
-GLM_FUNC_QUALIFIER __m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta)
-{
-	__m128 dot0 = sse_dot_ps(N, I);
-	__m128 mul0 = _mm_mul_ps(eta, eta);
-	__m128 mul1 = _mm_mul_ps(dot0, dot0);
-	__m128 sub0 = _mm_sub_ps(glm::detail::one, mul0);
-	__m128 sub1 = _mm_sub_ps(glm::detail::one, mul1);
-	__m128 mul2 = _mm_mul_ps(sub0, sub1);
-	
-	if(_mm_movemask_ps(_mm_cmplt_ss(mul2, glm::detail::zero)) == 0)
-		return glm::detail::zero;
-
-	__m128 sqt0 = _mm_sqrt_ps(mul2);
-	__m128 mul3 = _mm_mul_ps(eta, dot0);
-	__m128 add0 = _mm_add_ps(mul3, sqt0);
-	__m128 mul4 = _mm_mul_ps(add0, N);
-	__m128 mul5 = _mm_mul_ps(eta, I);
-	__m128 sub2 = _mm_sub_ps(mul5, mul4);
-
-	return sub2;
-}
-
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/intrinsic_matrix.hpp b/include/gal/opengl/glm/core/intrinsic_matrix.hpp
deleted file mode 100644
index b2f4767ddc..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_matrix.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_common.hpp
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_matrix
-#define glm_detail_intrinsic_matrix
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-#include "intrinsic_geometric.hpp"
-
-namespace glm{
-namespace detail
-{
-	void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
-
-	void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
-
-	__m128 sse_mul_ps(__m128 m[4], __m128 v);
-
-	__m128 sse_mul_ps(__m128 v, __m128 m[4]);
-
-	void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
-
-	void sse_transpose_ps(__m128 const in[4], __m128 out[4]);
-
-	void sse_inverse_ps(__m128 const in[4], __m128 out[4]);
-
-	void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
-
-	__m128 sse_det_ps(__m128 const m[4]);
-
-	__m128 sse_slow_det_ps(__m128 const m[4]);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_matrix.inl"
-
-#endif//GLM_ARCH
-#endif//glm_detail_intrinsic_matrix
diff --git a/include/gal/opengl/glm/core/intrinsic_matrix.inl b/include/gal/opengl/glm/core/intrinsic_matrix.inl
deleted file mode 100644
index ec53f032b0..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_matrix.inl
+++ /dev/null
@@ -1,1070 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_common.inl
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-static const __m128 GLM_VAR_USED _m128_rad_ps = _mm_set_ps1(3.141592653589793238462643383279f / 180.f);
-static const __m128 GLM_VAR_USED _m128_deg_ps = _mm_set_ps1(180.f / 3.141592653589793238462643383279f);
-
-template <typename matType>
-GLM_FUNC_QUALIFIER matType sse_comp_mul_ps
-(
-	__m128 const in1[4],
-	__m128 const in2[4],
-	__m128 out[4]
-)
-{
-	out[0] = _mm_mul_ps(in1[0], in2[0]);
-	out[1] = _mm_mul_ps(in1[1], in2[1]);
-	out[2] = _mm_mul_ps(in1[2], in2[2]);
-	out[3] = _mm_mul_ps(in1[3], in2[3]);
-}
-
-GLM_FUNC_QUALIFIER void sse_add_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		out[0] = _mm_add_ps(in1[0], in2[0]);
-		out[1] = _mm_add_ps(in1[1], in2[1]);
-		out[2] = _mm_add_ps(in1[2], in2[2]);
-		out[3] = _mm_add_ps(in1[3], in2[3]);
-	}
-}
-
-GLM_FUNC_QUALIFIER void sse_sub_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		out[0] = _mm_sub_ps(in1[0], in2[0]);
-		out[1] = _mm_sub_ps(in1[1], in2[1]);
-		out[2] = _mm_sub_ps(in1[2], in2[2]);
-		out[3] = _mm_sub_ps(in1[3], in2[3]);
-	}
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 const m[4], __m128 v)
-{
-	__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
-
-	__m128 m0 = _mm_mul_ps(m[0], v0);
-	__m128 m1 = _mm_mul_ps(m[1], v1);
-	__m128 m2 = _mm_mul_ps(m[2], v2);
-	__m128 m3 = _mm_mul_ps(m[3], v3);
-
-	__m128 a0 = _mm_add_ps(m0, m1);
-	__m128 a1 = _mm_add_ps(m2, m3);
-	__m128 a2 = _mm_add_ps(a0, a1);
-
-	return a2;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 v, __m128 const m[4])
-{
-	__m128 i0 = m[0];
-	__m128 i1 = m[1];
-	__m128 i2 = m[2];
-	__m128 i3 = m[3];
-
-	__m128 m0 = _mm_mul_ps(v, i0);
-	__m128 m1 = _mm_mul_ps(v, i1);
-	__m128 m2 = _mm_mul_ps(v, i2);
-	__m128 m3 = _mm_mul_ps(v, i3);
-
-	__m128 u0 = _mm_unpacklo_ps(m0, m1);
-	__m128 u1 = _mm_unpackhi_ps(m0, m1);
-	__m128 a0 = _mm_add_ps(u0, u1);
-
-	__m128 u2 = _mm_unpacklo_ps(m2, m3);
-	__m128 u3 = _mm_unpackhi_ps(m2, m3);
-	__m128 a1 = _mm_add_ps(u2, u3);
-
-	__m128 f0 = _mm_movelh_ps(a0, a1);
-	__m128 f1 = _mm_movehl_ps(a1, a0);
-	__m128 f2 = _mm_add_ps(f0, f1);
-
-	return f2;
-}
-
-GLM_FUNC_QUALIFIER void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[0] = a2;
-	}
-
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[1] = a2;
-	}
-
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[2] = a2;
-	}
-
-	{
-		//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
-		__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[3] = a2;
-	}
-}
-
-GLM_FUNC_QUALIFIER void sse_transpose_ps(__m128 const in[4], __m128 out[4])
-{
-    __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
-    __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
-    __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
-    __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
-
-    out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
-    out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
-    out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
-    out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_slow_det_ps(__m128 const in[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0]
-	//						+ m[0][1] * Inverse[1][0]
-	//						+ m[0][2] * Inverse[2][0]
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	return Det0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_detd_ps
-(
-	__m128 const m[4]
-)
-{
-	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
-
-	//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-	//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-	//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-	//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-	//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-	//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-
-	// First 2 columns
- 	__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
- 	__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
-	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
-
-	// Second 2 columns
-	__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
-	__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
-	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
-
-	// Columns subtraction
-	__m128 SubE = _mm_sub_ps(MulA, MulB);
-
-	// Last 2 rows
-	__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
-	__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
-	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
-	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
-
-	//detail::tvec4<T> DetCof(
-	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
-	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
-	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
-	//	- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
-
-	__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
-	__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
-	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
-
-	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
-	__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
-	__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
-	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
-
-	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
-
-	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
-	__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
-	__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
-	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
-
-	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
-	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
-
-	//return m[0][0] * DetCof[0]
-	//	 + m[0][1] * DetCof[1]
-	//	 + m[0][2] * DetCof[2]
-	//	 + m[0][3] * DetCof[3];
-
-	return sse_dot_ps(m[0], DetCof);
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_det_ps
-(
-	__m128 const m[4]
-)
-{
-	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
-
-	//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-	//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-	//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-	//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-	//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-	//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-
-	// First 2 columns
- 	__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
- 	__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
-	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
-
-	// Second 2 columns
-	__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
-	__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
-	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
-
-	// Columns subtraction
-	__m128 SubE = _mm_sub_ps(MulA, MulB);
-
-	// Last 2 rows
-	__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
-	__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
-	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
-	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
-
-	//detail::tvec4<T> DetCof(
-	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
-	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
-	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
-	//	- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
-
-	__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
-	__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
-	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
-
-	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
-	__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
-	__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
-	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
-
-	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
-
-	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
-	__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
-	__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
-	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
-
-	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
-	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
-
-	//return m[0][0] * DetCof[0]
-	//	 + m[0][1] * DetCof[1]
-	//	 + m[0][2] * DetCof[2]
-	//	 + m[0][3] * DetCof[3];
-
-	return sse_dot_ps(m[0], DetCof);
-}
-
-GLM_FUNC_QUALIFIER void sse_inverse_ps(__m128 const in[4], __m128 out[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-    }
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0] 
-	//						+ m[0][1] * Inverse[1][0] 
-	//						+ m[0][2] * Inverse[2][0] 
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	__m128 Rcp0 = _mm_div_ps(one, Det0);
-	//__m128 Rcp0 = _mm_rcp_ps(Det0);
-
-	//	Inverse /= Determinant;
-	out[0] = _mm_mul_ps(Inv0, Rcp0);
-	out[1] = _mm_mul_ps(Inv1, Rcp0);
-	out[2] = _mm_mul_ps(Inv2, Rcp0);
-	out[3] = _mm_mul_ps(Inv3, Rcp0);
-}
-
-GLM_FUNC_QUALIFIER void sse_inverse_fast_ps(__m128 const in[4], __m128 out[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0] 
-	//						+ m[0][1] * Inverse[1][0] 
-	//						+ m[0][2] * Inverse[2][0] 
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	__m128 Rcp0 = _mm_rcp_ps(Det0);
-	//__m128 Rcp0 = _mm_div_ps(one, Det0);
-	//	Inverse /= Determinant;
-	out[0] = _mm_mul_ps(Inv0, Rcp0);
-	out[1] = _mm_mul_ps(Inv1, Rcp0);
-	out[2] = _mm_mul_ps(Inv2, Rcp0);
-	out[3] = _mm_mul_ps(Inv3, Rcp0);
-}
-/*
-GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
-{
-	float a = glm::radians(Angle);
-    float c = cos(a);
-    float s = sin(a);
-
-	glm::vec4 AxisA(v[0], v[1], v[2], float(0));
-	__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
-    __m128 AxisC = detail::sse_nrm_ps(AxisB);
-
-	__m128 Cos0 = _mm_set_ss(c);
-	__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Sin0 = _mm_set_ss(s);
-	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
-
-	// detail::tvec3<valType> temp = (valType(1) - c) * axis;
-	__m128 Temp0 = _mm_sub_ps(one, CosA);
-	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
-	
-	//Rotate[0][0] = c + temp[0] * axis[0];
-	//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
-	//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
-	__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
-	__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
-	__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
-	__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
-	__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
-	__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
-	__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
-
-	//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
-	//Rotate[1][1] = c + temp[1] * axis[1];
-	//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
-	__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
-	__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
-	__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
-	__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
-	__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
-	__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
-	__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
-
-    //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
-    //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
-    //Rotate[2][2] = c + temp[2] * axis[2];
-	__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
-	__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
-	__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
-	__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
-	__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
-	__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
-	__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
-
-	__m128 Result[4];
-	Result[0] = TmpA4;
-	Result[1] = TmpB4;
-	Result[2] = TmpC4;
-	Result[3] = _mm_set_ps(1, 0, 0, 0);
-
-	//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::null);
-	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
-	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
-	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
-	//Result[3] = m[3];
-	//return Result;
-	sse_mul_ps(in, Result, out);
-}
-*/
-GLM_FUNC_QUALIFIER void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
-{
-	out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
-	out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
-	out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
-	out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
-}
-
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/intrinsic_trigonometric.hpp b/include/gal/opengl/glm/core/intrinsic_trigonometric.hpp
deleted file mode 100644
index b7d298ba83..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_trigonometric.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_trigonometric.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_trigonometric
-#define glm_detail_intrinsic_trigonometric
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_trigonometric.inl"
-
-#endif//GLM_ARCH
-#endif//glm_detail_intrinsic_trigonometric
diff --git a/include/gal/opengl/glm/core/intrinsic_trigonometric.inl b/include/gal/opengl/glm/core/intrinsic_trigonometric.inl
deleted file mode 100644
index 93343bc9d6..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_trigonometric.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_trigonometric.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/core/intrinsic_vector_relational.hpp b/include/gal/opengl/glm/core/intrinsic_vector_relational.hpp
deleted file mode 100644
index c9ec82e5fc..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_vector_relational.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_vector_relational.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_vector_relational
-#define glm_detail_intrinsic_vector_relational
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_vector_relational.inl"
-
-#endif//GLM_ARCH
-#endif//glm_detail_intrinsic_vector_relational
diff --git a/include/gal/opengl/glm/core/intrinsic_vector_relational.inl b/include/gal/opengl/glm/core/intrinsic_vector_relational.inl
deleted file mode 100644
index 806883259d..0000000000
--- a/include/gal/opengl/glm/core/intrinsic_vector_relational.inl
+++ /dev/null
@@ -1,366 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/intrinsic_vector_relational.inl
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-//
-//// lessThan
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThan
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//    return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThan
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThan
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
-//}
-//
-//// lessThanEqual
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThanEqual
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThanEqual
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThanEqual
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
-//}
-//
-//// greaterThan
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type greaterThan
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThan
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThan
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
-//}
-//
-//// greaterThanEqual
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type greaterThanEqual
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThanEqual
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThanEqual
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
-//}
-//
-//// equal
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type equal
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename detail::tvec2<valType>::bool_type(x.x == y.x, x.y == y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type equal
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename detail::tvec3<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type equal
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename detail::tvec4<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
-//}
-//
-//// notEqual
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type notEqual
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename detail::tvec2<valType>::bool_type(x.x != y.x, x.y != y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type notEqual
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename detail::tvec3<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type notEqual
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename detail::tvec4<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
-//}
-//
-//// any
-//GLM_FUNC_QUALIFIER bool any(detail::tvec2<bool> const & x)
-//{
-//	return x.x || x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
-//{
-//    return x.x || x.y || x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
-//{
-//    return x.x || x.y || x.z || x.w;
-//}
-//
-//// all
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec2<bool>& x)
-//{
-//    return x.x && x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
-//{
-//    return x.x && x.y && x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
-//{
-//    return x.x && x.y && x.z && x.w;
-//}
-//
-//// not
-//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
-//(
-//	detail::tvec2<bool> const & v
-//)
-//{
-//    return detail::tvec2<bool>::bool_type(!v.x, !v.y);
-//}
-//
-//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
-//(
-//	detail::tvec3<bool> const & v
-//)
-//{
-//    return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
-//}
-//
-//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
-//(
-//	detail::tvec4<bool> const & v
-//)
-//{
-//    return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
-//}
\ No newline at end of file
diff --git a/include/gal/opengl/glm/core/setup.hpp b/include/gal/opengl/glm/core/setup.hpp
deleted file mode 100644
index 95020ea020..0000000000
--- a/include/gal/opengl/glm/core/setup.hpp
+++ /dev/null
@@ -1,694 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/setup.hpp
-/// @date 2006-11-13 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_setup
-#define glm_setup
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Version
-
-#define GLM_VERSION					94
-#define GLM_VERSION_MAJOR			0
-#define GLM_VERSION_MINOR			9
-#define GLM_VERSION_PATCH			4
-#define GLM_VERSION_REVISION		7
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Platform
-
-#define GLM_PLATFORM_UNKNOWN		0x00000000
-#define GLM_PLATFORM_WINDOWS		0x00010000
-#define GLM_PLATFORM_LINUX			0x00020000
-#define GLM_PLATFORM_APPLE			0x00040000
-//#define GLM_PLATFORM_IOS			0x00080000
-#define GLM_PLATFORM_ANDROID		0x00100000
-#define GLM_PLATFORM_CHROME_NACL	0x00200000
-#define GLM_PLATFORM_UNIX			0x00400000
-#define GLM_PLATFORM_QNXNTO			0x00800000
-#define GLM_PLATFORM_WINCE			0x01000000
-
-#ifdef GLM_FORCE_PLATFORM_UNKNOWN
-#	define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
-#elif defined(__QNXNTO__)
-#	define GLM_PLATFORM GLM_PLATFORM_QNXNTO
-#elif defined(__APPLE__)
-#	define GLM_PLATFORM GLM_PLATFORM_APPLE
-#elif defined(WINCE)
-#	define GLM_PLATFORM GLM_PLATFORM_WINCE
-#elif defined(_WIN32)
-#	define GLM_PLATFORM GLM_PLATFORM_WINDOWS
-#elif defined(__native_client__)
-#	define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
-#elif defined(__ANDROID__)
-#	define GLM_PLATFORM GLM_PLATFORM_ANDROID
-#elif defined(__linux)
-#	define GLM_PLATFORM GLM_PLATFORM_LINUX
-#elif defined(__unix)
-#	define GLM_PLATFORM GLM_PLATFORM_UNIX
-#else
-#	define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
-#endif//
-
-// Report platform detection
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED))
-#	define GLM_MESSAGE_PLATFORM_DISPLAYED
-#	if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
-#		pragma message("GLM: QNX platform detected")
-//#	elif(GLM_PLATFORM & GLM_PLATFORM_IOS)
-//#		pragma message("GLM: iOS platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_APPLE)
-#		pragma message("GLM: Apple platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_WINCE)
-#		pragma message("GLM: WinCE platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
-#		pragma message("GLM: Windows platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
-#		pragma message("GLM: Native Client detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-#		pragma message("GLM: Android platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_LINUX)
-#		pragma message("GLM: Linux platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
-#		pragma message("GLM: UNIX platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN)
-#		pragma message("GLM: platform unknown")
-#	else
-#		pragma message("GLM: platform not detected")
-#	endif
-#endif//GLM_MESSAGE
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Compiler
-
-// User defines: GLM_FORCE_COMPILER_UNKNOWN
-// TODO ? __llvm__ 
-
-#define GLM_COMPILER_UNKNOWN		0x00000000
-
-// Intel
-#define GLM_COMPILER_INTEL			0x00100000
-#define GLM_COMPILER_INTEL9			0x00100010
-#define GLM_COMPILER_INTEL10_0		0x00100020
-#define GLM_COMPILER_INTEL10_1		0x00100030
-#define GLM_COMPILER_INTEL11_0		0x00100040
-#define GLM_COMPILER_INTEL11_1		0x00100050
-#define GLM_COMPILER_INTEL12_0		0x00100060
-#define GLM_COMPILER_INTEL12_1		0x00100070
-#define GLM_COMPILER_INTEL13_0		0x00100080
-
-// Visual C++ defines
-#define GLM_COMPILER_VC				0x01000000
-#define GLM_COMPILER_VC2			0x01000010
-#define GLM_COMPILER_VC4			0x01000020
-#define GLM_COMPILER_VC5			0x01000030
-#define GLM_COMPILER_VC6			0x01000040
-#define GLM_COMPILER_VC2002			0x01000050
-#define GLM_COMPILER_VC2003			0x01000060
-#define GLM_COMPILER_VC2005			0x01000070
-#define GLM_COMPILER_VC2008			0x01000080
-#define GLM_COMPILER_VC2010			0x01000090
-#define GLM_COMPILER_VC2012			0x010000A0
-#define GLM_COMPILER_VC2013			0x010000B0
-
-// GCC defines
-#define GLM_COMPILER_GCC			0x02000000
-#define GLM_COMPILER_GCC_LLVM		0x02000001
-#define GLM_COMPILER_GCC_CLANG		0x02000002
-#define GLM_COMPILER_GCC30			0x02000010
-#define GLM_COMPILER_GCC31			0x02000020
-#define GLM_COMPILER_GCC32			0x02000030
-#define GLM_COMPILER_GCC33			0x02000040
-#define GLM_COMPILER_GCC34			0x02000050
-#define GLM_COMPILER_GCC35			0x02000060
-#define GLM_COMPILER_GCC40			0x02000070
-#define GLM_COMPILER_GCC41			0x02000080
-#define GLM_COMPILER_GCC42			0x02000090
-#define GLM_COMPILER_GCC43			0x020000A0
-#define GLM_COMPILER_GCC44			0x020000B0
-#define GLM_COMPILER_GCC45			0x020000C0
-#define GLM_COMPILER_GCC46			0x020000D0
-#define GLM_COMPILER_GCC47			0x020000E0
-#define GLM_COMPILER_GCC48			0x020000F0
-#define GLM_COMPILER_GCC49			0x02000100
-
-// G++ command line to display defined
-// echo "" | g++ -E -dM -x c++ - | sort
-
-// Borland C++ defines. How to identify BC?
-#define GLM_COMPILER_BC				0x04000000
-#define GLM_COMPILER_BCB4			0x04000100
-#define GLM_COMPILER_BCB5			0x04000200
-#define GLM_COMPILER_BCB6			0x04000300
-//#define GLM_COMPILER_BCBX			0x04000400 // What's the version value?
-#define GLM_COMPILER_BCB2009		0x04000500
-
-// CodeWarrior
-#define GLM_COMPILER_CODEWARRIOR	0x08000000
-
-// CUDA
-#define GLM_COMPILER_CUDA			0x10000000
-#define GLM_COMPILER_CUDA30			0x10000010
-#define GLM_COMPILER_CUDA31			0x10000020
-#define GLM_COMPILER_CUDA32			0x10000030
-#define GLM_COMPILER_CUDA40			0x10000040
-#define GLM_COMPILER_CUDA41			0x10000050
-#define GLM_COMPILER_CUDA42			0x10000060
-
-// Clang
-#define GLM_COMPILER_CLANG			0x20000000
-#define GLM_COMPILER_CLANG26		0x20000010
-#define GLM_COMPILER_CLANG27		0x20000020
-#define GLM_COMPILER_CLANG28		0x20000030
-#define GLM_COMPILER_CLANG29		0x20000040
-#define GLM_COMPILER_CLANG30		0x20000050
-#define GLM_COMPILER_CLANG31		0x20000060
-#define GLM_COMPILER_CLANG32		0x20000070
-#define GLM_COMPILER_CLANG33		0x20000080
-#define GLM_COMPILER_CLANG40		0x20000090
-#define GLM_COMPILER_CLANG41		0x200000A0
-#define GLM_COMPILER_CLANG42		0x200000B0
-#define GLM_COMPILER_CLANG43		0x200000C0
-
-// LLVM GCC
-#define GLM_COMPILER_LLVM_GCC		0x40000000
-
-// Build model
-#define GLM_MODEL_32				0x00000010
-#define GLM_MODEL_64				0x00000020
-
-// Force generic C++ compiler
-#ifdef GLM_FORCE_COMPILER_UNKNOWN
-#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
-
-#elif defined(__INTEL_COMPILER)
-#	if __INTEL_COMPILER == 900
-#		define GLM_COMPILER GLM_COMPILER_INTEL9
-#	elif __INTEL_COMPILER == 1000
-#		define GLM_COMPILER GLM_COMPILER_INTEL10_0
-#	elif __INTEL_COMPILER == 1010
-#		define GLM_COMPILER GLM_COMPILER_INTEL10_1
-#	elif __INTEL_COMPILER == 1100
-#		define GLM_COMPILER GLM_COMPILER_INTEL11_0
-#	elif __INTEL_COMPILER == 1110
-#		define GLM_COMPILER GLM_COMPILER_INTEL11_1
-#	elif __INTEL_COMPILER == 1200
-#		define GLM_COMPILER GLM_COMPILER_INTEL12_0
-#	elif __INTEL_COMPILER == 1210
-#		define GLM_COMPILER GLM_COMPILER_INTEL12_1
-#	elif __INTEL_COMPILER >= 1300
-#		define GLM_COMPILER GLM_COMPILER_INTEL13_0
-#	else
-#		define GLM_COMPILER GLM_COMPILER_INTEL
-#	endif
-
-// CUDA
-#elif defined(__CUDACC__)
-#	if CUDA_VERSION < 3000
-#		error "GLM requires CUDA 3.0 or higher"
-#	else
-#		define GLM_COMPILER GLM_COMPILER_CUDA
-#	endif
-
-// Visual C++
-#elif defined(_MSC_VER)
-#	if _MSC_VER < 1400
-#		error "GLM requires Visual C++ 2005 or higher"
-#	elif _MSC_VER == 1400
-#		define GLM_COMPILER GLM_COMPILER_VC2005
-#	elif _MSC_VER == 1500
-#		define GLM_COMPILER GLM_COMPILER_VC2008
-#	elif _MSC_VER == 1600
-#		define GLM_COMPILER GLM_COMPILER_VC2010
-#	elif _MSC_VER == 1700
-#		define GLM_COMPILER GLM_COMPILER_VC2012
-#	elif _MSC_VER >= 1800
-#		define GLM_COMPILER GLM_COMPILER_VC2013
-#	else//_MSC_VER
-#		define GLM_COMPILER GLM_COMPILER_VC
-#	endif//_MSC_VER
-
-// Clang
-#elif defined(__clang__)
-#	if (__clang_major__ <= 1) || ((__clang_major__ == 2) && (__clang_minor__ < 6))
-#		error "GLM requires Clang 2.6 or higher"
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 6)
-#		define GLM_COMPILER GLM_COMPILER_CLANG26
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 7)
-#		define GLM_COMPILER GLM_COMPILER_CLANG27
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 8)
-#		define GLM_COMPILER GLM_COMPILER_CLANG28
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 9)
-#		define GLM_COMPILER GLM_COMPILER_CLANG29
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 0)
-#		define GLM_COMPILER GLM_COMPILER_CLANG30
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 1)
-#		define GLM_COMPILER GLM_COMPILER_CLANG31
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 2)
-#		define GLM_COMPILER GLM_COMPILER_CLANG32
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 3)
-#		define GLM_COMPILER GLM_COMPILER_CLANG33
-#	elif(__clang_major__ == 4) && (__clang_minor__ == 0)
-#		define GLM_COMPILER GLM_COMPILER_CLANG40
-#	elif(__clang_major__ == 4) && (__clang_minor__ == 1)
-#		define GLM_COMPILER GLM_COMPILER_CLANG41
-#	elif(__clang_major__ == 4) && (__clang_minor__ == 2)
-#		define GLM_COMPILER GLM_COMPILER_CLANG42
-#	elif(__clang_major__ == 4) && (__clang_minor__ >= 3)
-#		define GLM_COMPILER GLM_COMPILER_CLANG43
-#	elif(__clang_major__ > 4)
-#		define GLM_COMPILER GLM_COMPILER_CLANG43
-#	else
-#		define GLM_COMPILER GLM_COMPILER_CLANG
-#	endif
-
-// G++ 
-#elif(defined(__GNUC__) || defined(__MINGW32__))// || defined(__llvm__) || defined(__clang__)
-#	if   (__GNUC__ == 3) && (__GNUC_MINOR__ == 2)
-#		define GLM_COMPILER GLM_COMPILER_GCC32
-#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 3)
-#		define GLM_COMPILER GLM_COMPILER_GCC33
-#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
-#		define GLM_COMPILER GLM_COMPILER_GCC34
-#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 5)
-#		define GLM_COMPILER GLM_COMPILER_GCC35
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 0)
-#		define GLM_COMPILER (GLM_COMPILER_GCC40)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 1)
-#		define GLM_COMPILER (GLM_COMPILER_GCC41)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
-#		define GLM_COMPILER (GLM_COMPILER_GCC42)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
-#		define GLM_COMPILER (GLM_COMPILER_GCC43)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4)
-#		define GLM_COMPILER (GLM_COMPILER_GCC44)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5)
-#		define GLM_COMPILER (GLM_COMPILER_GCC45)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
-#		define GLM_COMPILER (GLM_COMPILER_GCC46)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
-#		define GLM_COMPILER (GLM_COMPILER_GCC47)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
-#		define GLM_COMPILER (GLM_COMPILER_GCC48)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
-#		define GLM_COMPILER (GLM_COMPILER_GCC49)
-#	elif (__GNUC__ > 4 )
-#		define GLM_COMPILER (GLM_COMPILER_GCC49)
-#	else
-#		define GLM_COMPILER (GLM_COMPILER_GCC)
-#	endif
-
-// Borland C++
-#elif defined(_BORLANDC_)
-#	define GLM_COMPILER GLM_COMPILER_BC
-
-// Codewarrior
-#elif defined(__MWERKS__)
-#	define GLM_COMPILER GLM_COMPILER_CODEWARRIOR
-
-#else
-#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
-#endif
-
-#ifndef GLM_COMPILER
-#error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
-#endif//GLM_COMPILER
-
-// Report compiler detection
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED))
-#	define GLM_MESSAGE_COMPILER_DISPLAYED
-#	if(GLM_COMPILER & GLM_COMPILER_CUDA)
-#		pragma message("GLM: CUDA compiler detected")
-#	elif(GLM_COMPILER & GLM_COMPILER_VC)
-#		pragma message("GLM: Visual C++ compiler detected")
-#	elif(GLM_COMPILER & GLM_COMPILER_CLANG)
-#		pragma message("GLM: Clang compiler detected")
-#	elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
-#		pragma message("GLM: LLVM GCC compiler detected")
-#	elif(GLM_COMPILER & GLM_COMPILER_GCC)
-#		if(GLM_COMPILER == GLM_COMPILER_GCC_LLVM)
-#			pragma message("GLM: LLVM GCC compiler detected")
-#		elif(GLM_COMPILER == GLM_COMPILER_GCC_CLANG)
-#			pragma message("GLM: CLANG compiler detected")
-#		else
-#			pragma message("GLM: GCC compiler detected")
-#		endif
-#	elif(GLM_COMPILER & GLM_COMPILER_BC)
-#		pragma message("GLM: Borland compiler detected but not supported")
-#	elif(GLM_COMPILER & GLM_COMPILER_CODEWARRIOR)
-#		pragma message("GLM: Codewarrior compiler detected but not supported")
-#	else
-#		pragma message("GLM: Compiler not detected")
-#	endif
-#endif//GLM_MESSAGE
-
-/////////////////
-// Build model //
-
-#if(defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__))
-#		define GLM_MODEL	GLM_MODEL_64
-#elif(defined(__i386__) || defined(__ppc__))
-#	define GLM_MODEL	GLM_MODEL_32
-#else
-#	define GLM_MODEL	GLM_MODEL_32
-#endif//
-
-#if(!defined(GLM_MODEL) && GLM_COMPILER != 0)
-#	error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
-#endif//GLM_MODEL
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED))
-#	define GLM_MESSAGE_MODEL_DISPLAYED
-#	if(GLM_MODEL == GLM_MODEL_64)
-#		pragma message("GLM: 64 bits model")
-#	elif(GLM_MODEL == GLM_MODEL_32)
-#		pragma message("GLM: 32 bits model")
-#	endif//GLM_MODEL
-#endif//GLM_MESSAGE
-
-/////////////////
-// C++ Version //
-
-// User defines: GLM_FORCE_CXX98
-
-#define GLM_LANG_CXX			(0 << 0)
-#define GLM_LANG_CXX98			((1 << 1) | GLM_LANG_CXX)
-#define GLM_LANG_CXX03			((1 << 2) | GLM_LANG_CXX98)
-#define GLM_LANG_CXX0X			((1 << 3) | GLM_LANG_CXX03)
-#define GLM_LANG_CXX11			((1 << 4) | GLM_LANG_CXX0X)
-#define GLM_LANG_CXXMS			(1 << 5)
-#define GLM_LANG_CXXGNU			(1 << 6)
-
-#if(defined(GLM_FORCE_CXX11))
-#	define GLM_LANG GLM_LANG_CXX11
-#elif(defined(GLM_FORCE_CXX03))
-#	define GLM_LANG GLM_LANG_CXX03
-#elif(defined(GLM_FORCE_CXX98))
-#	define GLM_LANG GLM_LANG_CXX98
-#else
-#	if(__cplusplus >= 201103L)
-#		define GLM_LANG GLM_LANG_CXX11
-#	elif((GLM_COMPILER & GLM_COMPILER_CLANG) == GLM_COMPILER_CLANG)
-#		if(GLM_PLATFORM == GLM_PLATFORM_APPLE)
-#			define GLM_DETAIL_MAJOR 1
-#		else
-#			define GLM_DETAIL_MAJOR 0
-#		endif
-#		if(__clang_major__ < (2 + GLM_DETAIL_MAJOR))
-#			define GLM_LANG GLM_LANG_CXX
-#		elif(__has_feature(cxx_auto_type))
-#			define GLM_LANG GLM_LANG_CXX0X
-#		else
-#			define GLM_LANG GLM_LANG_CXX98
-#		endif
-#	elif((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC)
-#		if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#			define GLM_LANG GLM_LANG_CXX0X
-#		else
-#			define GLM_LANG GLM_LANG_CXX98
-#		endif
-#	elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS))
-#		define GLM_LANG GLM_LANG_CXXMS
-#	elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && !defined(_MSC_EXTENSIONS))
-#		if(GLM_COMPILER >= GLM_COMPILER_VC2010)
-#			define GLM_LANG GLM_LANG_CXX0X
-#		else
-#			define GLM_LANG GLM_LANG_CXX98
-#		endif
-#	elif(__cplusplus >= 199711L)
-#		define GLM_LANG GLM_LANG_CXX98
-#	else
-#		define GLM_LANG GLM_LANG_CXX
-#	endif
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED))
-#	define GLM_MESSAGE_LANG_DISPLAYED
-#	if(GLM_LANG == GLM_LANG_CXX98)
-#		pragma message("GLM: C++98")
-#	elif(GLM_LANG == GLM_LANG_CXX03)
-#		pragma message("GLM: C++03")
-#	elif(GLM_LANG == GLM_LANG_CXX0X)
-#		pragma message("GLM: C++0x")
-#	elif(GLM_LANG == GLM_LANG_CXX11)
-#		pragma message("GLM: C++11")
-#	elif(GLM_LANG == GLM_LANG_CXXGNU)
-#		pragma message("GLM: C++ with GNU language extensions")
-#	elif(GLM_LANG == GLM_LANG_CXXMS)
-#		pragma message("GLM: C++ with VC language extensions")
-#	else
-#		pragma message("GLM: C++ language undetected")
-#	endif//GLM_MODEL
-#endif//GLM_MESSAGE
-
-/////////////////
-// Platform 
-
-// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_AVX
-
-#define GLM_ARCH_PURE		0x0000
-#define GLM_ARCH_SSE2		0x0001
-#define GLM_ARCH_SSE3		0x0002// | GLM_ARCH_SSE2
-#define GLM_ARCH_SSE4		0x0004// | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
-#define GLM_ARCH_AVX		0x0008// | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
-#define GLM_ARCH_AVX2		0x0010// | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
-
-#if(defined(GLM_FORCE_PURE))
-#	define GLM_ARCH GLM_ARCH_PURE
-#elif(defined(GLM_FORCE_AVX2))
-#	define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#elif(defined(GLM_FORCE_AVX))
-#	define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#elif(defined(GLM_FORCE_SSE4))
-#	define GLM_ARCH (GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#elif(defined(GLM_FORCE_SSE3))
-#	define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#elif(defined(GLM_FORCE_SSE2))
-#	define GLM_ARCH (GLM_ARCH_SSE2)
-#elif((GLM_COMPILER & GLM_COMPILER_VC) && (defined(_M_IX86) || defined(_M_X64)))
-#	if(GLM_PLATFORM == GLM_PLATFORM_WINCE)
-#		define GLM_ARCH GLM_ARCH_PURE
-#	elif(defined(_M_CEE_PURE))
-#		define GLM_ARCH GLM_ARCH_PURE
-/* TODO: Explore auto detection of instruction set support
-#	elif(defined(_M_IX86_FP))
-#		if(_M_IX86_FP >= 3)
-#			define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#		elif(_M_IX86_FP >= 2)
-#			define GLM_ARCH (GLM_ARCH_SSE2)
-#		else
-#			define GLM_ARCH GLM_ARCH_PURE
-#		endif
-*/
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2012)
-#		define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2010)
-#		if(_MSC_FULL_VER >= 160031118) //160031118: VC2010 SP1 beta full version
-#			define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)//GLM_ARCH_AVX (Require SP1)
-#		else
-#			define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#		endif
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2008) 
-#		define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2005)
-#		define GLM_ARCH GLM_ARCH_SSE2
-#	else
-#		define GLM_ARCH GLM_ARCH_PURE
-#	endif
-#elif((GLM_PLATFORM & GLM_PLATFORM_APPLE) && (GLM_COMPILER & GLM_COMPILER_GCC))
-#	define GLM_ARCH GLM_ARCH_PURE
-#elif(((GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__))) || (GLM_COMPILER & GLM_COMPILER_LLVM_GCC))
-#	define GLM_ARCH (GLM_ARCH_PURE \
-| (defined(__AVX2__) ? GLM_ARCH_AVX2 : 0) \
-| (defined(__AVX__) ? GLM_ARCH_AVX : 0) \
-| (defined(__SSE4__) ? GLM_ARCH_SSE4 : 0) \
-| (defined(__SSE3__) ? GLM_ARCH_SSE3 : 0) \
-| (defined(__SSE2__) ? GLM_ARCH_SSE2 : 0))
-#else
-#	define GLM_ARCH GLM_ARCH_PURE
-#endif
-
-// With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is
-// that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems.
-// To fix, we just explicitly include intrin.h here.
-#if defined(__MINGW32__) && (GLM_ARCH != GLM_ARCH_PURE)
-#   include <intrin.h>
-#endif
-
-//#if(GLM_ARCH != GLM_ARCH_PURE)
-#if(GLM_ARCH & GLM_ARCH_AVX2)
-#	include <immintrin.h>
-#endif//GLM_ARCH
-#if(GLM_ARCH & GLM_ARCH_AVX)
-#	include <immintrin.h>
-#endif//GLM_ARCH
-#if(GLM_ARCH & GLM_ARCH_SSE4)
-#	include <smmintrin.h>
-#endif//GLM_ARCH
-#if(GLM_ARCH & GLM_ARCH_SSE3)
-#	include <pmmintrin.h>
-#endif//GLM_ARCH
-#if(GLM_ARCH & GLM_ARCH_SSE2)
-#	include <emmintrin.h>
-#endif//GLM_ARCH
-//#endif//(GLM_ARCH != GLM_ARCH_PURE)
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED))
-#	define GLM_MESSAGE_ARCH_DISPLAYED
-#	if(GLM_ARCH == GLM_ARCH_PURE)
-#		pragma message("GLM: Platform independent")
-#	elif(GLM_ARCH & GLM_ARCH_SSE2)
-#		pragma message("GLM: SSE2 instruction set")
-#	elif(GLM_ARCH & GLM_ARCH_SSE3)
-#		pragma message("GLM: SSE3 instruction set")
-#	elif(GLM_ARCH & GLM_ARCH_SSE4)
-#		pragma message("GLM: SSE4 instruction set")
-#	elif(GLM_ARCH & GLM_ARCH_AVX)
-#		pragma message("GLM: AVX instruction set")
-#	elif(GLM_ARCH & GLM_ARCH_AVX2)
-#		pragma message("GLM: AVX2 instruction set")
-#	endif//GLM_ARCH
-#endif//GLM_MESSAGE
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Support check macros
-
-#define GLM_SUPPORT_ANONYMOUS_UNION() \
-	((GLM_LANG & GLM_LANG_CXX98) == GLM_LANG_CXX98)
-
-//#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() <backslash>
-//	(((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X)))
-
-#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
-	(((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && ((GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS)) || ((GLM_LANG == GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
-
-#define GLM_SUPPORT_SWIZZLE_OPERATOR() \
-	(/*defined(GLM_SWIZZLE) && */GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE())
-
-#define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE)
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Components
-
-//#define GLM_FORCE_ONLY_XYZW
-#define GLM_COMPONENT_ONLY_XYZW				0 // To disable multiple vector component names access.
-#define GLM_COMPONENT_CXX98					1 //  
-#define GLM_COMPONENT_CXX11					2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
-
-#if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
-#	define GLM_COMPONENT GLM_COMPONENT_CXX11
-#elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
-#	define GLM_COMPONENT GLM_COMPONENT_CXX98
-#else
-#	define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
-#	define GLM_MESSAGE_COMPONENT_DISPLAYED
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-#		pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types")
-#	elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-#		pragma message("GLM: x,y,z,w component names for all vector types")
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-#		pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
-#	else
-#		error "GLM: GLM_COMPONENT value unknown"
-#	endif//GLM_MESSAGE_COMPONENT_DISPLAYED
-#endif//GLM_MESSAGE
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Radians
-
-//#define GLM_FORCE_RADIANS
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Static assert
-
-#if(GLM_LANG == GLM_LANG_CXX0X)
-#	define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
-#elif(defined(BOOST_STATIC_ASSERT))
-#	define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
-#elif(GLM_COMPILER & GLM_COMPILER_VC)
-#	define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
-#else
-#	define GLM_STATIC_ASSERT(x, message)
-#	define GLM_STATIC_ASSERT_NULL
-#endif//GLM_LANG
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Qualifiers 
-
-// User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
-
-#if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
-#	define GLM_CUDA_FUNC_DEF __device__ __host__ 
-#	define GLM_CUDA_FUNC_DECL __device__ __host__ 
-#else
-#	define GLM_CUDA_FUNC_DEF
-#	define GLM_CUDA_FUNC_DECL
-#endif
-
-#if GLM_COMPILER & GLM_COMPILER_GCC
-#	define GLM_VAR_USED __attribute__ ((unused))
-#else
-#	define GLM_VAR_USED
-#endif
-
-#if(defined(GLM_FORCE_INLINE))
-#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
-#		define GLM_INLINE __forceinline
-#	elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34))
-#		define GLM_INLINE __attribute__((always_inline))
-#	elif(GLM_COMPILER & GLM_COMPILER_CLANG)
-#		define GLM_INLINE __attribute__((always_inline))
-#	else
-#		define GLM_INLINE inline
-#	endif//GLM_COMPILER
-#else
-#	define GLM_INLINE inline
-#endif//defined(GLM_FORCE_INLINE)
-
-#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
-#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Swizzle operators
-
-// User defines: GLM_SWIZZLE
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
-#	define GLM_MESSAGE_SWIZZLE_DISPLAYED
-#	if(GLM_SUPPORT_SWIZZLE_OPERATOR())
-#		pragma message("GLM: Swizzling operators enabled")
-#	elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
-#		pragma message("GLM: Swizzling operators supported through swizzling functions")
-#	else
-#		pragma message("GLM: Swizzling operators disabled")
-#	endif
-#endif//GLM_MESSAGE
-
-#endif//glm_setup
diff --git a/include/gal/opengl/glm/core/type.hpp b/include/gal/opengl/glm/core/type.hpp
deleted file mode 100644
index 6361e2e503..0000000000
--- a/include/gal/opengl/glm/core/type.hpp
+++ /dev/null
@@ -1,341 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type.hpp
-/// @date 2008-01-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type
-#define glm_core_type
-
-#include "type_half.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-
-#include "type_gentype.hpp"
-
-#include "type_vec1.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_vec4.hpp"
-
-#include "type_mat2x2.hpp"
-#include "type_mat2x3.hpp"
-#include "type_mat2x4.hpp"
-#include "type_mat3x2.hpp"
-#include "type_mat3x3.hpp"
-#include "type_mat3x4.hpp"
-#include "type_mat4x2.hpp"
-#include "type_mat4x3.hpp"
-#include "type_mat4x4.hpp"
-
-namespace glm
-{
-	/// @addtogroup core_types
-	/// @{
-
-	//////////////////////////
-	// Float definition
-
-#if(defined(GLM_PRECISION_HIGHP_FLOAT))
-	typedef highp_vec2          vec2;
-	typedef highp_vec3          vec3;
-	typedef highp_vec4          vec4;
-	typedef highp_mat2x2		mat2x2;
-	typedef highp_mat2x3		mat2x3;
-	typedef highp_mat2x4		mat2x4;
-	typedef highp_mat3x2		mat3x2;
-	typedef highp_mat3x3		mat3x3;
-	typedef highp_mat3x4		mat3x4;
-	typedef highp_mat4x2		mat4x2;
-	typedef highp_mat4x3		mat4x3;
-	typedef highp_mat4x4		mat4x4;
-#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
-	typedef mediump_vec2		vec2;
-	typedef mediump_vec3		vec3;
-	typedef mediump_vec4		vec4;
-	typedef mediump_mat2x2      mat2x2;
-	typedef mediump_mat2x3      mat2x3;
-	typedef mediump_mat2x4      mat2x4;
-	typedef mediump_mat3x2      mat3x2;
-	typedef mediump_mat3x3      mat3x3;
-	typedef mediump_mat3x4      mat3x4;
-	typedef mediump_mat4x2      mat4x2;
-	typedef mediump_mat4x3      mat4x3;
-	typedef mediump_mat4x4      mat4x4;
-#elif(defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef lowp_vec2			vec2;
-	typedef lowp_vec3			vec3;
-	typedef lowp_vec4			vec4;
-	typedef lowp_mat2x2			mat2x2;
-	typedef lowp_mat2x3			mat2x3;
-	typedef lowp_mat2x4			mat2x4;
-	typedef lowp_mat3x2			mat3x2;
-	typedef lowp_mat3x3			mat3x3;
-	typedef lowp_mat3x4			mat3x4;
-	typedef lowp_mat4x2			mat4x2;
-	typedef lowp_mat4x3			mat4x3;
-	typedef lowp_mat4x4			mat4x4;
-#else
-	/// 2 components vector of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_vec2		vec2;
-
-	//! 3 components vector of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_vec3		vec3;
-
-	//! 4 components vector of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_vec4		vec4;
-
-	//! 2 columns of 2 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat2x2		mat2x2;
-
-	//! 2 columns of 3 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat2x3		mat2x3;
-
-	//! 2 columns of 4 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat2x4		mat2x4;
-
-	//! 3 columns of 2 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat3x2		mat3x2;
-
-	//! 3 columns of 3 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat3x3		mat3x3;
-
-	//! 3 columns of 4 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat3x4		mat3x4;
-
-	//! 4 columns of 2 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat4x2		mat4x2;
-
-	//! 4 columns of 3 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat4x3		mat4x3;
-
-	//! 4 columns of 4 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mediump_mat4x4		mat4x4;
-
-#endif//GLM_PRECISION
-
-	//! 2 columns of 2 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mat2x2							mat2;
-
-	//! 3 columns of 3 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mat3x3							mat3;
-
-	//! 4 columns of 4 components matrix of floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef mat4x4							mat4;
-
-	//////////////////////////
-	// Signed integer definition
-
-#if(defined(GLM_PRECISION_HIGHP_INT))
-	typedef highp_ivec2			ivec2;
-	typedef highp_ivec3			ivec3;
-	typedef highp_ivec4			ivec4;
-#elif(defined(GLM_PRECISION_MEDIUMP_INT))
-	typedef mediump_ivec2		ivec2;
-	typedef mediump_ivec3		ivec3;
-	typedef mediump_ivec4		ivec4;
-#elif(defined(GLM_PRECISION_LOWP_INT))
-	typedef lowp_ivec2			ivec2;
-	typedef lowp_ivec3			ivec3;
-	typedef lowp_ivec4			ivec4;
-#else
-	//! 2 components vector of signed integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_ivec2		ivec2;
-
-	//! 3 components vector of signed integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_ivec3		ivec3;
-
-	//! 4 components vector of signed integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_ivec4		ivec4;
-#endif//GLM_PRECISION
-
-	//////////////////////////
-	// Unsigned integer definition
-
-#if(defined(GLM_PRECISION_HIGHP_UINT))
-	typedef highp_uvec2			uvec2;
-	typedef highp_uvec3			uvec3;
-	typedef highp_uvec4			uvec4;
-#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
-	typedef mediump_uvec2		uvec2;
-	typedef mediump_uvec3		uvec3;
-	typedef mediump_uvec4		uvec4;
-#elif(defined(GLM_PRECISION_LOWP_UINT))
-	typedef lowp_uvec2			uvec2;
-	typedef lowp_uvec3			uvec3;
-	typedef lowp_uvec4			uvec4;
-#else
-	//! 2 components vector of unsigned integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_uvec2		uvec2;
-
-	//! 3 components vector of unsigned integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_uvec3		uvec3;
-
-	//! 4 components vector of unsigned integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_uvec4		uvec4;
-#endif//GLM_PRECISION
-
-	//////////////////////////
-	// Boolean definition
-
-	//! 2 components vector of boolean. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec2<bool>		bvec2;
-
-	//! 3 components vector of boolean. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec3<bool>		bvec3;
-
-	//! 4 components vector of boolean. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec4<bool>		bvec4;
-
-	//////////////////////////
-	// Double definition
-
-	//! Vector of 2 double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec2<double>	dvec2;
-
-	//! Vector of 3 double-precision floating-point numbers.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec3<double>	dvec3;
-
-	//! Vector of 4 double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec4<double>	dvec4;
-
-	//! 2 * 2 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat2x2<double>	dmat2;
-
-	//! 3 * 3 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat3x3<double>	dmat3;
-
-	//! 4 * 4 matrix of double-precision floating-point numbers.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat4x4<double>	dmat4;
-
-	//! 2 * 2 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat2x2<double>	dmat2x2;
-
-	//! 2 * 3 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat2x3<double>	dmat2x3;
-
-	//! 2 * 4 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat2x4<double>	dmat2x4;
-
-	//! 3 * 2 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat3x2<double>	dmat3x2;
-
-	//! 3 * 3 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat3x3<double>	dmat3x3;
-
-	//! 3 * 4 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat3x4<double>	dmat3x4;
-
-	//! 4 * 2 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat4x2<double>	dmat4x2;
-
-	//! 4 * 3 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat4x3<double>	dmat4x3;
-
-	//! 4 * 4 matrix of double-precision floating-point numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	typedef detail::tmat4x4<double>	dmat4x4;
-
-	/// @}
-}//namespace glm
-
-#endif//glm_core_type
diff --git a/include/gal/opengl/glm/core/type_float.hpp b/include/gal/opengl/glm/core/type_float.hpp
deleted file mode 100644
index 095812c651..0000000000
--- a/include/gal/opengl/glm/core/type_float.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_float.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_float
-#define glm_core_type_float
-
-#include "type_half.hpp"
-#include "setup.hpp"
-
-namespace glm
-{
-#ifdef GLM_USE_HALF_SCALAR
-	typedef detail::half		lowp_float_t;
-#else//GLM_USE_HALF_SCALAR
-	typedef float				lowp_float_t;
-#endif//GLM_USE_HALF_SCALAR
-	typedef float				mediump_float_t;
-	typedef double				highp_float_t;
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// Low precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef lowp_float_t		lowp_float;
-
-	/// Medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef mediump_float_t     mediump_float;
-
-	/// High precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef highp_float_t		highp_float;
-
-#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef mediump_float				float_t;
-#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef highp_float                  float_t;
-#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef mediump_float				float_t;
-#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef lowp_float					float_t;
-#else
-#	error "GLM error: multiple default precision requested for floating-point types"
-#endif
-
-	/// @}
-}//namespace glm
-
-#endif//glm_core_type_float
diff --git a/include/gal/opengl/glm/core/type_gentype.hpp b/include/gal/opengl/glm/core/type_gentype.hpp
deleted file mode 100644
index c79152a92f..0000000000
--- a/include/gal/opengl/glm/core/type_gentype.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_gentype.hpp
-/// @date 2008-10-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype
-#define glm_core_type_gentype
-
-#include "type_size.hpp"
-
-namespace glm
-{
-	enum profile
-	{
-		nice,
-		fast,
-		simd
-	};
-
-namespace detail
-{
-	template
-	<
-		typename VALTYPE, 
-		template <typename> class TYPE
-	>
-	struct genType
-	{
-	public:
-		enum ctor{null};
-
-		typedef VALTYPE value_type;
-		typedef VALTYPE & value_reference;
-		typedef VALTYPE * value_pointer;
-		typedef VALTYPE const * value_const_pointer;
-		typedef TYPE<bool> bool_type;
-
-		typedef sizeType size_type;
-		static bool is_vector();
-		static bool is_matrix();
-		
-		typedef TYPE<VALTYPE> type;
-		typedef TYPE<VALTYPE> * pointer;
-		typedef TYPE<VALTYPE> const * const_pointer;
-		typedef TYPE<VALTYPE> const * const const_pointer_const;
-		typedef TYPE<VALTYPE> * const pointer_const;
-		typedef TYPE<VALTYPE> & reference;
-		typedef TYPE<VALTYPE> const & const_reference;
-		typedef TYPE<VALTYPE> const & param_type;
-
-		//////////////////////////////////////
-		// Address (Implementation details)
-
-		value_const_pointer value_address() const{return value_pointer(this);}
-		value_pointer value_address(){return value_pointer(this);}
-
-	//protected:
-	//	enum kind
-	//	{
-	//		GEN_TYPE,
-	//		VEC_TYPE,
-	//		MAT_TYPE
-	//	};
-
-	//	typedef typename TYPE::kind kind;
-	};
-
-	template
-	<
-		typename VALTYPE, 
-		template <typename> class TYPE
-	>
-	bool genType<VALTYPE, TYPE>::is_vector()
-	{
-		return true;
-	}
-/*
-	template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
-	class base
-	{
-	public:
-		//////////////////////////////////////
-		// Traits
-
-		typedef sizeType							size_type;
-		typedef valTypeT							value_type;
-
-		typedef base<value_type, colT, rowT>		class_type;
-
-		typedef base<bool, colT, rowT>				bool_type;
-		typedef base<value_type, rowT, 1>			col_type;
-		typedef base<value_type, colT, 1>			row_type;
-		typedef base<value_type, rowT, colT>		transpose_type;
-
-		static size_type							col_size();
-		static size_type							row_size();
-		static size_type							value_size();
-		static bool									is_scalar();
-		static bool									is_vector();
-		static bool									is_matrix();
-
-	private:
-		// Data 
-		col_type value[colT];		
-
-	public:
-		//////////////////////////////////////
-		// Constructors
-		base();
-		base(class_type const & m);
-
-		explicit base(value_type const & x);
-		explicit base(value_type const * const x);
-		explicit base(col_type const * const x);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename vU, uint cU, uint rU, profile pU>
-		explicit base(base<vU, cU, rU, pU> const & m);
-
-		//////////////////////////////////////
-		// Accesses
-		col_type& operator[](size_type i);
-		col_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Unary updatable operators
-		class_type& operator=  (class_type const & x);
-		class_type& operator+= (value_type const & x);
-		class_type& operator+= (class_type const & x);
-		class_type& operator-= (value_type const & x);
-		class_type& operator-= (class_type const & x);
-		class_type& operator*= (value_type const & x);
-		class_type& operator*= (class_type const & x);
-		class_type& operator/= (value_type const & x);
-		class_type& operator/= (class_type const & x);
-		class_type& operator++ ();
-		class_type& operator-- ();
-	};
-*/
-	}//namespace detail
-}//namespace glm
-
-//#include "type_gentype.inl"
-
-#endif//glm_core_type_gentype
diff --git a/include/gal/opengl/glm/core/type_gentype.inl b/include/gal/opengl/glm/core/type_gentype.inl
deleted file mode 100644
index 2ca7496f47..0000000000
--- a/include/gal/opengl/glm/core/type_gentype.inl
+++ /dev/null
@@ -1,366 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_gentype.inl
-/// @date 2008-10-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-/////////////////////////////////
-// Static functions
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::col_size()
-{
-	return cT;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::row_size()
-{
-	return rT;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::value_size()
-{
-	return rT * cT;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-bool base<vT, cT, rT, pT>::is_scalar()
-{
-	return rT == 1 && cT == 1;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-bool base<vT, cT, rT, pT>::is_vector()
-{
-	return rT == 1;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-bool base<vT, cT, rT, pT>::is_matrix()
-{
-	return rT != 1;
-}
-
-/////////////////////////////////
-// Constructor
-
-template <typename vT, uint cT, uint rT, profile pT>
-base<vT, cT, rT, pT>::base()
-{
-	memset(&this->value, 0, cT * rT * sizeof(vT));
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-base<vT, cT, rT, pT>::base
-(
-	typename base<vT, cT, rT, pT>::class_type const & m
-)
-{
-	for
-	(
-		typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-		i < base<vT, cT, rT, pT>::col_size();
-		++i
-	)
-	{
-		this->value[i] = m[i];
-	}
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-base<vT, cT, rT, pT>::base
-(
-	typename base<vT, cT, rT, pT>::value_type const & x
-)
-{
-	if(rT == 1) // vector
-	{
-		for
-		(
-			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-			i < base<vT, cT, rT, pT>::col_size();
-			++i
-		)
-		{
-			this->value[i][rT] = x;
-		}
-	}
-	else // matrix
-	{
-		memset(&this->value, 0, cT * rT * sizeof(vT));
-
-		typename base<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
-
-		for
-		(
-			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-			i < stop;
-			++i
-		)
-		{
-			this->value[i][i] = x;
-		}
-	}
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-base<vT, cT, rT, pT>::base
-(
-	typename base<vT, cT, rT, pT>::value_type const * const x
-)
-{
-	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-base<vT, cT, rT, pT>::base
-(
-	typename base<vT, cT, rT, pT>::col_type const * const x
-)
-{
-	for
-	(
-		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-		i < base<vT, cT, rT, pT>::col_size();
-		++i
-	)
-	{
-		this->value[i] = x[i];
-	}
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-template <typename vU, uint cU, uint rU, profile pU>
-base<vT, cT, rT, pT>::base
-(
-	base<vU, cU, rU, pU> const & m
-)
-{
-	for
-	(
-		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-		i < base<vT, cT, rT, pT>::col_size();
-		++i
-	)
-	{
-		this->value[i] = base<vT, cT, rT, pT>(m[i]);
-	}
-}
-
-//////////////////////////////////////
-// Accesses
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
-(
-	typename base<vT, cT, rT, pT>::size_type i
-)
-{
-	return this->value[i];
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
-(
-	typename base<vT, cT, rT, pT>::size_type i
-) const
-{
-	return this->value[i];
-}
-
-//////////////////////////////////////
-// Unary updatable operators
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator= 
-(
-	typename base<vT, cT, rT, pT>::class_type const & x
-)
-{
-	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
-(
-	typename base<vT, cT, rT, pT>::value_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] += x;
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
-(
-	typename base<vT, cT, rT, pT>::class_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] += x[j][i];
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
-(
-	typename base<vT, cT, rT, pT>::value_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] -= x;
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
-(
-	typename base<vT, cT, rT, pT>::class_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] -= x[j][i];
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
-(
-	typename base<vT, cT, rT, pT>::value_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] *= x;
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
-(
-	typename base<vT, cT, rT, pT>::class_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] *= x[j][i];
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
-(
-	typename base<vT, cT, rT, pT>::value_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] /= x;
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
-(
-	typename base<vT, cT, rT, pT>::class_type const & x
-)
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		this->value[j][i] /= x[j][i];
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		++this->value[j][i];
-
-	return *this;
-}
-
-template <typename vT, uint cT, uint rT, profile pT>
-typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
-{
-	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
-	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
-
-	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
-		--this->value[j][i];
-
-	return *this;
-}
-
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_half.hpp b/include/gal/opengl/glm/core/type_half.hpp
deleted file mode 100644
index 5f14fbd721..0000000000
--- a/include/gal/opengl/glm/core/type_half.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_half.hpp
-/// @date 2008-08-17 / 2011-09-20
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_half
-#define glm_core_type_half
-
-#include <cstdlib>
-
-namespace glm{
-namespace detail
-{
-	typedef short hdata;
-
-	GLM_FUNC_DECL float toFloat32(hdata value);
-	GLM_FUNC_DECL hdata toFloat16(float const & value);
-
-	class half
-	{
-	public: 
-		// Constructors
-		GLM_FUNC_DECL half();
-		GLM_FUNC_DECL half(half const & s);
-			
-		template <typename U>
-		GLM_FUNC_DECL explicit half(U const & s);
-
-		// Cast
-		//template <typename U>
-		//GLM_FUNC_DECL operator U() const;
-		GLM_FUNC_DECL operator float() const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL half& operator= (half const & s);
-		GLM_FUNC_DECL half& operator+=(half const & s);
-		GLM_FUNC_DECL half& operator-=(half const & s);
-		GLM_FUNC_DECL half& operator*=(half const & s);
-		GLM_FUNC_DECL half& operator/=(half const & s);
-		GLM_FUNC_DECL half& operator++();
-		GLM_FUNC_DECL half& operator--();
-	
-		GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
-
-		GLM_FUNC_DECL hdata _data() const{return data;}
-
-	private:
-		hdata data;
-	};
-
-	GLM_FUNC_DECL half operator+ (half const & s1, half const & s2);
-
-	GLM_FUNC_DECL half operator- (half const & s1, half const & s2);
-
-	GLM_FUNC_DECL half operator* (half const & s1, half const & s2);
-
-	GLM_FUNC_DECL half operator/ (half const & s1, half const & s2);
-
-	// Unary constant operators
-	GLM_FUNC_DECL half operator- (half const & s);
-
-	GLM_FUNC_DECL half operator-- (half const & s, int);
-
-	GLM_FUNC_DECL half operator++ (half const & s, int);
-
-	GLM_FUNC_DECL bool operator==(
-		detail::half const & x, 
-		detail::half const & y);
-
-	GLM_FUNC_DECL bool operator!=(
-		detail::half const & x, 
-		detail::half const & y);
-
-	GLM_FUNC_DECL bool operator<(
-		detail::half const & x, 
-		detail::half const & y);
-
-	GLM_FUNC_DECL bool operator<=(
-		detail::half const & x, 
-		detail::half const & y);
-
-	GLM_FUNC_DECL bool operator>(
-		detail::half const & x, 
-		detail::half const & y);
-
-	GLM_FUNC_DECL bool operator>=(
-		detail::half const & x, 
-		detail::half const & y);
-
-}//namespace detail
-}//namespace glm
-
-#include "type_half.inl"
-
-#endif//glm_core_type_half
diff --git a/include/gal/opengl/glm/core/type_half.inl b/include/gal/opengl/glm/core/type_half.inl
deleted file mode 100644
index 9cd72b3ddf..0000000000
--- a/include/gal/opengl/glm/core/type_half.inl
+++ /dev/null
@@ -1,421 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///
-/// This half implementation is based on OpenEXR which is Copyright (c) 2002, 
-/// Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
-///
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_half.inl
-/// @date 2008-08-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_detail.hpp"
-
-namespace glm{
-namespace detail
-{
-	GLM_FUNC_QUALIFIER float overflow()
-	{
-		volatile float f = 1e10;
-
-		for(int i = 0; i < 10; ++i)	
-			f *= f;             // this will overflow before
-								// the for­loop terminates
-		return f;
-	}
-
-	GLM_FUNC_QUALIFIER float toFloat32(hdata value)
-	{
-		int s = (value >> 15) & 0x00000001;
-		int e = (value >> 10) & 0x0000001f;
-		int m =  value        & 0x000003ff;
-
-		if(e == 0)
-		{
-			if(m == 0)
-			{
-				//
-				// Plus or minus zero
-				//
-
-				detail::uif result;
-				result.i = (unsigned int)(s << 31);
-				return result.f;
-			}
-			else
-			{
-				//
-				// Denormalized number -- renormalize it
-				//
-
-				while(!(m & 0x00000400))
-				{
-					m <<= 1;
-					e -=  1;
-				}
-
-				e += 1;
-				m &= ~0x00000400;
-			}
-		}
-		else if(e == 31)
-		{
-			if(m == 0)
-			{
-				//
-				// Positive or negative infinity
-				//
-
-				uif result;
-				result.i = (unsigned int)((s << 31) | 0x7f800000);
-				return result.f;
-			}
-			else
-			{
-				//
-				// Nan -- preserve sign and significand bits
-				//
-
-				uif result;
-				result.i = (unsigned int)((s << 31) | 0x7f800000 | (m << 13));
-				return result.f;
-			}
-		}
-
-		//
-		// Normalized number
-		//
-
-		e = e + (127 - 15);
-		m = m << 13;
-
-		//
-		// Assemble s, e and m.
-		//
-
-		uif Result;
-		Result.i = (unsigned int)((s << 31) | (e << 23) | m);
-		return Result.f;
-	}
-
-	GLM_FUNC_QUALIFIER hdata toFloat16(float const & f)
-	{
-		uif Entry;
-		Entry.f = f;
-		int i = (int)Entry.i;
-
-		//
-		// Our floating point number, f, is represented by the bit
-		// pattern in integer i.  Disassemble that bit pattern into
-		// the sign, s, the exponent, e, and the significand, m.
-		// Shift s into the position where it will go in in the
-		// resulting half number.
-		// Adjust e, accounting for the different exponent bias
-		// of float and half (127 versus 15).
-		//
-
-		int s =  (i >> 16) & 0x00008000;
-		int e = ((i >> 23) & 0x000000ff) - (127 - 15);
-		int m =   i        & 0x007fffff;
-
-		//
-		// Now reassemble s, e and m into a half:
-		//
-
-		if(e <= 0)
-		{
-			if(e < -10)
-			{
-				//
-				// E is less than -10.  The absolute value of f is
-				// less than half_MIN (f may be a small normalized
-				// float, a denormalized float or a zero).
-				//
-				// We convert f to a half zero.
-				//
-
-				return hdata(s);
-			}
-
-			//
-			// E is between -10 and 0.  F is a normalized float,
-			// whose magnitude is less than __half_NRM_MIN.
-			//
-			// We convert f to a denormalized half.
-			// 
-
-			m = (m | 0x00800000) >> (1 - e);
-
-			//
-			// Round to nearest, round "0.5" up.
-			//
-			// Rounding may cause the significand to overflow and make
-			// our number normalized.  Because of the way a half's bits
-			// are laid out, we don't have to treat this case separately;
-			// the code below will handle it correctly.
-			// 
-
-			if(m & 0x00001000) 
-				m += 0x00002000;
-
-			//
-			// Assemble the half from s, e (zero) and m.
-			//
-
-			return hdata(s | (m >> 13));
-		}
-		else if(e == 0xff - (127 - 15))
-		{
-			if(m == 0)
-			{
-				//
-				// F is an infinity; convert f to a half
-				// infinity with the same sign as f.
-				//
-
-				return hdata(s | 0x7c00);
-			}
-			else
-			{
-				//
-				// F is a NAN; we produce a half NAN that preserves
-				// the sign bit and the 10 leftmost bits of the
-				// significand of f, with one exception: If the 10
-				// leftmost bits are all zero, the NAN would turn 
-				// into an infinity, so we have to set at least one
-				// bit in the significand.
-				//
-
-				m >>= 13;
-
-				return hdata(s | 0x7c00 | m | (m == 0));
-			}
-		}
-		else
-		{
-			//
-			// E is greater than zero.  F is a normalized float.
-			// We try to convert f to a normalized half.
-			//
-
-			//
-			// Round to nearest, round "0.5" up
-			//
-
-			if(m &  0x00001000)
-			{
-				m += 0x00002000;
-
-				if(m & 0x00800000)
-				{
-					m =  0;     // overflow in significand,
-					e += 1;     // adjust exponent
-				}
-			}
-
-			//
-			// Handle exponent overflow
-			//
-
-			if (e > 30)
-			{
-				overflow();        // Cause a hardware floating point overflow;
-
-				return hdata(s | 0x7c00);
-				// if this returns, the half becomes an
-			}   // infinity with the same sign as f.
-
-			//
-			// Assemble the half from s, e and m.
-			//
-
-			return hdata(s | (e << 10) | (m >> 13));
-		}
-	}
-
-	GLM_FUNC_QUALIFIER half::half() :
-		data(0)
-	{}
-
-	GLM_FUNC_QUALIFIER half::half(half const & s) :
-		data(s.data)
-	{}
-
-	template <typename U>
-	GLM_FUNC_QUALIFIER half::half(U const & s) :
-		data(toFloat16(float(s)))
-	{}
-/*
-	template <typename U>
-	GLM_FUNC_QUALIFIER half::operator U() const
-	{
-		return static_cast<U>(toFloat32(this->data));
-	}
-*/
-
-	GLM_FUNC_QUALIFIER half::operator float() const
-	{
-		return toFloat32(this->data);
-	}
-
-	// Unary updatable operators
-	GLM_FUNC_QUALIFIER half& half::operator= (half const & s)
-	{
-		data = s.data;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator+=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) + toFloat32(s.data));
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator-=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) - toFloat32(s.data));
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator*=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) * toFloat32(s.data));		
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator/=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) / toFloat32(s.data));
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator++()
-	{
-		float Casted = toFloat32(data);
-		this->data = toFloat16(++Casted);
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator--()
-	{
-		float Casted = toFloat32(data);
-		this->data = toFloat16(--Casted);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	GLM_FUNC_QUALIFIER detail::half operator+ (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) + float(s2));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator- (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) - float(s2));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator* (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) * float(s2));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator/ (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) / float(s2));
-	}
-
-	// Unary constant operators
-	GLM_FUNC_QUALIFIER detail::half operator- (detail::half const & s)
-	{
-		return detail::half(-float(s));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator-- (detail::half const & s, int)
-	{
-		return detail::half(float(s) - 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator++ (detail::half const & s, int)
-	{
-		return detail::half(float(s) + 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return x._data() == y._data();
-	}
-
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return x._data() != y._data();
-	}
-
-	GLM_FUNC_QUALIFIER bool operator<
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) < float(y);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator<=
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) <= float(y);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator>
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) > float(y);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator>=
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) >= float(y);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/type_int.hpp b/include/gal/opengl/glm/core/type_int.hpp
deleted file mode 100644
index c7de0c5a1f..0000000000
--- a/include/gal/opengl/glm/core/type_int.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_int.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_int
-#define glm_core_type_int
-
-#include "setup.hpp"
-#include "_detail.hpp"
-
-namespace glm{
-namespace detail
-{
-	typedef signed short			lowp_int_t;
-	typedef signed int				mediump_int_t;
-	typedef sint64					highp_int_t;
-
-	typedef unsigned short			lowp_uint_t;
-	typedef unsigned int			mediump_uint_t;
-	typedef uint64					highp_uint_t;
-
-	GLM_DETAIL_IS_INT(signed char);
-	GLM_DETAIL_IS_INT(signed short);
-	GLM_DETAIL_IS_INT(signed int);
-	GLM_DETAIL_IS_INT(signed long);
-
-	GLM_DETAIL_IS_UINT(unsigned char);
-	GLM_DETAIL_IS_UINT(unsigned short);
-	GLM_DETAIL_IS_UINT(unsigned int);
-	GLM_DETAIL_IS_UINT(unsigned long);
-	
-#if(GLM_LANG >= GLM_LANG_CXX0X)
-	GLM_DETAIL_IS_INT(signed long long);
-	GLM_DETAIL_IS_UINT(unsigned long long);
-#else
-	GLM_DETAIL_IS_INT(highp_int_t);
-	GLM_DETAIL_IS_UINT(highp_uint_t);
-#endif
-}//namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// Low precision signed integer. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::lowp_int_t				lowp_int;
-
-	/// Medium precision signed integer. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::mediump_int_t			mediump_int;
-
-	/// High precision signed integer.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::highp_int_t				highp_int;
-
-	/// Low precision unsigned integer. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::lowp_uint_t				lowp_uint;
-
-	/// Medium precision unsigned integer. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::mediump_uint_t			mediump_uint;
-
-	/// High precision unsigned integer. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::highp_uint_t				highp_uint;
-
-#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
-	typedef mediump_int                 int_t;
-#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
-	typedef highp_int					int_t;
-#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
-	typedef mediump_int                 int_t;
-#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
-	typedef lowp_int					int_t;
-#else
-#	error "GLM error: multiple default precision requested for signed interger types"
-#endif
-
-#if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
-	typedef mediump_uint				uint_t;
-#elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
-	typedef highp_uint					uint_t;
-#elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
-	typedef mediump_uint				uint_t;
-#elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
-	typedef lowp_uint					uint_t;
-#else
-#	error "GLM error: multiple default precision requested for unsigned interger types"
-#endif
-
-	/// Unsigned integer type. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
-	typedef uint_t								uint;
-
-	/// @}
-}//namespace glm
-
-#endif//glm_core_type_int
diff --git a/include/gal/opengl/glm/core/type_mat.hpp b/include/gal/opengl/glm/core/type_mat.hpp
deleted file mode 100644
index 1520ad5430..0000000000
--- a/include/gal/opengl/glm/core/type_mat.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat.hpp
-/// @date 2010-01-26 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat
-#define glm_core_type_mat
-
-#include "type_gentype.hpp"
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#endif//glm_core_type_mat
diff --git a/include/gal/opengl/glm/core/type_mat.inl b/include/gal/opengl/glm/core/type_mat.inl
deleted file mode 100644
index 477d17e097..0000000000
--- a/include/gal/opengl/glm/core/type_mat.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/core/type_mat2x2.hpp b/include/gal/opengl/glm/core/type_mat2x2.hpp
deleted file mode 100644
index 432a6b9977..0000000000
--- a/include/gal/opengl/glm/core/type_mat2x2.hpp
+++ /dev/null
@@ -1,314 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core	
-/// @file glm/core/type_mat2x2.hpp
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat2x2
-#define glm_core_type_mat2x2
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat2x2
-	{
-		// Implementation detail
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> col_type;
-		typedef tvec2<T> row_type;
-		typedef tmat2x2<T> type;
-		typedef tmat2x2<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	public:
-		// Implementation detail
-		GLM_FUNC_DECL tmat2x2<T> _inverse() const;
-
-	private:
-		//////////////////////////////////////
-		// Implementation detail
-		col_type value[2];
-
-	public:
-		//////////////////////////////////////
-		// Constructors
-		GLM_FUNC_DECL tmat2x2();
-		GLM_FUNC_DECL tmat2x2(
-			tmat2x2 const & m);
-
-		GLM_FUNC_DECL explicit tmat2x2(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat2x2(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat2x2(
-			value_type const & x1, value_type const & y1, 
-			value_type const & x2, value_type const & y2);
-		GLM_FUNC_DECL explicit tmat2x2(
-			col_type const & v1, 
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x2(
-			U const & x);
-
-		template <typename U, typename V, typename M, typename N> 
-		GLM_FUNC_DECL explicit tmat2x2(
-			U const & x1, V const & y1, 
-			M const & x2, N const & y2);
-			
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tmat2x2(
-			tvec2<U> const & v1, 
-			tvec2<V> const & v2);
-
-		//////////////////////////////////////
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator+=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator-=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator*=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator/=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
-		GLM_FUNC_DECL tmat2x2<T> & operator++();
-		GLM_FUNC_DECL tmat2x2<T> & operator--();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator+ (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator+ (
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator+ (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator- (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator- (
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator- (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator* (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator* (
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat2x2<T>::col_type operator* (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat2x2<T>::row_type operator* (
-		typename tmat2x2<T>::col_type const & v, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator* (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat3x2<T> operator* (
-		tmat2x2<T> const & m1, 
-		tmat3x2<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat4x2<T> operator* (
-		tmat2x2<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator/ (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator/ (
-		typename tmat2x2<T>::value_type const & s,
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat2x2<T>::col_type operator/ (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat2x2<T>::row_type operator/ (
-		typename tmat2x2<T>::col_type const & v, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> operator/ (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> const operator-  (
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> const operator-- (
-		tmat2x2<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x2<T> const operator++ (
-		tmat2x2<T> const & m, 
-		int);
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 2 columns of 2 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<lowp_float>		lowp_mat2;
-
-	/// 2 columns of 2 components matrix of medium precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<mediump_float>	mediump_mat2;
-
-	/// 2 columns of 2 components matrix of high precision floating-point numbers. 
-	/// There is no guarantee on the actual precision. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<highp_float>	highp_mat2;
-
-	/// 2 columns of 2 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
-
-	/// 2 columns of 2 components matrix of medium precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
-
-	/// 2 columns of 2 components matrix of high precision floating-point numbers. 
-	/// There is no guarantee on the actual precision. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<highp_float>	highp_mat2x2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x2.inl"
-#endif
-
-#endif //glm_core_type_mat2x2
diff --git a/include/gal/opengl/glm/core/type_mat2x2.inl b/include/gal/opengl/glm/core/type_mat2x2.inl
deleted file mode 100644
index 9d6e191100..0000000000
--- a/include/gal/opengl/glm/core/type_mat2x2.inl
+++ /dev/null
@@ -1,688 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat2x2.inl
-/// @date 2005-01-16 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x2<T>::size_type tmat2x2<T>::length() const
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::col_size()
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::row_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type &
-	tmat2x2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type const &
-	tmat2x2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2()
-	{
-		this->value[0] = col_type(1, 0);
-		this->value[1] = col_type(0, 1);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero);
-		this->value[1] = col_type(Zero, s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		value_type const & x0, value_type const & y0, 
-		value_type const & x1, value_type const & y1
-	)
-	{
-		this->value[0] = col_type(x0, y0);
-		this->value[1] = col_type(x1, y1);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		col_type const & v0, 
-		col_type const & v1
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat2x2<T>::tmat2x2
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec2<T>(value_type(s), Zero);
-		this->value[1] = tvec2<T>(Zero, value_type(s));
-	}
-	
-	template <typename T> 
-	template <typename X1, typename Y1, typename X2, typename Y2> 
-	GLM_FUNC_DECL tmat2x2<T>::tmat2x2
-	(
-		X1 const & x1, Y1 const & y1, 
-		X2 const & x2, Y2 const & y2
-	)
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1));
-		this->value[1] = col_type(value_type(x2), value_type(y2));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2> 
-	GLM_FUNC_DECL tmat2x2<T>::tmat2x2
-	(
-		tvec2<V1> const & v1, 
-		tvec2<V2> const & v2
-	)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-	}
-
-	//////////////////////////////////////////////////////////////
-	// mat2x2 matrix conversions
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x2<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> tmat2x2<T>::_inverse() const
-	{
-		typename tmat2x2<T>::value_type Determinant = this->value[0][0] * this->value[1][1] - this->value[1][0] * this->value[0][1];
-
-		tmat2x2<T> Inverse(
-			+ this->value[1][1] / Determinant,
-			- this->value[0][1] / Determinant,
-			- this->value[1][0] / Determinant, 
-			+ this->value[0][0] / Determinant);
-		return Inverse;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// mat2x2 operators
-
-	// This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
-	(
-		tmat2x2<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
-	(
-		tmat2x2<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
-	(
-		tmat2x2<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= 
-	(
-		tmat2x2<U> const & m
-	)
-	{
-		return (*this = *this * m);
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= 
-	(
-		tmat2x2<U> const & m
-	)
-	{
-		return (*this = *this / m);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-	{
-		return tmat2x2<T>(
-			m[0] + s,
-			m[1] + s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
-	(
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-	{
-		return tmat2x2<T>(
-			m[0] + s,
-			m[1] + s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x2<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-	{
-		return tmat2x2<T>(
-			m[0] - s,
-			m[1] - s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
-	(
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-	{
-		return tmat2x2<T>(
-			s - m[0],
-			s - m[1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x2<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-	{
-		return tmat2x2<T>(
-			m[0] * s,
-			m[1] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(	
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-	{
-		return tmat2x2<T>(
-			m[0] * s,
-			m[1] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator*
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type const & v
-	)
-	{
-		return detail::tvec2<T>(
-			m[0][0] * v.x + m[1][0] * v.y,
-			m[0][1] * v.x + m[1][1] * v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator*
-	(
-		typename tmat2x2<T>::col_type const & v, 
-		tmat2x2<T> const & m
-	)
-	{
-		return detail::tvec2<T>(
-			v.x * m[0][0] + v.y * m[0][1],
-			v.x * m[1][0] + v.y * m[1][1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator*
-	(
-		tmat2x2<T> const & m1,
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator*
-	(
-		tmat2x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator*
-	(
-		tmat2x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-	{
-		return tmat2x2<T>(
-			m[0] / s,
-			m[1] / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
-	(
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-	{
-		return tmat2x2<T>(
-			s / m[0],
-			s / m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator/ 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type & v
-	)
-	{
-		return m._inverse() * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator/ 
-	(
-		typename tmat2x2<T>::col_type const & v,
-		tmat2x2<T> const & m
-	)
-	{
-		return v * m._inverse();
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return m1 * m2._inverse();
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> const operator- 
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		return tmat2x2<T>(
-			-m[0], 
-			-m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> const operator++ 
-	(
-		tmat2x2<T> const & m, 
-		int
-	) 
-	{
-		return tmat2x2<T>(
-			m[0] + T(1),
-			m[1] + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> const operator-- 
-	(
-		tmat2x2<T> const & m, 
-		int
-	) 
-	{
-		return tmat2x2<T>(
-			m[0] - T(1),
-			m[1] - T(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat2x3.hpp b/include/gal/opengl/glm/core/type_mat2x3.hpp
deleted file mode 100644
index 14f1548bbb..0000000000
--- a/include/gal/opengl/glm/core/type_mat2x3.hpp
+++ /dev/null
@@ -1,258 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat2x3.hpp
-/// @date 2006-10-01 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat2x3
-#define glm_core_type_mat2x3
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat2x3
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> col_type;
-		typedef tvec2<T> row_type;
-		typedef tmat2x3<T> type;
-		typedef tmat3x2<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	private:
-		// Data 
-		col_type value[2];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat2x3();
-		GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
-
-		GLM_FUNC_DECL explicit tmat2x3(
-			ctor);
-		GLM_FUNC_DECL explicit tmat2x3(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat2x3(
-			value_type const & x0, value_type const & y0, value_type const & z0,
-			value_type const & x1, value_type const & y1, value_type const & z1);
-		GLM_FUNC_DECL explicit tmat2x3(
-			col_type const & v0, 
-			col_type const & v1);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x3(
-			U const & x);
-			
-		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> 
-		GLM_FUNC_DECL explicit tmat2x3(
-			X1 const & x1, Y1 const & y1, Z1 const & z1, 
-			X2 const & x2, Y2 const & y2, Z2 const & z2);
-			
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tmat2x3(
-			tvec3<U> const & v1, 
-			tvec3<V> const & v2);
-
-		//////////////////////////////////////
-		// Matrix conversion
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator/= (U s);
-
-		GLM_FUNC_DECL tmat2x3<T> & operator++ ();
-		GLM_FUNC_DECL tmat2x3<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator+ (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator+ (
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator- (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator- (
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator* (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator* (
-		typename tmat2x3<T>::value_type const & s, 
-		tmat2x3<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL typename tmat2x3<T>::col_type operator* (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat2x3<T>::row_type operator* (
-		typename tmat2x3<T>::col_type const & v, 
-		tmat2x3<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat2x3<T> operator* (
-		tmat2x3<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat3x3<T> operator* (
-		tmat2x3<T> const & m1, 
-		tmat3x2<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat4x3<T> operator* (
-		tmat2x3<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator/ (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator/ (
-		typename tmat2x3<T>::value_type const & s,
-		tmat2x3<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> const operator-  (
-		tmat2x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> const operator-- (
-		tmat2x3<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> const operator++ (
-		tmat2x3<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 2 columns of 3 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<lowp_float>		lowp_mat2x3;
-    
-	/// 2 columns of 3 components matrix of medium precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<mediump_float>	mediump_mat2x3;
-    
-	/// 2 columns of 3 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<highp_float>	highp_mat2x3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x3.inl"
-#endif
-
-#endif //glm_core_type_mat2x3
diff --git a/include/gal/opengl/glm/core/type_mat2x3.inl b/include/gal/opengl/glm/core/type_mat2x3.inl
deleted file mode 100644
index b77f4fa0d7..0000000000
--- a/include/gal/opengl/glm/core/type_mat2x3.inl
+++ /dev/null
@@ -1,633 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat2x3.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x3<T>::size_type tmat2x3<T>::length() const
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::col_size()
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::row_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type &
-	tmat2x3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type const &
-	tmat2x3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3()
-	{
-		this->value[0] = col_type(T(1), T(0), T(0));
-		this->value[1] = col_type(T(0), T(1), T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		value_type const & s
-	)
-	{
-		this->value[0] = col_type(s, T(0), T(0));
-		this->value[1] = col_type(T(0), s, T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		value_type const & x0, value_type const & y0, value_type const & z0,
-		value_type const & x1, value_type const & y1, value_type const & z1
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0);
-		this->value[1] = col_type(x1, y1, z1);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		col_type const & v0, 
-		col_type const & v1
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat2x3<T>::tmat2x3
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-		this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, 
-		typename X2, typename Y2, typename Z2> 
-	GLM_FUNC_DECL tmat2x3<T>::tmat2x3
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2
-	)		
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2> 
-	GLM_FUNC_DECL tmat2x3<T>::tmat2x3
-	(
-		tvec3<V1> const & v1, 
-		tvec3<V2> const & v2
-	)		
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-	}
-
-	//////////////////////////////////////
-	// Matrix conversions
-    
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x3<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator= 
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator= 
-	(
-		tmat2x3<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator+=
-	(
-		tmat2x3<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= 
-	(
-		tmat2x3<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator*= 
-	(
-		tmat2x3<U> const & m
-	)
-	{
-		return (*this = tmat2x3<U>(*this * m));
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator+ 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-	{
-		return tmat2x3<T>(
-			m[0] + s,
-			m[1] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator+ 
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator- 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-	{
-		return tmat2x3<T>(
-			m[0] - s,
-			m[1] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator- 
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-	{
-		return tmat2x3<T>(
-			m[0] * s,
-			m[1] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		typename tmat2x3<T>::value_type const & s, 
-		tmat2x3<T> const & m
-	)
-	{
-		return tmat2x3<T>(
-			m[0] * s,
-			m[1] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type operator* 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::row_type const & v)
-	{
-		return typename tmat2x3<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y,
-			m[0][1] * v.x + m[1][1] * v.y,
-			m[0][2] * v.x + m[1][2] * v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::row_type operator* 
-	(
-		typename tmat2x3<T>::col_type const & v, 
-		tmat2x3<T> const & m) 
-	{
-		return typename tmat2x3<T>::row_type(
-			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
-			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat2x3<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		typename tmat2x3<T>::value_type SrcA00 = m1[0][0];
-		typename tmat2x3<T>::value_type SrcA01 = m1[0][1];
-		typename tmat2x3<T>::value_type SrcA02 = m1[0][2];
-		typename tmat2x3<T>::value_type SrcA10 = m1[1][0];
-		typename tmat2x3<T>::value_type SrcA11 = m1[1][1];
-		typename tmat2x3<T>::value_type SrcA12 = m1[1][2];
-
-		typename tmat2x3<T>::value_type SrcB00 = m2[0][0];
-		typename tmat2x3<T>::value_type SrcB01 = m2[0][1];
-		typename tmat2x3<T>::value_type SrcB10 = m2[1][0];
-		typename tmat2x3<T>::value_type SrcB11 = m2[1][1];
-		typename tmat2x3<T>::value_type SrcB20 = m2[2][0];
-		typename tmat2x3<T>::value_type SrcB21 = m2[2][1];
-
-		tmat3x3<T> Result(tmat3x3<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* 
-	(
-		tmat2x3<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return tmat4x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator/ 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-	{
-		return tmat2x3<T>(
-			m[0] / s,
-			m[1] / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator/ 
-	(
-		typename tmat2x3<T>::value_type const & s, 
-		tmat2x3<T> const & m
-	)
-	{
-		return tmat2x3<T>(
-			s / m[0],
-			s / m[1]);
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> const operator- 
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		return tmat2x3<T>(
-			-m[0], 
-			-m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> const operator++ 
-	(
-		tmat2x3<T> const & m, 
-		int
-	) 
-	{
-		return tmat2x3<T>(
-			m[0] + typename tmat2x3<T>::value_type(1),
-			m[1] + typename tmat2x3<T>::value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> const operator-- 
-	(
-		tmat2x3<T> const & m, 
-		int
-	) 
-	{
-		return tmat2x3<T>(
-			m[0] - typename tmat2x3<T>::value_type(1),
-			m[1] - typename tmat2x3<T>::value_type(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat2x4.hpp b/include/gal/opengl/glm/core/type_mat2x4.hpp
deleted file mode 100644
index c3357009cd..0000000000
--- a/include/gal/opengl/glm/core/type_mat2x4.hpp
+++ /dev/null
@@ -1,260 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat2x4.hpp
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat2x4
-#define glm_core_type_mat2x4
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat2x4
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> col_type;
-		typedef tvec2<T> row_type;
-		typedef tmat2x4<T> type;
-		typedef tmat4x2<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	private:
-		// Data 
-		col_type value[2];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat2x4();
-		GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
-
-		GLM_FUNC_DECL explicit tmat2x4(
-			ctor);
-		GLM_FUNC_DECL explicit tmat2x4(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat2x4(
-			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
-		GLM_FUNC_DECL explicit tmat2x4(
-			col_type const & v0, 
-			col_type const & v1);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x4(
-			U const & x);
-			
-		template <
-			typename X1, typename Y1, typename Z1, typename W1, 
-			typename X2, typename Y2, typename Z2, typename W2> 
-		GLM_FUNC_DECL explicit tmat2x4(
-			X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-			X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
-			
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tmat2x4(
-			tvec4<U> const & v1, 
-			tvec4<V> const & v2);
-
-		//////////////////////////////////////
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator/= (U s);
-
-		GLM_FUNC_DECL tmat2x4<T>& operator++ ();
-		GLM_FUNC_DECL tmat2x4<T>& operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator+ (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator+ (
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator- (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator- (
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator* (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator* (
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL typename tmat2x4<T>::col_type operator* (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat2x4<T>::row_type operator* (
-		typename tmat2x4<T>::col_type const & v, 
-		tmat2x4<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T> operator* (
-		tmat2x4<T> const & m1, 
-		tmat4x2<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat2x4<T> operator* (
-		tmat2x4<T> const & m1, 
-		tmat2x2<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat3x4<T> operator* (
-		tmat2x4<T> const & m1, 
-		tmat3x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator/ (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> operator/ (
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> const operator-  (
-		tmat2x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> const operator-- (
-		tmat2x4<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x4<T> const operator++ (
-		tmat2x4<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 2 columns of 4 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<lowp_float>		lowp_mat2x4;
-
-	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<mediump_float>	mediump_mat2x4;
-
-	/// 2 columns of 4 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<highp_float>	highp_mat2x4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x4.inl"
-#endif
-
-#endif //glm_core_type_mat2x4
diff --git a/include/gal/opengl/glm/core/type_mat2x4.inl b/include/gal/opengl/glm/core/type_mat2x4.inl
deleted file mode 100644
index 598bddc304..0000000000
--- a/include/gal/opengl/glm/core/type_mat2x4.inl
+++ /dev/null
@@ -1,652 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat2x4.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x4<T>::size_type tmat2x4<T>::length() const
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::col_size()
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::row_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type &
-	tmat2x4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type const &
-	tmat2x4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4()
-	{
-		value_type const Zero(0);
-		value_type const One(1);
-		this->value[0] = col_type(One, Zero, Zero, Zero);
-		this->value[1] = col_type(Zero, One, Zero, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero, Zero, Zero);
-		this->value[1] = col_type(Zero, s, Zero, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-		value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0, w0);
-		this->value[1] = col_type(x1, y1, z1, w1);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		col_type const & v0, 
-		col_type const & v1
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat2x4<T>::tmat2x4
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
-		this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, typename W1, 
-		typename X2, typename Y2, typename Z2, typename W2> 
-	GLM_FUNC_DECL tmat2x4<T>::tmat2x4
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2 
-	)		
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
-		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2> 
-	GLM_FUNC_DECL tmat2x4<T>::tmat2x4
-	(
-		tvec4<V1> const & v1, 
-		tvec4<V2> const & v2
-	)		
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-	}
-
-	//////////////////////////////////////
-	// Matrix conversions
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x4<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator= 
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator= 
-	(
-		tmat2x4<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= 
-	(
-		tmat2x4<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= 
-	(
-		tmat2x4<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*=
-	(
-		tmat2x4<U> const & m
-	)
-	{
-		return (*this = tmat2x4<T>(*this * m));
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> & tmat2x4<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator+
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-	{
-		return tmat2x4<T>(
-			m[0] + s,
-			m[1] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator+ 
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator- 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-	{
-		return tmat2x4<T>(
-			m[0] - s,
-			m[1] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator- 
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-	{
-		return tmat2x4<T>(
-			m[0] * s,
-			m[1] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator*
-	(
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m
-	)
-	{
-		return tmat2x4<T>(
-			m[0] * s,
-			m[1] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type operator* 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::row_type const & v
-	)
-	{
-		return typename tmat2x4<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y,
-			m[0][1] * v.x + m[1][1] * v.y,
-			m[0][2] * v.x + m[1][2] * v.y,
-			m[0][3] * v.x + m[1][3] * v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::row_type operator* 
-	(
-		typename tmat2x4<T>::col_type const & v, 
-		tmat2x4<T> const & m
-	) 
-	{
-		return typename tmat2x4<T>::row_type(
-			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
-			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat2x4<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		typename tmat2x4<T>::value_type SrcA00 = m1[0][0];
-		typename tmat2x4<T>::value_type SrcA01 = m1[0][1];
-		typename tmat2x4<T>::value_type SrcA02 = m1[0][2];
-		typename tmat2x4<T>::value_type SrcA03 = m1[0][3];
-		typename tmat2x4<T>::value_type SrcA10 = m1[1][0];
-		typename tmat2x4<T>::value_type SrcA11 = m1[1][1];
-		typename tmat2x4<T>::value_type SrcA12 = m1[1][2];
-		typename tmat2x4<T>::value_type SrcA13 = m1[1][3];
-
-		typename tmat2x4<T>::value_type SrcB00 = m2[0][0];
-		typename tmat2x4<T>::value_type SrcB01 = m2[0][1];
-		typename tmat2x4<T>::value_type SrcB10 = m2[1][0];
-		typename tmat2x4<T>::value_type SrcB11 = m2[1][1];
-		typename tmat2x4<T>::value_type SrcB20 = m2[2][0];
-		typename tmat2x4<T>::value_type SrcB21 = m2[2][1];
-		typename tmat2x4<T>::value_type SrcB30 = m2[3][0];
-		typename tmat2x4<T>::value_type SrcB31 = m2[3][1];
-
-		tmat4x4<T> Result(tmat4x4<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
-		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
-		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
-		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
-		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
-		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
-		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
-		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat2x4<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator/ 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-	{
-		return tmat2x4<T>(
-			m[0] / s,
-			m[1] / s);        
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator/ 
-	(
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m
-	)
-	{
-		return tmat2x4<T>(
-			s / m[0],
-			s / m[1]);        
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> const operator- 
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		return tmat2x4<T>(
-			-m[0], 
-			-m[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> const operator++ 
-	(
-		tmat2x4<T> const & m, 
-		int
-	) 
-	{
-		return tmat2x4<T>(
-			m[0] + typename tmat2x4<T>::value_type(1),
-			m[1] + typename tmat2x4<T>::value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> const operator-- 
-	(
-		tmat2x4<T> const & m, 
-		int
-	) 
-	{
-		return tmat2x4<T>(
-			m[0] - typename tmat2x4<T>::value_type(1),
-			m[1] - typename tmat2x4<T>::value_type(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat3x2.hpp b/include/gal/opengl/glm/core/type_mat3x2.hpp
deleted file mode 100644
index 06a3228f09..0000000000
--- a/include/gal/opengl/glm/core/type_mat3x2.hpp
+++ /dev/null
@@ -1,265 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat3x2.hpp
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat3x2
-#define glm_core_type_mat3x2
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat3x2
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> col_type;
-		typedef tvec3<T> row_type;
-		typedef tmat3x2<T> type;
-		typedef tmat2x3<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	private:
-		// Data
-		col_type value[3];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat3x2();
-		GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
-
-		GLM_FUNC_DECL explicit tmat3x2(
-			ctor);
-		GLM_FUNC_DECL explicit tmat3x2(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat3x2(
-			value_type const & x0, value_type const & y0,
-			value_type const & x1, value_type const & y1,
-			value_type const & x2, value_type const & y2);
-		GLM_FUNC_DECL explicit tmat3x2(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x2(
-			U const & x);
-			
-		template 
-		<
-			typename X1, typename Y1, 
-			typename X2, typename Y2, 
-			typename X3, typename Y3
-		> 
-		GLM_FUNC_DECL explicit tmat3x2(
-			X1 const & x1, Y1 const & y1, 
-			X2 const & x2, Y2 const & y2,
-			X3 const & x3, Y3 const & y3);
-			
-		template <typename V1, typename V2, typename V3> 
-		GLM_FUNC_DECL explicit tmat3x2(
-			tvec2<V1> const & v1, 
-			tvec2<V2> const & v2,
-			tvec2<V3> const & v3);
-
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator/= (U s);
-
-		GLM_FUNC_DECL tmat3x2<T> & operator++ ();
-		GLM_FUNC_DECL tmat3x2<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator+ (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator+ (
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator- (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator- (
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator* (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator* (
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL typename tmat3x2<T>::col_type operator* (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat3x2<T>::row_type operator* (
-		typename tmat3x2<T>::col_type const & v,
-		tmat3x2<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat2x2<T> operator* (
-		tmat3x2<T> const & m1, 
-		tmat2x3<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat3x2<T> operator* (
-		tmat3x2<T> const & m1, 
-		tmat3x3<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat4x2<T> operator* (
-		tmat3x2<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator/ (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> operator/ (
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> const operator-  (
-		tmat3x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> const operator-- (
-		tmat3x2<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x2<T> const operator++ (
-		tmat3x2<T> const & m, 
-		int);
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 3 columns of 2 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<lowp_float>		lowp_mat3x2;
-
-	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<mediump_float>	mediump_mat3x2;
-
-	/// 3 columns of 2 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<highp_float>	highp_mat3x2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat3x2.inl"
-#endif
-
-#endif //glm_core_type_mat3x2
diff --git a/include/gal/opengl/glm/core/type_mat3x2.inl b/include/gal/opengl/glm/core/type_mat3x2.inl
deleted file mode 100644
index 7d7e16e64e..0000000000
--- a/include/gal/opengl/glm/core/type_mat3x2.inl
+++ /dev/null
@@ -1,670 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat3x2.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x2<T>::size_type tmat3x2<T>::length() const
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::col_size()
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::row_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type &
-	tmat3x2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type const & 
-	tmat3x2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2()
-	{
-		this->value[0] = col_type(1, 0);
-		this->value[1] = col_type(0, 1);
-		this->value[2] = col_type(0, 0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		value_type const & s
-	)
-	{
-		this->value[0] = col_type(s, 0);
-		this->value[1] = col_type(0, s);
-		this->value[2] = col_type(0, 0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		value_type const & x0, value_type const & y0,
-		value_type const & x1, value_type const & y1,
-		value_type const & x2, value_type const & y2
-	)
-	{
-		this->value[0] = col_type(x0, y0);
-		this->value[1] = col_type(x1, y1);
-		this->value[2] = col_type(x2, y2);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		col_type const & v0, 
-		col_type const & v1, 
-		col_type const & v2
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-		this->value[2] = v2;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat3x2<T>::tmat3x2
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec2<T>(value_type(s), Zero);
-		this->value[1] = tvec2<T>(Zero, value_type(s));
-		this->value[2] = tvec2<T>(Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, 
-		typename X2, typename Y2, 
-		typename X3, typename Y3> 
-	GLM_FUNC_DECL tmat3x2<T>::tmat3x2
-	(
-		X1 const & x1, Y1 const & y1, 
-		X2 const & x2, Y2 const & y2, 
-		X3 const & x3, Y3 const & y3
-	)		
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1));
-		this->value[1] = col_type(value_type(x2), value_type(y2));
-		this->value[2] = col_type(value_type(x3), value_type(y3));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3> 
-	GLM_FUNC_DECL tmat3x2<T>::tmat3x2
-	(
-		tvec2<V1> const & v1, 
-		tvec2<V2> const & v2, 
-		tvec2<V3> const & v3
-	)		
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-		this->value[2] = col_type(v3);
-	}
-
-	//////////////////////////////////////////////////////////////
-	// mat3x2 matrix conversions
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x2<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = col_type(T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator= 
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator= 
-	(
-		tmat3x2<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		this->value[2] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= 
-	(
-		tmat3x2<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		this->value[2] += m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		this->value[2] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= 
-	(
-		tmat3x2<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		this->value[2] -= m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		this->value[2] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= 
-	(
-		tmat3x2<U> const & m
-	)
-	{
-		return (*this = tmat3x2<T>(*this * m));
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> & tmat3x2<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		this->value[2] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		++this->value[2];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		--this->value[2];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator+ 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-	{
-		return tmat3x2<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator+ 
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1],
-			m1[2] + m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator- 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-	{
-		return tmat3x2<T>(
-			m[0] - s,
-			m[1] - s,
-			m[2] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator- 
-	(	
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1],
-			m1[2] - m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-	{
-		return tmat3x2<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m
-	)
-	{
-		return tmat3x2<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s);
-	}
-   
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type operator* 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::row_type const & v)
-	{
-		return typename tmat3x2<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::row_type operator* 
-	(
-		typename tmat3x2<T>::col_type const & v, 
-		tmat3x2<T> const & m) 
-	{
-		return typename tmat3x2<T>::row_type(
-			v.x * m[0][0] + v.y * m[0][1],
-			v.x * m[1][0] + v.y * m[1][1],
-			v.x * m[2][0] + v.y * m[2][1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat3x2<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		const T SrcA00 = m1[0][0];
-		const T SrcA01 = m1[0][1];
-		const T SrcA10 = m1[1][0];
-		const T SrcA11 = m1[1][1];
-		const T SrcA20 = m1[2][0];
-		const T SrcA21 = m1[2][1];
-
-		const T SrcB00 = m2[0][0];
-		const T SrcB01 = m2[0][1];
-		const T SrcB02 = m2[0][2];
-		const T SrcB10 = m2[1][0];
-		const T SrcB11 = m2[1][1];
-		const T SrcB12 = m2[1][2];
-
-		tmat2x2<T> Result(tmat2x2<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat3x2<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator/ 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-	{
-		return tmat3x2<T>(
-			m[0] / s,
-			m[1] / s,
-			m[2] / s);        
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator/ 
-	(
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m
-	)
-	{
-		return tmat3x2<T>(
-			s / m[0],
-			s / m[1],
-			s / m[2]);        
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> const operator- 
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		return tmat3x2<T>(
-			-m[0], 
-			-m[1],
-			-m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> const operator++ 
-	(
-		tmat3x2<T> const & m, 
-		int
-	) 
-	{
-		typename tmat3x2<T>::value_type One(1);
-		return tmat3x2<T>(
-			m[0] + One,
-			m[1] + One,
-			m[2] + One);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> const operator-- 
-	(
-		tmat3x2<T> const & m, 
-		int
-	) 
-	{
-		typename tmat3x2<T>::value_type One(1);
-		return tmat3x2<T>(
-			m[0] - One,
-			m[1] - One,
-			m[2] - One);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat3x3.hpp b/include/gal/opengl/glm/core/type_mat3x3.hpp
deleted file mode 100644
index b2122d8e98..0000000000
--- a/include/gal/opengl/glm/core/type_mat3x3.hpp
+++ /dev/null
@@ -1,318 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat3x3.hpp
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat3x3
-#define glm_core_type_mat3x3
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat3x3
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> col_type;
-		typedef tvec3<T> row_type;
-		typedef tmat3x3<T> type;
-		typedef tmat3x3<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	public:
-		/// Implementation detail
-		/// @cond DETAIL
-		GLM_FUNC_DECL tmat3x3<T> _inverse() const;
-		/// @endcond
-        
-	private:
-		// Data
-		col_type value[3];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat3x3();
-		GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
-
-		GLM_FUNC_DECL explicit tmat3x3(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat3x3(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat3x3(
-			value_type const & x0, value_type const & y0, value_type const & z0,
-			value_type const & x1, value_type const & y1, value_type const & z1,
-			value_type const & x2, value_type const & y2, value_type const & z2);
-		GLM_FUNC_DECL explicit tmat3x3(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x3(
-			U const & x);
-			
-		template 
-		<
-			typename X1, typename Y1, typename Z1, 
-			typename X2, typename Y2, typename Z2, 
-			typename X3, typename Y3, typename Z3
-		> 
-		GLM_FUNC_DECL explicit tmat3x3(
-			X1 const & x1, Y1 const & y1, Z1 const & z1, 
-			X2 const & x2, Y2 const & y2, Z2 const & z2, 
-			X3 const & x3, Y3 const & y3, Z3 const & z3);
-			
-		template <typename V1, typename V2, typename V3> 
-		GLM_FUNC_DECL explicit tmat3x3(
-			tvec3<V1> const & v1, 
-			tvec3<V2> const & v2,
-			tvec3<V3> const & v3);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator/= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
-		GLM_FUNC_DECL tmat3x3<T>& operator++ ();
-		GLM_FUNC_DECL tmat3x3<T>& operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator+ (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator+ (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator+ (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-	    
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator- (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator- (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator- (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator* (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator* (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat3x3<T>::col_type operator* (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat3x3<T>::row_type operator* (
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator* (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat2x3<T> operator* (
-		tmat3x3<T> const & m1, 
-		tmat2x3<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat4x3<T> operator* (
-		tmat3x3<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator/ (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator/ (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat3x3<T>::col_type operator/ (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat3x3<T>::row_type operator/ (
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator/ (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> const operator-  (
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> const operator-- (
-		tmat3x3<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> const operator++ (
-		tmat3x3<T> const & m, 
-		int);
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 3 columns of 3 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<lowp_float>		lowp_mat3;
-	
-	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<mediump_float>	mediump_mat3;
-	
-	/// 3 columns of 3 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<highp_float>	highp_mat3;
-
-	/// 3 columns of 3 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<lowp_float>		lowp_mat3x3;
-
-	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<mediump_float>	mediump_mat3x3;
-
-	/// 3 columns of 3 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<highp_float>	highp_mat3x3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat3x3.inl"
-#endif
-
-#endif //glm_core_type_mat3x3
diff --git a/include/gal/opengl/glm/core/type_mat3x3.inl b/include/gal/opengl/glm/core/type_mat3x3.inl
deleted file mode 100644
index 73731e9e1b..0000000000
--- a/include/gal/opengl/glm/core/type_mat3x3.inl
+++ /dev/null
@@ -1,800 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat3x3.inl
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x3<T>::size_type tmat3x3<T>::length() const
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::row_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type &
-	tmat3x3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type const &
-	tmat3x3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3()
-	{
-		value_type const Zero(0);
-		value_type const One(1);
-		this->value[0] = col_type(One, Zero, Zero);
-		this->value[1] = col_type(Zero, One, Zero);
-		this->value[2] = col_type(Zero, Zero, One);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero, Zero);
-		this->value[1] = col_type(Zero, s, Zero);
-		this->value[2] = col_type(Zero, Zero, s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		value_type const & x0, value_type const & y0, value_type const & z0, 
-		value_type const & x1, value_type const & y1, value_type const & z1,
-		value_type const & x2, value_type const & y2, value_type const & z2
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0);
-		this->value[1] = col_type(x1, y1, z1);
-		this->value[2] = col_type(x2, y2, z2);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		col_type const & v0, 
-		col_type const & v1, 
-		col_type const & v2
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-		this->value[2] = v2;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat3x3<T>::tmat3x3
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-		this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-		this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, 
-		typename X2, typename Y2, typename Z2, 
-		typename X3, typename Y3, typename Z3>  
-	GLM_FUNC_DECL tmat3x3<T>::tmat3x3
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3 
-	)
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-		this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3> 
-	GLM_FUNC_DECL tmat3x3<T>::tmat3x3
-	(
-		tvec3<V1> const & v1, 
-		tvec3<V2> const & v2, 
-		tvec3<V3> const & v3
-	)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-		this->value[2] = col_type(v3);
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Conversions
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x3<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(m[2], value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(m[2], value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
-	(
-		tmat3x3<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		this->value[2] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+=
-	(
-		tmat3x3<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		this->value[2] += m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		this->value[2] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
-	(
-		tmat3x3<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		this->value[2] -= m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		this->value[2] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
-	(
-		tmat3x3<U> const & m
-	)
-	{
-		return (*this = *this * m);
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		this->value[2] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
-	(
-		tmat3x3<U> const & m
-	)
-	{
-		return (*this = *this / m);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		++this->value[2];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		--this->value[2];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> tmat3x3<T>::_inverse() const
-	{
-		T S00 = value[0][0];
-		T S01 = value[0][1];
-		T S02 = value[0][2];
-
-		T S10 = value[1][0];
-		T S11 = value[1][1];
-		T S12 = value[1][2];
-
-		T S20 = value[2][0];
-		T S21 = value[2][1];
-		T S22 = value[2][2];
-/*
-		tmat3x3<T> Inverse(
-			+ (S11 * S22 - S21 * S12),
-			- (S10 * S22 - S20 * S12),
-			+ (S10 * S21 - S20 * S11),
-			- (S01 * S22 - S21 * S02),
-			+ (S00 * S22 - S20 * S02),
-			- (S00 * S21 - S20 * S01),
-			+ (S01 * S12 - S11 * S02),
-			- (S00 * S12 - S10 * S02),
-			+ (S00 * S11 - S10 * S01));
-*/
-		tmat3x3<T> Inverse(
-			S11 * S22 - S21 * S12,
-			S12 * S20 - S22 * S10,
-			S10 * S21 - S20 * S11,
-			S02 * S21 - S01 * S22,
-			S00 * S22 - S02 * S20,
-			S01 * S20 - S00 * S21,
-			S12 * S01 - S11 * S02,
-			S10 * S02 - S12 * S00,
-			S11 * S00 - S10 * S01);
-
-		T Determinant = S00 * (S11 * S22 - S21 * S12)
-						- S10 * (S01 * S22 - S21 * S02)
-						+ S20 * (S01 * S12 - S11 * S02);
-
-		Inverse /= Determinant;
-		return Inverse;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-	{
-		return tmat3x3<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-	{
-		return tmat3x3<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return tmat3x3<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1],
-			m1[2] + m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-	{
-		return tmat3x3<T>(
-			m[0] - s,
-			m[1] - s,
-			m[2] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-	{
-		return tmat3x3<T>(
-			s - m[0],
-			s - m[1],
-			s - m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return tmat3x3<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1],
-			m1[2] - m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-	{
-		return tmat3x3<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-	{
-		return tmat3x3<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator* 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v
-	)
-	{
-		return typename tmat3x3<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
-			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator* 
-	(
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m
-	)
-	{
-		return typename tmat3x3<T>::row_type(
-			m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
-			m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
-			m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
-		typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
-		typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
-		typename tmat3x3<T>::value_type const SrcA10 = m1[1][0];
-		typename tmat3x3<T>::value_type const SrcA11 = m1[1][1];
-		typename tmat3x3<T>::value_type const SrcA12 = m1[1][2];
-		typename tmat3x3<T>::value_type const SrcA20 = m1[2][0];
-		typename tmat3x3<T>::value_type const SrcA21 = m1[2][1];
-		typename tmat3x3<T>::value_type const SrcA22 = m1[2][2];
-
-		typename tmat3x3<T>::value_type const SrcB00 = m2[0][0];
-		typename tmat3x3<T>::value_type const SrcB01 = m2[0][1];
-		typename tmat3x3<T>::value_type const SrcB02 = m2[0][2];
-		typename tmat3x3<T>::value_type const SrcB10 = m2[1][0];
-		typename tmat3x3<T>::value_type const SrcB11 = m2[1][1];
-		typename tmat3x3<T>::value_type const SrcB12 = m2[1][2];
-		typename tmat3x3<T>::value_type const SrcB20 = m2[2][0];
-		typename tmat3x3<T>::value_type const SrcB21 = m2[2][1];
-		typename tmat3x3<T>::value_type const SrcB22 = m2[2][2];
-
-		tmat3x3<T> Result(tmat3x3<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat3x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* 
-	(
-		tmat3x3<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return tmat4x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-	{
-		return tmat3x3<T>(
-			m[0] / s,
-			m[1] / s,
-			m[2] / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-	{
-		return tmat3x3<T>(
-			s / m[0],
-			s / m[1],
-			s / m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator/ 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v
-	)
-	{
-		return m._inverse() * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator/ 
-	(
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m
-	)
-	{
-		return v * m._inverse();
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return m1 * m2._inverse();
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> const operator- 
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		return tmat3x3<T>(
-			-m[0], 
-			-m[1],
-			-m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> const operator++ 
-	(
-		tmat3x3<T> const & m, 
-		int
-	) 
-	{
-		return tmat3x3<T>(
-			m[0] + T(1),
-			m[1] + T(1),
-			m[2] + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> const operator-- 
-	(
-		tmat3x3<T> const & m, 
-		int
-	) 
-	{
-		return tmat3x3<T>(
-			m[0] - T(1),
-			m[1] - T(1),
-			m[2] - T(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat3x4.hpp b/include/gal/opengl/glm/core/type_mat3x4.hpp
deleted file mode 100644
index 8fe31060c1..0000000000
--- a/include/gal/opengl/glm/core/type_mat3x4.hpp
+++ /dev/null
@@ -1,266 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat3x4.hpp
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat3x4
-#define glm_core_type_mat3x4
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat3x4
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> col_type;
-		typedef tvec3<T> row_type;
-		typedef tmat3x4<T> type;
-		typedef tmat4x3<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	private:
-		// Data 
-		col_type value[3];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat3x4();
-		GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
-
-		GLM_FUNC_DECL explicit tmat3x4(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat3x4(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat3x4(
-			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-			value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
-		GLM_FUNC_DECL explicit tmat3x4(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x4(
-            U const & x);
-			
-		template 
-        <
-            typename X1, typename Y1, typename Z1, typename W1, 
-            typename X2, typename Y2, typename Z2, typename W2, 
-            typename X3, typename Y3, typename Z3, typename W3 
-        > 
-		GLM_FUNC_DECL explicit tmat3x4(
-            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-            X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
-			
-		template <typename V1, typename V2, typename V3> 
-		GLM_FUNC_DECL explicit tmat3x4(
-            tvec4<V1> const & v1, 
-            tvec4<V2> const & v2,
-            tvec4<V3> const & v3);
-            
-		// Matrix conversion
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator/= (U s);
-
-		GLM_FUNC_DECL tmat3x4<T> & operator++ ();
-		GLM_FUNC_DECL tmat3x4<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator+ (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-	    
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator+ (
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2);
-	    
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator- (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator- (
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator* (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator* (
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL typename tmat3x4<T>::col_type operator* (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat3x4<T>::row_type operator* (
-		typename tmat3x4<T>::col_type const & v, 
-		tmat3x4<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T> operator* (
-		tmat3x4<T> const & m1, 
-		tmat4x3<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat2x4<T> operator* (
-		tmat3x4<T> const & m1, 
-		tmat2x3<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat3x4<T> operator* (
-		tmat3x4<T> const & m1, 
-		tmat3x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator/ (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> operator/ (
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> const operator-  (
-		tmat3x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> const operator-- (
-		tmat3x4<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x4<T> const operator++ (
-		tmat3x4<T> const & m, 
-		int);
-
-}//namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 3 columns of 4 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<lowp_float>		lowp_mat3x4;
-
-	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<mediump_float>	mediump_mat3x4;
-
-	/// 3 columns of 4 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<highp_float>	highp_mat3x4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat3x4.inl"
-#endif
-
-#endif //glm_core_type_mat3x4
diff --git a/include/gal/opengl/glm/core/type_mat3x4.inl b/include/gal/opengl/glm/core/type_mat3x4.inl
deleted file mode 100644
index be613d0689..0000000000
--- a/include/gal/opengl/glm/core/type_mat3x4.inl
+++ /dev/null
@@ -1,700 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat3x4.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x4<T>::size_type tmat3x4<T>::length() const
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::col_size()
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::row_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type & 
-	tmat3x4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type const & 
-	tmat3x4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4()
-	{
-		this->value[0] = col_type(1, 0, 0, 0);
-		this->value[1] = col_type(0, 1, 0, 0);
-		this->value[2] = col_type(0, 0, 1, 0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero, Zero, Zero);
-		this->value[1] = col_type(Zero, s, Zero, Zero);
-		this->value[2] = col_type(Zero, Zero, s, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-		value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-		value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0, w0);
-		this->value[1] = col_type(x1, y1, z1, w1);
-		this->value[2] = col_type(x2, y2, z2, w2);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		col_type const & v0, 
-		col_type const & v1, 
-		col_type const & v2
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-		this->value[2] = v2;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat3x4<T>::tmat3x4
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
-		this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
-		this->value[2] = tvec4<T>(Zero, Zero, value_type(s), Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, typename W1, 
-		typename X2, typename Y2, typename Z2, typename W2, 
-		typename X3, typename Y3, typename Z3, typename W3>  
-	GLM_FUNC_DECL tmat3x4<T>::tmat3x4
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3  
-	)
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
-		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
-		this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3), value_type(w3));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3> 
-	GLM_FUNC_DECL tmat3x4<T>::tmat3x4
-	(
-		tvec4<V1> const & v1, 
-		tvec4<V2> const & v2, 
-		tvec4<V3> const & v3
-	)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-		this->value[2] = col_type(v3);
-	}
-
-	// Conversion
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x4<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-		this->value[2] = col_type(T(0), T(0), T(1), T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-		this->value[2] = col_type(m[2], T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-		this->value[2] = col_type(T(0), T(0), T(1), T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-		this->value[2] = col_type(m[2], T(0), T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(T(0), T(0), T(1), T(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
-		this->value[2] = col_type(m[2], detail::tvec2<T>(T(1), T(0)));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-		this->value[2] = col_type(m[2], T(0));
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator= 
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator= 
-	(
-		tmat3x4<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		this->value[2] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= 
-	(
-		tmat3x4<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		this->value[2] += m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		this->value[2] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= 
-	(
-		tmat3x4<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		this->value[2] -= m[2];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		this->value[2] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= 
-	(
-		tmat3x4<U> const & m
-	)
-	{
-		return (*this = tmat3x4<T>(*this * m));
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> & tmat3x4<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		this->value[2] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		++this->value[2];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		--this->value[2];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator+ 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-	{
-		return tmat3x4<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator+ 
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1],
-			m1[2] + m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator- 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-	{
-		return tmat3x4<T>(
-			m[0] - s,
-			m[1] - s,
-			m[2] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator- 
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1],
-			m1[2] - m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-	{
-		return tmat3x4<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m
-	)
-	{
-		return tmat3x4<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type operator* 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::row_type const & v
-	)
-	{
-		return typename tmat3x4<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
-			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
-			m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::row_type operator* 
-	(
-		typename tmat3x4<T>::col_type const & v, 
-		tmat3x4<T> const & m
-	)
-	{
-		return typename tmat3x4<T>::row_type(
-			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
-			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
-			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat3x4<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		const T SrcA00 = m1[0][0];
-		const T SrcA01 = m1[0][1];
-		const T SrcA02 = m1[0][2];
-		const T SrcA03 = m1[0][3];
-		const T SrcA10 = m1[1][0];
-		const T SrcA11 = m1[1][1];
-		const T SrcA12 = m1[1][2];
-		const T SrcA13 = m1[1][3];
-		const T SrcA20 = m1[2][0];
-		const T SrcA21 = m1[2][1];
-		const T SrcA22 = m1[2][2];
-		const T SrcA23 = m1[2][3];
-
-		const T SrcB00 = m2[0][0];
-		const T SrcB01 = m2[0][1];
-		const T SrcB02 = m2[0][2];
-		const T SrcB10 = m2[1][0];
-		const T SrcB11 = m2[1][1];
-		const T SrcB12 = m2[1][2];
-		const T SrcB20 = m2[2][0];
-		const T SrcB21 = m2[2][1];
-		const T SrcB22 = m2[2][2];
-		const T SrcB30 = m2[3][0];
-		const T SrcB31 = m2[3][1];
-		const T SrcB32 = m2[3][2];
-
-		tmat4x4<T> Result(tmat4x4<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
-		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
-		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
-		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
-		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
-		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
-		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
-		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat3x4<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator/ 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-	{
-		return tmat3x4<T>(
-			m[0] / s,
-			m[1] / s,
-			m[2] / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator/
-	(
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m
-	)
-	{
-		return tmat3x4<T>(
-			s / m[0],
-			s / m[1],
-			s / m[2]);
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> const operator- 
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		return tmat3x4<T>(
-			-m[0], 
-			-m[1],
-			-m[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> const operator++ 
-	(
-		tmat3x4<T> const & m, 
-		int
-	) 
-	{
-		return tmat3x4<T>(
-			m[0] + T(1),
-			m[1] + T(1),
-			m[2] + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> const operator-- 
-	(
-		tmat3x4<T> const & m, 
-		int
-	) 
-	{
-		return tmat3x4<T>(
-			m[0] - T(1),
-			m[1] - T(1),
-			m[2] - T(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
-	}
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat4x2.hpp b/include/gal/opengl/glm/core/type_mat4x2.hpp
deleted file mode 100644
index 3bc6cc0083..0000000000
--- a/include/gal/opengl/glm/core/type_mat4x2.hpp
+++ /dev/null
@@ -1,270 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat4x2.hpp
-/// @date 2006-10-01 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat4x2
-#define glm_core_type_mat4x2
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat4x2
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> col_type;
-		typedef tvec4<T> row_type;
-		typedef tmat4x2<T> type;
-		typedef tmat2x4<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	private:
-		// Data 
-		col_type value[4];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat4x2();
-		GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
-
-		GLM_FUNC_DECL explicit tmat4x2(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat4x2(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat4x2(
-			value_type const & x0, value_type const & y0,
-			value_type const & x1, value_type const & y1,
-			value_type const & x2, value_type const & y2,
-			value_type const & x3, value_type const & y3);
-		GLM_FUNC_DECL explicit tmat4x2(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2,
-			col_type const & v3);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x2(
-			U const & x);
-			
-		template 
-		<
-			typename X1, typename Y1, 
-			typename X2, typename Y2, 
-			typename X3, typename Y3,
-			typename X4, typename Y4
-		> 
-		GLM_FUNC_DECL explicit tmat4x2(
-			X1 const & x1, Y1 const & y1, 
-			X2 const & x2, Y2 const & y2,
-			X3 const & x3, Y3 const & y3,
-			X4 const & x4, Y4 const & y4);
-			
-		template <typename V1, typename V2, typename V3, typename V4> 
-		GLM_FUNC_DECL explicit tmat4x2(
-			tvec2<V1> const & v1, 
-			tvec2<V2> const & v2,
-			tvec2<V3> const & v3,
-			tvec2<V4> const & v4);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
-			
-		GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator/= (U s);
-
-		GLM_FUNC_DECL tmat4x2<T>& operator++ ();
-		GLM_FUNC_DECL tmat4x2<T>& operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator+ (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator+ (
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator- (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator- (
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator* (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator* (
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL typename tmat4x2<T>::col_type operator* (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat4x2<T>::row_type operator* (
-		typename tmat4x2<T>::col_type const & v, 
-		tmat4x2<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat3x2<T> operator* (
-		tmat4x2<T> const & m1, 
-		tmat3x4<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat4x2<T> operator* (
-		tmat4x2<T> const & m1, 
-		tmat4x4<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat2x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator/ (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> operator/ (
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> const operator-  (
-		tmat4x2<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> const operator-- (
-		tmat4x2<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x2<T> const operator++ (
-		tmat4x2<T> const & m, 
-		int);
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 4 columns of 2 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<lowp_float>		lowp_mat4x2;
-
-	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<mediump_float>	mediump_mat4x2;
-
-	/// 4 columns of 2 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<highp_float>	highp_mat4x2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat4x2.inl"
-#endif
-
-#endif //glm_core_type_mat4x2
diff --git a/include/gal/opengl/glm/core/type_mat4x2.inl b/include/gal/opengl/glm/core/type_mat4x2.inl
deleted file mode 100644
index 3f65e63bcc..0000000000
--- a/include/gal/opengl/glm/core/type_mat4x2.inl
+++ /dev/null
@@ -1,716 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat4x2.inl
-/// @date 2006-10-01 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat4x2<T>::size_type tmat4x2<T>::length() const
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::col_size()
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::row_size()
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type & 
-	tmat4x2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type const & 
-	tmat4x2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2()
-	{
-		value_type const Zero(0);
-		value_type const One(1);
-		this->value[0] = col_type(One, Zero);
-		this->value[1] = col_type(Zero, One);
-		this->value[2] = col_type(Zero, Zero);
-		this->value[3] = col_type(Zero, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-		this->value[3] = m.value[3];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero);
-		this->value[1] = col_type(Zero, s);
-		this->value[2] = col_type(Zero, Zero);
-		this->value[3] = col_type(Zero, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		value_type const & x0, value_type const & y0,
-		value_type const & x1, value_type const & y1,
-		value_type const & x2, value_type const & y2,
-		value_type const & x3, value_type const & y3
-	)
-	{
-		this->value[0] = col_type(x0, y0);
-		this->value[1] = col_type(x1, y1);
-		this->value[2] = col_type(x2, y2);
-		this->value[3] = col_type(x3, y3);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		col_type const & v0, 
-		col_type const & v1, 
-		col_type const & v2,
-		col_type const & v3
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-		this->value[2] = v2;
-		this->value[3] = v3;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat4x2<T>::tmat4x2
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec2<T>(value_type(s), Zero);
-		this->value[1] = tvec2<T>(Zero, value_type(s));
-		this->value[2] = tvec2<T>(Zero, Zero);
-		this->value[3] = tvec2<T>(Zero, Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, 
-		typename X2, typename Y2, 
-		typename X3, typename Y3, 
-		typename X4, typename Y4>  
-	GLM_FUNC_DECL tmat4x2<T>::tmat4x2
-	(
-		X1 const & x1, Y1 const & y1, 
-		X2 const & x2, Y2 const & y2,
-		X3 const & x3, Y3 const & y3,
-		X4 const & x4, Y4 const & y4
-	)		
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1));
-		this->value[1] = col_type(value_type(x2), value_type(y2));
-		this->value[2] = col_type(value_type(x3), value_type(y3));
-		this->value[3] = col_type(value_type(x4), value_type(y4));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3, typename V4> 
-	GLM_FUNC_DECL tmat4x2<T>::tmat4x2
-	(
-		tvec2<V1> const & v1, 
-		tvec2<V2> const & v2, 
-		tvec2<V3> const & v3,
-		tvec2<V4> const & v4
-	)		
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-		this->value[2] = col_type(v3);
-		this->value[3] = col_type(v4);
-	}
-
-	// Conversion
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x2<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(value_type(0));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(value_type(0));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(value_type(0));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(value_type(0));
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator= 
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator= 
-	(
-		tmat4x2<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		this->value[2] += s;
-		this->value[3] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= 
-	(
-		tmat4x2<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		this->value[2] += m[2];
-		this->value[3] += m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		this->value[2] -= s;
-		this->value[3] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= 
-	(
-		tmat4x2<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		this->value[2] -= m[2];
-		this->value[3] -= m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		this->value[2] *= s;
-		this->value[3] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= 
-	(
-		tmat4x2<U> const & m
-	)
-	{
-		return (*this = tmat4x2<T>(*this * m));
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		this->value[2] /= s;
-		this->value[3] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		++this->value[2];
-		++this->value[3];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		--this->value[2];
-		--this->value[3];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator+ 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-	{
-		return tmat4x2<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s,
-			m[3] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator+ 
-	(	
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1],
-			m1[2] + m2[2],
-			m1[3] + m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator- 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-	{
-		return tmat4x2<T>(
-			m[0] - s,
-			m[1] - s,
-			m[2] - s,
-			m[3] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator- 
-	(	
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1],
-			m1[2] - m2[2],
-			m1[3] - m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-	{
-		return tmat4x2<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s,
-			m[3] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m
-	)
-	{
-		return tmat4x2<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s,
-			m[3] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type operator* 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::row_type const & v)
-	{
-		return typename tmat4x2<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
-			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::row_type operator* 
-	(
-		typename tmat4x2<T>::col_type const & v, 
-		tmat4x2<T> const & m) 
-	{
-		return typename tmat4x2<T>::row_type(
-			v.x * m[0][0] + v.y * m[0][1],
-			v.x * m[1][0] + v.y * m[1][1],
-			v.x * m[2][0] + v.y * m[2][1],
-			v.x * m[3][0] + v.y * m[3][1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat4x2<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		T const SrcA00 = m1[0][0];
-		T const SrcA01 = m1[0][1];
-		T const SrcA10 = m1[1][0];
-		T const SrcA11 = m1[1][1];
-		T const SrcA20 = m1[2][0];
-		T const SrcA21 = m1[2][1];
-		T const SrcA30 = m1[3][0];
-		T const SrcA31 = m1[3][1];
-
-		T const SrcB00 = m2[0][0];
-		T const SrcB01 = m2[0][1];
-		T const SrcB02 = m2[0][2];
-		T const SrcB03 = m2[0][3];
-		T const SrcB10 = m2[1][0];
-		T const SrcB11 = m2[1][1];
-		T const SrcB12 = m2[1][2];
-		T const SrcB13 = m2[1][3];
-
-		tmat2x2<T> Result(tmat2x2<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat4x2<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat4x2<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator/ 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-	{
-		return tmat4x2<T>(
-			m[0] / s,
-			m[1] / s,
-			m[2] / s,
-			m[3] / s);        
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator/ 
-	(
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m
-	)
-	{
-		return tmat4x2<T>(
-			s / m[0],
-			s / m[1],
-			s / m[2],
-			s / m[3]);        
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> const operator- 
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		return tmat4x2<T>(
-			-m[0], 
-			-m[1], 
-			-m[2], 
-			-m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> const operator++ 
-	(
-		tmat4x2<T> const & m, 
-		int
-	) 
-	{
-		return tmat4x2<T>(
-			m[0] + typename tmat4x2<T>::value_type(1),
-			m[1] + typename tmat4x2<T>::value_type(1),
-			m[2] + typename tmat4x2<T>::value_type(1),
-			m[3] + typename tmat4x2<T>::value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> const operator-- 
-	(
-		tmat4x2<T> const & m, 
-		int
-	) 
-	{
-		return tmat4x2<T>(
-			m[0] - typename tmat4x2<T>::value_type(1),
-			m[1] - typename tmat4x2<T>::value_type(1),
-			m[2] - typename tmat4x2<T>::value_type(1),
-			m[3] - typename tmat4x2<T>::value_type(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
-	}
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_mat4x3.hpp b/include/gal/opengl/glm/core/type_mat4x3.hpp
deleted file mode 100644
index 8465a83782..0000000000
--- a/include/gal/opengl/glm/core/type_mat4x3.hpp
+++ /dev/null
@@ -1,268 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat4x3.hpp
-/// @date 2006-08-04 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat4x3
-#define glm_core_type_mat4x3
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat4x3
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> col_type;
-		typedef tvec4<T> row_type;
-		typedef tmat4x3<T> type;
-		typedef tmat3x4<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	private:
-		// Data 
-		col_type value[4];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat4x3();
-		GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
-
-		GLM_FUNC_DECL explicit tmat4x3(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat4x3(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat4x3(
-			value_type const & x0, value_type const & y0, value_type const & z0,
-			value_type const & x1, value_type const & y1, value_type const & z1,
-			value_type const & x2, value_type const & y2, value_type const & z2,
-			value_type const & x3, value_type const & y3, value_type const & z3);
-		GLM_FUNC_DECL explicit tmat4x3(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2,
-			col_type const & v3);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x3(
-			U const & x);
-
-		template <
-			typename X1, typename Y1, typename Z1, 
-			typename X2, typename Y2, typename Z2, 
-			typename X3, typename Y3, typename Z3, 
-			typename X4, typename Y4, typename Z4> 
-		GLM_FUNC_DECL explicit tmat4x3(
-			X1 const & x1, Y1 const & y1, Z1 const & z1, 
-			X2 const & x2, Y2 const & y2, Z2 const & z2, 
-			X3 const & x3, Y3 const & y3, Z3 const & z3, 
-			X4 const & x4, Y4 const & y4, Z4 const & z4);
-			
-		template <typename V1, typename V2, typename V3, typename V4> 
-		GLM_FUNC_DECL explicit tmat4x3(
-			tvec3<V1> const & v1, 
-			tvec3<V2> const & v2,
-			tvec3<V3> const & v3,
-			tvec3<V4> const & v4);
-
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
-			
-		GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator+= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator-= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator*= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator/= (U s);
-
-		GLM_FUNC_DECL tmat4x3<T> & operator++ ();
-		GLM_FUNC_DECL tmat4x3<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator+ (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator+ (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator- (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator- (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator* (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator* (
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m);
-
-	template <typename T>
-	GLM_FUNC_DECL typename tmat4x3<T>::col_type operator* (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat4x3<T>::row_type operator* (
-		typename tmat4x3<T>::col_type const & v, 
-		tmat4x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat2x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat3x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat3x4<T> const & m2);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat4x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator/ (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> operator/ (
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> const operator- (
-		tmat4x3<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> const operator-- (
-		tmat4x3<T> const & m, 
-		int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x3<T> const operator++ (
-		tmat4x3<T> const & m, 
-		int);
-}//namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 4 columns of 3 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<lowp_float>		lowp_mat4x3;
-
-	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<mediump_float>	mediump_mat4x3;
-
-	/// 4 columns of 3 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<highp_float>	highp_mat4x3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat4x3.inl"
-#endif //GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_mat4x3
diff --git a/include/gal/opengl/glm/core/type_mat4x3.inl b/include/gal/opengl/glm/core/type_mat4x3.inl
deleted file mode 100644
index 75307a5fd5..0000000000
--- a/include/gal/opengl/glm/core/type_mat4x3.inl
+++ /dev/null
@@ -1,725 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat4x3.inl
-/// @date 2006-04-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat4x3<T>::size_type tmat4x3<T>::length() const
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::col_size()
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::row_size()
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type & 
-	tmat4x3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type const & 
-	tmat4x3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3()
-	{
-		value_type const Zero(0);
-		value_type const One(1);
-		this->value[0] = col_type(One, Zero, Zero);
-		this->value[1] = col_type(Zero, One, Zero);
-		this->value[2] = col_type(Zero, Zero, One);
-		this->value[3] = col_type(Zero, Zero, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-		this->value[3] = m.value[3];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero, Zero);
-		this->value[1] = col_type(Zero, s, Zero);
-		this->value[2] = col_type(Zero, Zero, s);
-		this->value[3] = col_type(Zero, Zero, Zero);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		value_type const & x0, value_type const & y0, value_type const & z0,
-		value_type const & x1, value_type const & y1, value_type const & z1,
-		value_type const & x2, value_type const & y2, value_type const & z2,
-		value_type const & x3, value_type const & y3, value_type const & z3
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0);
-		this->value[1] = col_type(x1, y1, z1);
-		this->value[2] = col_type(x2, y2, z2);
-		this->value[3] = col_type(x3, y3, z3);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		col_type const & v0, 
-		col_type const & v1, 
-		col_type const & v2,
-		col_type const & v3
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-		this->value[2] = v2;
-		this->value[3] = v3;
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat4x3<T>::tmat4x3
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-		this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-		this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
-		this->value[3] = tvec3<T>(Zero, Zero, Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, 
-		typename X2, typename Y2, typename Z2, 
-		typename X3, typename Y3, typename Z3, 
-		typename X4, typename Y4, typename Z4>  
-	GLM_FUNC_DECL tmat4x3<T>::tmat4x3
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3, 
-		X4 const & x4, Y4 const & y4, Z4 const & z4
-	)		
-	{
-		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-		this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
-		this->value[3] = col_type(value_type(x4), value_type(y4), value_type(z4));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3, typename V4> 
-	GLM_FUNC_DECL tmat4x3<T>::tmat4x3
-	(
-		tvec3<V1> const & v1, 
-		tvec3<V2> const & v2, 
-		tvec3<V3> const & v3,
-		tvec3<V4> const & v4
-	)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-		this->value[2] = col_type(v3);
-		this->value[3] = col_type(v4);
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Matrix conversions
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x3<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(m[2], value_type(1));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(m[2], value_type(1));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
-		this->value[3] = col_type(value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(m[2], value_type(1));
-		this->value[3] = col_type(m[3], value_type(0));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(value_type(0));
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator= 
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator= 
-	(
-		tmat4x3<U> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		this->value[2] += s;
-		this->value[3] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= 
-	(
-		tmat4x3<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		this->value[2] += m[2];
-		this->value[3] += m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		this->value[2] -= s;
-		this->value[3] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= 
-	(
-		tmat4x3<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		this->value[2] -= m[2];
-		this->value[3] -= m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		this->value[2] *= s;
-		this->value[3] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= 
-	(
-		tmat4x3<U> const & m
-	)
-	{
-		return (*this = tmat4x3<T>(*this * m));
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		this->value[2] /= s;
-		this->value[3] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		++this->value[2];
-		++this->value[3];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		--this->value[2];
-		--this->value[3];
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Binary operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s)
-	{
-		return tmat4x3<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s,
-			m[3] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2)
-	{
-		return tmat4x3<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1],
-			m1[2] + m2[2],
-			m1[3] + m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s)
-	{
-		return tmat4x3<T>(
-			m[0] - s,
-			m[1] - s,
-			m[2] - s,
-			m[3] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2)
-	{
-		return tmat4x3<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1],
-			m1[2] - m2[2],
-			m1[3] - m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s)
-	{
-		return tmat4x3<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s,
-			m[3] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m)
-	{
-		return tmat4x3<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s,
-			m[3] * s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type operator* 
-	(
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::row_type const & v)
-	{
-		return typename tmat4x3<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
-			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
-			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::row_type operator* 
-	(
-		typename tmat4x3<T>::col_type const & v, 
-		tmat4x3<T> const & m) 
-	{
-		return typename tmat4x3<T>::row_type(
-			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
-			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
-			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
-			v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat4x3<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat4x3<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		T const SrcA00 = m1[0][0];
-		T const SrcA01 = m1[0][1];
-		T const SrcA02 = m1[0][2];
-		T const SrcA10 = m1[1][0];
-		T const SrcA11 = m1[1][1];
-		T const SrcA12 = m1[1][2];
-		T const SrcA20 = m1[2][0];
-		T const SrcA21 = m1[2][1];
-		T const SrcA22 = m1[2][2];
-		T const SrcA30 = m1[3][0];
-		T const SrcA31 = m1[3][1];
-		T const SrcA32 = m1[3][2];
-
-		T const SrcB00 = m2[0][0];
-		T const SrcB01 = m2[0][1];
-		T const SrcB02 = m2[0][2];
-		T const SrcB03 = m2[0][3];
-		T const SrcB10 = m2[1][0];
-		T const SrcB11 = m2[1][1];
-		T const SrcB12 = m2[1][2];
-		T const SrcB13 = m2[1][3];
-		T const SrcB20 = m2[2][0];
-		T const SrcB21 = m2[2][1];
-		T const SrcB22 = m2[2][2];
-		T const SrcB23 = m2[2][3];
-
-		tmat3x3<T> Result(tmat3x3<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* 
-	(
-		tmat4x3<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return tmat4x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator/ 
-	(
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s
-	)
-	{
-		return tmat4x3<T>(
-			m[0] / s,
-			m[1] / s,
-			m[2] / s,
-			m[3] / s);        
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator/ 
-	(
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m
-	)
-	{
-		return tmat4x3<T>(
-			s / m[0],
-			s / m[1],
-			s / m[2],
-			s / m[3]);        
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> const operator- 
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		return tmat4x3<T>(
-			-m[0], 
-			-m[1],
-			-m[2],
-			-m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> const operator++ 
-	(
-		tmat4x3<T> const & m, 
-		int
-	) 
-	{
-		return tmat4x3<T>(
-			m[0] + T(1),
-			m[1] + T(1),
-			m[2] + T(1),
-			m[3] + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> const operator-- 
-	(
-		tmat4x3<T> const & m, 
-		int
-	) 
-	{
-		return tmat4x3<T>(
-			m[0] - T(1),
-			m[1] - T(1),
-			m[2] - T(1),
-			m[3] - T(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
-	}
-} //namespace detail
-} //namespace glm
-
diff --git a/include/gal/opengl/glm/core/type_mat4x4.hpp b/include/gal/opengl/glm/core/type_mat4x4.hpp
deleted file mode 100644
index 85696b9a5f..0000000000
--- a/include/gal/opengl/glm/core/type_mat4x4.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat4x4.hpp
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat4x4
-#define glm_core_type_mat4x4
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	template <typename T> 
-	struct tmat4x4
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> col_type;
-		typedef tvec4<T> row_type;
-		typedef tmat4x4<T> type;
-		typedef tmat4x4<T> transpose_type;
-
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-	public:
-		/// Implementation detail
-		/// @cond DETAIL
-		GLM_FUNC_DECL tmat4x4<T> _inverse() const;
-		/// @endcond
-
-	private:
-		// Data 
-		col_type value[4];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat4x4();
-		GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
-
-		GLM_FUNC_DECL explicit tmat4x4(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat4x4(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat4x4(
-			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-			value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
-			value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
-		GLM_FUNC_DECL explicit tmat4x4(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2,
-			col_type const & v3);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x4(
-			U const & x);
-			
-		template <
-			typename X1, typename Y1, typename Z1, typename W1, 
-			typename X2, typename Y2, typename Z2, typename W2, 
-			typename X3, typename Y3, typename Z3, typename W3, 
-			typename X4, typename Y4, typename Z4, typename W4> 
-		GLM_FUNC_DECL explicit tmat4x4(
-			X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-			X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-			X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3, 
-			X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
-			
-		template <typename V1, typename V2, typename V3, typename V4> 
-		GLM_FUNC_DECL explicit tmat4x4(
-			tvec4<V1> const & v1, 
-			tvec4<V2> const & v2,
-			tvec4<V3> const & v3,
-			tvec4<V4> const & v4);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<T> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator+= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator-= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator*= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator/= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
-		GLM_FUNC_DECL tmat4x4<T> & operator++ ();
-		GLM_FUNC_DECL tmat4x4<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator+ (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator+ (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator+ (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-	    
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator- (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator- (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator- (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator* (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator* (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat4x4<T>::col_type operator* (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat4x4<T>::row_type operator* (
-		typename tmat4x4<T>::col_type const & v, 
-		tmat4x4<T> const & m);
-		
-	template <typename T>
-	GLM_FUNC_DECL tmat2x4<T> operator* (
-		tmat4x4<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T>
-	GLM_FUNC_DECL tmat3x4<T> operator* (
-		tmat4x4<T> const & m1, 
-		tmat3x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator* (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator/ (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator/ (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat4x4<T>::col_type operator/ (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v);
-
-	template <typename T> 
-	GLM_FUNC_DECL typename tmat4x4<T>::row_type operator/ (
-		typename tmat4x4<T>::col_type & v, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> operator/ (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> const operator-  (
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> const operator-- (
-		tmat4x4<T> const & m, int);
-
-	template <typename T> 
-	GLM_FUNC_DECL tmat4x4<T> const operator++ (
-		tmat4x4<T> const & m, int);
-
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 4 columns of 4 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<lowp_float>		lowp_mat4;
-
-	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<mediump_float>	mediump_mat4;
-
-	/// 4 columns of 4 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<highp_float>	highp_mat4;
-
-	/// 4 columns of 4 components matrix of low precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<lowp_float>		lowp_mat4x4;
-
-	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<mediump_float>	mediump_mat4x4;
-
-	/// 4 columns of 4 components matrix of high precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<highp_float>	highp_mat4x4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat4x4.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_mat4x4
diff --git a/include/gal/opengl/glm/core/type_mat4x4.inl b/include/gal/opengl/glm/core/type_mat4x4.inl
deleted file mode 100644
index 29f80d8eb2..0000000000
--- a/include/gal/opengl/glm/core/type_mat4x4.inl
+++ /dev/null
@@ -1,893 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_mat4x4.inl
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat4x4<T>::size_type tmat4x4<T>::length() const
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::col_size()
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::row_size()
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type & 
-	tmat4x4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type const & 
-	tmat4x4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Constructors
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4()
-	{
-		value_type Zero(0);
-		value_type One(1);
-		this->value[0] = col_type(One, Zero, Zero, Zero);
-		this->value[1] = col_type(Zero, One, Zero, Zero);
-		this->value[2] = col_type(Zero, Zero, One, Zero);
-		this->value[3] = col_type(Zero, Zero, Zero, One);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-		this->value[3] = m.value[3];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		ctor
-	)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		value_type const & s
-	)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(s, Zero, Zero, Zero);
-		this->value[1] = col_type(Zero, s, Zero, Zero);
-		this->value[2] = col_type(Zero, Zero, s, Zero);
-		this->value[3] = col_type(Zero, Zero, Zero, s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-		value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-		value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
-		value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0, w0);
-		this->value[1] = col_type(x1, y1, z1, w1);
-		this->value[2] = col_type(x2, y2, z2, w2);
-		this->value[3] = col_type(x3, y3, z3, w3);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		col_type const & v0, 
-		col_type const & v1, 
-		col_type const & v2,
-		col_type const & v3
-	)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-		this->value[2] = v2;
-		this->value[3] = v3;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x4<U> const & m
-	)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(m[2]);
-		this->value[3] = col_type(m[3]);
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat4x4<T>::tmat4x4
-	(
-		U const & s
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<U>::is_float || std::numeric_limits<U>::is_integer, "*mat4x4 constructor only takes float and integer types");
-
-		value_type const Zero(0);
-		this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
-		this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
-		this->value[2] = tvec4<T>(Zero, Zero, value_type(s), Zero);
-		this->value[3] = tvec4<T>(Zero, Zero, Zero, value_type(s));
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, typename W1, 
-		typename X2, typename Y2, typename Z2, typename W2, 
-		typename X3, typename Y3, typename Z3, typename W3, 
-		typename X4, typename Y4, typename Z4, typename W4>  
-	GLM_FUNC_DECL tmat4x4<T>::tmat4x4
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3, 
-		X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<X1>::is_float || std::numeric_limits<X1>::is_integer, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y1>::is_float || std::numeric_limits<Y1>::is_integer, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z1>::is_float || std::numeric_limits<Z1>::is_integer, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W1>::is_float || std::numeric_limits<W1>::is_integer, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
-
-		GLM_STATIC_ASSERT(detail::type<X2>::is_float || std::numeric_limits<X2>::is_integer, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y2>::is_float || std::numeric_limits<Y2>::is_integer, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z2>::is_float || std::numeric_limits<Z2>::is_integer, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W2>::is_float || std::numeric_limits<W2>::is_integer, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid.");
-
-		GLM_STATIC_ASSERT(detail::type<X3>::is_float || std::numeric_limits<X3>::is_integer, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y3>::is_float || std::numeric_limits<Y3>::is_integer, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z3>::is_float || std::numeric_limits<Z3>::is_integer, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W3>::is_float || std::numeric_limits<W3>::is_integer, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid.");
-
-		GLM_STATIC_ASSERT(detail::type<X4>::is_float || std::numeric_limits<X4>::is_integer, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y4>::is_float || std::numeric_limits<Y4>::is_integer, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z4>::is_float || std::numeric_limits<Z4>::is_integer, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W4>::is_float || std::numeric_limits<W4>::is_integer, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
-
-		this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
-		this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
-		this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3), value_type(w3));
-		this->value[3] = col_type(value_type(x4), value_type(y4), value_type(z4), value_type(w4));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3, typename V4> 
-	GLM_FUNC_DECL tmat4x4<T>::tmat4x4
-	(
-		tvec4<V1> const & v1, 
-		tvec4<V2> const & v2, 
-		tvec4<V3> const & v3,
-		tvec4<V4> const & v4
-	)		
-	{
-		GLM_STATIC_ASSERT(detail::type<V1>::is_float || std::numeric_limits<V1>::is_integer, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<V2>::is_float || std::numeric_limits<V2>::is_integer, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<V3>::is_float || std::numeric_limits<V3>::is_integer, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<V4>::is_float || std::numeric_limits<V4>::is_integer, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
-
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-		this->value[2] = col_type(v3);
-		this->value[3] = col_type(v4);
-	}
-
-	//////////////////////////////////////
-	// Matrix convertion constructors
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat2x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-		this->value[2] = col_type(value_type(0));
-		this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(m[2], value_type(0));
-		this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat2x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], value_type(0));
-		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(value_type(0));
-		this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat3x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-		this->value[2] = col_type(m[2], detail::tvec2<T>(0));
-		this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat2x4<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = col_type(T(0));
-		this->value[3] = col_type(T(0), T(0), T(0), T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x2<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-		this->value[2] = col_type(T(0));
-		this->value[3] = col_type(T(0), T(0), T(0), T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat3x4<T> const & m
-	)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = col_type(T(0), T(0), T(0), T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x3<T> const & m
-	)
-	{
-		this->value[0] = col_type(m[0], T(0));
-		this->value[1] = col_type(m[1], T(0));
-		this->value[2] = col_type(m[2], T(0));
-		this->value[3] = col_type(m[3], T(1));
-	}
-
-	//////////////////////////////////////////////////////////////
-	// Operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator= 
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		//memcpy could be faster
-		//memcpy(&this->value, &m.value, 16 * sizeof(valType));
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator= 
-	(
-		tmat4x4<U> const & m
-	)
-	{
-		//memcpy could be faster
-		//memcpy(&this->value, &m.value, 16 * sizeof(valType));
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		this->value[2] = m[2];
-		this->value[3] = m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= (U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		this->value[2] += s;
-		this->value[3] += s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= 
-	(
-		tmat4x4<U> const & m
-	)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		this->value[2] += m[2];
-		this->value[3] += m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= (U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		this->value[2] -= s;
-		this->value[3] -= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= 
-	(
-		tmat4x4<U> const & m
-	)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		this->value[2] -= m[2];
-		this->value[3] -= m[3];
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= (U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		this->value[2] *= s;
-		this->value[3] *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= 
-	(
-		tmat4x4<U> const & m
-	)
-	{
-		return (*this = *this * m);
-	}
-
-	template <typename T> 
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= (U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		this->value[2] /= s;
-		this->value[3] /= s;
-		return *this;
-	}
-
-	template <typename T> 
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= 
-	(
-		tmat4x4<U> const & m
-	)
-	{
-		return (*this = *this / m);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator++ ()
-	{
-		++this->value[0];
-		++this->value[1];
-		++this->value[2];
-		++this->value[3];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-- ()
-	{
-		--this->value[0];
-		--this->value[1];
-		--this->value[2];
-		--this->value[3];
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> tmat4x4<T>::_inverse() const
-	{
-		// Calculate all mat2 determinants
-		value_type SubFactor00 = this->value[2][2] * this->value[3][3] - this->value[3][2] * this->value[2][3];
-		value_type SubFactor01 = this->value[2][1] * this->value[3][3] - this->value[3][1] * this->value[2][3];
-		value_type SubFactor02 = this->value[2][1] * this->value[3][2] - this->value[3][1] * this->value[2][2];
-		value_type SubFactor03 = this->value[2][0] * this->value[3][3] - this->value[3][0] * this->value[2][3];
-		value_type SubFactor04 = this->value[2][0] * this->value[3][2] - this->value[3][0] * this->value[2][2];
-		value_type SubFactor05 = this->value[2][0] * this->value[3][1] - this->value[3][0] * this->value[2][1];
-		value_type SubFactor06 = this->value[1][2] * this->value[3][3] - this->value[3][2] * this->value[1][3];
-		value_type SubFactor07 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
-		value_type SubFactor08 = this->value[1][1] * this->value[3][2] - this->value[3][1] * this->value[1][2];
-		value_type SubFactor09 = this->value[1][0] * this->value[3][3] - this->value[3][0] * this->value[1][3];
-		value_type SubFactor10 = this->value[1][0] * this->value[3][2] - this->value[3][0] * this->value[1][2];
-		value_type SubFactor11 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
-		value_type SubFactor12 = this->value[1][0] * this->value[3][1] - this->value[3][0] * this->value[1][1];
-		value_type SubFactor13 = this->value[1][2] * this->value[2][3] - this->value[2][2] * this->value[1][3];
-		value_type SubFactor14 = this->value[1][1] * this->value[2][3] - this->value[2][1] * this->value[1][3];
-		value_type SubFactor15 = this->value[1][1] * this->value[2][2] - this->value[2][1] * this->value[1][2];
-		value_type SubFactor16 = this->value[1][0] * this->value[2][3] - this->value[2][0] * this->value[1][3];
-		value_type SubFactor17 = this->value[1][0] * this->value[2][2] - this->value[2][0] * this->value[1][2];
-		value_type SubFactor18 = this->value[1][0] * this->value[2][1] - this->value[2][0] * this->value[1][1];
-/*
-		tmat4x4<T> Inverse(
-			+ (this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02),
-			- (this->value[1][0] * SubFactor00 - this->value[1][2] * SubFactor03 + this->value[1][3] * SubFactor04),
-			+ (this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05),
-			- (this->value[1][0] * SubFactor02 - this->value[1][1] * SubFactor04 + this->value[1][2] * SubFactor05),
-
-			- (this->value[0][1] * SubFactor00 - this->value[0][2] * SubFactor01 + this->value[0][3] * SubFactor02),
-			+ (this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04),
-			- (this->value[0][0] * SubFactor01 - this->value[0][1] * SubFactor03 + this->value[0][3] * SubFactor05),
-			+ (this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05),
-
-			+ (this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08),
-			- (this->value[0][0] * SubFactor06 - this->value[0][2] * SubFactor09 + this->value[0][3] * SubFactor10),
-			+ (this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12),
-			- (this->value[0][0] * SubFactor08 - this->value[0][1] * SubFactor10 + this->value[0][2] * SubFactor12),
-
-			- (this->value[0][1] * SubFactor13 - this->value[0][2] * SubFactor14 + this->value[0][3] * SubFactor15),
-			+ (this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17),
-			- (this->value[0][0] * SubFactor14 - this->value[0][1] * SubFactor16 + this->value[0][3] * SubFactor18),
-			+ (this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18));
-*/
-		tmat4x4<T> Inverse(
-			+ this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02,
-			- this->value[1][0] * SubFactor00 + this->value[1][2] * SubFactor03 - this->value[1][3] * SubFactor04,
-			+ this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05,
-			- this->value[1][0] * SubFactor02 + this->value[1][1] * SubFactor04 - this->value[1][2] * SubFactor05,
-
-			- this->value[0][1] * SubFactor00 + this->value[0][2] * SubFactor01 - this->value[0][3] * SubFactor02,
-			+ this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04,
-			- this->value[0][0] * SubFactor01 + this->value[0][1] * SubFactor03 - this->value[0][3] * SubFactor05,
-			+ this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05,
-
-			+ this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08,
-			- this->value[0][0] * SubFactor06 + this->value[0][2] * SubFactor09 - this->value[0][3] * SubFactor10,
-			+ this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12,
-			- this->value[0][0] * SubFactor08 + this->value[0][1] * SubFactor10 - this->value[0][2] * SubFactor12,
-
-			- this->value[0][1] * SubFactor13 + this->value[0][2] * SubFactor14 - this->value[0][3] * SubFactor15,
-			+ this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17,
-			- this->value[0][0] * SubFactor14 + this->value[0][1] * SubFactor16 - this->value[0][3] * SubFactor18,
-			+ this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18);
-
-		value_type Determinant = 
-			+ this->value[0][0] * Inverse[0][0] 
-			+ this->value[0][1] * Inverse[1][0] 
-			+ this->value[0][2] * Inverse[2][0] 
-			+ this->value[0][3] * Inverse[3][0];
-
-		Inverse /= Determinant;
-		return Inverse;
-	}
-
-	// Binary operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s
-	)
-	{
-		return tmat4x4<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s,
-			m[3] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-	{
-		return tmat4x4<T>(
-			m[0] + s,
-			m[1] + s,
-			m[2] + s,
-			m[3] + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return tmat4x4<T>(
-			m1[0] + m2[0],
-			m1[1] + m2[1],
-			m1[2] + m2[2],
-			m1[3] + m2[3]);
-	}
-    
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s
-	)
-	{
-		return tmat4x4<T>(
-			m[0] - s,
-			m[1] - s,
-			m[2] - s,
-			m[3] - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-	{
-		return tmat4x4<T>(
-			s - m[0],
-			s - m[1],
-			s - m[2],
-			s - m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return tmat4x4<T>(
-			m1[0] - m2[0],
-			m1[1] - m2[1],
-			m1[2] - m2[2],
-			m1[3] - m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const  & s
-	)
-	{
-		return tmat4x4<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s,
-			m[3] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-	{
-		return tmat4x4<T>(
-			m[0] * s,
-			m[1] * s,
-			m[2] * s,
-			m[3] * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator* 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v
-	)
-	{
-		return typename tmat4x4<T>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
-			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
-			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w,
-			m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z + m[3][3] * v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator* 
-	(
-		typename tmat4x4<T>::col_type const & v, 
-		tmat4x4<T> const & m
-	)
-	{
-		return typename tmat4x4<T>::row_type(
-			m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w,
-			m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
-			m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
-			m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat4x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat4x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		typename tmat4x4<T>::col_type const SrcA0 = m1[0];
-		typename tmat4x4<T>::col_type const SrcA1 = m1[1];
-		typename tmat4x4<T>::col_type const SrcA2 = m1[2];
-		typename tmat4x4<T>::col_type const SrcA3 = m1[3];
-
-		typename tmat4x4<T>::col_type const SrcB0 = m2[0];
-		typename tmat4x4<T>::col_type const SrcB1 = m2[1];
-		typename tmat4x4<T>::col_type const SrcB2 = m2[2];
-		typename tmat4x4<T>::col_type const SrcB3 = m2[3];
-
-		tmat4x4<T> Result(tmat4x4<T>::null);
-		Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
-		Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
-		Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
-		Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s
-	)
-	{
-		return tmat4x4<T>(
-			m[0] / s,
-			m[1] / s,
-			m[2] / s,
-			m[3] / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-	{
-		return tmat4x4<T>(
-			s / m[0],
-			s / m[1],
-			s / m[2],
-			s / m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator/ 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v
-	)
-	{
-		return m._inverse() * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator/ 
-	(
-		typename tmat4x4<T>::col_type const & v, 
-		tmat4x4<T> const & m
-	)
-	{
-		return v * m._inverse();
-	}
- 
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return m1 * m2._inverse();
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> const operator- 
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		return tmat4x4<T>(
-			-m[0], 
-			-m[1],
-			-m[2],
-			-m[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> const operator++ 
-	(
-		tmat4x4<T> const & m, 
-		int
-	) 
-	{
-		return tmat4x4<T>(
-			m[0] + typename tmat4x4<T>::value_type(1),
-			m[1] + typename tmat4x4<T>::value_type(1),
-			m[2] + typename tmat4x4<T>::value_type(1),
-			m[3] + typename tmat4x4<T>::value_type(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> const operator-- 
-	(
-		tmat4x4<T> const & m, 
-		int
-	) 
-	{
-		return tmat4x4<T>(
-			m[0] - typename tmat4x4<T>::value_type(1),
-			m[1] - typename tmat4x4<T>::value_type(1),
-			m[2] - typename tmat4x4<T>::value_type(1),
-			m[3] - typename tmat4x4<T>::value_type(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/include/gal/opengl/glm/core/type_size.hpp b/include/gal/opengl/glm/core/type_size.hpp
deleted file mode 100644
index b7a7c3182f..0000000000
--- a/include/gal/opengl/glm/core/type_size.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_size.hpp
-/// @date 2008-10-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_size
-#define glm_core_type_size
-
-#include <cstdlib>
-
-namespace glm{
-namespace detail
-{
-	//typedef std::size_t size_t;
-	typedef int sizeType;
-
-}//namespace detail
-}//namespace glm
-
-#endif//glm_core_type_size
diff --git a/include/gal/opengl/glm/core/type_vec.hpp b/include/gal/opengl/glm/core/type_vec.hpp
deleted file mode 100644
index 60e2b705e2..0000000000
--- a/include/gal/opengl/glm/core/type_vec.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec.hpp
-/// @date 2010-01-26 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_vec
-#define glm_core_type_vec
-
-#include "type_gentype.hpp"
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#endif//glm_core_type_vec
diff --git a/include/gal/opengl/glm/core/type_vec.inl b/include/gal/opengl/glm/core/type_vec.inl
deleted file mode 100644
index ef3f8f429d..0000000000
--- a/include/gal/opengl/glm/core/type_vec.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/core/type_vec1.hpp b/include/gal/opengl/glm/core/type_vec1.hpp
deleted file mode 100644
index 395cc7894a..0000000000
--- a/include/gal/opengl/glm/core/type_vec1.hpp
+++ /dev/null
@@ -1,212 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec1.hpp
-/// @date 2008-08-25 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype1
-#define glm_core_type_gentype1
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref1;
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-
-	template <typename T>
-	struct tvec1
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec1<T> type;
-		typedef tvec1<bool> bool_type;
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-		//////////////////////////////////////
-		// Data
-
-#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-			value_type x;
-#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
-			union {value_type x, r, s;};
-#		endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec1();
-		GLM_FUNC_DECL tvec1(tvec1<T> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec1(
-			ctor);
-		GLM_FUNC_DECL explicit tvec1(
-			value_type const & s);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec1(tref1<T> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(U const & s);
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator= (tvec1<U> const & v);
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator+=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator-=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator*=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator/=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<U> const & v);
-		GLM_FUNC_DECL tvec1<T> & operator++();
-		GLM_FUNC_DECL tvec1<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator%=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator&=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator|=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator^=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator<<=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator>>=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref1<T> swizzle(comp X);
-	};
-
-	template <typename T>
-	struct tref1
-	{
-		GLM_FUNC_DECL tref1(T & x);
-		GLM_FUNC_DECL tref1(tref1<T> const & r);
-		GLM_FUNC_DECL tref1(tvec1<T> const & v);
-
-		GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
-		GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
-
-		T& x;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec1);
-
-	typedef detail::tvec1<highp_float>		highp_vec1_t;
-	typedef detail::tvec1<mediump_float>	mediump_vec1_t;
-	typedef detail::tvec1<lowp_float>		lowp_vec1_t;
-	typedef detail::tvec1<highp_int>		highp_ivec1_t;
-	typedef detail::tvec1<mediump_int>		mediump_ivec1_t;
-	typedef detail::tvec1<lowp_int>			lowp_ivec1_t;
-	typedef detail::tvec1<highp_uint>		highp_uvec1_t;
-	typedef detail::tvec1<mediump_uint>		mediump_uvec1_t;
-	typedef detail::tvec1<lowp_uint>		lowp_uvec1_t;
-
-}//namespace detail
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec1.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype1
diff --git a/include/gal/opengl/glm/core/type_vec1.inl b/include/gal/opengl/glm/core/type_vec1.inl
deleted file mode 100644
index 6b12e03d44..0000000000
--- a/include/gal/opengl/glm/core/type_vec1.inl
+++ /dev/null
@@ -1,928 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec1.inl
-/// @date 2008-08-25 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec1<T>::size_type tvec1<T>::length() const
-	{
-		return 1;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec1<T>::value_type & tvec1<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec1<T>::value_type const & tvec1<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1() :
-		x(value_type(0))
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec1<T> const & v
-	) :
-		x(v.x)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		value_type const & s
-	) :
-		x(s)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tref1<T> const & r
-	) :
-		x(r.x)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		U const & s
-	) :
-		x(value_type(s))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec2<U> const & v
-	) :
-		x(value_type(v.x))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec3<U> const & v
-	) :
-		x(value_type(v.x))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
-	(
-		tvec1<T> const & v
-	)
-	{
-		this->x = v.x;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
-	(
-		U const & s
-	)
-	{
-		this->x += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
-	(
-		U const & s
-	)
-	{
-		this->x -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
-	(
-		U const & s
-	)
-	{
-		this->x *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
-	(	
-		tvec1<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
-	(
-		U const & s
-	)
-	{
-		this->x /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator++()
-	{
-		++this->x;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator--()
-	{
-		--this->x;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return (v1.x == v2.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return (v1.x != v2.x);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
-	(
-		U const & s
-	)
-	{
-		this->x %= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x %= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
-	(
-		U const & s
-	)
-	{
-		this->x &= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x &= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
-	(
-		U const & s
-	)
-	{
-		this->x |= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x |= U(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
-	(
-		U const & s
-	)
-	{
-		this->x ^= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x ^= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
-	(
-		U const & s
-	)
-	{
-		this->x <<= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
-	(
-		U const & s
-	)
-	{
-		this->x >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T 
-	tvec1<T>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> 
-	tvec1<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> 
-	tvec1<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> 
-	tvec1<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref1<T> 
-	tvec1<T>::swizzle
-	(
-		comp x
-	)
-	{
-		return tref1<T>(
-			(*this)[x]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s + v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x + v2.x);
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s - v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x - v2.x);
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator* 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator* 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s * v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator*
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x * v2.x);
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s / v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x / v2.x);
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			-v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator++ 
-	(
-		tvec1<T> const & v, 
-		int
-	)
-	{
-		return tvec1<T>(
-			v.x + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator-- 
-	(
-		tvec1<T> const & v, 
-		int
-	)
-	{
-		return tvec1<T>(
-			v.x - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator% 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x % s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator% 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s % v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator% 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x % v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator& 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x & s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator& 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s & v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator& 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x & v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator| 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x | s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator| 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s | v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator| 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x | v2.x);
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x ^ s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s ^ v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x ^ v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x << s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s << v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x << v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x >> s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s >> v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x >> v2.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator~ 
-	(
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			~v.x);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T>::tref1
-	(
-		T & x
-	) :
-		x(x)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T>::tref1
-	(
-		tref1<T> const & r
-	) :
-		x(r.x)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T>::tref1
-	(
-		tvec1<T> const & v
-	) :
-		x(v.x)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
-	(
-		tref1<T> const & r
-	)
-	{
-		x = r.x;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
-	(
-		tvec1<T> const & v
-	)
-	{
-		x = v.x;
-		return *this;
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/type_vec2.hpp b/include/gal/opengl/glm/core/type_vec2.hpp
deleted file mode 100644
index a858198029..0000000000
--- a/include/gal/opengl/glm/core/type_vec2.hpp
+++ /dev/null
@@ -1,317 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec2.hpp
-/// @date 2008-08-18 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype2
-#define glm_core_type_gentype2
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-
-	template <typename T>
-	struct tvec2
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> type;
-		typedef tvec2<bool> bool_type;
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-		//////////////////////////////////////
-		// Data
-
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-		union 
-		{
-			struct{value_type x, y;};
-			struct{value_type r, g;};
-			struct{value_type s, t;};
-
-#		if(defined(GLM_SWIZZLE))
-			_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y)
-			_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g)
-			_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t)
-			_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y)
-			_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g)
-			_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t)
-			_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y)
-			_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g)
-			_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t)
-#		endif//(defined(GLM_SWIZZLE))
-		};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-		union {value_type x, r, s;};
-		union {value_type y, g, t;};
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, detail::tvec2, detail::tref2)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
-#		endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, detail::tvec2, detail::tref2, x, y)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec2();
-		GLM_FUNC_DECL tvec2(tvec2<T> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec2(
-			ctor);
-		GLM_FUNC_DECL explicit tvec2(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tvec2(
-			value_type const & s1, 
-			value_type const & s2);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec2(tref2<T> const & r);
-
-		template <int E0, int E1>
-		GLM_FUNC_DECL tvec2(const glm::detail::swizzle<2,T,tvec2<T>,E0,E1,-1,-2>& that)
-		{
-			*this = that();
-		}
-
-		//////////////////////////////////////
-		// Convertion constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(
-			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tvec2(
-			U const & x, 
-			V const & y);
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator+=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator-=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator*=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator/=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
-		GLM_FUNC_DECL tvec2<T> & operator++();
-		GLM_FUNC_DECL tvec2<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator%= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator&= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator|= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator^= (U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator<<=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator>>=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-	};
-
-	template <typename T>
-	struct tref2
-	{
-		GLM_FUNC_DECL tref2(T & x, T & y);
-		GLM_FUNC_DECL tref2(tref2<T> const & r);
-		GLM_FUNC_DECL explicit tref2(tvec2<T> const & v);
-
-		GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
-		GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
-
-		GLM_FUNC_DECL tvec2<T> operator() ();
-
-		T & x;
-		T & y;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec2);
-
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 2 components vector of high precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<highp_float>		highp_vec2;
-
-	/// 2 components vector of medium precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<mediump_float>	mediump_vec2;
-
-	/// 2 components vector of low precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<lowp_float>		lowp_vec2;
-
-	/// 2 components vector of high precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<highp_int>		highp_ivec2;
-
-	/// 2 components vector of medium precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<mediump_int>		mediump_ivec2;
-
-	/// 2 components vector of low precision signed integer numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<lowp_int>			lowp_ivec2;
-	
-	/// 2 components vector of high precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<highp_uint>		highp_uvec2;
-
-	/// 2 components vector of medium precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<mediump_uint>		mediump_uvec2;
-
-	/// 2 components vector of low precision unsigned integer numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<lowp_uint>		lowp_uvec2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec2.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype2
diff --git a/include/gal/opengl/glm/core/type_vec2.inl b/include/gal/opengl/glm/core/type_vec2.inl
deleted file mode 100644
index 32e4f9f596..0000000000
--- a/include/gal/opengl/glm/core/type_vec2.inl
+++ /dev/null
@@ -1,998 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_tvec2.inl
-/// @date 2008-08-18 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec2<T>::size_type tvec2<T>::length() const
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type & 
-	tvec2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type const & 
-	tvec2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2() :
-		x(value_type(0)),
-		y(value_type(0))
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec2<T> const & v
-	) :
-		x(v.x),
-		y(v.y)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		value_type const & s
-	) :
-		x(s),
-		y(s)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		value_type const & s1, 
-		value_type const & s2
-	) :
-		x(s1),
-		y(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tref2<T> const & r
-	) :
-		x(r.x),
-		y(r.y)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		U const & x
-	) :
-		x(value_type(x)),
-		y(value_type(x))
-	{}
-
-	template <typename T>
-	template <typename U, typename V> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		U const & a, 
-		V const & b
-	) :
-		x(value_type(a)),
-		y(value_type(b))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec2<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec3<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator= 
-	(
-		tvec2<T> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator= 
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		this->y = T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=(U s)
-	{
-		this->x += T(s);
-		this->y += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		this->y += T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=(U s)
-	{
-		this->x -= T(s);
-		this->y -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		this->y -= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=(U s)
-	{
-		this->x *= T(s);
-		this->y *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		this->y *= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=(U s)
-	{
-		this->x /= T(s);
-		this->y /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		this->y /= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator++()
-	{
-		++this->x;
-		++this->y;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator--()
-	{
-		--this->x;
-		--this->y;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=(U s)
-	{
-		this->x %= T(s);
-		this->y %= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x %= T(v.x);
-		this->y %= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=(U s)
-	{
-		this->x &= T(s);
-		this->y &= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x &= T(v.x);
-		this->y &= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=(U s)
-	{
-		this->x |= T(s);
-		this->y |= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x |= T(v.x);
-		this->y |= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=(U s)
-	{
-		this->x ^= T(s);
-		this->y ^= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x ^= T(v.x);
-		this->y ^= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=(U s)
-	{
-		this->x <<= T(s);
-		this->y <<= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		this->y <<= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=(U s)
-	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		this->y >>= T(v.y);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type tvec2<T>::swizzle
-	(
-		comp x
-	) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref2<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y
-	)
-	{
-		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x + T(s),
-			v.y + T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) + v.x,
-			T(s) + v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x + T(v2.x),
-			v1.y + T(v2.y));
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator-
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x - T(s),
-			v.y - T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator- 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) - v.x,
-			T(s) - v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator- 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x - T(v2.x),
-			v1.y - T(v2.y));
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator* 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x * T(s),
-			v.y * T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator* 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) * v.x,
-			T(s) * v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator*
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x * T(v2.x),
-			v1.y * T(v2.y));
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator/
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x / T(s),
-			v.y / T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator/
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) / v.x,
-			T(s) / v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator/ 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x / T(v2.x),
-			v1.y / T(v2.y));
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator- 
-	(
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			-v.x, 
-			-v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator++ 
-	(
-		tvec2<T> const & v, 
-		int
-	)
-	{
-		return tvec2<T>(
-			v.x + T(1), 
-			v.y + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator-- 
-	(
-		tvec2<T> const & v, 
-		int
-	)
-	{
-		return tvec2<T>(
-			v.x - T(1), 
-			v.y - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator% 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x % T(s),
-			v.y % T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator%
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) % v.x,
-			T(s) % v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator% 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x % T(v2.x),
-			v1.y % T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator& 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x & T(s),
-			v.y & T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator& 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) & v.x,
-			T(s) & v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator& 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x & T(v2.x),
-			v1.y & T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator| 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x | T(s),
-			v.y | T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator| 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) | v.x,
-			T(s) | v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator| 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x | T(v2.x),
-			v1.y | T(v2.y));
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator^ 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x ^ T(s),
-			v.y ^ T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator^ 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) ^ v.x,
-			T(s) ^ v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator^ 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x ^ T(v2.x),
-			v1.y ^ T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator<< 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x << T(s),
-			v.y << T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator<< 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			s << T(v.x),
-			s << T(v.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator<< 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x << T(v2.x),
-			v1.y << T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator>> 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x >> T(s),
-			v.y >> T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator>> 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) >> v.x,
-			T(s) >> v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator>>
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x >> T(v2.x),
-			v1.y >> T(v2.y));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator~ 
-	(
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			~v.x,
-			~v.y);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	tref2<T>::tref2
-	(
-		T & x, 
-		T & y
-	) :
-		x(x),
-		y(y)
-	{}
-
-	template <typename T> 
-	tref2<T>::tref2
-	(
-		tref2<T> const & r
-	) :
-		x(r.x),
-		y(r.y)
-	{}
-
-	template <typename T> 
-	tref2<T>::tref2
-	(
-		tvec2<T> const & v
-	) :
-		x(v.x),
-		y(v.y)
-	{}
-
-	template <typename T> 
-	tref2<T>& tref2<T>::operator= 
-	(
-		tref2<T> const & r
-	)
-	{
-		x = r.x;
-		y = r.y;
-		return *this;
-	}
-
-	template <typename T> 
-	tref2<T>& tref2<T>::operator= 
-	(
-		tvec2<T> const & v
-	)
-	{
-		x = v.x;
-		y = v.y;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> tref2<T>::operator() ()
-	{
-		return tvec2<T>(this->x, this->y);
-	}
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/type_vec3.hpp b/include/gal/opengl/glm/core/type_vec3.hpp
deleted file mode 100644
index ea265ca97a..0000000000
--- a/include/gal/opengl/glm/core/type_vec3.hpp
+++ /dev/null
@@ -1,342 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec3.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype3
-#define glm_core_type_gentype3
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec4;
-
-	template <typename T>
-	struct tvec3
-	{	
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> type;
-		typedef tvec3<bool> bool_type;
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-		//////////////////////////////////////
-		// Data
-
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-		union 
-		{
-			struct{value_type x, y, z;};
-			struct{value_type r, g, b;};
-			struct{value_type s, t, p;};
-
-#		if(defined(GLM_SWIZZLE))
-			_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z)
-			_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b)
-			_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p)
-			_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z)
-			_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b)
-			_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p)
-			_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z)
-			_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b)
-			_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p)
-#		endif//(defined(GLM_SWIZZLE))
-		};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-		union {value_type x, r, s;};
-		union {value_type y, g, t;};
-		union {value_type z, b, p;};
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, detail::tvec3, detail::tref2, detail::tref3)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
-#		endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y, z;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, detail::tvec3, detail::tref2, detail::tref3, x, y, z)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec3();
-		GLM_FUNC_DECL tvec3(tvec3<T> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec3(
-			ctor);
-		GLM_FUNC_DECL explicit tvec3(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tvec3(
-			value_type const & s1, 
-			value_type const & s2, 
-			value_type const & s3);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(
-			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V, typename W> 
-		GLM_FUNC_DECL explicit tvec3(
-			U const & x, 
-			V const & y, 
-			W const & z);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec3(tref3<T> const & r);
-
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(tref2<A> const & v, B const & s);
-
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B> const & v);
-
-		template <int E0, int E1, int E2>
-		GLM_FUNC_DECL tvec3(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & that)
-		{
-			*this = that();
-		}
-
-		template <int E0, int E1>
-		GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s)
-		{
-			*this = tvec3<T>(v(), s);
-		}
-
-		template <int E0, int E1>
-		GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
-		{
-			*this = tvec3<T>(s, v());
-		}
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator+=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator-=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator*=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator/=(U s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
-		GLM_FUNC_DECL tvec3<T> & operator++();
-		GLM_FUNC_DECL tvec3<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator%= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator&= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator|= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator^= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator<<=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator>>=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
-	};
-
-	template <typename T>
-	struct tref3
-	{
-		GLM_FUNC_DECL tref3(T & x, T & y, T & z);
-		GLM_FUNC_DECL tref3(tref3<T> const & r);
-		GLM_FUNC_DECL explicit tref3(tvec3<T> const & v);
-
-		GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
-		GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
-
-		GLM_FUNC_DECL tvec3<T> operator() ();
-
-		T & x;
-		T & y;
-		T & z;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec3);
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 3 components vector of high precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<highp_float>		highp_vec3;
-
-	/// 3 components vector of medium precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<mediump_float>	mediump_vec3;
-
-	/// 3 components vector of low precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<lowp_float>		lowp_vec3;
-
-	/// 3 components vector of high precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<highp_int>		highp_ivec3;
-
-	/// 3 components vector of medium precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<mediump_int>		mediump_ivec3;
-
-	/// 3 components vector of low precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<lowp_int>			lowp_ivec3;
-
-	/// 3 components vector of high precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<highp_uint>		highp_uvec3;
-
-	/// 3 components vector of medium precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<mediump_uint>		mediump_uvec3;
-
-	/// 3 components vector of low precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<lowp_uint>		lowp_uvec3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec3.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype3
diff --git a/include/gal/opengl/glm/core/type_vec3.inl b/include/gal/opengl/glm/core/type_vec3.inl
deleted file mode 100644
index 2279abf5af..0000000000
--- a/include/gal/opengl/glm/core/type_vec3.inl
+++ /dev/null
@@ -1,1122 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_tvec3.inl
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec3<T>::size_type tvec3<T>::length() const
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type & 
-	tvec3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type const & 
-	tvec3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3() :
-		x(value_type(0)),
-		y(value_type(0)),
-		z(value_type(0))
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec3<T> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		value_type const & s
-	) :
-		x(s),
-		y(s),
-		z(s)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		value_type const & s0, 
-		value_type const & s1, 
-		value_type const & s2
-	) :
-		x(s0),
-		y(s1),
-		z(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tref3<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tref2<A> const & v, 
-		B const & s
-	) : 
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		A const & s, 
-		tref2<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y))
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		U const & s
-	) :
-		x(value_type(s)),
-		y(value_type(s)),
-		z(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		A const & x, 
-		B const & y, 
-		C const & z
-	) :
-		x(value_type(x)),
-		y(value_type(y)),
-		z(value_type(z))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec2<A> const & v, 
-		B const & s
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(	
-		A const & s, 
-		tvec2<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec3<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>& tvec3<T>::operator= 
-	(
-		tvec3<T> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>& tvec3<T>::operator= 
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		this->y = T(v.y);
-		this->z = T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=(U s)
-	{
-		this->x += T(s);
-		this->y += T(s);
-		this->z += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		this->y += T(v.y);
-		this->z += T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=(U s)
-	{
-		this->x -= T(s);
-		this->y -= T(s);
-		this->z -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		this->y -= T(v.y);
-		this->z -= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=(U s)
-	{
-		this->x *= T(s);
-		this->y *= T(s);
-		this->z *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		this->y *= T(v.y);
-		this->z *= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=(U s)
-	{
-		this->x /= T(s);
-		this->y /= T(s);
-		this->z /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		this->y /= T(v.y);
-		this->z /= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=(U s)
-	{
-		this->x %= s;
-		this->y %= s;
-		this->z %= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x %= v.x;
-		this->y %= v.y;
-		this->z %= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=(U s)
-	{
-		this->x &= s;
-		this->y &= s;
-		this->z &= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x &= v.x;
-		this->y &= v.y;
-		this->z &= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=(U s)
-	{
-		this->x |= s;
-		this->y |= s;
-		this->z |= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x |= v.x;
-		this->y |= v.y;
-		this->z |= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=(U s)
-	{
-		this->x ^= s;
-		this->y ^= s;
-		this->z ^= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x ^= v.x;
-		this->y ^= v.y;
-		this->z ^= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=(U s)
-	{
-		this->x <<= s;
-		this->y <<= s;
-		this->z <<= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		this->y <<= T(v.y);
-		this->z <<= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=(U s)
-	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		this->z >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		this->y >>= T(v.y);
-		this->z >>= T(v.z);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type 
-	tvec3<T>::swizzle
-	(
-		comp x
-	) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref2<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y
-	)
-	{
-		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref3<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	)
-	{
-		return tref3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator+
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x + T(s),
-			v.y + T(s),
-			v.z + T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator+ 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) + v.x,
-			T(s) + v.y,
-			T(s) + v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator+ 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x + T(v2.x),
-			v1.y + T(v2.y),
-			v1.z + T(v2.z));
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x - T(s),
-			v.y - T(s),
-			v.z - T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) - v.x,
-			T(s) - v.y,
-			T(s) - v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x - T(v2.x),
-			v1.y - T(v2.y),
-			v1.z - T(v2.z));
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator*
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x * T(s),
-			v.y * T(s),
-			v.z * T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator* 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) * v.x,
-			T(s) * v.y,
-			T(s) * v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator* 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x * T(v2.x),
-			v1.y * T(v2.y),
-			v1.z * T(v2.z));
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator/
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x / T(s),
-			v.y / T(s),
-			v.z / T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator/ 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) / v.x,
-			T(s) / v.y,
-			T(s) / v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator/ 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x / T(v2.x),
-			v1.y / T(v2.y),
-			v1.z / T(v2.z));
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			-v.x, 
-			-v.y, 
-			-v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator++ 
-	(
-		tvec3<T> const & v, 
-		int
-	)
-	{
-		return tvec3<T>(
-			v.x + T(1), 
-			v.y + T(1), 
-			v.z + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator-- 
-	(
-		tvec3<T> const & v, 
-		int
-	)
-	{
-		return tvec3<T>(
-			v.x - T(1), 
-			v.y - T(1), 
-			v.z - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator% 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x % T(s),
-			v.y % T(s),
-			v.z % T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator%
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) % v.x,
-			T(s) % v.y,
-			T(s) % v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator% 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x % T(v2.x),
-			v1.y % T(v2.y),
-			v1.z % T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator& 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x & T(s),
-			v.y & T(s),
-			v.z & T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator& 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) & v.x,
-			T(s) & v.y,
-			T(s) & v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator& 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x & T(v2.x),
-			v1.y & T(v2.y),
-			v1.z & T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator| 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x | T(s),
-			v.y | T(s),
-			v.z | T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator| 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) | v.x,
-			T(s) | v.y,
-			T(s) | v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator| 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x | T(v2.x),
-			v1.y | T(v2.y),
-			v1.z | T(v2.z));
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x ^ T(s),
-			v.y ^ T(s),
-			v.z ^ T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) ^ v.x,
-			T(s) ^ v.y,
-			T(s) ^ v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x ^ T(v2.x),
-			v1.y ^ T(v2.y),
-			v1.z ^ T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x << T(s),
-			v.y << T(s),
-			v.z << T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) << v.x,
-			T(s) << v.y,
-			T(s) << v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x << T(v2.x),
-			v1.y << T(v2.y),
-			v1.z << T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x >> T(s),
-			v.y >> T(s),
-			v.z >> T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			s >> T(v.x),
-			s >> T(v.y),
-			s >> T(v.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x >> T(v2.x),
-			v1.y >> T(v2.y),
-			v1.z >> T(v2.z));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator~ 
-	(
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			~v.x,
-			~v.y,
-			~v.z);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3(T & x, T & y, T & z) :
-		x(x),
-		y(y),
-		z(z)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3
-	(
-		tref3<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3
-	(
-		tvec3<T> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T> & tref3<T>::operator=
-	(
-		tref3<T> const & r
-	)
-	{
-		x = r.x;
-		y = r.y;
-		z = r.z;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T> & tref3<T>::operator=
-	(
-		tvec3<T> const & v
-	)
-	{
-		x = v.x;
-		y = v.y;
-		z = v.z;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> tref3<T>::operator() ()
-	{
-		return tvec3<T>(this->x, this->y, this->z);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/core/type_vec4.hpp b/include/gal/opengl/glm/core/type_vec4.hpp
deleted file mode 100644
index d1e1b7111b..0000000000
--- a/include/gal/opengl/glm/core/type_vec4.hpp
+++ /dev/null
@@ -1,399 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_vec4.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype4
-#define glm_core_type_gentype4
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-
-	template <typename T>
-	struct tvec4
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> type;
-		typedef tvec4<bool> bool_type;
-
-		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
-
-		//////////////////////////////////////
-		// Data
-
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-		union 
-		{
-			struct{value_type x, y, z, w;};
-			struct{value_type r, g, b, a;};
-			struct{value_type s, t, p, q;};
-
-#		if(defined(GLM_SWIZZLE))
-			_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z, w)
-			_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b, a)
-			_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p, q)
-			_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z, w)
-			_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b, a)
-			_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p, q)
-			_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z, w)
-			_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b, a)
-			_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p, q)
-#		endif//(defined(GLM_SWIZZLE))
-		};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-		union {value_type x, r, s;};
-		union {value_type y, g, t;};
-		union {value_type z, b, p;};
-		union {value_type w, a, q;};
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
-#		endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y, z, w;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec4();
-		GLM_FUNC_DECL tvec4(type const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec4(
-			ctor);
-		GLM_FUNC_DECL explicit tvec4(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tvec4(
-			value_type const & s0, 
-			value_type const & s1, 
-			value_type const & s2, 
-			value_type const & s3);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec4(
-			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, typename D> 
-		GLM_FUNC_DECL explicit tvec4(
-			A const & x, 
-			B const & y, 
-			C const & z, 
-			D const & w);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
-
-		template <int E0, int E1, int E2, int E3>
-		GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T>, E0, E1, E2, E3> const & that)
-		{
-			*this = that();
-		}
-
-		template <int E0, int E1, int F0, int F1>
-		GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, glm::detail::swizzle<2, T, tvec2<T>, F0, F1, -1, -2> const & u)
-		{
-			*this = tvec4<T>(v(), u());
-		}
-
-		template <int E0, int E1>
-		GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
-		{
-			*this = tvec4<T>(x, y, v());
-		}
-
-		template <int E0, int E1>
-		GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
-		{
-			*this = tvec4<T>(x, v(), w);
-		}
-
-		template <int E0, int E1>
-		GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
-		{
-			*this = tvec4<T>(v(), z, w);
-		}
-
-		template <int E0, int E1, int E2>
-		GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
-		{
-			*this = tvec4<T>(v(), w);
-		}
-
-		template <int E0, int E1, int E2>
-		GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
-		{
-			*this = tvec4<T>(x, v());
-		}
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec4(tref4<T> const & r);
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v, B const & s1, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B> const & v, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tref3<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tref2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tref2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tvec2<B> const & v2);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
-
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator/=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
-		GLM_FUNC_DECL tvec4<T> & operator++();
-		GLM_FUNC_DECL tvec4<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator%= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator&= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator|= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator^= (U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator<<=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator>>=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
-		GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
-	};
-
-	template <typename T>
-	struct tref4
-	{
-		GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
-		GLM_FUNC_DECL tref4(tref4<T> const & r);
-		GLM_FUNC_DECL explicit tref4(tvec4<T> const & v);
-
-		GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
-		GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
-
-		GLM_FUNC_DECL tvec4<T> operator() ();
-
-		T & x;
-		T & y;
-		T & z;
-		T & w;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec4);
-}//namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 4 components vector of high precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	///
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<highp_float>		highp_vec4;
-
-	/// 4 components vector of medium precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<mediump_float>	mediump_vec4;
-
-	/// 4 components vector of low precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<lowp_float>		lowp_vec4;
-
-	/// 4 components vector of high precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<highp_int>		highp_ivec4;
-
-	/// 4 components vector of medium precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<mediump_int>		mediump_ivec4;
-
-	/// 4 components vector of low precision signed integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<lowp_int>			lowp_ivec4;
-
-	/// 4 components vector of high precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<highp_uint>		highp_uvec4;
-
-	/// 4 components vector of medium precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<mediump_uint>		mediump_uvec4;
-
-	/// 4 components vector of low precision unsigned integer numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<lowp_uint>		lowp_uvec4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec4.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype4
diff --git a/include/gal/opengl/glm/core/type_vec4.inl b/include/gal/opengl/glm/core/type_vec4.inl
deleted file mode 100644
index 7f98c1b301..0000000000
--- a/include/gal/opengl/glm/core/type_vec4.inl
+++ /dev/null
@@ -1,1348 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/type_tvec4.inl
-/// @date 2008-08-23 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec4<T>::size_type tvec4<T>::length() const
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type & 
-	tvec4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type const & 
-	tvec4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4() :
-		x(value_type(0)),
-		y(value_type(0)),
-		z(value_type(0)),
-		w(value_type(0))
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		type const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(v.w)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		value_type const & s
-	) :
-		x(s),
-		y(s),
-		z(s),
-		w(s)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		value_type const & s1, 
-		value_type const & s2, 
-		value_type const & s3, 
-		value_type const & s4
-	) :
-		x(s1),
-		y(s2),
-		z(s3),
-		w(s4)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref4<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref2<A> const & v, 
-		B const & s1, 
-		C const & s2
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s1)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		tref2<B> const & v, 
-		C const & s2
-	) :
-		x(value_type(s1)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		B const & s2, 
-		tref2<C> const & v
-	) :
-		x(value_type(s1)),
-		y(value_type(s2)),
-		z(value_type(v.x)),
-		w(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref3<A> const & v, 
-		B const & s
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s, 
-		tref3<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(v.z))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref2<A> const & v1, 
-		tref2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec2<A> const & v1, 
-		tref2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref2<A> const & v1, 
-		tvec2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		U const & x
-	) :
-		x(value_type(x)),
-		y(value_type(x)),
-		z(value_type(x)),
-		w(value_type(x))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C, typename D> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & x, 
-		B const & y, 
-		C const & z, 
-		D const & w
-	) :
-		x(value_type(x)),
-		y(value_type(y)),
-		z(value_type(z)),
-		w(value_type(w))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec2<A> const & v, 
-		B const & s1, 
-		C const & s2
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s1)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		tvec2<B> const & v, 
-		C const & s2
-	) :
-		x(value_type(s1)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		B const & s2, 
-		tvec2<C> const & v
-	) :
-		x(value_type(s1)),
-		y(value_type(s2)),
-		z(value_type(v.x)),
-		w(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec3<A> const & v, 
-		B const & s
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s, 
-		tvec3<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(v.z))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec2<A> const & v1, 
-		tvec2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(v.w))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator= 
-	(
-		tvec4<T> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		this->w = v.w;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator= 
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		this->y = T(v.y);
-		this->z = T(v.z);
-		this->w = T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+= (U s)
-	{
-		this->x += T(s);
-		this->y += T(s);
-		this->z += T(s);
-		this->w += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		this->y += T(v.y);
-		this->z += T(v.z);
-		this->w += T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-= (U s)
-	{
-		this->x -= T(s);
-		this->y -= T(s);
-		this->z -= T(s);
-		this->w -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		this->y -= T(v.y);
-		this->z -= T(v.z);
-		this->w -= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*= (U s)
-	{
-		this->x *= T(s);
-		this->y *= T(s);
-		this->z *= T(s);
-		this->w *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		this->y *= T(v.y);
-		this->z *= T(v.z);
-		this->w *= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/= (U s)
-	{
-		this->x /= T(s);
-		this->y /= T(s);
-		this->z /= T(s);
-		this->w /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		this->y /= T(v.y);
-		this->z /= T(v.z);
-		this->w /= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		++this->w;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		--this->w;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%= (U s)
-	{
-		this->x %= T(s);
-		this->y %= T(s);
-		this->z %= T(s);
-		this->w %= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x %= T(v.x);
-		this->y %= T(v.y);
-		this->z %= T(v.z);
-		this->w %= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&= (U s)
-	{
-		this->x &= T(s);
-		this->y &= T(s);
-		this->z &= T(s);
-		this->w &= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x &= T(v.x);
-		this->y &= T(v.y);
-		this->z &= T(v.z);
-		this->w &= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|= (U s)
-	{
-		this->x |= T(s);
-		this->y |= T(s);
-		this->z |= T(s);
-		this->w |= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x |= T(v.x);
-		this->y |= T(v.y);
-		this->z |= T(v.z);
-		this->w |= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^= (U s)
-	{
-		this->x ^= T(s);
-		this->y ^= T(s);
-		this->z ^= T(s);
-		this->w ^= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x ^= T(v.x);
-		this->y ^= T(v.y);
-		this->z ^= T(v.z);
-		this->w ^= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<= (U s)
-	{
-		this->x <<= T(s);
-		this->y <<= T(s);
-		this->z <<= T(s);
-		this->w <<= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		this->y <<= T(v.y);
-		this->z <<= T(v.z);
-		this->w <<= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>= (U s)
-	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		this->z >>= T(s);
-		this->w >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		this->y >>= T(v.y);
-		this->z >>= T(v.z);
-		this->w >>= T(v.w);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type 
-	tvec4<T>::swizzle
-	(	
-		comp x
-	) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref2<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y
-	)
-	{
-		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref3<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	)
-	{
-		return tref3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref4<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	)
-	{
-		return tref4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x + s,
-			v.y + s,
-			v.z + s,
-			v.w + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s + v.x,
-			s + v.y,
-			s + v.z,
-			s + v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x + v2.x,
-			v1.y + v2.y,
-			v1.z + v2.z,
-			v1.w + v2.w);
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x - s,
-			v.y - s,
-			v.z - s,
-			v.w - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s - v.x,
-			s - v.y,
-			s - v.z,
-			s - v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x - v2.x,
-			v1.y - v2.y,
-			v1.z - v2.z,
-			v1.w - v2.w);
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator* 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x * s,
-			v.y * s,
-			v.z * s,
-			v.w * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator* 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s * v.x,
-			s * v.y,
-			s * v.z,
-			s * v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator*
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x * v2.x,
-			v1.y * v2.y,
-			v1.z * v2.z,
-			v1.w * v2.w);
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x / s,
-			v.y / s,
-			v.z / s,
-			v.w / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s / v.x,
-			s / v.y,
-			s / v.z,
-			s / v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x / v2.x,
-			v1.y / v2.y,
-			v1.z / v2.z,
-			v1.w / v2.w);
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			-v.x, 
-			-v.y, 
-			-v.z, 
-			-v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator++ 
-	(
-		tvec4<T> const & v, 
-		int
-	)
-	{
-		typename tvec4<T>::value_type One(1);
-		return tvec4<T>(
-			v.x + One, 
-			v.y + One, 
-			v.z + One, 
-			v.w + One);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator-- 
-	(
-		tvec4<T> const & v, 
-		int
-	)
-	{
-		typename tvec4<T>::value_type One(1);
-		return tvec4<T>(
-			v.x - One, 
-			v.y - One, 
-			v.z - One, 
-			v.w - One);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator% 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x % s,
-			v.y % s,
-			v.z % s,
-			v.w % s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator% 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s % v.x,
-			s % v.y,
-			s % v.z,
-			s % v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator%
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x % v2.x,
-			v1.y % v2.y,
-			v1.z % v2.z,
-			v1.w % v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator& 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x & s,
-			v.y & s,
-			v.z & s,
-			v.w & s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator& 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s & v.x,
-			s & v.y,
-			s & v.z,
-			s & v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator&
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x & v2.x,
-			v1.y & v2.y,
-			v1.z & v2.z,
-			v1.w & v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator|
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x | s,
-			v.y | s,
-			v.z | s,
-			v.w | s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator|
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s | v.x,
-			s | v.y,
-			s | v.z,
-			s | v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator|
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x | v2.x,
-			v1.y | v2.y,
-			v1.z | v2.z,
-			v1.w | v2.w);
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator^
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x ^ s,
-			v.y ^ s,
-			v.z ^ s,
-			v.w ^ s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator^
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s ^ v.x,
-			s ^ v.y,
-			s ^ v.z,
-			s ^ v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator^
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x ^ v2.x,
-			v1.y ^ v2.y,
-			v1.z ^ v2.z,
-			v1.w ^ v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator<<
-	(
-		tvec4<T> const & v,
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x << s,
-			v.y << s,
-			v.z << s,
-			v.w << s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator<<
-	(
-		typename tvec4<T>::value_type const & s,
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s << v.x,
-			s << v.y,
-			s << v.z,
-			s << v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator<<
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x << v2.x,
-			v1.y << v2.y,
-			v1.z << v2.z,
-			v1.w << v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator>>
-	(
-		tvec4<T> const & v,
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x >> s,
-			v.y >> s,
-			v.z >> s,
-			v.w >> s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator>>
-	(
-		typename tvec4<T>::value_type const & s,
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s >> v.x,
-			s >> v.y,
-			s >> v.z,
-			s >> v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator>>
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x >> v2.x,
-			v1.y >> v2.y,
-			v1.z >> v2.z,
-			v1.w >> v2.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator~
-	(
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			~v.x,
-			~v.y,
-			~v.z,
-			~v.w);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	tref4<T>::tref4
-	(
-		T & x, 
-		T & y, 
-		T & z, 
-		T & w
-	) :
-		x(x),
-		y(y),
-		z(z),
-		w(w)
-	{}
-
-	template <typename T> 
-	tref4<T>::tref4
-	(
-		tref4<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
-	{}
-
-	template <typename T> 
-	tref4<T>::tref4
-	(
-		tvec4<T> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(v.w)
-	{}
-
-	template <typename T> 
-	tref4<T>& tref4<T>::operator= 
-	(
-		tref4<T> const & r
-	)
-	{
-		x = r.x;
-		y = r.y;
-		z = r.z;
-		w = r.w;
-		return *this;
-	}
-
-	template <typename T> 
-	tref4<T>& tref4<T>::operator= 
-	(
-		tvec4<T> const & v
-	)
-	{
-		x = v.x;
-		y = v.y;
-		z = v.z;
-		w = v.w;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> tref4<T>::operator() ()
-	{
-		return tvec4<T>(this->x, this->y, this->z, this->w);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/include/gal/opengl/glm/ext.hpp b/include/gal/opengl/glm/ext.hpp
deleted file mode 100644
index 9ef0c92732..0000000000
--- a/include/gal/opengl/glm/ext.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @file glm/glm.hpp
-/// @date 2009-05-01 / 2011-05-16
-/// @author Christophe Riccio
-///
-/// @ref core (Dependence)
-/// 
-/// @defgroup gtc GTC Extensions (Stable)
-///
-/// @brief Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program.
-/// 
-/// GTC extensions aim to be stable. 
-/// 
-/// Even if it's highly unrecommended, it's possible to include all the extensions at once by
-/// including <glm/ext.hpp>. Otherwise, each extension needs to be included  a specific file.
-/// 
-/// @defgroup gtx GTX Extensions (Experimental)
-/// 
-/// @brief Functions and types that the GLSL specification doesn't define, but 
-/// useful to have for a C++ program.
-/// 
-/// Experimental extensions are useful functions and types, but the development of
-/// their API and functionality is not necessarily stable. They can change 
-/// substantially between versions. Backwards compatibility is not much of an issue
-/// for them.
-/// 
-/// Even if it's highly unrecommended, it's possible to include all the extensions 
-/// at once by including <glm/ext.hpp>. Otherwise, each extension needs to be 
-/// included  a specific file.
-/// 
-/// @defgroup virtrev VIRTREV Extensions
-/// 
-/// @brief Extensions develop and maintain by Mathieu [matrem] Roumillac
-/// (http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showprofile&User=22660).
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_ext
-#define glm_ext
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED))
-#	define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
-#	pragma message("GLM: All extensions included (not recommanded)")
-#endif//GLM_MESSAGES
-
-#include "./gtc/constants.hpp"
-#include "./gtc/epsilon.hpp"
-#include "./gtc/half_float.hpp"
-#include "./gtc/matrix_access.hpp"
-#include "./gtc/matrix_integer.hpp"
-#include "./gtc/matrix_inverse.hpp"
-#include "./gtc/matrix_transform.hpp"
-#include "./gtc/noise.hpp"
-#include "./gtc/quaternion.hpp"
-#include "./gtc/random.hpp"
-#include "./gtc/reciprocal.hpp"
-#include "./gtc/swizzle.hpp"
-#include "./gtc/type_precision.hpp"
-#include "./gtc/type_ptr.hpp"
-#include "./gtc/ulp.hpp"
-
-#include "./gtx/associated_min_max.hpp"
-#include "./gtx/bit.hpp"
-#include "./gtx/closest_point.hpp"
-#include "./gtx/color_cast.hpp"
-#include "./gtx/color_space.hpp"
-#include "./gtx/color_space_YCoCg.hpp"
-#include "./gtx/compatibility.hpp"
-#include "./gtx/component_wise.hpp"
-#include "./gtx/euler_angles.hpp"
-#include "./gtx/extend.hpp"
-#include "./gtx/extented_min_max.hpp"
-#include "./gtx/fast_exponential.hpp"
-#include "./gtx/fast_square_root.hpp"
-#include "./gtx/fast_trigonometry.hpp"
-#include "./gtx/gradient_paint.hpp"
-#include "./gtx/handed_coordinate_space.hpp"
-#include "./gtx/inertia.hpp"
-#include "./gtx/int_10_10_10_2.hpp"
-#include "./gtx/integer.hpp"
-#include "./gtx/intersect.hpp"
-#include "./gtx/log_base.hpp"
-#include "./gtx/matrix_cross_product.hpp"
-#include "./gtx/matrix_interpolation.hpp"
-#include "./gtx/matrix_major_storage.hpp"
-#include "./gtx/matrix_operation.hpp"
-#include "./gtx/matrix_query.hpp"
-#include "./gtx/mixed_product.hpp"
-#include "./gtx/multiple.hpp"
-#include "./gtx/norm.hpp"
-#include "./gtx/normal.hpp"
-#include "./gtx/normalize_dot.hpp"
-#include "./gtx/number_precision.hpp"
-#include "./gtx/ocl_type.hpp"
-#include "./gtx/optimum_pow.hpp"
-#include "./gtx/orthonormalize.hpp"
-#include "./gtx/perpendicular.hpp"
-#include "./gtx/polar_coordinates.hpp"
-#include "./gtx/projection.hpp"
-#include "./gtx/quaternion.hpp"
-#include "./gtx/raw_data.hpp"
-#include "./gtx/rotate_vector.hpp"
-#include "./gtx/spline.hpp"
-#include "./gtx/std_based_type.hpp"
-#include "./gtx/string_cast.hpp"
-#include "./gtx/transform.hpp"
-#include "./gtx/transform2.hpp"
-#include "./gtx/vec1.hpp"
-#include "./gtx/vector_access.hpp"
-#include "./gtx/vector_angle.hpp"
-#include "./gtx/vector_query.hpp"
-#include "./gtx/verbose_operator.hpp"
-#include "./gtx/wrap.hpp"
-
-#if(GLM_ARCH & GLM_ARCH_SSE2)
-#	include "./gtx/simd_vec4.hpp"
-#	include "./gtx/simd_mat4.hpp"
-#endif
-
-#include "./virtrev/xstream.hpp"
-
-//const float goldenRatio = 1.618033988749894848f;
-//const float pi = 3.141592653589793238f;
-
-#endif //glm_ext
diff --git a/include/gal/opengl/glm/glm.hpp b/include/gal/opengl/glm/glm.hpp
deleted file mode 100644
index 5474fe336e..0000000000
--- a/include/gal/opengl/glm/glm.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/glm.hpp
-/// @date 2005-01-14 / 2011-10-24
-/// @author Christophe Riccio
-///
-///	@defgroup core GLM Core
-///	
-///	@brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
-///
-/// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and
-/// C++ functions that mirror the GLSL functions. It also includes 
-/// @ref core_precision "a set of precision-based types" that can be used in the appropriate
-/// functions. The C++ types are all based on a basic set of @ref core_template "template types".
-/// 
-/// The best documentation for GLM Core is the current GLSL specification,
-/// <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.clean.pdf">version 4.2
-/// (pdf file)</a>.
-/// There are a few @ref pg_differences "differences" between GLM core and GLSL.
-/// 
-/// GLM core functionnalities require <glm/glm.hpp> to be included to be used.
-/// 
-/// @defgroup core_types Types
-/// 
-/// @brief The standard types defined by the specification.
-/// 
-/// These types are all typedefs of more generalized, template types. To see the definiton
-/// of these template types, go to @ref core_template.
-/// 
-/// @ingroup core
-/// 
-/// @defgroup core_precision Precision types
-/// 
-/// @brief Non-GLSL types that are used to define precision-based types.
-/// 
-/// The GLSL language allows the user to define the precision of a particular variable.
-/// In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility
-/// with OpenGL ES's precision qualifiers, where they @em do have an effect.
-/// 
-/// C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing:
-/// a number of typedefs of the @ref core_template that use a particular precision.
-/// 
-/// None of these types make any guarantees about the actual precision used.
-/// 
-/// @ingroup core
-/// 
-/// @defgroup core_template Template types
-/// 
-/// @brief The generic template types used as the basis for the core types. 
-/// 
-/// These types are all templates used to define the actual @ref core_types.
-/// These templetes are implementation details of GLM types and should not be used explicitly.
-/// 
-/// @ingroup core
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "core/_fixes.hpp"
-
-#ifndef glm_glm
-#define glm_glm
-
-#include <cmath>
-#include <climits>
-#include <cfloat>
-#include <limits>
-#include <cstdio>
-//#include <type_traits>
-#include "core/setup.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
-#	define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
-#	pragma message("GLM: Core library included")
-#endif//GLM_MESSAGE
-
-#include "./core/_detail.hpp"
-#include "./core/_vectorize.hpp"
-#include "./core/type.hpp"
-
-#include "./core/func_trigonometric.hpp"
-#include "./core/func_exponential.hpp"
-#include "./core/func_common.hpp"
-#include "./core/func_packing.hpp"
-#include "./core/func_geometric.hpp"
-#include "./core/func_matrix.hpp"
-#include "./core/func_vector_relational.hpp"
-#include "./core/func_integer.hpp"
-#include "./core/func_noise.hpp"
-#include "./core/_swizzle.hpp"
-
-////////////////////
-// check type sizes
-#ifndef GLM_STATIC_ASSERT_NULL
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int8) == 1, "int8 size isn't 1 byte on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int16) == 2, "int16 size isn't 2 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int32) == 4, "int32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int64) == 8, "int64 size isn't 8 bytes on this platform");
-
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint8) == 1, "uint8 size isn't 1 byte on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
-
-	GLM_STATIC_ASSERT(sizeof(glm::detail::float16) == 2, "float16 size isn't 2 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::float32) == 4, "float32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::float64) == 8, "float64 size isn't 8 bytes on this platform");
-#endif//GLM_STATIC_ASSERT_NULL
-
-#endif//glm_glm
diff --git a/include/gal/opengl/glm/gtc/constants.hpp b/include/gal/opengl/glm/gtc/constants.hpp
deleted file mode 100644
index 48876297f6..0000000000
--- a/include/gal/opengl/glm/gtc/constants.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_constants
-/// @file glm/gtc/constants.hpp
-/// @date 2011-09-30 / 2012-01-25
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-///
-/// @defgroup gtc_constants GLM_GTC_constants
-/// @ingroup gtc
-/// 
-/// @brief Allow to perform bit operations on integer values
-/// 
-/// <glm/gtc/constants.hpp> need to be included to use these features.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_constants
-#define GLM_GTC_constants GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_constants extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_constants
-	/// @{
-
-	/// Return the epsilon constant for floating point types.
-	/// @todo Implement epsilon for half-precision floating point type.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType epsilon();
-
-	/// Return 0.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType zero();
-
-	/// Return 1.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType one();
-
-	/// Return the pi constant.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType pi();
-
-	/// Return square root of pi.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_pi();
-
-	/// Return pi / 2.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType half_pi();
-
-	/// Return pi / 4.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType quarter_pi();
-
-	/// Return 1 / pi.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType one_over_pi();
-
-	/// Return 2 / pi.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType two_over_pi();
-
-	/// Return 2 / sqrt(pi).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType two_over_root_pi();
-
-	/// Return 1 / sqrt(2).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType one_over_root_two();
-
-	/// Return sqrt(pi / 2).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_half_pi();
-
-	/// Return sqrt(2 * pi).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_two_pi();
-
-	/// Return sqrt(ln(4)).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_ln_four();
-
-	/// Return e constant.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType e();
-
-	/// Return Euler's constant.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType euler();
-
-	/// Return sqrt(2).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_two();
-
-	/// Return sqrt(3).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_three();
-
-	/// Return sqrt(5).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType root_five();
-
-	/// Return ln(2).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType ln_two();
-
-	/// Return ln(10).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType ln_ten();
-
-	/// Return ln(ln(2)).
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType ln_ln_two();
-
-	/// Return 1 / 3.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType third();
-
-	/// Return 2 / 3.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType two_thirds();
-
-	/// Return the golden ratio constant.
-	/// @see gtc_constants
-	template <typename genType>
-	GLM_FUNC_DECL genType golden_ratio();
-
-	/// @}
-} //namespace glm
-
-#include "constants.inl"
-
-#endif//GLM_GTC_constants
diff --git a/include/gal/opengl/glm/gtc/constants.inl b/include/gal/opengl/glm/gtc/constants.inl
deleted file mode 100644
index e9bde753f2..0000000000
--- a/include/gal/opengl/glm/gtc/constants.inl
+++ /dev/null
@@ -1,186 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_constants
-/// @file glm/gtx/constants.inl
-/// @date 2011-10-14 / 2012-01-25
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType epsilon()
-	{
-		return std::numeric_limits<genType>::epsilon();
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER half epsilon()
-	{
-		return half(1.19209290e-007);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType zero()
-	{
-		return genType(0);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType one()
-	{
-		return genType(1);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType pi()
-	{
-		return genType(3.14159265358979323846264338327950288);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_pi()
-	{
-		return genType(1.772453850905516027);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType half_pi()
-	{
-		return genType(1.57079632679489661923132169163975144);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType quarter_pi()
-	{
-		return genType(0.785398163397448309615660845819875721);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType one_over_pi()
-	{
-		return genType(0.318309886183790671537767526745028724);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType two_over_pi()
-	{
-		return genType(0.636619772367581343075535053490057448);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType two_over_root_pi()
-	{
-		return genType(1.12837916709551257389615890312154517);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType one_over_root_two()
-	{
-		return genType(0.707106781186547524400844362104849039);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_half_pi()
-	{
-		return genType(1.253314137315500251);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_two_pi()
-	{
-		return genType(2.506628274631000502);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_ln_four()
-	{
-		return genType(1.17741002251547469);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType e()
-	{
-		return genType(2.71828182845904523536);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType euler()
-	{
-		return genType(0.577215664901532860606);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_two()
-	{
-		return genType(1.41421356237309504880168872420969808);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_three()
-	{
-		return genType(1.73205080756887729352744634150587236);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType root_five()
-	{
-		return genType(2.23606797749978969640917366873127623);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ln_two()
-	{
-		return genType(0.693147180559945309417232121458176568);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ln_ten()
-	{
-		return genType(2.30258509299404568401799145468436421);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ln_ln_two()
-	{
-		return genType(-0.3665129205816643);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType third()
-	{
-		return genType(0.3333333333333333333333333333333333333333);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType two_thirds()
-	{
-		return genType(0.666666666666666666666666666666666666667);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType golden_ratio()
-	{
-		return genType(1.61803398874989484820458683436563811);
-	}
-} //namespace glm
diff --git a/include/gal/opengl/glm/gtc/epsilon.hpp b/include/gal/opengl/glm/gtc/epsilon.hpp
deleted file mode 100644
index b8729f3f1e..0000000000
--- a/include/gal/opengl/glm/gtc/epsilon.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_epsilon
-/// @file glm/gtc/epsilon.hpp
-/// @date 2012-04-07 / 2012-04-07
-/// @author Christophe Riccio
-/// 
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtc_quaternion (dependence)
-///
-/// @defgroup gtc_epsilon GLM_GTC_epsilon
-/// @ingroup gtc
-/// 
-/// @brief Comparison functions for a user defined epsilon values.
-/// 
-/// <glm/gtc/epsilon.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_epsilon
-#define GLM_GTC_epsilon GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-#include "../gtc/quaternion.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_epsilon extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_epsilon
-	/// @{
-
-	/// Returns the component-wise compare of |x - y| < epsilon.
-	/// @see gtc_epsilon
-	template <typename genType>
-	typename genType::boolType epsilonEqual(
-		genType const & x,
-		genType const & y,
-		typename genType::value_type const & epsilon);
-
-	/// Returns the component-wise compare of |x - y| < epsilon.
-	/// @see gtc_epsilon
-	template <typename genType> 
-	typename genType::boolType epsilonEqual(
-		genType const & x, 
-		genType const & y, 
-		genType const & epsilon);
-
-	/// Returns the component-wise compare of |x - y| < epsilon.
-	/// @see gtc_epsilon
-	template <typename genType>
-	typename genType::boolType epsilonNotEqual(
-		genType const & x,
-		genType const & y,
-		typename genType::value_type const & epsilon);
-
-	/// Returns the component-wise compare of |x - y| >= epsilon.
-	/// @see gtc_epsilon
-	template <typename genType>
-	typename genType::boolType epsilonNotEqual(
-		genType const & x, 
-		genType const & y, 
-		genType const & epsilon);
-
-	/// @}
-}//namespace glm
-
-#include "epsilon.inl"
-
-#endif//GLM_GTC_epsilon
diff --git a/include/gal/opengl/glm/gtc/epsilon.inl b/include/gal/opengl/glm/gtc/epsilon.inl
deleted file mode 100644
index ecfc4aa5eb..0000000000
--- a/include/gal/opengl/glm/gtc/epsilon.inl
+++ /dev/null
@@ -1,286 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_epsilon
-/// @file glm/gtc/epsilon.inl
-/// @date 2012-04-07 / 2012-04-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	GLM_FUNC_QUALIFIER bool epsilonEqual
-	(
-		glm::half const & x, 
-		glm::half const & y, 
-		glm::half const & epsilon
-	)
-	{
-		return abs(x - y) < epsilon;
-	}
-
-	GLM_FUNC_QUALIFIER bool epsilonEqual
-	(
-		float const & x, 
-		float const & y, 
-		float const & epsilon
-	)
-	{
-		return abs(x - y) < epsilon;
-	}
-
-	GLM_FUNC_QUALIFIER bool epsilonEqual
-	(
-		double const & x, 
-		double const & y, 
-		double const & epsilon
-	)
-	{
-		return abs(x - y) < epsilon;
-	}
-
-	GLM_FUNC_QUALIFIER bool epsilonNotEqual
-	(
-		glm::half const & x, 
-		glm::half const & y, 
-		glm::half const & epsilon
-	)
-	{
-		return abs(x - y) >= epsilon;
-	}
-
-	GLM_FUNC_QUALIFIER bool epsilonNotEqual
-	(
-		float const & x, 
-		float const & y, 
-		float const & epsilon
-	)
-	{
-		return abs(x - y) >= epsilon;
-	}
-
-	GLM_FUNC_QUALIFIER bool epsilonNotEqual
-	(
-		double const & x, 
-		double const & y, 
-		double const & epsilon
-	)
-	{
-		return abs(x - y) >= epsilon;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonEqual
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y, 
-		valType const & epsilon)
-	{
-		return detail::tvec2<bool>(
-			abs(x.x - y.x) < epsilon,
-			abs(x.y - y.y) < epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonEqual
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y, 
-		detail::tvec2<valType> const & epsilon
-	)
-	{
-		return detail::tvec2<bool>(
-			abs(x.x - y.x) < epsilon.x,
-			abs(x.y - y.y) < epsilon.y);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonEqual
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y, 
-		valType const & epsilon)
-	{
-		return detail::tvec3<bool>(
-			abs(x.x - y.x) < epsilon,
-			abs(x.y - y.y) < epsilon,
-			abs(x.z - y.z) < epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonEqual
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y, 
-		detail::tvec3<valType> const & epsilon
-	)
-	{
-		return detail::tvec3<bool>(
-			abs(x.x - y.x) < epsilon.x,
-			abs(x.y - y.y) < epsilon.y,
-			abs(x.z - y.z) < epsilon.z);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonEqual
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y, 
-		valType const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(x.x - y.x) < epsilon,
-			abs(x.y - y.y) < epsilon,
-			abs(x.z - y.z) < epsilon,
-			abs(x.w - y.w) < epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonEqual
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y, 
-		detail::tvec4<valType> const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(x.x - y.x) < epsilon.x,
-			abs(x.y - y.y) < epsilon.y,
-			abs(x.z - y.z) < epsilon.z,
-			abs(x.w - y.w) < epsilon.w);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonNotEqual
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y, 
-		valType const & epsilon
-	)
-	{
-		return detail::tvec2<bool>(
-			abs(x.x - y.x) >= epsilon,
-			abs(x.y - y.y) >= epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonNotEqual
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y, 
-		detail::tvec2<valType> const & epsilon
-	)
-	{
-		return detail::tvec2<bool>(
-			abs(x.x - y.x) >= epsilon.x,
-			abs(x.y - y.y) >= epsilon.y);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonNotEqual
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y, 
-		valType const & epsilon
-	)
-	{
-		return detail::tvec3<bool>(
-			abs(x.x - y.x) >= epsilon,
-			abs(x.y - y.y) >= epsilon,
-			abs(x.z - y.z) >= epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonNotEqual
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y, 
-		detail::tvec3<valType> const & epsilon
-	)
-	{
-		return detail::tvec3<bool>(
-			abs(x.x - y.x) >= epsilon.x,
-			abs(x.y - y.y) >= epsilon.y,
-			abs(x.z - y.z) >= epsilon.z);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonNotEqual
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y, 
-		valType const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(x.x - y.x) >= epsilon,
-			abs(x.y - y.y) >= epsilon,
-			abs(x.z - y.z) >= epsilon,
-			abs(x.w - y.w) >= epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonNotEqual
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y, 
-		detail::tvec4<valType> const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(x.x - y.x) >= epsilon.x,
-			abs(x.y - y.y) >= epsilon.y,
-			abs(x.z - y.z) >= epsilon.z,
-			abs(x.w - y.w) >= epsilon.w);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonEqual
-	(
-		detail::tquat<valType> const & x, 
-		detail::tquat<valType> const & y, 
-		valType const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(x.x - y.x) < epsilon,
-			abs(x.y - y.y) < epsilon,
-			abs(x.z - y.z) < epsilon,
-			abs(x.w - y.w) < epsilon);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonNotEqual
-	(
-		detail::tquat<valType> const & x, 
-		detail::tquat<valType> const & y, 
-		valType const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(x.x - y.x) >= epsilon,
-			abs(x.y - y.y) >= epsilon,
-			abs(x.z - y.z) >= epsilon,
-			abs(x.w - y.w) >= epsilon);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/half_float.hpp b/include/gal/opengl/glm/gtc/half_float.hpp
deleted file mode 100644
index fa0fe1aa36..0000000000
--- a/include/gal/opengl/glm/gtc/half_float.hpp
+++ /dev/null
@@ -1,454 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_half_float
-/// @file glm/gtc/half_float.hpp
-/// @date 2009-04-29 / 2012-11-06
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtc_half_float GLM_GTC_half_float
-/// @ingroup gtc
-/// 
-/// Defines the half-precision floating-point type, along with various typedefs for vectors and matrices.
-/// <glm/gtc/half_float.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_half_float
-#define GLM_GTC_half_float GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_half_float extension included")
-#endif
-
-namespace glm{
-namespace detail
-{
-#if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-	template <>
-	struct tvec2<half>
-	{
-		enum ctor{null};
-		typedef half value_type;
-		typedef std::size_t size_type;
-
-		GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type value_size();
-
-		typedef tvec2<half> type;
-		typedef tvec2<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-		half x, y;
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL half & operator[](size_type i);
-		GLM_FUNC_DECL half const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec2();
-		GLM_FUNC_DECL tvec2(tvec2<half> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec2(ctor);
-		GLM_FUNC_DECL explicit tvec2(
-			half const & s);
-		GLM_FUNC_DECL explicit tvec2(
-			half const & s1, 
-			half const & s2);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec2(tref2<half> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tvec2(U const & x, V const & y);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec2<half>& operator= (tvec2<half> const & v);
-
-		GLM_FUNC_DECL tvec2<half>& operator+=(half const & s);
-		GLM_FUNC_DECL tvec2<half>& operator+=(tvec2<half> const & v);
-		GLM_FUNC_DECL tvec2<half>& operator-=(half const & s);
-		GLM_FUNC_DECL tvec2<half>& operator-=(tvec2<half> const & v);
-		GLM_FUNC_DECL tvec2<half>& operator*=(half const & s);
-		GLM_FUNC_DECL tvec2<half>& operator*=(tvec2<half> const & v);
-		GLM_FUNC_DECL tvec2<half>& operator/=(half const & s);
-		GLM_FUNC_DECL tvec2<half>& operator/=(tvec2<half> const & v);
-		GLM_FUNC_DECL tvec2<half>& operator++();
-		GLM_FUNC_DECL tvec2<half>& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL half swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<half> swizzle(comp X, comp Y);
-	};
-
-	template <>
-	struct tvec3<half>
-	{
-		enum ctor{null};
-		typedef half value_type;
-		typedef std::size_t size_type;
-		GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type value_size();
-
-		typedef tvec3<half> type;
-		typedef tvec3<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-		half x, y, z;
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL half & operator[](size_type i);
-		GLM_FUNC_DECL half const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec3();
-		GLM_FUNC_DECL tvec3(tvec3<half> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec3(ctor);
-		GLM_FUNC_DECL explicit tvec3(
-			half const & s);
-		GLM_FUNC_DECL explicit tvec3(
-			half const & s1, 
-			half const & s2, 
-			half const & s3);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec3(tref3<half> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V, typename W> 
-		GLM_FUNC_DECL explicit tvec3(U const & x, V const & y, W const & z);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec3<half>& operator= (tvec3<half> const & v);
-
-		GLM_FUNC_DECL tvec3<half>& operator+=(half const & s);
-		GLM_FUNC_DECL tvec3<half>& operator+=(tvec3<half> const & v);
-		GLM_FUNC_DECL tvec3<half>& operator-=(half const & s);
-		GLM_FUNC_DECL tvec3<half>& operator-=(tvec3<half> const & v);
-		GLM_FUNC_DECL tvec3<half>& operator*=(half const & s);
-		GLM_FUNC_DECL tvec3<half>& operator*=(tvec3<half> const & v);
-		GLM_FUNC_DECL tvec3<half>& operator/=(half const & s);
-		GLM_FUNC_DECL tvec3<half>& operator/=(tvec3<half> const & v);
-		GLM_FUNC_DECL tvec3<half>& operator++();
-		GLM_FUNC_DECL tvec3<half>& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL half swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref3<half> swizzle(comp X, comp Y, comp Z);
-	};
-
-	template <>
-	struct tvec4<half>
-	{
-		enum ctor{null};
-		typedef half value_type;
-		typedef std::size_t size_type;
-		GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type value_size();
-
-		typedef tvec4<half> type;
-		typedef tvec4<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-		half x, y, z, w;
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL half & operator[](size_type i);
-		GLM_FUNC_DECL half const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec4();
-		GLM_FUNC_DECL tvec4(tvec4<half> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec4(ctor);
-		GLM_FUNC_DECL explicit tvec4(
-			half const & s);
-		GLM_FUNC_DECL explicit tvec4(
-			half const & s0, 
-			half const & s1, 
-			half const & s2, 
-			half const & s3);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec4(tref4<half> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec4(U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, typename D> 
-		GLM_FUNC_DECL explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec4<half>& operator= (tvec4<half> const & v);
-
-		GLM_FUNC_DECL tvec4<half>& operator+=(half const & s);
-		GLM_FUNC_DECL tvec4<half>& operator+=(tvec4<half> const & v);
-		GLM_FUNC_DECL tvec4<half>& operator-=(half const & s);
-		GLM_FUNC_DECL tvec4<half>& operator-=(tvec4<half> const & v);
-		GLM_FUNC_DECL tvec4<half>& operator*=(half const & s);
-		GLM_FUNC_DECL tvec4<half>& operator*=(tvec4<half> const & v);
-		GLM_FUNC_DECL tvec4<half>& operator/=(half const & s);
-		GLM_FUNC_DECL tvec4<half>& operator/=(tvec4<half> const & v);
-		GLM_FUNC_DECL tvec4<half>& operator++();
-		GLM_FUNC_DECL tvec4<half>& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL half swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref4<half> swizzle(comp X, comp Y, comp Z, comp W);
-	};
-#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-}
-//namespace detail
-
-	/// @addtogroup gtc_half_float
-	/// @{
-
-	/// Type for half-precision floating-point numbers. 
-	/// @see gtc_half_float
-	typedef detail::half					half;
-
-	/// Vector of 2 half-precision floating-point numbers. 
-	/// @see gtc_half_float
-	typedef detail::tvec2<detail::half>	hvec2;
-
-	/// Vector of 3 half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tvec3<detail::half>	hvec3;
-
-	/// Vector of 4 half-precision floating-point numbers. 
-	/// @see gtc_half_float
-	typedef detail::tvec4<detail::half>	hvec4;
-
-	/// 2 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x2<detail::half>	hmat2;
-
-	/// 3 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x3<detail::half>	hmat3;
-
-	/// 4 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x4<detail::half>	hmat4;
-
-	/// 2 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x2<detail::half>	hmat2x2;
-
-	/// 2 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x3<detail::half>	hmat2x3;
-
-	/// 2 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x4<detail::half>	hmat2x4;
-
-	/// 3 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x2<detail::half>	hmat3x2;
-
-	/// 3 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x3<detail::half>	hmat3x3;
-
-	/// 3 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x4<detail::half>	hmat3x4;
-
-	/// 4 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x2<detail::half>	hmat4x2;    
-
-	/// 4 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x3<detail::half>	hmat4x3;
-
-	/// 4 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x4<detail::half>	hmat4x4;
-
-	/// Returns the absolute value of a half-precision floating-point value
-	/// @see gtc_half_float
-	GLM_FUNC_DECL half abs(half const & x);
-
-	/// Returns the absolute value of a half-precision floating-point two dimensional vector
-	/// @see gtc_half_float
-	GLM_FUNC_DECL hvec2 abs(hvec2 const & x);
-
-	/// Returns the absolute value of a half-precision floating-point three dimensional vector
-	/// @see gtc_half_float
-	GLM_FUNC_DECL hvec3 abs(hvec3 const & x);
-
-	/// Returns the absolute value of a half-precision floating-point four dimensional vector
-	/// @see gtc_half_float
-	GLM_FUNC_DECL hvec4 abs(hvec4 const & x);
-
-	/// Selects which vector each returned component comes
-	/// from. For a component of <a> that is false, the
-	/// corresponding component of x is returned. For a
-	/// component of a that is true, the corresponding
-	/// component of y is returned. Components of x and y that
-	/// are not selected are allowed to be invalid floating point
-	/// values and will have no effect on the results. Thus, this
-	/// provides different functionality than
-	/// genType mix(genType x, genType y, genType(a))
-	/// where a is a Boolean vector.
-	///
-	/// @see gtc_half_float
-	GLM_FUNC_DECL half mix(half const & x, half const & y, bool const & a);
-
-	/// @}
-}// namespace glm
-
-#include "half_float.inl"
-
-#endif//GLM_GTC_half_float
diff --git a/include/gal/opengl/glm/gtc/half_float.inl b/include/gal/opengl/glm/gtc/half_float.inl
deleted file mode 100644
index 57dae8ee52..0000000000
--- a/include/gal/opengl/glm/gtc/half_float.inl
+++ /dev/null
@@ -1,1050 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_half_float
-/// @file glm/gtc/half_float.inl
-/// @date 2009-04-29 / 2012-11-06
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-#if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-
-	//////////////////////////////////////
-	// hvec2
-
-	GLM_FUNC_QUALIFIER tvec2<half>::size_type tvec2<half>::length() const
-	{
-		return 2;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half>::size_type tvec2<half>::value_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	GLM_FUNC_QUALIFIER half & tvec2<half>::operator[](tvec2<half>::size_type i)
-	{
-		assert(/*i >= tvec2<half>::size_type(0) && */i < tvec2<half>::value_size());
-		return (&x)[i];
-	}
-
-	GLM_FUNC_QUALIFIER half const & tvec2<half>::operator[](tvec2<half>::size_type i) const
-	{
-		assert(/*i >= tvec2<half>::size_type(0) && */i < tvec2<half>::value_size());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2() :
-		x(half(0.f)),
-		y(half(0.f))
-	{}
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tvec2<half> const & v
-	) :
-		x(v.x),
-		y(v.y)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		half const & s
-	) :
-		x(s),
-		y(s)
-	{}
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		half const & s1, 
-		half const & s2
-	) :
-		x(s1),
-		y(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tref2<half> const & r
-	) :
-		x(r.x),
-		y(r.y)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		U const & x
-	) :
-		x(half(x)),
-		y(half(x))
-	{}
-
-	template <typename U, typename V> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		U const & x, 
-		V const & y
-	) :
-		x(half(x)),
-		y(half(y))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tvec2<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(	
-		tvec3<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tvec4<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator= 
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator+=
-	(
-		half const & s
-	)
-	{
-		this->x += s;
-		this->y += s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator+=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x += v.x;
-		this->y += v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator-=
-	(
-		half const & s
-	)
-	{
-		this->x -= s;
-		this->y -= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator-=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x -= v.x;
-		this->y -= v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half>& tvec2<half>::operator*=
-	(
-		half const & s
-	)
-	{
-		this->x *= s;
-		this->y *= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator*=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x *= v.x;
-		this->y *= v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator/=
-	(
-		half const & s
-	)
-	{
-		this->x /= s;
-		this->y /= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator/=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x /= v.x;
-		this->y /= v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator++()
-	{
-		++this->x;
-		++this->y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half>& tvec2<half>::operator--()
-	{
-		--this->x;
-		--this->y;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	GLM_FUNC_QUALIFIER half tvec2<half>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> tvec2<half>::swizzle(comp x, comp y) const
-	{
-		return tvec2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> tvec2<half>::swizzle(comp x, comp y, comp z) const
-	{
-		return tvec3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half> tvec2<half>::swizzle(comp x, comp y, comp z, comp w) const
-	{
-		return tvec4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	GLM_FUNC_QUALIFIER tref2<half> tvec2<half>::swizzle(comp x, comp y)
-	{
-		return tref2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	//////////////////////////////////////
-	// hvec3
-
-	GLM_FUNC_QUALIFIER tvec3<half>::size_type tvec3<half>::length() const
-	{
-		return 3;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half>::size_type tvec3<half>::value_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	GLM_FUNC_QUALIFIER half & tvec3<half>::operator[]
-	(
-		tvec3<half>::size_type i
-	)
-	{
-		assert(/*i >= tvec3<half>::size_type(0) &&*/ i < tvec3<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	GLM_FUNC_QUALIFIER half const & tvec3<half>::operator[]
-	(
-		tvec3<half>::size_type i
-	) const
-	{
-		assert(/*i >= tvec3<half>::size_type(0) &&*/ i < tvec3<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3() :
-		x(half(0)),
-		y(half(0)),
-		z(half(0))
-	{}
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec3<half> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		half const & s
-	) :
-		x(s),
-		y(s),
-		z(s)
-	{}
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		half const & s0, 
-		half const & s1, 
-		half const & s2
-	) :
-		x(s0),
-		y(s1),
-		z(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tref3<half> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		U const & x
-	) :
-		x(half(x)),
-		y(half(x)),
-		z(half(x))
-	{}
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		A const & x, 
-		B const & y, 
-		C const & z
-	) :
-		x(half(x)),
-		y(half(y)),
-		z(half(z))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec2<A> const & v, 
-		B const & s
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(s))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		A const & s, 
-		tvec2<B> const & v
-	) :
-		x(half(s)),
-		y(half(v.x)),
-		z(half(v.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec3<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec4<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator= 
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator+=
-	(
-		half const & s
-	)
-	{
-		this->x += s;
-		this->y += s;
-		this->z += s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator+=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x += v.x;
-		this->y += v.y;
-		this->z += v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator-=
-	(
-		half const & s
-	)
-	{
-		this->x -= s;
-		this->y -= s;
-		this->z -= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator-=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x -= v.x;
-		this->y -= v.y;
-		this->z -= v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator*=
-	(
-		half const & s
-	)
-	{
-		this->x *= s;
-		this->y *= s;
-		this->z *= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator*=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x *= v.x;
-		this->y *= v.y;
-		this->z *= v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator/=
-	(
-		half const & s
-	)
-	{
-		this->x /= s;
-		this->y /= s;
-		this->z /= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator/=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x /= v.x;
-		this->y /= v.y;
-		this->z /= v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	GLM_FUNC_QUALIFIER half tvec3<half>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> tvec3<half>::swizzle(comp x, comp y) const
-	{
-		return tvec2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> tvec3<half>::swizzle(comp x, comp y, comp z) const
-	{
-		return tvec3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half> tvec3<half>::swizzle(comp x, comp y, comp z, comp w) const
-	{
-		return tvec4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	GLM_FUNC_QUALIFIER tref3<half> tvec3<half>::swizzle(comp x, comp y, comp z)
-	{
-		return tref3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	//////////////////////////////////////
-	// hvec4
-
-	GLM_FUNC_QUALIFIER tvec4<half>::size_type tvec4<half>::length() const
-	{
-		return 4;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>::size_type tvec4<half>::value_size()
-	{
-		return 4;
-	}
-	
-	//////////////////////////////////////
-	// Accesses
-
-	GLM_FUNC_QUALIFIER half & tvec4<half>::operator[]
-	(
-		tvec4<half>::size_type i
-	)
-	{
-		assert(/*i >= tvec4<half>::size_type(0) && */i < tvec4<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	GLM_FUNC_QUALIFIER half const & tvec4<half>::operator[]
-	(
-		tvec4<half>::size_type i
-	) const
-	{
-		assert(/*i >= tvec4<half>::size_type(0) && */i < tvec4<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4() :
-		x(half(0)),
-		y(half(0)),
-		z(half(0)),
-		w(half(0))
-	{}
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec4<half> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(v.w)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		half const & s
-	) :
-		x(s),
-		y(s),
-		z(s),
-		w(s)
-	{}
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		half const & s1, 
-		half const & s2, 
-		half const & s3, 
-		half const & s4
-	) :
-		x(s1),
-		y(s2),
-		z(s3),
-		w(s4)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tref4<half> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		U const & x
-	) :
-		x(half(x)),
-		y(half(x)),
-		z(half(x)),
-		w(half(x))
-	{}
-
-	template <typename A, typename B, typename C, typename D> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & x, 
-		B const & y, 
-		C const & z, 
-		D const & w
-	) :
-		x(half(x)),
-		y(half(y)),
-		z(half(z)),
-		w(half(w))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec2<A> const & v, 
-		B const & s1, 
-		C const & s2
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(s1)),
-		w(half(s2))
-	{}
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & s1, 
-		tvec2<B> const & v, 
-		C const & s2
-	) :
-		x(half(s1)),
-		y(half(v.x)),
-		z(half(v.y)),
-		w(half(s2))
-	{}
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & s1, 
-		B const & s2, 
-		tvec2<C> const & v
-	) :
-		x(half(s1)),
-		y(half(s2)),
-		z(half(v.x)),
-		w(half(v.y))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec3<A> const & v, 
-		B const & s
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z)),
-		w(half(s))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & s, 
-		tvec3<B> const & v
-	) :
-		x(half(s)),
-		y(half(v.x)),
-		z(half(v.y)),
-		w(half(v.z))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec2<A> const & v1, 
-		tvec2<B> const & v2
-	) :
-		x(half(v1.x)),
-		y(half(v1.y)),
-		z(half(v2.x)),
-		w(half(v2.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec4<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z)),
-		w(half(v.w))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator= 
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		this->w = v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator+=
-	(
-		half const & s
-	)
-	{
-		this->x += s;
-		this->y += s;
-		this->z += s;
-		this->w += s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator+=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x += v.x;
-		this->y += v.y;
-		this->z += v.z;
-		this->w += v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator-=
-	(
-		half const & s
-	)
-	{
-		this->x -= s;
-		this->y -= s;
-		this->z -= s;
-		this->w -= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator-=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x -= v.x;
-		this->y -= v.y;
-		this->z -= v.z;
-		this->w -= v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator*=
-	(
-		half const & s
-	)
-	{
-		this->x *= s;
-		this->y *= s;
-		this->z *= s;
-		this->w *= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator*=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x *= v.x;
-		this->y *= v.y;
-		this->z *= v.z;
-		this->w *= v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator/=
-	(
-		half const & s
-	)
-	{
-		this->x /= s;
-		this->y /= s;
-		this->z /= s;
-		this->w /= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator/=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x /= v.x;
-		this->y /= v.y;
-		this->z /= v.z;
-		this->w /= v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		++this->w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		--this->w;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	GLM_FUNC_QUALIFIER half tvec4<half>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> tvec4<half>::swizzle(comp x, comp y) const
-	{
-		return tvec2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> tvec4<half>::swizzle(comp x, comp y, comp z) const
-	{
-		return tvec3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half> tvec4<half>::swizzle(comp x, comp y, comp z, comp w) const
-	{
-		return tvec4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	GLM_FUNC_QUALIFIER tref4<half> tvec4<half>::swizzle(comp x, comp y, comp z, comp w)
-	{
-		return tref4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-
-}//namespace detail
-
-	GLM_FUNC_QUALIFIER half abs(half const & x)
-	{
-		return float(x) >= float(0) ? x : -x;
-	}
-
-	GLM_FUNC_QUALIFIER hvec2 abs(hvec2 const & v)
-	{
-		return hvec2(
-			float(v.x) >= float(0) ? v.x : -v.x, 
-			float(v.y) >= float(0) ? v.y : -v.y);
-	}
-
-	GLM_FUNC_QUALIFIER hvec3 abs(hvec3 const & v)
-	{
-		return hvec3(
-			float(v.x) >= float(0) ? v.x : -v.x, 
-			float(v.y) >= float(0) ? v.y : -v.y, 
-			float(v.z) >= float(0) ? v.z : -v.z);
-	}
-
-	GLM_FUNC_QUALIFIER hvec4 abs(hvec4 const & v)
-	{
-		return hvec4(
-			float(v.x) >= float(0) ? v.x : -v.x, 
-			float(v.y) >= float(0) ? v.y : -v.y, 
-			float(v.z) >= float(0) ? v.z : -v.z, 
-			float(v.w) >= float(0) ? v.w : -v.w);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER glm::half mix
-	(
-		glm::half const & x, 
-		glm::half const & y, 
-		bool const & a
-	)
-	{
-		return a ? y : x;
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/matrix_access.hpp b/include/gal/opengl/glm/gtc/matrix_access.hpp
deleted file mode 100644
index 201317ea83..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_access.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-/// 
-/// @ref gtc_matrix_access
-/// @file glm/gtc/matrix_access.hpp
-/// @date 2005-12-27 / 2011-05-16
-/// @author Christophe Riccio
-/// 
-/// @see core (dependence)
-/// 
-/// @defgroup gtc_matrix_access GLM_GTC_matrix_access
-/// @ingroup gtc
-/// 
-/// Defines functions to access rows or columns of a matrix easily.
-/// <glm/gtc/matrix_access.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_matrix_access
-#define GLM_GTC_matrix_access GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_matrix_access extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_matrix_access
-	/// @{
-
-	/// Get a specific row of a matrix.
-	/// @see gtc_matrix_access
-	template <typename genType> 
-	typename genType::row_type row(
-		genType const & m, 
-		int index);
-
-	/// Set a specific row to a matrix.
-	/// @see gtc_matrix_access
-	template <typename genType> 
-	genType row(
-		genType const & m, 
-		int index, 
-		typename genType::row_type const & x);
-
-	/// Get a specific column of a matrix.
-	/// @see gtc_matrix_access
-	template <typename genType> 
-	typename genType::col_type column(
-		genType const & m, 
-		int index);
-
-	 /// Set a specific column to a matrix.
-	 /// @see gtc_matrix_access
-	template <typename genType> 
-	genType column(
-		genType const & m, 
-		int index, 
-		typename genType::col_type const & x);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_access.inl"
-
-#endif//GLM_GTC_matrix_access
diff --git a/include/gal/opengl/glm/gtc/matrix_access.inl b/include/gal/opengl/glm/gtc/matrix_access.inl
deleted file mode 100644
index a9e48bbb29..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_access.inl
+++ /dev/null
@@ -1,80 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_matrix_access
-/// @file glm/gtc/matrix_access.inl
-/// @date 2005-12-27 / 2011-06-05
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType row
-	(
-		genType const & m, 
-		int index, 
-		typename genType::row_type const & x
-	)
-	{
-		genType Result = m;
-		for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
-			Result[i][index] = x[i];
-		return Result;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::row_type row
-	(
-		genType const & m, 
-		int index
-	)
-	{
-		typename genType::row_type Result;
-		for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
-			Result[i] = m[i][index];
-		return Result;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType column
-	(
-		genType const & m, 
-		int index, 
-		typename genType::col_type const & x
-	)
-	{
-		genType Result = m;
-		Result[index] = x;
-		return Result;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::col_type column
-	(
-		genType const & m, 
-		int index
-	)
-	{
-		return m[index];
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/matrix_integer.hpp b/include/gal/opengl/glm/gtc/matrix_integer.hpp
deleted file mode 100644
index caed80794d..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_integer.hpp
+++ /dev/null
@@ -1,506 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_matrix_integer
-/// @file glm/gtc/matrix_integer.hpp
-/// @date 2011-01-20 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtc_matrix_integer GLM_GTC_matrix_integer
-/// @ingroup gtc
-/// 
-/// Defines a number of matrices with integer types.
-/// <glm/gtc/matrix_integer.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_matrix_integer
-#define GLM_GTC_matrix_integer GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_matrix_integer extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_matrix_integer
-	/// @{
-
-	/// High-precision signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<highp_int>				highp_imat2;	
-
-	/// High-precision signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<highp_int>				highp_imat3;
-
-	/// High-precision signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<highp_int>				highp_imat4;
-
-	/// High-precision signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<highp_int>				highp_imat2x2;
-
-	/// High-precision signed integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<highp_int>				highp_imat2x3;
-
-	/// High-precision signed integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<highp_int>				highp_imat2x4;
-
-	/// High-precision signed integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<highp_int>				highp_imat3x2;
-
-	/// High-precision signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<highp_int>				highp_imat3x3;
-
-	/// High-precision signed integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<highp_int>				highp_imat3x4;
-
-	/// High-precision signed integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<highp_int>				highp_imat4x2;
-
-	/// High-precision signed integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<highp_int>				highp_imat4x3;
-
-	/// High-precision signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<highp_int>				highp_imat4x4;
-
-
-	/// Medium-precision signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<mediump_int>			mediump_imat2;
-
-	/// Medium-precision signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<mediump_int>			mediump_imat3;
-
-	/// Medium-precision signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<mediump_int>			mediump_imat4;
-
-
-	/// Medium-precision signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<mediump_int>			mediump_imat2x2;
-
-	/// Medium-precision signed integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<mediump_int>			mediump_imat2x3;
-
-	/// Medium-precision signed integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<mediump_int>			mediump_imat2x4;
-
-	/// Medium-precision signed integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<mediump_int>			mediump_imat3x2;
-
-	/// Medium-precision signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<mediump_int>			mediump_imat3x3;
-
-	/// Medium-precision signed integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<mediump_int>			mediump_imat3x4;
-
-	/// Medium-precision signed integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<mediump_int>			mediump_imat4x2;
-
-	/// Medium-precision signed integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<mediump_int>			mediump_imat4x3;
-
-	/// Medium-precision signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<mediump_int>			mediump_imat4x4;
-
-
-	/// Low-precision signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<lowp_int>				lowp_imat2;
-	
-	/// Low-precision signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<lowp_int>				lowp_imat3;
-
-	/// Low-precision signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<lowp_int>				lowp_imat4;
-
-
-	/// Low-precision signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<lowp_int>				lowp_imat2x2;
-
-	/// Low-precision signed integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<lowp_int>				lowp_imat2x3;
-
-	/// Low-precision signed integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<lowp_int>				lowp_imat2x4;
-
-	/// Low-precision signed integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<lowp_int>				lowp_imat3x2;
-
-	/// Low-precision signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<lowp_int>				lowp_imat3x3;
-
-	/// Low-precision signed integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<lowp_int>				lowp_imat3x4;
-
-	/// Low-precision signed integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<lowp_int>				lowp_imat4x2;
-
-	/// Low-precision signed integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<lowp_int>				lowp_imat4x3;
-
-	/// Low-precision signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<lowp_int>				lowp_imat4x4;
-
-
-	/// High-precision unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<highp_uint>				highp_umat2;	
-
-	/// High-precision unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<highp_uint>				highp_umat3;
-
-	/// High-precision unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<highp_uint>				highp_umat4;
-
-	/// High-precision unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<highp_uint>				highp_umat2x2;
-
-	/// High-precision unsigned integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<highp_uint>				highp_umat2x3;
-
-	/// High-precision unsigned integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<highp_uint>				highp_umat2x4;
-
-	/// High-precision unsigned integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<highp_uint>				highp_umat3x2;
-
-	/// High-precision unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<highp_uint>				highp_umat3x3;
-
-	/// High-precision unsigned integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<highp_uint>				highp_umat3x4;
-
-	/// High-precision unsigned integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<highp_uint>				highp_umat4x2;
-
-	/// High-precision unsigned integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<highp_uint>				highp_umat4x3;
-
-	/// High-precision unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<highp_uint>				highp_umat4x4;
-
-
-	/// Medium-precision unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<mediump_uint>			mediump_umat2;
-
-	/// Medium-precision unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<mediump_uint>			mediump_umat3;
-
-	/// Medium-precision unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<mediump_uint>			mediump_umat4;
-
-
-	/// Medium-precision unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<mediump_uint>			mediump_umat2x2;
-
-	/// Medium-precision unsigned integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<mediump_uint>			mediump_umat2x3;
-
-	/// Medium-precision unsigned integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<mediump_uint>			mediump_umat2x4;
-
-	/// Medium-precision unsigned integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<mediump_uint>			mediump_umat3x2;
-
-	/// Medium-precision unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<mediump_uint>			mediump_umat3x3;
-
-	/// Medium-precision unsigned integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<mediump_uint>			mediump_umat3x4;
-
-	/// Medium-precision unsigned integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<mediump_uint>			mediump_umat4x2;
-
-	/// Medium-precision unsigned integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<mediump_uint>			mediump_umat4x3;
-
-	/// Medium-precision unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<mediump_uint>			mediump_umat4x4;
-
-
-	/// Low-precision unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<lowp_uint>				lowp_umat2;
-	
-	/// Low-precision unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<lowp_uint>				lowp_umat3;
-
-	/// Low-precision unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<lowp_uint>				lowp_umat4;
-
-
-	/// Low-precision unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<lowp_uint>				lowp_umat2x2;
-
-	/// Low-precision unsigned integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<lowp_uint>				lowp_umat2x3;
-
-	/// Low-precision unsigned integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<lowp_uint>				lowp_umat2x4;
-
-	/// Low-precision unsigned integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<lowp_uint>				lowp_umat3x2;
-
-	/// Low-precision unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<lowp_uint>				lowp_umat3x3;
-
-	/// Low-precision unsigned integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<lowp_uint>				lowp_umat3x4;
-
-	/// Low-precision unsigned integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<lowp_uint>				lowp_umat4x2;
-
-	/// Low-precision unsigned integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<lowp_uint>				lowp_umat4x3;
-
-	/// Low-precision unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<lowp_uint>				lowp_umat4x4;
-
-#if(defined(GLM_PRECISION_HIGHP_INT))
-	typedef highp_imat2								imat2;
-	typedef highp_imat3								imat3;
-	typedef highp_imat4								imat4;
-	typedef highp_imat2x2							imat2x2;
-	typedef highp_imat2x3							imat2x3;
-	typedef highp_imat2x4							imat2x4;
-	typedef highp_imat3x2							imat3x2;
-	typedef highp_imat3x3							imat3x3;
-	typedef highp_imat3x4							imat3x4;
-	typedef highp_imat4x2							imat4x2;
-	typedef highp_imat4x3							imat4x3;
-	typedef highp_imat4x4							imat4x4;
-#elif(defined(GLM_PRECISION_LOWP_INT))
-	typedef lowp_imat2								imat2;
-	typedef lowp_imat3								imat3;
-	typedef lowp_imat4								imat4;
-	typedef lowp_imat2x2							imat2x2;
-	typedef lowp_imat2x3							imat2x3;
-	typedef lowp_imat2x4							imat2x4;
-	typedef lowp_imat3x2							imat3x2;
-	typedef lowp_imat3x3							imat3x3;
-	typedef lowp_imat3x4							imat3x4;
-	typedef lowp_imat4x2							imat4x2;
-	typedef lowp_imat4x3							imat4x3;
-	typedef lowp_imat4x4							imat4x4;
-#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
-
-	/// Signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat2							imat2;
-
-	/// Signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat3							imat3;
-
-	/// Signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat4							imat4;
-
-	/// Signed integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat2x2							imat2x2;
-
-	/// Signed integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat2x3							imat2x3;
-
-	/// Signed integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat2x4							imat2x4;
-
-	/// Signed integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat3x2							imat3x2;
-
-	/// Signed integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat3x3							imat3x3;
-
-	/// Signed integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat3x4							imat3x4;
-
-	/// Signed integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat4x2							imat4x2;
-
-	/// Signed integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat4x3							imat4x3;
-
-	/// Signed integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_imat4x4							imat4x4;
-#endif//GLM_PRECISION
-
-#if(defined(GLM_PRECISION_HIGHP_UINT))
-	typedef highp_umat2								umat2;
-	typedef highp_umat3								umat3;
-	typedef highp_umat4								umat4;
-	typedef highp_umat2x2							umat2x2;
-	typedef highp_umat2x3							umat2x3;
-	typedef highp_umat2x4							umat2x4;
-	typedef highp_umat3x2							umat3x2;
-	typedef highp_umat3x3							umat3x3;
-	typedef highp_umat3x4							umat3x4;
-	typedef highp_umat4x2							umat4x2;
-	typedef highp_umat4x3							umat4x3;
-	typedef highp_umat4x4							umat4x4;
-#elif(defined(GLM_PRECISION_LOWP_UINT))
-	typedef lowp_umat2								umat2;
-	typedef lowp_umat3								umat3;
-	typedef lowp_umat4								umat4;
-	typedef lowp_umat2x2							umat2x2;
-	typedef lowp_umat2x3							umat2x3;
-	typedef lowp_umat2x4							umat2x4;
-	typedef lowp_umat3x2							umat3x2;
-	typedef lowp_umat3x3							umat3x3;
-	typedef lowp_umat3x4							umat3x4;
-	typedef lowp_umat4x2							umat4x2;
-	typedef lowp_umat4x3							umat4x3;
-	typedef lowp_umat4x4							umat4x4;
-#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
-	
-    /// Unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat2							umat2;
-
-	/// Unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat3							umat3;
-
-	/// Unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat4							umat4;
-
-	/// Unsigned integer 2x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat2x2							umat2x2;
-
-	/// Unsigned integer 2x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat2x3							umat2x3;
-
-	/// Unsigned integer 2x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat2x4							umat2x4;
-
-	/// Unsigned integer 3x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat3x2							umat3x2;
-
-	/// Unsigned integer 3x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat3x3							umat3x3;
-
-	/// Unsigned integer 3x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat3x4							umat3x4;
-
-	/// Unsigned integer 4x2 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat4x2							umat4x2;
-
-	/// Unsigned integer 4x3 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat4x3							umat4x3;
-
-	/// Unsigned integer 4x4 matrix.
-	/// @see gtc_matrix_integer
-	typedef mediump_umat4x4							umat4x4;
-#endif//GLM_PRECISION
-
-	/// @}
-}//namespace glm
-
-#endif//GLM_GTC_matrix_integer
diff --git a/include/gal/opengl/glm/gtc/matrix_inverse.hpp b/include/gal/opengl/glm/gtc/matrix_inverse.hpp
deleted file mode 100644
index 6ccfe3527b..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_inverse.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_matrix_inverse
-/// @file glm/gtc/matrix_inverse.hpp
-/// @date 2005-12-21 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// 
-/// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse
-/// @ingroup gtc
-/// 
-/// Defines additional matrix inverting functions.
-/// <glm/gtc/matrix_inverse.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_matrix_inverse
-#define GLM_GTC_matrix_inverse GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_matrix_inverse extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_matrix_inverse
-	/// @{
-
-	/// Fast matrix inverse for affine matrix.
-	/// 
-	/// @param m Input matrix to invert.
-	/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
-	/// @see gtc_matrix_inverse
-	template <typename genType> 
-	genType affineInverse(genType const & m);
-
-	/// Compute the inverse transpose of a matrix.
-	/// 
-	/// @param m Input matrix to invert transpose.
-	/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
-	/// @see gtc_matrix_inverse
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER typename genType::value_type inverseTranspose(
-		genType const & m);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_inverse.inl"
-
-#endif//GLM_GTC_matrix_inverse
diff --git a/include/gal/opengl/glm/gtc/matrix_inverse.inl b/include/gal/opengl/glm/gtc/matrix_inverse.inl
deleted file mode 100644
index 470dca87c3..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_inverse.inl
+++ /dev/null
@@ -1,159 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_matrix_inverse
-/// @file glm/gtc/matrix_inverse.inl
-/// @date 2005-12-21 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> affineInverse
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		detail::tmat3x3<T> Result(m);
-		Result[2] = detail::tvec3<T>(0, 0, 1);
-		Result = transpose(Result);
-		detail::tvec3<T> Translation = Result * detail::tvec3<T>(-detail::tvec2<T>(m[2]), m[2][2]);
-		Result[2] = Translation;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> affineInverse
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		detail::tmat4x4<T> Result(m);
-		Result[3] = detail::tvec4<T>(0, 0, 0, 1);
-		Result = transpose(Result);
-		detail::tvec4<T> Translation = Result * detail::tvec4<T>(-detail::tvec3<T>(m[3]), m[3][3]);
-		Result[3] = Translation;
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> inverseTranspose
-	(
-		detail::tmat2x2<valType> const & m
-	)
-	{
-		valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
-
-		detail::tmat2x2<valType> Inverse(
-			+ m[1][1] / Determinant,
-			- m[0][1] / Determinant,
-			- m[1][0] / Determinant, 
-			+ m[0][0] / Determinant);
-
-		return Inverse;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> inverseTranspose
-	(
-		detail::tmat3x3<valType> const & m
-	)
-	{
-		valType Determinant = 
-			+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
-			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
-			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
-
-		detail::tmat3x3<valType> Inverse;
-		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
-		Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
-		Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
-		Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
-		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
-		Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
-		Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-		Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
-		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
-		Inverse /= Determinant;
-
-		return Inverse;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> inverseTranspose
-	(
-		detail::tmat4x4<valType> const & m
-	)
-	{
-		valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		valType SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-		valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-		valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-		valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-		valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-		valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		detail::tmat4x4<valType> Inverse;
-		Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
-		Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
-		Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
-		Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05);
-
-		Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02);
-		Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04);
-		Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
-		Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05);
-
-		Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
-		Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10);
-		Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12);
-		Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12);
-
-		Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15);
-		Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17);
-		Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18);
-		Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18);
-
-		valType Determinant = 
-			+ m[0][0] * Inverse[0][0] 
-			+ m[0][1] * Inverse[0][1] 
-			+ m[0][2] * Inverse[0][2] 
-			+ m[0][3] * Inverse[0][3];
-
-		Inverse /= Determinant;
-    
-		return Inverse;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/matrix_transform.hpp b/include/gal/opengl/glm/gtc/matrix_transform.hpp
deleted file mode 100644
index 020c6dd992..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_transform.hpp
+++ /dev/null
@@ -1,291 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_matrix_transform
-/// @file glm/gtc/matrix_transform.hpp
-/// @date 2009-04-29 / 2011-05-16
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_transform
-/// @see gtx_transform2
-/// 
-/// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform
-/// @ingroup gtc
-/// 
-/// @brief Defines functions that generate common transformation matrices.
-/// 
-/// The matrices generated by this extension use standard OpenGL fixed-function
-/// conventions. For example, the lookAt function generates a transform from world
-/// space into the specific eye space that the projective matrix functions 
-/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
-/// specifications defines the particular layout of this eye space.
-/// 
-/// <glm/gtc/matrix_transform.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_matrix_transform
-#define GLM_GTC_matrix_transform GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_matrix_transform extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_matrix_transform
-	/// @{
-
-	/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
-	/// 
-	/// @param m Input matrix multiplied by this translation matrix.
-	/// @param v Coordinates of a translation vector.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @code
-	/// #include <glm/glm.hpp>
-	/// #include <glm/gtc/matrix_transform.hpp>
-	/// ...
-	/// glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f));
-	/// // m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f
-	/// // m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f
-	/// // m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f
-	/// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
-	/// @endcode
-	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - translate(T x, T y, T z)
-	/// @see - translate(detail::tmat4x4<T> const & m, T x, T y, T z)
-	/// @see - translate(detail::tvec3<T> const & v)
-	template <typename T> 
-	detail::tmat4x4<T> translate(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v);
-		
-	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. 
-	/// 
-	/// @param m Input matrix multiplied by this rotation matrix.
-	/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param axis Rotation axis, recommanded to be normalized.
-	/// @tparam T Value type used to build the matrix. Supported: half, float or double.
-	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - rotate(T angle, T x, T y, T z) 
-	/// @see - rotate(detail::tmat4x4<T> const & m, T angle, T x, T y, T z) 
-	/// @see - rotate(T angle, detail::tvec3<T> const & v) 
-	template <typename T> 
-	detail::tmat4x4<T> rotate(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & axis);
-
-	/// Builds a scale 4 * 4 matrix created from 3 scalars. 
-	/// 
-	/// @param m Input matrix multiplied by this scale matrix.
-	/// @param v Ratio of scaling for each axis.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - scale(T x, T y, T z) scale(T const & x, T const & y, T const & z)
-	/// @see - scale(detail::tmat4x4<T> const & m, T x, T y, T z)
-	/// @see - scale(detail::tvec3<T> const & v)
-	template <typename T> 
-	detail::tmat4x4<T> scale(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v);
-
-	/// Creates a matrix for an orthographic parallel viewing volume.
-	/// 
-	/// @param left 
-	/// @param right 
-	/// @param bottom 
-	/// @param top 
-	/// @param zNear 
-	/// @param zFar 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
-	template <typename T> 
-	detail::tmat4x4<T> ortho(
-		T const & left, 
-		T const & right, 
-		T const & bottom, 
-		T const & top, 
-		T const & zNear, 
-		T const & zFar);
-
-	/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
-	/// 
-	/// @param left 
-	/// @param right 
-	/// @param bottom 
-	/// @param top 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-    /// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
-	template <typename T> 
-	detail::tmat4x4<T> ortho(
-		T const & left, 
-		T const & right, 
-		T const & bottom, 
-		T const & top);
-
-	/// Creates a frustum matrix.
-	/// 
-	/// @param left 
-	/// @param right 
-	/// @param bottom 
-	/// @param top 
-	/// @param near 
-	/// @param far 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template <typename T> 
-	detail::tmat4x4<T> frustum(
-		T const & left, 
-		T const & right, 
-		T const & bottom, 
-		T const & top, 
-		T const & near, 
-		T const & far);
-
-	/// Creates a matrix for a symetric perspective-view frustum.
-	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param aspect 
-	/// @param near 
-	/// @param far 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template <typename T> 
-	detail::tmat4x4<T> perspective(
-		T const & fovy, 
-		T const & aspect, 
-		T const & near, 
-		T const & far);
-
-	/// Builds a perspective projection matrix based on a field of view.
-	/// 
-	/// @param fov Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param width 
-	/// @param height 
-	/// @param near 
-	/// @param far 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template <typename valType> 
-	detail::tmat4x4<valType> perspectiveFov(
-		valType const & fov, 
-		valType const & width, 
-		valType const & height, 
-		valType const & near, 
-		valType const & far);
-
-	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
-	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param aspect 
-	/// @param near 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-    template <typename T> 
-	detail::tmat4x4<T> infinitePerspective(
-		T fovy, T aspect, T near);
-
-	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
-	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param aspect 
-	/// @param near 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-    template <typename T> 
-	detail::tmat4x4<T> tweakedInfinitePerspective(
-		T fovy, T aspect, T near);
-
-	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
-	/// 
-	/// @param obj 
-	/// @param model 
-	/// @param proj
-	/// @param viewport 
-	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
-	/// @tparam U Currently supported: Floating-point types and integer types.
-	/// @see gtc_matrix_transform
-	template <typename T, typename U> 
-	detail::tvec3<T> project(
-		detail::tvec3<T> const & obj, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport);
-
-	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
-	/// 
-	/// @param win 
-	/// @param model 
-	/// @param proj
-	/// @param viewport 
-	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
-	/// @tparam U Currently supported: Floating-point types and integer types.
-	/// @see gtc_matrix_transform
-	template <typename T, typename U> 
-	detail::tvec3<T> unProject(
-		detail::tvec3<T> const & win, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport);
-
-	/// Define a picking region
-	/// 
-	/// @param center 
-	/// @param delta 
-	/// @param viewport
-	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
-	/// @tparam U Currently supported: Floating-point types and integer types.
-	/// @see gtc_matrix_transform
-	template <typename T, typename U> 
-	detail::tmat4x4<T> pickMatrix(
-		detail::tvec2<T> const & center, 
-		detail::tvec2<T> const & delta, 
-		detail::tvec4<U> const & viewport);
-
-	/// Build a look at view matrix.
-	/// 
-	/// @param eye Position of the camera
-	/// @param center Position where the camera is looking at
-	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
-	/// @see gtc_matrix_transform
-	/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
-	template <typename T> 
-	detail::tmat4x4<T> lookAt(
-		detail::tvec3<T> const & eye, 
-		detail::tvec3<T> const & center, 
-		detail::tvec3<T> const & up);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_transform.inl"
-
-#endif//GLM_GTC_matrix_transform
diff --git a/include/gal/opengl/glm/gtc/matrix_transform.inl b/include/gal/opengl/glm/gtc/matrix_transform.inl
deleted file mode 100644
index 6f20b4cd52..0000000000
--- a/include/gal/opengl/glm/gtc/matrix_transform.inl
+++ /dev/null
@@ -1,434 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_matrix_transform
-/// @file glm/gtc/matrix_transform.inl
-/// @date 2009-04-29 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(m);
-		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
-		return Result;
-	}
-		
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate
-	(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & v
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		T a = angle;
-#else
-		T a = radians(angle);		
-#endif
-		T c = cos(a);
-		T s = sin(a);
-
-		detail::tvec3<T> axis = normalize(v);
-
-		detail::tvec3<T> temp = (T(1) - c) * axis;
-
-		detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null);
-		Rotate[0][0] = c + temp[0] * axis[0];
-		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
-		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
-
-		Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
-		Rotate[1][1] = c + temp[1] * axis[1];
-		Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
-
-		Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
-		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
-		Rotate[2][2] = c + temp[2] * axis[2];
-
-		detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
-		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
-		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
-		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
-		Result[3] = m[3];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
-		Result[0] = m[0] * v[0];
-		Result[1] = m[1] * v[1];
-		Result[2] = m[2] * v[2];
-		Result[3] = m[3];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(T(1));
-		Result[3] = detail::tvec4<T>(v, T(1));
-		return m * Result;
-
-		//detail::tmat4x4<valType> Result(m);
-		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
-		//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
-		//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
-		//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
-		//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
-		//return Result;
-	}
-		
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow
-	(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & v
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		T const a = angle;
-#else
-		T const a = radians(angle);
-#endif
-		T c = cos(a);
-		T s = sin(a);
-		detail::tmat4x4<T> Result;
-
-		detail::tvec3<T> axis = normalize(v);
-
-		Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
-		Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
-		Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
-		Result[0][3] = 0;
-
-		Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
-		Result[1][1] = c + (1 - c) * axis.y * axis.y;
-		Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
-		Result[1][3] = 0;
-
-		Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
-		Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
-		Result[2][2] = c + (1 - c) * axis.z * axis.z;
-		Result[2][3] = 0;
-
-		Result[3] = detail::tvec4<T>(0, 0, 0, 1);
-		return m * Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(T(1));
-		Result[0][0] = v.x;
-		Result[1][1] = v.y;
-		Result[2][2] = v.z;
-		return m * Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho
-	(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		detail::tmat4x4<valType> Result(1);
-		Result[0][0] = valType(2) / (right - left);
-		Result[1][1] = valType(2) / (top - bottom);
-		Result[2][2] = - valType(2) / (zFar - zNear);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top)
-	{
-		detail::tmat4x4<valType> Result(1);
-		Result[0][0] = valType(2) / (right - left);
-		Result[1][1] = valType(2) / (top - bottom);
-		Result[2][2] = - valType(1);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum
-	(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top, 
-		valType const & nearVal, 
-		valType const & farVal
-	)
-	{
-		detail::tmat4x4<valType> Result(0);
-		Result[0][0] = (valType(2) * nearVal) / (right - left);
-		Result[1][1] = (valType(2) * nearVal) / (top - bottom);
-		Result[2][0] = (right + left) / (right - left);
-		Result[2][1] = (top + bottom) / (top - bottom);
-		Result[2][2] = -(farVal + nearVal) / (farVal - nearVal);
-		Result[2][3] = valType(-1);
-		Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective
-	(
-		valType const & fovy, 
-		valType const & aspect, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		assert(aspect != valType(0));
-		assert(zFar != zNear);
-
-#ifdef GLM_FORCE_RADIANS
-		valType const rad = fovy;
-#else
-		valType const rad = glm::radians(fovy);
-#endif
-
-		valType tanHalfFovy = tan(rad / valType(2));
-		detail::tmat4x4<valType> Result(valType(0));
-		Result[0][0] = valType(1) / (aspect * tanHalfFovy);
-		Result[1][1] = valType(1) / (tanHalfFovy);
-		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
-		Result[2][3] = - valType(1);
-		Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
-		return Result;
-	}
-	
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov
-	(
-		valType const & fov, 
-		valType const & width, 
-		valType const & height, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		valType rad = fov;
-#else
-		valType rad = glm::radians(fov);
-#endif
-		valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
-		valType w = h * height / width; ///todo max(width , Height) / min(width , Height)?
-
-		detail::tmat4x4<valType> Result(valType(0));
-		Result[0][0] = w;
-		Result[1][1] = h;
-		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
-		Result[2][3] = - valType(1);
-		Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective
-	(
-		T fovy, 
-		T aspect, 
-		T zNear
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		T const range = tan(fovy / T(2)) * zNear;	
-#else
-		T const range = tan(radians(fovy / T(2))) * zNear;	
-#endif
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
-
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
-		Result[2][2] = - T(1);
-		Result[2][3] = - T(1);
-		Result[3][2] = - T(2) * zNear;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective
-	(
-		T fovy, 
-		T aspect, 
-		T zNear
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		T range = tan(fovy / T(2)) * zNear;	
-#else
-		T range = tan(radians(fovy / T(2))) * zNear;	
-#endif
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
-
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
-		Result[2][2] = T(0.0001) - T(1);
-		Result[2][3] = T(-1);
-		Result[3][2] = - (T(0.0001) - T(2)) * zNear;
-		return Result;
-	}
-
-	template <typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> project
-	(
-		detail::tvec3<T> const & obj, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
-		tmp = model * tmp;
-		tmp = proj * tmp;
-
-		tmp /= tmp.w;
-		tmp = tmp * T(0.5) + T(0.5);
-		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
-		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
-
-		return detail::tvec3<T>(tmp);
-	}
-
-	template <typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> unProject
-	(
-		detail::tvec3<T> const & win, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		detail::tmat4x4<T> inverse = glm::inverse(proj * model);
-
-		detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1));
-		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
-		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
-		tmp = tmp * T(2) - T(1);
-
-		detail::tvec4<T> obj = inverse * tmp;
-		obj /= obj.w;
-
-		return detail::tvec3<T>(obj);
-	}
-
-	template <typename T, typename U> 
-	detail::tmat4x4<T> pickMatrix
-	(
-		detail::tvec2<T> const & center, 
-		detail::tvec2<T> const & delta, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		assert(delta.x > T(0) && delta.y > T(0));
-		detail::tmat4x4<T> Result(1.0f);
-
-		if(!(delta.x > T(0) && delta.y > T(0))) 
-			return Result; // Error
-
-		detail::tvec3<T> Temp(
-			(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
-			(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
-			T(0));
-
-		// Translate and scale the picked region to the entire window
-		Result = translate(Result, Temp);
-		return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
-	(
-		detail::tvec3<T> const & eye,
-		detail::tvec3<T> const & center,
-		detail::tvec3<T> const & up
-	)
-	{
-		detail::tvec3<T> f = normalize(center - eye);
-		detail::tvec3<T> u = normalize(up);
-		detail::tvec3<T> s = normalize(cross(f, u));
-		u = cross(s, f);
-
-		detail::tmat4x4<T> Result(1);
-		Result[0][0] = s.x;
-		Result[1][0] = s.y;
-		Result[2][0] = s.z;
-		Result[0][1] = u.x;
-		Result[1][1] = u.y;
-		Result[2][1] = u.z;
-		Result[0][2] =-f.x;
-		Result[1][2] =-f.y;
-		Result[2][2] =-f.z;
-		Result[3][0] =-dot(s, eye);
-		Result[3][1] =-dot(u, eye);
-		Result[3][2] = dot(f, eye);
-		return Result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/noise.hpp b/include/gal/opengl/glm/gtc/noise.hpp
deleted file mode 100644
index 1768bd2f86..0000000000
--- a/include/gal/opengl/glm/gtc/noise.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_noise
-/// @file glm/gtc/noise.hpp
-/// @date 2011-04-21 / 2011-09-27
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtc_noise GLM_GTC_noise
-/// @ingroup gtc
-/// 
-/// Defines 2D, 3D and 4D procedural noise functions 
-/// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
-/// https://github.com/ashima/webgl-noise 
-/// Following Stefan Gustavson's paper "Simplex noise demystified": 
-/// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
-/// <glm/gtc/noise.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_noise
-#define GLM_GTC_noise GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_noise extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_noise
-	/// @{
-
-	/// Classic perlin noise.
-    /// @see gtc_noise
-	template <typename T, template<typename> class vecType> 
-    T perlin(
-		vecType<T> const & p);
-		
-	/// Periodic perlin noise.
-	/// @see gtc_noise
-	template <typename T, template<typename> class vecType> 
-    T perlin(
-		vecType<T> const & p, 
-		vecType<T> const & rep);
-
-	/// Simplex noise.
-	/// @see gtc_noise
-	template <typename T, template<typename> class vecType> 
-    T simplex(
-		vecType<T> const & p);
-
-	/// @}
-}//namespace glm
-
-#include "noise.inl"
-
-#endif//GLM_GTC_noise
diff --git a/include/gal/opengl/glm/gtc/noise.inl b/include/gal/opengl/glm/gtc/noise.inl
deleted file mode 100644
index 1c6d557e08..0000000000
--- a/include/gal/opengl/glm/gtc/noise.inl
+++ /dev/null
@@ -1,867 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_noise
-/// @file glm/gtc/noise.inl
-/// @date 2011-04-21 / 2012-04-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
-// https://github.com/ashima/webgl-noise 
-// Following Stefan Gustavson's paper "Simplex noise demystified": 
-// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER T mod289(T const & x)
-	{
-		return x - floor(x * T(1.0 / 289.0)) * T(289.0);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T permute(T const & x)
-	{
-		return mod289(((x * T(34)) + T(1)) * x);
-	}
-
-	template <typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> permute(vecType<T> const & x)
-	{
-		return mod289(((x * T(34)) + T(1)) * x);
-	}
-  
-	template <typename T>
-	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-
-	template <typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> taylorInvSqrt(vecType<T> const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER vecType<T> fade(vecType<T> const & t) 
-	{
-		return t * t * t * (t * (t * T(6) - T(15)) + T(10));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> grad4(T const & j, detail::tvec4<T> const & ip)
-	{
-		detail::tvec3<T> pXYZ = floor(fract(detail::tvec3<T>(j) * detail::tvec3<T>(ip)) * T(7)) * ip[2] - T(1);
-		T pW = T(1.5) - dot(abs(pXYZ), detail::tvec3<T>(1));
-		detail::tvec4<T> s = detail::tvec4<T>(lessThan(detail::tvec4<T>(pXYZ, pW), detail::tvec4<T>(0.0)));
-		pXYZ = pXYZ + (detail::tvec3<T>(s) * T(2) - T(1)) * s.w; 
-		return detail::tvec4<T>(pXYZ, pW);
-	}
-
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
-	{
-		detail::tvec4<T> Pi = glm::floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		detail::tvec4<T> Pf = glm::fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
-		detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
-		detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
-		detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
-		detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
-
-		detail::tvec4<T> i = glm::permute(glm::permute(ix) + iy);
-
-		detail::tvec4<T> gx = T(2) * glm::fract(i / T(41)) - T(1);
-		detail::tvec4<T> gy = glm::abs(gx) - T(0.5);
-		detail::tvec4<T> tx = glm::floor(gx + T(0.5));
-		gx = gx - tx;
-
-		detail::tvec2<T> g00(gx.x, gy.x);
-		detail::tvec2<T> g10(gx.y, gy.y);
-		detail::tvec2<T> g01(gx.z, gy.z);
-		detail::tvec2<T> g11(gx.w, gy.w);
-
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
-		g00 *= norm.x;  
-		g01 *= norm.y;  
-		g10 *= norm.z;  
-		g11 *= norm.w;  
-
-		T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
-		T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
-		T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
-		T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
-
-		detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
-		detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
-		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
-		return T(2.3) * n_xy;
-	}
-
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
-	{
-		detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
-		detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
-		Pi0 = mod289(Pi0);
-		Pi1 = mod289(Pi1);
-		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy = detail::tvec4<T>(detail::tvec2<T>(Pi0.y), detail::tvec2<T>(Pi1.y));
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-
-		detail::tvec4<T> gx0 = ixy0 * T(1.0 / 7.0);
-		detail::tvec4<T> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);
-		gx0 = fract(gx0);
-		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
-		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
-		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
-		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
-
-		detail::tvec4<T> gx1 = ixy1 * T(1.0 / 7.0);
-		detail::tvec4<T> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);
-		gx1 = fract(gx1);
-		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
-		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
-		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
-		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
-
-		detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
-		detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
-		detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
-		detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
-		detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
-		detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
-		detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
-		detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
-
-		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
-		g000 *= norm0.x;
-		g010 *= norm0.y;
-		g100 *= norm0.z;
-		g110 *= norm0.w;
-		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
-		g001 *= norm1.x;
-		g011 *= norm1.y;
-		g101 *= norm1.z;
-		g111 *= norm1.w;
-
-		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
-		T n111 = dot(g111, Pf1);
-
-		detail::tvec3<T> fade_xyz = fade(Pf0);
-		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
-		detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
-		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-		return T(2.2) * n_xyz;
-	}
-	/*
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
-	{
-		detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
-		detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
-		Pi0 = mod(Pi0, T(289));
-		Pi1 = mod(Pi1, T(289));
-		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-
-		detail::tvec4<T> gx0 = ixy0 / T(7);
-		detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
-		gx0 = fract(gx0);
-		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
-		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
-		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
-		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
-
-		detail::tvec4<T> gx1 = ixy1 / T(7);
-		detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
-		gx1 = fract(gx1);
-		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
-		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
-		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
-		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
-
-		detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
-		detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
-		detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
-		detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
-		detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
-		detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
-		detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
-		detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
-
-		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
-		g000 *= norm0.x;
-		g010 *= norm0.y;
-		g100 *= norm0.z;
-		g110 *= norm0.w;
-		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
-		g001 *= norm1.x;
-		g011 *= norm1.y;
-		g101 *= norm1.z;
-		g111 *= norm1.w;
-
-		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
-		T n111 = dot(g111, Pf1);
-
-		detail::tvec3<T> fade_xyz = fade(Pf0);
-		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
-		detail::tvec2<T> n_yz = mix(
-			detail::tvec2<T>(n_z.x, n_z.y), 
-			detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
-		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-		return T(2.2) * n_xyz;
-	}
-	*/
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P)
-	{
-		detail::tvec4<T> Pi0 = floor(P); // Integer part for indexing
-		detail::tvec4<T> Pi1 = Pi0 + T(1); // Integer part + 1
-		Pi0 = mod(Pi0, T(289));
-		Pi1 = mod(Pi1, T(289));
-		detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-		detail::tvec4<T> iw0(Pi0.w);
-		detail::tvec4<T> iw1(Pi1.w);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-		detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
-		detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
-		detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
-		detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
-
-		detail::tvec4<T> gx00 = ixy00 / T(7);
-		detail::tvec4<T> gy00 = floor(gx00) / T(7);
-		detail::tvec4<T> gz00 = floor(gy00) / T(6);
-		gx00 = fract(gx00) - T(0.5);
-		gy00 = fract(gy00) - T(0.5);
-		gz00 = fract(gz00) - T(0.5);
-		detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
-		detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0.0));
-		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
-		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
-
-		detail::tvec4<T> gx01 = ixy01 / T(7);
-		detail::tvec4<T> gy01 = floor(gx01) / T(7);
-		detail::tvec4<T> gz01 = floor(gy01) / T(6);
-		gx01 = fract(gx01) - T(0.5);
-		gy01 = fract(gy01) - T(0.5);
-		gz01 = fract(gz01) - T(0.5);
-		detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
-		detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
-		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
-		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
-
-		detail::tvec4<T> gx10 = ixy10 / T(7);
-		detail::tvec4<T> gy10 = floor(gx10) / T(7);
-		detail::tvec4<T> gz10 = floor(gy10) / T(6);
-		gx10 = fract(gx10) - T(0.5);
-		gy10 = fract(gy10) - T(0.5);
-		gz10 = fract(gz10) - T(0.5);
-		detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
-		detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0));
-		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
-		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
-
-		detail::tvec4<T> gx11 = ixy11 / T(7);
-		detail::tvec4<T> gy11 = floor(gx11) / T(7);
-		detail::tvec4<T> gz11 = floor(gy11) / T(6);
-		gx11 = fract(gx11) - T(0.5);
-		gy11 = fract(gy11) - T(0.5);
-		gz11 = fract(gz11) - T(0.5);
-		detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
-		detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
-		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
-		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
-
-		detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
-		detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
-		detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
-		detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
-		detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
-		detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
-		detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
-		detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
-		detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
-		detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
-		detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
-		detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
-		detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
-		detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
-		detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
-		detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
-
-		detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
-		g0000 *= norm00.x;
-		g0100 *= norm00.y;
-		g1000 *= norm00.z;
-		g1100 *= norm00.w;
-
-		detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
-		g0001 *= norm01.x;
-		g0101 *= norm01.y;
-		g1001 *= norm01.z;
-		g1101 *= norm01.w;
-
-		detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
-		g0010 *= norm10.x;
-		g0110 *= norm10.y;
-		g1010 *= norm10.z;
-		g1110 *= norm10.w;
-
-		detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
-		g0011 *= norm11.x;
-		g0111 *= norm11.y;
-		g1011 *= norm11.z;
-		g1111 *= norm11.w;
-
-		T n0000 = dot(g0000, Pf0);
-		T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
-		T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
-		T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
-		T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
-		T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
-		T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
-		T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
-		T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
-		T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
-		T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
-		T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
-		T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
-		T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
-		T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
-		T n1111 = dot(g1111, Pf1);
-
-		detail::tvec4<T> fade_xyzw = fade(Pf0);
-		detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
-		detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
-		detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
-		detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
-		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
-		return T(2.2) * n_xyzw;
-	}
-
-	// Classic Perlin noise, periodic variant
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P, detail::tvec2<T> const & rep)
-	{
-		detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		Pi = mod(Pi, detail::tvec4<T>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
-		Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
-		detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
-		detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
-		detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
-		detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
-
-		detail::tvec4<T> i = permute(permute(ix) + iy);
-
-		detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
-		detail::tvec4<T> gy = abs(gx) - T(0.5);
-		detail::tvec4<T> tx = floor(gx + T(0.5));
-		gx = gx - tx;
-
-		detail::tvec2<T> g00(gx.x, gy.x);
-		detail::tvec2<T> g10(gx.y, gy.y);
-		detail::tvec2<T> g01(gx.z, gy.z);
-		detail::tvec2<T> g11(gx.w, gy.w);
-
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
-		g00 *= norm.x;  
-		g01 *= norm.y;  
-		g10 *= norm.z;  
-		g11 *= norm.w;  
-
-		T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
-		T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
-		T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
-		T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
-
-		detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
-		detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
-		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
-		return T(2.3) * n_xy;
-	}
-
-	// Classic Perlin noise, periodic variant
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P, detail::tvec3<T> const & rep)
-	{
-		detail::tvec3<T> Pi0 = mod(floor(P), rep); // Integer part, modulo period
-		detail::tvec3<T> Pi1 = mod(Pi0 + detail::tvec3<T>(1.0), rep); // Integer part + 1, mod period
-		Pi0 = mod(Pi0, T(289));
-		Pi1 = mod(Pi1, T(289));
-		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec3<T> Pf1 = Pf0 - detail::tvec3<T>(1.0); // Fractional part - 1.0
-		detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-
-		detail::tvec4<T> gx0 = ixy0 / T(7);
-		detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
-		gx0 = fract(gx0);
-		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
-		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0));
-		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
-		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
-
-		detail::tvec4<T> gx1 = ixy1 / T(7);
-		detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
-		gx1 = fract(gx1);
-		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
-		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
-		gx1 -= sz1 * (step(0.0, gx1) - T(0.5));
-		gy1 -= sz1 * (step(0.0, gy1) - T(0.5));
-
-		detail::tvec3<T> g000 = detail::tvec3<T>(gx0.x, gy0.x, gz0.x);
-		detail::tvec3<T> g100 = detail::tvec3<T>(gx0.y, gy0.y, gz0.y);
-		detail::tvec3<T> g010 = detail::tvec3<T>(gx0.z, gy0.z, gz0.z);
-		detail::tvec3<T> g110 = detail::tvec3<T>(gx0.w, gy0.w, gz0.w);
-		detail::tvec3<T> g001 = detail::tvec3<T>(gx1.x, gy1.x, gz1.x);
-		detail::tvec3<T> g101 = detail::tvec3<T>(gx1.y, gy1.y, gz1.y);
-		detail::tvec3<T> g011 = detail::tvec3<T>(gx1.z, gy1.z, gz1.z);
-		detail::tvec3<T> g111 = detail::tvec3<T>(gx1.w, gy1.w, gz1.w);
-
-		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
-		g000 *= norm0.x;
-		g010 *= norm0.y;
-		g100 *= norm0.z;
-		g110 *= norm0.w;
-		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
-		g001 *= norm1.x;
-		g011 *= norm1.y;
-		g101 *= norm1.z;
-		g111 *= norm1.w;
-
-		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
-		T n111 = dot(g111, Pf1);
-
-		detail::tvec3<T> fade_xyz = fade(Pf0);
-		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
-		detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
-		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-		return T(2.2) * n_xyz;
-	}
-
-	// Classic Perlin noise, periodic version
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P, detail::tvec4<T> const & rep)
-	{
-		detail::tvec4<T> Pi0 = mod(floor(P), rep); // Integer part modulo rep
-		detail::tvec4<T> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
-		detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-		detail::tvec4<T> iw0(Pi0.w);
-		detail::tvec4<T> iw1(Pi1.w);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-		detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
-		detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
-		detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
-		detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
-
-		detail::tvec4<T> gx00 = ixy00 / T(7);
-		detail::tvec4<T> gy00 = floor(gx00) / T(7);
-		detail::tvec4<T> gz00 = floor(gy00) / T(6);
-		gx00 = fract(gx00) - T(0.5);
-		gy00 = fract(gy00) - T(0.5);
-		gz00 = fract(gz00) - T(0.5);
-		detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
-		detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0));
-		gx00 -= sw00 * (step(0.0, gx00) - T(0.5));
-		gy00 -= sw00 * (step(0.0, gy00) - T(0.5));
-
-		detail::tvec4<T> gx01 = ixy01 / T(7);
-		detail::tvec4<T> gy01 = floor(gx01) / T(7);
-		detail::tvec4<T> gz01 = floor(gy01) / T(6);
-		gx01 = fract(gx01) - T(0.5);
-		gy01 = fract(gy01) - T(0.5);
-		gz01 = fract(gz01) - T(0.5);
-		detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
-		detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
-		gx01 -= sw01 * (step(0.0, gx01) - T(0.5));
-		gy01 -= sw01 * (step(0.0, gy01) - T(0.5));
-
-		detail::tvec4<T> gx10 = ixy10 / T(7);
-		detail::tvec4<T> gy10 = floor(gx10) / T(7);
-		detail::tvec4<T> gz10 = floor(gy10) / T(6);
-		gx10 = fract(gx10) - T(0.5);
-		gy10 = fract(gy10) - T(0.5);
-		gz10 = fract(gz10) - T(0.5);
-		detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
-		detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0.0));
-		gx10 -= sw10 * (step(0.0, gx10) - T(0.5));
-		gy10 -= sw10 * (step(0.0, gy10) - T(0.5));
-
-		detail::tvec4<T> gx11 = ixy11 / T(7);
-		detail::tvec4<T> gy11 = floor(gx11) / T(7);
-		detail::tvec4<T> gz11 = floor(gy11) / T(6);
-		gx11 = fract(gx11) - T(0.5);
-		gy11 = fract(gy11) - T(0.5);
-		gz11 = fract(gz11) - T(0.5);
-		detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
-		detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
-		gx11 -= sw11 * (step(0.0, gx11) - T(0.5));
-		gy11 -= sw11 * (step(0.0, gy11) - T(0.5));
-
-		detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
-		detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
-		detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
-		detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
-		detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
-		detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
-		detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
-		detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
-		detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
-		detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
-		detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
-		detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
-		detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
-		detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
-		detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
-		detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
-
-		detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
-		g0000 *= norm00.x;
-		g0100 *= norm00.y;
-		g1000 *= norm00.z;
-		g1100 *= norm00.w;
-
-		detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
-		g0001 *= norm01.x;
-		g0101 *= norm01.y;
-		g1001 *= norm01.z;
-		g1101 *= norm01.w;
-
-		detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
-		g0010 *= norm10.x;
-		g0110 *= norm10.y;
-		g1010 *= norm10.z;
-		g1110 *= norm10.w;
-
-		detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
-		g0011 *= norm11.x;
-		g0111 *= norm11.y;
-		g1011 *= norm11.z;
-		g1111 *= norm11.w;
-
-		T n0000 = dot(g0000, Pf0);
-		T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
-		T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
-		T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
-		T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
-		T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
-		T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
-		T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
-		T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
-		T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
-		T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
-		T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
-		T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
-		T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
-		T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
-		T n1111 = dot(g1111, Pf1);
-
-		detail::tvec4<T> fade_xyzw = fade(Pf0);
-		detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
-		detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
-		detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
-		detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
-		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
-		return T(2.2) * n_xyzw;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T simplex(glm::detail::tvec2<T> const & v)
-	{
-		detail::tvec4<T> const C = detail::tvec4<T>(
-			T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
-			T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
-			T(-0.577350269189626),	// -1.0 + 2.0 * C.x
-			T( 0.024390243902439)); //  1.0 / 41.0
-
-		// First corner
-		detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
-		detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
-
-		// Other corners
-		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
-		//i1.y = 1.0 - i1.x;
-		detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
-		// x0 = x0 - 0.0 + 0.0 * C.xx ;
-		// x1 = x0 - i1 + 1.0 * C.xx ;
-		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
-		x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
-
-		// Permutations
-		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		detail::tvec3<T> p = permute(
-			permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
-			+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
-
-		detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
-			dot(x0, x0), 
-			dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
-			dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
-		m = m * m ;
-		m = m * m ;
-
-		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
-		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
-
-		detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
-		detail::tvec3<T> h = abs(x) - T(0.5);
-		detail::tvec3<T> ox = floor(x + T(0.5));
-		detail::tvec3<T> a0 = x - ox;
-
-		// Normalise gradients implicitly by scaling m
-		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
-		m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
-
-		// Compute final noise value at P
-		detail::tvec3<T> g;
-		g.x  = a0.x  * x0.x  + h.x  * x0.y;
-		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-		g.y = a0.y * x12.x + h.y * x12.y;
-		g.z = a0.z * x12.z + h.z * x12.w;
-		return T(130) * dot(m, g);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T simplex(detail::tvec3<T> const & v)
-	{ 
-		detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
-		detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
-
-		// First corner
-		detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
-		detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
-
-		// Other corners
-		detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
-		detail::tvec3<T> l(T(1) - g);
-		detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
-		detail::tvec3<T> i2(max(g, detail::tvec3<T>(l.z, l.x, l.y)));
-
-		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
-		//   x1 = x0 - i1  + 1.0 * C.xxx;
-		//   x2 = x0 - i2  + 2.0 * C.xxx;
-		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
-		detail::tvec3<T> x1(x0 - i1 + C.x);
-		detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
-		detail::tvec3<T> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
-
-		// Permutations
-		i = mod289(i); 
-		detail::tvec4<T> p(permute(permute(permute( 
-			i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) + 
-			i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) + 
-			i.x + detail::tvec4<T>(T(0), i1.x, i2.x, T(1))));
-
-		// Gradients: 7x7 points over a square, mapped onto an octahedron.
-		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
-		T n_ = T(0.142857142857); // 1.0/7.0
-		detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
-
-		detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
-
-		detail::tvec4<T> x_(floor(j * ns.z));
-		detail::tvec4<T> y_(floor(j - T(7) * x_));    // mod(j,N)
-
-		detail::tvec4<T> x(x_ * ns.x + ns.y);
-		detail::tvec4<T> y(y_ * ns.x + ns.y);
-		detail::tvec4<T> h(T(1) - abs(x) - abs(y));
-
-		detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
-		detail::tvec4<T> b1(x.z, x.w, y.z, y.w);
-
-		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
-		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
-		detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
-		detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
-
-		detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
-		detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
-
-		detail::tvec3<T> p0(a0.x, a0.y, h.x);
-		detail::tvec3<T> p1(a0.z, a0.w, h.y);
-		detail::tvec3<T> p2(a1.x, a1.y, h.z);
-		detail::tvec3<T> p3(a1.z, a1.w, h.w);
-
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-
-		// Mix final noise value
-		detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
-		m = m * m;
-		return T(42) * dot(m * m, detail::tvec4<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T simplex(detail::tvec4<T> const & v)
-	{
-		detail::tvec4<T> const C(
-			0.138196601125011,  // (5 - sqrt(5))/20  G4
-			0.276393202250021,  // 2 * G4
-			0.414589803375032,  // 3 * G4
-			-0.447213595499958); // -1 + 4 * G4
-
-		// (sqrt(5) - 1)/4 = F4, used once below
-		T const F4 = T(0.309016994374947451);
-
-		// First corner
-		detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
-		detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
-
-		// Other corners
-
-		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		detail::tvec4<T> i0;
-		detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
-		detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
-		//  i0.x = dot(isX, vec3(1.0));
-		//i0.x = isX.x + isX.y + isX.z;
-		//i0.yzw = T(1) - isX;
-		i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
-		//  i0.y += dot(isYZ.xy, vec2(1.0));
-		i0.y += isYZ.x + isYZ.y;
-		//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
-		i0.z += T(1) - isYZ.x;
-		i0.w += T(1) - isYZ.y;
-		i0.z += isYZ.z;
-		i0.w += T(1) - isYZ.z;
-
-		// i0 now contains the unique values 0,1,2,3 in each channel
-		detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
-		detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
-		detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
-
-		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
-		//  x1 = x0 - i1  + 0.0 * C.xxxx
-		//  x2 = x0 - i2  + 0.0 * C.xxxx
-		//  x3 = x0 - i3  + 0.0 * C.xxxx
-		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		detail::tvec4<T> x1 = x0 - i1 + C.x;
-		detail::tvec4<T> x2 = x0 - i2 + C.y;
-		detail::tvec4<T> x3 = x0 - i3 + C.z;
-		detail::tvec4<T> x4 = x0 + C.w;
-
-		// Permutations
-		i = mod(i, T(289)); 
-		T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
-		detail::tvec4<T> j1 = permute(permute(permute(permute(
-					i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
-				+ i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
-				+ i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
-				+ i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
-
-		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
-		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
-
-		detail::tvec4<T> p0 = grad4(j0,   ip);
-		detail::tvec4<T> p1 = grad4(j1.x, ip);
-		detail::tvec4<T> p2 = grad4(j1.y, ip);
-		detail::tvec4<T> p3 = grad4(j1.z, ip);
-		detail::tvec4<T> p4 = grad4(j1.w, ip);
-
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-		p4 *= taylorInvSqrt(dot(p4, p4));
-
-		// Mix contributions from the five corners
-		detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
-		m0 = m0 * m0;
-		m1 = m1 * m1;
-		return T(49) * 
-			(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
-			dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/quaternion.hpp b/include/gal/opengl/glm/gtc/quaternion.hpp
deleted file mode 100644
index 705d3d3452..0000000000
--- a/include/gal/opengl/glm/gtc/quaternion.hpp
+++ /dev/null
@@ -1,381 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_quaternion
-/// @file glm/gtc/quaternion.hpp
-/// @date 2009-05-21 / 2012-12-20
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtc_constants (dependence)
-///
-/// @defgroup gtc_quaternion GLM_GTC_quaternion
-/// @ingroup gtc
-/// 
-/// @brief Defines a templated quaternion type and several quaternion operations.
-/// 
-/// <glm/gtc/quaternion.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_quaternion
-#define GLM_GTC_quaternion GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-#include "../gtc/constants.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_quaternion extension included")
-#endif
-
-namespace glm{
-namespace detail
-{
-	template <typename T> 
-	struct tquat// : public genType<T, tquat>
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-
-	public:
-		value_type x, y, z, w;
-
-		GLM_FUNC_DECL size_type length() const;
-
-		// Constructors
-		tquat();
-		explicit tquat(
-			value_type const & s, 
-			glm::detail::tvec3<T> const & v);
-		explicit tquat(
-			value_type const & w, 
-			value_type const & x, 
-			value_type const & y, 
-			value_type const & z);
-
-		// Convertions
-
-		/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
-		explicit tquat(
-			tvec3<T> const & eulerAngles);
-		explicit tquat(
-			tmat3x3<T> const & m);
-		explicit tquat(
-			tmat4x4<T> const & m);
-
-		// Accesses
-		value_type & operator[](int i);
-		value_type const & operator[](int i) const;
-
-		// Operators
-		tquat<T> & operator*=(value_type const & s);
-		tquat<T> & operator/=(value_type const & s);
-	};
-
-	template <typename T> 
-	detail::tquat<T> operator- (
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tquat<T> operator+ ( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p); 
-
-	template <typename T> 
-	detail::tquat<T> operator* ( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p); 
-
-	template <typename T> 
-	detail::tvec3<T> operator* (
-		detail::tquat<T> const & q, 
-		detail::tvec3<T> const & v);
-
-	template <typename T> 
-	detail::tvec3<T> operator* (
-		detail::tvec3<T> const & v,
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tvec4<T> operator* (
-		detail::tquat<T> const & q, 
-		detail::tvec4<T> const & v);
-
-	template <typename T> 
-	detail::tvec4<T> operator* (
-		detail::tvec4<T> const & v,
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tquat<T> operator* (
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s);
-
-	template <typename T> 
-	detail::tquat<T> operator* (
-		typename detail::tquat<T>::value_type const & s,
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tquat<T> operator/ (
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s);
-
-} //namespace detail
-
-	/// @addtogroup gtc_quaternion
-	/// @{
-
-	/// Returns the length of the quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	T length(
-		detail::tquat<T> const & q);
-
-	/// Returns the normalized quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> normalize(
-		detail::tquat<T> const & q);
-		
-	/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	T dot(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2);
-
-	/// Spherical linear interpolation of two quaternions.
-	/// The interpolation is oriented and the rotation is performed at constant speed.
-	/// For short path spherical linear interpolation, use the slerp function.
-	/// 
-	/// @param x A quaternion
-	/// @param y A quaternion
-	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
-	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
-	/// @see gtc_quaternion
-	/// @see - slerp(detail::tquat<T> const & x, detail::tquat<T> const & y, T const & a) 
-	template <typename T> 
-	detail::tquat<T> mix(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a);
-
-	/// Linear interpolation of two quaternions. 
-	/// The interpolation is oriented.
-	/// 
-	/// @param x A quaternion
-	/// @param y A quaternion
-	/// @param a Interpolation factor. The interpolation is defined in the range [0, 1].
-	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> lerp(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a);
-
-	/// Spherical linear interpolation of two quaternions.
-	/// The interpolation always take the short path and the rotation is performed at constant speed.
-	/// 
-	/// @param x A quaternion
-	/// @param y A quaternion
-	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
-	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> slerp(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a);
-
-	/// Returns the q conjugate. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> conjugate(
-		detail::tquat<T> const & q);
-
-	/// Returns the q inverse. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> inverse(
-		detail::tquat<T> const & q);
-
-	/// Rotates a quaternion from an vector of 3 components axis and an angle.
-	/// 
-	/// @param q Source orientation
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param axis Axis of the rotation, must be normalized.
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> rotate(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & angle, 
-		detail::tvec3<T> const & axis);
-
-	/// Returns euler angles, yitch as x, yaw as y, roll as z. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tvec3<T> eulerAngles(
-		detail::tquat<T> const & x);
-
-	/// Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	valType roll(
-		detail::tquat<valType> const & x);
-
-	/// Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	valType pitch(
-		detail::tquat<valType> const & x);
-
-	/// Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	valType yaw(
-		detail::tquat<valType> const & x);
-
-	/// Converts a quaternion to a 3 * 3 matrix. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tmat3x3<T> mat3_cast(
-		detail::tquat<T> const & x);
-
-	/// Converts a quaternion to a 4 * 4 matrix. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tmat4x4<T> mat4_cast(
-		detail::tquat<T> const & x);
-
-	/// Converts a 3 * 3 matrix to a quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> quat_cast(
-		detail::tmat3x3<T> const & x);
-
-	/// Converts a 4 * 4 matrix to a quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> quat_cast(
-		detail::tmat4x4<T> const & x);
-
-	/// Returns the quaternion rotation angle. 
-	///
-	/// @see gtc_quaternion
-	template <typename valType> 
-	valType angle(
-		detail::tquat<valType> const & x);
-
-	/// Returns the q rotation axis. 
-	///
-	/// @see gtc_quaternion
-	template <typename valType> 
-	detail::tvec3<valType> axis(
-		detail::tquat<valType> const & x);
-
-	/// Build a quaternion from an angle and a normalized axis. 
-	///
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param x x component of the x-axis, x, y, z must be a normalized axis
-	/// @param y y component of the y-axis, x, y, z must be a normalized axis
-	/// @param z z component of the z-axis, x, y, z must be a normalized axis
-	///
-	/// @see gtc_quaternion
-	template <typename valType> 
-	detail::tquat<valType> angleAxis(
-		valType const & angle, 
-		valType const & x, 
-		valType const & y, 
-		valType const & z);
-
-	/// Build a quaternion from an angle and a normalized axis.
-	///
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
-	/// @param axis Axis of the quaternion, must be normalized. 
-	///
-	/// @see gtc_quaternion
-	template <typename valType> 
-	detail::tquat<valType> angleAxis(
-		valType const & angle, 
-		detail::tvec3<valType> const & axis);
-
-	/// Quaternion of floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<float> quat;
-
-	/// Quaternion of half-precision floating-point numbers.
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<detail::half>	hquat;
-
-	/// Quaternion of single-precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<float>	fquat;
-
-	/// Quaternion of double-precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<double>	dquat;
-
-	/// Quaternion of low precision floating-point numbers.
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<lowp_float>		lowp_quat;
-
-	/// Quaternion of medium precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<mediump_float>	mediump_quat;
-
-	/// Quaternion of high precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<highp_float>		highp_quat;
-
-	/// @}
-} //namespace glm
-
-#include "quaternion.inl"
-
-#endif//GLM_GTC_quaternion
diff --git a/include/gal/opengl/glm/gtc/quaternion.inl b/include/gal/opengl/glm/gtc/quaternion.inl
deleted file mode 100644
index 8b83865a89..0000000000
--- a/include/gal/opengl/glm/gtc/quaternion.inl
+++ /dev/null
@@ -1,792 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_quaternion
-/// @file glm/gtc/quaternion.inl
-/// @date 2009-05-21 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include <limits>
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tquat<T>::size_type tquat<T>::length() const
-	{
-		return 4;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat() : 
-		x(0),
-		y(0),
-		z(0),
-		w(1)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		value_type const & s, 
-		tvec3<T> const & v
-	) : 
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(s)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		value_type const & w, 
-		value_type const & x, 
-		value_type const & y, 
-		value_type const & z
-	) :
-		x(x),
-		y(y),
-		z(z),
-		w(w)
-	{}
-
-	//////////////////////////////////////////////////////////////
-	// tquat conversions
-
-	//template <typename valType> 
-	//GLM_FUNC_QUALIFIER tquat<valType>::tquat
-	//(
-	//	valType const & pitch, 
-	//	valType const & yaw, 
-	//	valType const & roll
-	//)
-	//{
-	//	tvec3<valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
-	//	tvec3<valType> c = glm::cos(eulerAngle * valType(0.5));
-	//	tvec3<valType> s = glm::sin(eulerAngle * valType(0.5));
-	//	
-	//	this->w = c.x * c.y * c.z + s.x * s.y * s.z;
-	//	this->x = s.x * c.y * c.z - c.x * s.y * s.z;
-	//	this->y = c.x * s.y * c.z + s.x * c.y * s.z;
-	//	this->z = c.x * c.y * s.z - s.x * s.y * c.z;
-	//}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		tvec3<T> const & eulerAngle
-	)
-	{
-		tvec3<T> c = glm::cos(eulerAngle * value_type(0.5));
-		tvec3<T> s = glm::sin(eulerAngle * value_type(0.5));
-		
-		this->w = c.x * c.y * c.z + s.x * s.y * s.z;
-		this->x = s.x * c.y * c.z - c.x * s.y * s.z;
-		this->y = c.x * s.y * c.z + s.x * c.y * s.z;
-		this->z = c.x * c.y * s.z - s.x * s.y * c.z;		
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		tmat3x3<T> const & m
-	)
-	{
-		*this = quat_cast(m);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		tmat4x4<T> const & m
-	)
-	{
-		*this = quat_cast(m);
-	}
-
-	//////////////////////////////////////////////////////////////
-	// tquat<T> accesses
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tquat<T>::value_type & tquat<T>::operator [] (int i)
-	{
-		return (&x)[i];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tquat<T>::value_type const & tquat<T>::operator [] (int i) const
-	{
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////////////////////////////
-	// tquat<valType> operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T> & tquat<T>::operator *=
-	(
-		value_type const & s
-	)
-	{
-		this->w *= s;
-		this->x *= s;
-		this->y *= s;
-		this->z *= s;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T> & tquat<T>::operator /=
-	(
-		value_type const & s
-	)
-	{
-		this->w /= s;
-		this->x /= s;
-		this->y /= s;
-		this->z /= s;
-		return *this;
-	}
-
-	//////////////////////////////////////////////////////////////
-	// tquat<valType> external operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator- 
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return detail::tquat<T>(-q.w, -q.x, -q.y, -q.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator+
-	( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p
-	) 
-	{ 
-		return detail::tquat<T>(
-			q.w + p.w,
-			q.x + p.x,
-			q.y + p.y,
-			q.z + p.z);
-	} 
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator*
-	( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p
-	) 
-	{ 
-		return detail::tquat<T>(
-			q.w * p.w - q.x * p.x - q.y * p.y - q.z * p.z,
-			q.w * p.x + q.x * p.w + q.y * p.z - q.z * p.y,
-			q.w * p.y + q.y * p.w + q.z * p.x - q.x * p.z,
-			q.w * p.z + q.z * p.w + q.x * p.y - q.y * p.x);
-	} 
-
-	// Transformation
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> operator* 
-	(
-		detail::tquat<T> const & q, 
-		detail::tvec3<T> const & v
-	)
-	{
-		typename detail::tquat<T>::value_type Two(2);
-
-		detail::tvec3<T> uv, uuv;
-		detail::tvec3<T> QuatVector(q.x, q.y, q.z);
-		uv = glm::cross(QuatVector, v);
-		uuv = glm::cross(QuatVector, uv);
-		uv *= (Two * q.w); 
-		uuv *= Two; 
-
-		return v + uv + uuv;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> operator* 
-	(
-		detail::tvec3<T> const & v,
-		detail::tquat<T> const & q 
-	)
-	{
-		return inverse(q) * v;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> operator* 
-	(
-		detail::tquat<T> const & q, 
-		detail::tvec4<T> const & v
-	)
-	{
-		return detail::tvec4<T>(q * detail::tvec3<T>(v), v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> operator* 
-	(
-		detail::tvec4<T> const & v,
-		detail::tquat<T> const & q 
-	)
-	{
-		return inverse(q) * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator* 
-	(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s
-	)
-	{
-		return detail::tquat<T>(
-			q.w * s, q.x * s, q.y * s, q.z * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator* 
-	(
-		typename detail::tquat<T>::value_type const & s,
-		detail::tquat<T> const & q
-	)
-	{
-		return q * s;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator/ 
-	(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s
-	)
-	{
-		return detail::tquat<T>(
-			q.w / s, q.x / s, q.y / s, q.z / s);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-	{
-		return (q1.x == q2.x) && (q1.y == q2.y) && (q1.z == q2.z) && (q1.w == q2.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-	{
-		return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
-	}
-
-}//namespace detail
-
-	////////////////////////////////////////////////////////
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T length
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return glm::sqrt(dot(q, q));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> normalize
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		typename detail::tquat<T>::value_type len = length(q);
-		if(len <= typename detail::tquat<T>::value_type(0)) // Problem
-			return detail::tquat<T>(1, 0, 0, 0);
-		typename detail::tquat<T>::value_type oneOverLen = typename detail::tquat<T>::value_type(1) / len;
-		return detail::tquat<T>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T dot
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-	{
-		return q1.x * q2.x + q1.y * q2.y + q1.z * q2.z + q1.w * q2.w;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> cross
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-	{
-		return detail::tquat<T>(
-			q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
-			q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
-			q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
-			q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x);
-	}
-/*
-	// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> mix
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		typename detail::tquat<T>::value_type const & a
-	)
-	{
-		if(a <= typename detail::tquat<T>::value_type(0)) return x;
-		if(a >= typename detail::tquat<T>::value_type(1)) return y;
-
-		float fCos = dot(x, y);
-		detail::tquat<T> y2(y); //BUG!!! tquat<T> y2;
-		if(fCos < typename detail::tquat<T>::value_type(0))
-		{
-			y2 = -y;
-			fCos = -fCos;
-		}
-
-		//if(fCos > 1.0f) // problem
-		float k0, k1;
-		if(fCos > typename detail::tquat<T>::value_type(0.9999))
-		{
-			k0 = typename detail::tquat<T>::value_type(1) - a;
-			k1 = typename detail::tquat<T>::value_type(0) + a; //BUG!!! 1.0f + a;
-		}
-		else
-		{
-			typename detail::tquat<T>::value_type fSin = sqrt(T(1) - fCos * fCos);
-			typename detail::tquat<T>::value_type fAngle = atan(fSin, fCos);
-			typename detail::tquat<T>::value_type fOneOverSin = T(1) / fSin;
-			k0 = sin((typename detail::tquat<T>::value_type(1) - a) * fAngle) * fOneOverSin;
-			k1 = sin((typename detail::tquat<T>::value_type(0) + a) * fAngle) * fOneOverSin;
-		}
-
-		return detail::tquat<T>(
-			k0 * x.w + k1 * y2.w,
-			k0 * x.x + k1 * y2.x,
-			k0 * x.y + k1 * y2.y,
-			k0 * x.z + k1 * y2.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> mix2
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-	{
-		bool flip = false;
-		if(a <= T(0)) return x;
-		if(a >= T(1)) return y;
-
-		T cos_t = dot(x, y);
-		if(cos_t < T(0))
-		{
-			cos_t = -cos_t;
-			flip = true;
-		}
-
-		T alpha(0), beta(0);
-
-		if(T(1) - cos_t < 1e-7)
-			beta = T(1) - alpha;
-		else
-		{
-			T theta = acos(cos_t);
-			T sin_t = sin(theta);
-			beta = sin(theta * (T(1) - alpha)) / sin_t;
-			alpha = sin(alpha * theta) / sin_t;
-		}
-
-		if(flip)
-			alpha = -alpha;
-		
-		return normalize(beta * x + alpha * y);
-	}
-*/
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> mix
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-	{
-		T cosTheta = dot(x, y);
-
-		// Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
-		if(cosTheta > T(1) - epsilon<T>())
-		{
-			// Linear interpolation
-			return detail::tquat<T>(
-				mix(x.w, y.w, a),
-				mix(x.x, y.x, a),
-				mix(x.y, y.y, a),
-				mix(x.z, y.z, a));
-		}
-		else
-		{
-			// Essential Mathematics, page 467
-			T angle = acos(cosTheta);
-			return (sin((T(1) - a) * angle) * x + sin(a * angle) * y) / sin(angle);
-		}
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> lerp
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-	{
-		// Lerp is only defined in [0, 1]
-		assert(a >= T(0));
-		assert(a <= T(1));
-
-		return x * (T(1) - a) + (y * a);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> slerp
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-	{
-		detail::tquat<T> z = y;
-
-		T cosTheta = dot(x, y);
-
-		// If cosTheta < 0, the interpolation will take the long way around the sphere. 
-		// To fix this, one quat must be negated.
-		if (cosTheta < T(0))
-		{
-			z        = -y;
-			cosTheta = -cosTheta;
-		}
-
-		// Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
-		if(cosTheta > T(1) - epsilon<T>())
-		{
-			// Linear interpolation
-			return detail::tquat<T>(
-				mix(x.w, z.w, a),
-				mix(x.x, z.x, a),
-				mix(x.y, z.y, a),
-				mix(x.z, z.z, a));
-		}
-		else
-		{
-			// Essential Mathematics, page 467
-			T angle = acos(cosTheta);
-			return (sin((T(1) - a) * angle) * x + sin(a * angle) * z) / sin(angle);
-		}
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> conjugate
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return detail::tquat<T>(q.w, -q.x, -q.y, -q.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> inverse
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return conjugate(q) / dot(q, q);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> rotate
-	(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & angle, 
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tvec3<T> Tmp = v;
-
-		// Axis of rotation must be normalised
-		typename detail::tquat<T>::value_type len = glm::length(Tmp);
-		if(abs(len - T(1)) > T(0.001))
-		{
-			T oneOverLen = T(1) / len;
-			Tmp.x *= oneOverLen;
-			Tmp.y *= oneOverLen;
-			Tmp.z *= oneOverLen;
-		}
-
-#ifdef GLM_FORCE_RADIANS
-		typename detail::tquat<T>::value_type const AngleRad(angle);
-#else
-		typename detail::tquat<T>::value_type const AngleRad = radians(angle);
-#endif
-		typename detail::tquat<T>::value_type const Sin = sin(AngleRad * T(0.5));
-
-		return q * detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
-		//return gtc::quaternion::cross(q, detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> eulerAngles
-	(
-		detail::tquat<T> const & x
-	)
-	{
-		return detail::tvec3<T>(pitch(x), yaw(x), roll(x));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType roll
-	(
-		detail::tquat<valType> const & q
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		return valType(atan2(valType(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
-#else
-		return glm::degrees(atan(valType(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
-#endif
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType pitch
-	(
-		detail::tquat<valType> const & q
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		return valType(atan2(valType(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
-#else
-		return glm::degrees(atan(valType(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
-#endif
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType yaw
-	(
-		detail::tquat<valType> const & q
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		return asin(valType(-2) * (q.x * q.z - q.w * q.y));
-#else
-		return glm::degrees(asin(valType(-2) * (q.x * q.z - q.w * q.y)));
-#endif
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> mat3_cast
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		detail::tmat3x3<T> Result(T(1));
-		Result[0][0] = 1 - 2 * q.y * q.y - 2 * q.z * q.z;
-		Result[0][1] = 2 * q.x * q.y + 2 * q.w * q.z;
-		Result[0][2] = 2 * q.x * q.z - 2 * q.w * q.y;
-
-		Result[1][0] = 2 * q.x * q.y - 2 * q.w * q.z;
-		Result[1][1] = 1 - 2 * q.x * q.x - 2 * q.z * q.z;
-		Result[1][2] = 2 * q.y * q.z + 2 * q.w * q.x;
-
-		Result[2][0] = 2 * q.x * q.z + 2 * q.w * q.y;
-		Result[2][1] = 2 * q.y * q.z - 2 * q.w * q.x;
-		Result[2][2] = 1 - 2 * q.x * q.x - 2 * q.y * q.y;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> mat4_cast
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return detail::tmat4x4<T>(mat3_cast(q));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> quat_cast
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		typename detail::tquat<T>::value_type fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
-		typename detail::tquat<T>::value_type fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
-		typename detail::tquat<T>::value_type fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1];
-		typename detail::tquat<T>::value_type fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2];
-
-		int biggestIndex = 0;
-		typename detail::tquat<T>::value_type fourBiggestSquaredMinus1 = fourWSquaredMinus1;
-		if(fourXSquaredMinus1 > fourBiggestSquaredMinus1)
-		{
-			fourBiggestSquaredMinus1 = fourXSquaredMinus1;
-			biggestIndex = 1;
-		}
-		if(fourYSquaredMinus1 > fourBiggestSquaredMinus1)
-		{
-			fourBiggestSquaredMinus1 = fourYSquaredMinus1;
-			biggestIndex = 2;
-		}
-		if(fourZSquaredMinus1 > fourBiggestSquaredMinus1)
-		{
-			fourBiggestSquaredMinus1 = fourZSquaredMinus1;
-			biggestIndex = 3;
-		}
-
-		typename detail::tquat<T>::value_type biggestVal = sqrt(fourBiggestSquaredMinus1 + T(1)) * T(0.5);
-		typename detail::tquat<T>::value_type mult = T(0.25) / biggestVal;
-
-		detail::tquat<T> Result;
-		switch(biggestIndex)
-		{
-		case 0:
-			Result.w = biggestVal; 
-			Result.x = (m[1][2] - m[2][1]) * mult;
-			Result.y = (m[2][0] - m[0][2]) * mult;
-			Result.z = (m[0][1] - m[1][0]) * mult;
-			break;
-		case 1:
-			Result.w = (m[1][2] - m[2][1]) * mult;
-			Result.x = biggestVal;
-			Result.y = (m[0][1] + m[1][0]) * mult;
-			Result.z = (m[2][0] + m[0][2]) * mult;
-			break;
-		case 2:
-			Result.w = (m[2][0] - m[0][2]) * mult;
-			Result.x = (m[0][1] + m[1][0]) * mult;
-			Result.y = biggestVal;
-			Result.z = (m[1][2] + m[2][1]) * mult;
-			break;
-		case 3:
-			Result.w = (m[0][1] - m[1][0]) * mult;
-			Result.x = (m[2][0] + m[0][2]) * mult;
-			Result.y = (m[1][2] + m[2][1]) * mult;
-			Result.z = biggestVal;
-			break;
-			
-        default:                // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity.
-            assert(false);
-            break;
-		}
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> quat_cast
-	(
-		detail::tmat4x4<T> const & m4
-	)
-	{
-		return quat_cast(detail::tmat3x3<T>(m4));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T angle
-	(
-		detail::tquat<T> const & x
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		return acos(x.w) * T(2);
-#else
-		return glm::degrees(acos(x.w) * T(2));
-#endif
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> axis
-	(
-		detail::tquat<T> const & x
-	)
-	{
-		T tmp1 = T(1) - x.w * x.w;
-		if(tmp1 <= T(0))
-			return detail::tvec3<T>(0, 0, 1);
-		T tmp2 = T(1) / sqrt(tmp1);
-		return detail::tvec3<T>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tquat<valType> angleAxis
-	(
-		valType const & angle, 
-		valType const & x, 
-		valType const & y, 
-		valType const & z
-	)
-	{
-		return angleAxis(angle, detail::tvec3<valType>(x, y, z));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tquat<valType> angleAxis
-	(
-		valType const & angle, 
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tquat<valType> result;
-
-#ifdef GLM_FORCE_RADIANS
-		valType a(angle);
-#else
-		valType a(glm::radians(angle));
-#endif
-		valType s = glm::sin(a * valType(0.5));
-
-		result.w = glm::cos(a * valType(0.5));
-		result.x = v.x * s;
-		result.y = v.y * s;
-		result.z = v.z * s;
-		return result;
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/random.hpp b/include/gal/opengl/glm/gtc/random.hpp
deleted file mode 100644
index 3cda59c763..0000000000
--- a/include/gal/opengl/glm/gtc/random.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_random
-/// @file glm/gtc/random.hpp
-/// @date 2011-09-18 / 2011-09-18
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtx_random (extended)
-///
-/// @defgroup gtc_random GLM_GTC_random
-/// @ingroup gtc
-/// 
-/// @brief Generate random number from various distribution methods.
-/// 
-/// <glm/gtc/random.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_random
-#define GLM_GTC_random GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_random extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_random
-	/// @{
-	
-	/// Generate random numbers in the interval [Min, Max], according a linear distribution 
-	/// 
-	/// @param Min 
-	/// @param Max 
-	/// @tparam genType Value type. Currently supported: half (not recommanded), float or double scalars and vectors.
-	/// @see gtc_random
-	template <typename genType> 
-	genType linearRand(
-		genType const & Min, 
-		genType const & Max);
-
-	/// Generate random numbers in the interval [Min, Max], according a gaussian distribution 
-	/// 
-	/// @param Mean
-	/// @param Deviation
-	/// @see gtc_random
-	template <typename genType>
-	genType gaussRand(
-		genType const & Mean, 
-		genType const & Deviation);
-	
-	/// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius
-	/// 
-	/// @param Radius 
-	/// @see gtc_random
-	template <typename T> 
-	detail::tvec2<T> circularRand(
-		T const & Radius); 
-	
-	/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
-	/// 
-	/// @param Radius
-	/// @see gtc_random
-	template <typename T> 
-	detail::tvec3<T> sphericalRand(
-		T const & Radius); 
-	
-	/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
-	/// 
-	/// @param Radius
-	/// @see gtc_random
-	template <typename T> 
-	detail::tvec2<T> diskRand(
-		T const & Radius); 
-	
-	/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
-	/// 
-	/// @param Radius
-	/// @see gtc_random
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> ballRand(
-		T const & Radius);
-	
-	/// @}
-}//namespace glm
-
-#include "random.inl"
-
-#endif//GLM_GTC_random
diff --git a/include/gal/opengl/glm/gtc/random.inl b/include/gal/opengl/glm/gtc/random.inl
deleted file mode 100644
index ca1bd7eb5c..0000000000
--- a/include/gal/opengl/glm/gtc/random.inl
+++ /dev/null
@@ -1,170 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_random
-/// @file glm/gtc/random.inl
-/// @date 2011-09-19 / 2012-04-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include <ctime>
-#include <cassert>
-
-namespace glm{
-namespace detail
-{
-	struct compute_linearRand
-	{
-		template <typename T>
-		GLM_FUNC_QUALIFIER T operator() (T const & Min, T const & Max) const;
-/*
-		{
-			GLM_STATIC_ASSERT(0, "'linearRand' invalid template parameter type. GLM_GTC_random only supports floating-point template types.");
-			return Min;
-		}
-*/
-	};
-    
-	template <>
-	GLM_FUNC_QUALIFIER half compute_linearRand::operator()<half> (half const & Min, half const & Max) const
-	{
-		return half(float(std::rand()) / float(RAND_MAX) * (float(Max) - float(Min)) + float(Min));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER float compute_linearRand::operator()<float> (float const & Min, float const & Max) const
-	{
-		return float(std::rand()) / float(RAND_MAX) * (Max - Min) + Min;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER double compute_linearRand::operator()<double> (double const & Min, double const & Max) const
-	{
-		return double(std::rand()) / double(RAND_MAX) * (Max - Min) + Min;
-	}
-    
-	template <>
-	GLM_FUNC_QUALIFIER long double compute_linearRand::operator()<long double> (long double const & Min, long double const & Max) const
-	{
-		return (long double)(std::rand()) / (long double)(RAND_MAX) * (Max - Min) + Min;
-	}
-}//namespace detail
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType linearRand
-	(
-		genType const & Min, 
-		genType const & Max
-	)
-	{
-		return detail::compute_linearRand()(Min, Max);
-	}
-
-	VECTORIZE_VEC_VEC(linearRand)
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType gaussRand
-	(
-		genType const & Mean,	
-		genType const & Deviation
-	)
-	{
-		genType w, x1, x2;
-	
-		do
-		{
-			x1 = linearRand(genType(-1), genType(1));
-			x2 = linearRand(genType(-1), genType(1));
-		
-			w = x1 * x1 + x2 * x2;
-		} while(w > genType(1));
-	
-		return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean;
-	}
-
-	VECTORIZE_VEC_VEC(gaussRand)
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> diskRand
-	(
-		T const & Radius
-	)
-	{		
-		detail::tvec2<T> Result(T(0));
-		T LenRadius(T(0));
-		
-		do
-		{
-			Result = linearRand(detail::tvec2<T>(-Radius), detail::tvec2<T>(Radius));
-			LenRadius = length(Result);
-		}
-		while(LenRadius > Radius);
-		
-		return Result;
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> ballRand
-	(
-		T const & Radius
-	)
-	{		
-		detail::tvec3<T> Result(T(0));
-		T LenRadius(T(0));
-		
-		do
-		{
-			Result = linearRand(detail::tvec3<T>(-Radius), detail::tvec3<T>(Radius));
-			LenRadius = length(Result);
-		}
-		while(LenRadius > Radius);
-		
-		return Result;
-	}
-	
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> circularRand
-	(
-		T const & Radius
-	)
-	{
-		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
-		return detail::tvec2<T>(cos(a), sin(a)) * Radius;		
-	}
-	
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> sphericalRand
-	(
-		T const & Radius
-	)
-	{
-		T z = linearRand(T(-1), T(1));
-		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
-	
-		T r = sqrt(T(1) - z * z);
-	
-		T x = r * cos(a);
-		T y = r * sin(a);
-	
-		return detail::tvec3<T>(x, y, z) * Radius;	
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/reciprocal.hpp b/include/gal/opengl/glm/gtc/reciprocal.hpp
deleted file mode 100644
index 4b04b66724..0000000000
--- a/include/gal/opengl/glm/gtc/reciprocal.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_reciprocal
-/// @file glm/gtc/reciprocal.hpp
-/// @date 2008-10-09 / 2012-01-25
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtc_reciprocal GLM_GTC_reciprocal
-/// @ingroup gtc
-/// 
-/// @brief Define secant, cosecant and cotangent functions.
-/// 
-/// <glm/gtc/reciprocal.hpp> need to be included to use these features.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_reciprocal
-#define GLM_GTC_reciprocal GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_reciprocal extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_reciprocal
-	/// @{
-
-	/// Secant function. 
-	/// hypotenuse / adjacent or 1 / cos(x)
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType sec(genType const & angle);
-
-	/// Cosecant function. 
-	/// hypotenuse / opposite or 1 / sin(x)
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType csc(genType const & angle);
-		
-	/// Cotangent function. 
-	/// adjacent / opposite or 1 / tan(x)
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType cot(genType const & angle);
-
-	/// Inverse secant function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType asec(genType const & x);
-
-	/// Inverse cosecant function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType acsc(genType const & x);
-		
-	/// Inverse cotangent function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType acot(genType const & x);
-
-	/// Secant hyperbolic function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType sech(genType const & angle);
-
-	/// Cosecant hyperbolic function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType csch(genType const & angle);
-		
-	/// Cotangent hyperbolic function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType coth(genType const & angle);
-
-	/// Inverse secant hyperbolic function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType asech(genType const & x);
-
-	/// Inverse cosecant hyperbolic function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType acsch(genType const & x);
-		
-	/// Inverse cotangent hyperbolic function. 
-	/// 
-	/// @see gtc_reciprocal
-	template <typename genType> 
-	genType acoth(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "reciprocal.inl"
-
-#endif//GLM_GTC_reciprocal
diff --git a/include/gal/opengl/glm/gtc/reciprocal.inl b/include/gal/opengl/glm/gtc/reciprocal.inl
deleted file mode 100644
index 84f5cb79ff..0000000000
--- a/include/gal/opengl/glm/gtc/reciprocal.inl
+++ /dev/null
@@ -1,199 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_reciprocal
-/// @file glm/gtc/reciprocal.inl
-/// @date 2008-10-09 / 2012-04-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// sec
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sec
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sec' only accept floating-point values");
-
-		return genType(1) / glm::cos(angle);
-	}
-
-	VECTORIZE_VEC(sec)
-
-	// csc
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType csc
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'csc' only accept floating-point values");
-
-		return genType(1) / glm::sin(angle);
-	}
-
-	VECTORIZE_VEC(csc)
-
-	// cot
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType cot
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cot' only accept floating-point values");
-
-		return genType(1) / glm::tan(angle);
-	}
-
-	VECTORIZE_VEC(cot)
-
-	// asec
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType asec
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asec' only accept floating-point values");
-	
-		return acos(genType(1) / x);
-	}
-
-	VECTORIZE_VEC(asec)
-
-	// acsc
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType acsc
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acsc' only accept floating-point values");
-
-		return asin(genType(1) / x);
-	}
-
-	VECTORIZE_VEC(acsc)
-
-	// acot
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType acot
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acot' only accept floating-point values");
-
-		genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0);
-		return pi_over_2 - atan(x);
-	}
-
-	VECTORIZE_VEC(acot)
-
-	// sech
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sech
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sech' only accept floating-point values");
-
-		return genType(1) / glm::cosh(angle);
-	}
-
-	VECTORIZE_VEC(sech)
-
-	// csch
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType csch
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'csch' only accept floating-point values");
-
-		return genType(1) / glm::sinh(angle);
-	}
-
-	VECTORIZE_VEC(csch)
-
-	// coth
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType coth
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'coth' only accept floating-point values");
-
-		return glm::cosh(angle) / glm::sinh(angle);
-	}
-
-	VECTORIZE_VEC(coth)
-
-	// asech
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType asech
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asech' only accept floating-point values");
-
-		return acosh(genType(1) / x);
-	}
-
-	VECTORIZE_VEC(asech)
-
-	// acsch
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType acsch
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acsch' only accept floating-point values");
-
-		return asinh(genType(1) / x);
-	}
-
-	VECTORIZE_VEC(acsch)
-
-	// acoth
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType acoth
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acoth' only accept floating-point values");
-
-		return atanh(genType(1) / x);
-	}
-
-	VECTORIZE_VEC(acoth)
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/swizzle.hpp b/include/gal/opengl/glm/gtc/swizzle.hpp
deleted file mode 100644
index 31fdf61e21..0000000000
--- a/include/gal/opengl/glm/gtc/swizzle.hpp
+++ /dev/null
@@ -1,375 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_swizzle
-/// @file glm/gtc/swizzle.hpp
-/// @date 2010-02-20 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// 
-/// @defgroup gtc_swizzle GLM_GTC_swizzle
-/// @ingroup gtc
-/// 
-/// @brief Provide functions to emulate GLSL swizzle operator fonctionalities.
-/// 
-/// <glm/gtc/swizzle.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_swizzle
-#define GLM_GTC_swizzle GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/type_precision.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_swizzle extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_swizzle
-	/// @{
-
-	template <typename T, template <typename> class vecType>
-	T const & swizzle(	
-		vecType<T> const & v,
-		comp x);
-
-	template <typename T, template <typename> class vecType>
-	detail::tvec2<T> const & swizzle(
-		vecType<T> const & v,
-		comp x, comp y);
-
-	template <typename T, template <typename> class vecType>
-	detail::tvec3<T> const & swizzle(
-		vecType<T> const & v,
-		comp x, comp y, comp z);
-
-	template <typename T, template <typename> class vecType>
-	detail::tvec4<T> const & swizzle(
-		vecType<T> const & v,
-		comp x, comp y, comp z, comp w);
-
-	template <typename T, template <typename> class vecType>
-	T & swizzle(
-		vecType<T> & v,
-		comp x);
-
-	template <typename T, template <typename> class vecType>
-	detail::tref2<T> swizzle(
-		vecType<T> & v,
-		comp x, comp y);
-
-	template <typename T, template <typename> class vecType>
-	detail::tref3<T> swizzle(
-		vecType<T> & v,
-		comp x, comp y, comp z);
-
-	template <typename T, template <typename> class vecType>
-	detail::tref4<T> swizzle(
-		vecType<T> & v,
-		comp x, comp y, comp z, comp w);
-
-#	define static_swizzle1_const(TYPE, SIZE)							\
-		template <comp x>										\
-		GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-		{return v[x];}											
-																
-#	define static_swizzle1_ref(TYPE, SIZE)									\
-		template <comp x>													\
-		GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE> & v)		\
-		{return v[x];}
-
-	static_swizzle1_ref(detail::float16, 2)
-	static_swizzle1_ref(detail::float16, 3)
-	static_swizzle1_ref(detail::float16, 4)
-	static_swizzle1_ref(detail::float32, 2)
-	static_swizzle1_ref(detail::float32, 3)
-	static_swizzle1_ref(detail::float32, 4)
-	static_swizzle1_ref(detail::float64, 2)
-	static_swizzle1_ref(detail::float64, 3)
-	static_swizzle1_ref(detail::float64, 4)
-
-	static_swizzle1_ref(detail::int8,  2)
-	static_swizzle1_ref(detail::int8,  3)
-	static_swizzle1_ref(detail::int8,  4)
-	static_swizzle1_ref(detail::int16, 2)
-	static_swizzle1_ref(detail::int16, 3)
-	static_swizzle1_ref(detail::int16, 4)
-	static_swizzle1_ref(detail::int32, 2)
-	static_swizzle1_ref(detail::int32, 3)
-	static_swizzle1_ref(detail::int32, 4)
-	static_swizzle1_ref(detail::int64, 2)
-	static_swizzle1_ref(detail::int64, 3)
-	static_swizzle1_ref(detail::int64, 4)
-
-	static_swizzle1_ref(detail::uint8,  2)
-	static_swizzle1_ref(detail::uint8,  3)
-	static_swizzle1_ref(detail::uint8,  4)
-	static_swizzle1_ref(detail::uint16, 2)
-	static_swizzle1_ref(detail::uint16, 3)
-	static_swizzle1_ref(detail::uint16, 4)
-	static_swizzle1_ref(detail::uint32, 2)
-	static_swizzle1_ref(detail::uint32, 3)
-	static_swizzle1_ref(detail::uint32, 4)
-	static_swizzle1_ref(detail::uint64, 2)
-	static_swizzle1_ref(detail::uint64, 3)
-	static_swizzle1_ref(detail::uint64, 4)
-/*
-#	define static_swizzle2_const(TYPE) \
-		template <comp x, comp y> \
-		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
-		{return TYPE(v[x], v[y]);}
-
-#	define static_swizzle3_const(TYPE) \
-		template <comp x, comp y, comp z> \
-		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
-		{return TYPE(v[x], v[y], v[z]);}
-
-#	define static_swizzle4_const(TYPE) \
-		template <comp x, comp y, comp z, comp w> \
-		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
-		{return TYPE(v[x], v[y], v[z], v[w]);}
-*/
-
-#	define static_swizzle2_const(TYPE, SIZE)									\
-		template <comp x, comp y>												\
-		GLM_FUNC_QUALIFIER detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-		{return detail::tvec2<TYPE>(v[x], v[y]);}
-
-#	define static_swizzle3_const(TYPE, SIZE)									\
-		template <comp x, comp y, comp z>										\
-		GLM_FUNC_QUALIFIER detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-		{return detail::tvec3<TYPE>(v[x], v[y], v[z]);}
-
-#	define static_swizzle4_const(TYPE, SIZE)									\
-		template <comp x, comp y, comp z, comp w>								\
-		GLM_FUNC_QUALIFIER detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-		{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
-
-
-	static_swizzle2_const(glm::f16, 2)
-	static_swizzle2_const(glm::f16, 3)
-	static_swizzle2_const(glm::f16, 4)
-	static_swizzle2_const(glm::f32, 2)
-	static_swizzle2_const(glm::f32, 3)
-	static_swizzle2_const(glm::f32, 4)
-	static_swizzle2_const(glm::f64, 2)
-	static_swizzle2_const(glm::f64, 3)
-	static_swizzle2_const(glm::f64, 4)
-
-	static_swizzle2_const(glm::i8, 2)
-	static_swizzle2_const(glm::i8, 3)
-	static_swizzle2_const(glm::i8, 4)
-	static_swizzle2_const(glm::i16, 2)
-	static_swizzle2_const(glm::i16, 3)
-	static_swizzle2_const(glm::i16, 4)
-	static_swizzle2_const(glm::i32, 2)
-	static_swizzle2_const(glm::i32, 3)
-	static_swizzle2_const(glm::i32, 4)
-	static_swizzle2_const(glm::i64, 2)
-	static_swizzle2_const(glm::i64, 3)
-	static_swizzle2_const(glm::i64, 4)
-
-	static_swizzle2_const(glm::u8, 2)
-	static_swizzle2_const(glm::u8, 3)
-	static_swizzle2_const(glm::u8, 4)
-	static_swizzle2_const(glm::u16, 2)
-	static_swizzle2_const(glm::u16, 3)
-	static_swizzle2_const(glm::u16, 4)
-	static_swizzle2_const(glm::u32, 2)
-	static_swizzle2_const(glm::u32, 3)
-	static_swizzle2_const(glm::u32, 4)
-	static_swizzle2_const(glm::u64, 2)
-	static_swizzle2_const(glm::u64, 3)
-	static_swizzle2_const(glm::u64, 4)
-
-	static_swizzle3_const(glm::f16, 2)
-	static_swizzle3_const(glm::f16, 3)
-	static_swizzle3_const(glm::f16, 4)
-	static_swizzle3_const(glm::f32, 2)
-	static_swizzle3_const(glm::f32, 3)
-	static_swizzle3_const(glm::f32, 4)
-	static_swizzle3_const(glm::f64, 2)
-	static_swizzle3_const(glm::f64, 3)
-	static_swizzle3_const(glm::f64, 4)
-
-	static_swizzle3_const(glm::i8, 2)
-	static_swizzle3_const(glm::i8, 3)
-	static_swizzle3_const(glm::i8, 4)
-	static_swizzle3_const(glm::i16, 2)
-	static_swizzle3_const(glm::i16, 3)
-	static_swizzle3_const(glm::i16, 4)
-	static_swizzle3_const(glm::i32, 2)
-	static_swizzle3_const(glm::i32, 3)
-	static_swizzle3_const(glm::i32, 4)
-	static_swizzle3_const(glm::i64, 2)
-	static_swizzle3_const(glm::i64, 3)
-	static_swizzle3_const(glm::i64, 4)
-
-	static_swizzle3_const(glm::u8, 2)
-	static_swizzle3_const(glm::u8, 3)
-	static_swizzle3_const(glm::u8, 4)
-	static_swizzle3_const(glm::u16, 2)
-	static_swizzle3_const(glm::u16, 3)
-	static_swizzle3_const(glm::u16, 4)
-	static_swizzle3_const(glm::u32, 2)
-	static_swizzle3_const(glm::u32, 3)
-	static_swizzle3_const(glm::u32, 4)
-	static_swizzle3_const(glm::u64, 2)
-	static_swizzle3_const(glm::u64, 3)
-	static_swizzle3_const(glm::u64, 4)
-
-	static_swizzle4_const(glm::f16, 2)
-	static_swizzle4_const(glm::f16, 3)
-	static_swizzle4_const(glm::f16, 4)
-	static_swizzle4_const(glm::f32, 2)
-	static_swizzle4_const(glm::f32, 3)
-	static_swizzle4_const(glm::f32, 4)
-	static_swizzle4_const(glm::f64, 2)
-	static_swizzle4_const(glm::f64, 3)
-	static_swizzle4_const(glm::f64, 4)
-
-	static_swizzle4_const(glm::i8, 2)
-	static_swizzle4_const(glm::i8, 3)
-	static_swizzle4_const(glm::i8, 4)
-	static_swizzle4_const(glm::i16, 2)
-	static_swizzle4_const(glm::i16, 3)
-	static_swizzle4_const(glm::i16, 4)
-	static_swizzle4_const(glm::i32, 2)
-	static_swizzle4_const(glm::i32, 3)
-	static_swizzle4_const(glm::i32, 4)
-	static_swizzle4_const(glm::i64, 2)
-	static_swizzle4_const(glm::i64, 3)
-	static_swizzle4_const(glm::i64, 4)
-
-	static_swizzle4_const(glm::u8, 2)
-	static_swizzle4_const(glm::u8, 3)
-	static_swizzle4_const(glm::u8, 4)
-	static_swizzle4_const(glm::u16, 2)
-	static_swizzle4_const(glm::u16, 3)
-	static_swizzle4_const(glm::u16, 4)
-	static_swizzle4_const(glm::u32, 2)
-	static_swizzle4_const(glm::u32, 3)
-	static_swizzle4_const(glm::u32, 4)
-	static_swizzle4_const(glm::u64, 2)
-	static_swizzle4_const(glm::u64, 3)
-	static_swizzle4_const(glm::u64, 4)
-
-#	define static_swizzle2_ref(TYPE, SIZE) \
-		template <glm::comp x, glm::comp y> \
-		GLM_FUNC_QUALIFIER glm::detail::tref2<TYPE> swizzle(detail::tvec##SIZE<TYPE> & v) \
-		{return glm::detail::tref2<TYPE>(v[x], v[y]);}	
-
-#	define static_swizzle3_ref(TYPE, SIZE) \
-		template <glm::comp x, glm::comp y, glm::comp z> \
-		GLM_FUNC_QUALIFIER glm::detail::tref3<TYPE> swizzle(detail::tvec##SIZE<TYPE> & v) \
-		{return glm::detail::tref3<TYPE>(v[x], v[y], v[z]);}	
-
-#	define static_swizzle4_ref(TYPE, SIZE) \
-		template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
-		GLM_FUNC_QUALIFIER glm::detail::tref4<TYPE> swizzle(detail::tvec##SIZE<TYPE> & v) \
-		{return glm::detail::tref4<TYPE>(v[x], v[y], v[z], v[w]);}	
-
-	static_swizzle2_ref(glm::f16, 2)
-	static_swizzle2_ref(glm::f16, 3)
-	static_swizzle2_ref(glm::f16, 4)
-	static_swizzle2_ref(glm::f32, 2)
-	static_swizzle2_ref(glm::f32, 3)
-	static_swizzle2_ref(glm::f32, 4)
-	static_swizzle2_ref(glm::f64, 2)
-	static_swizzle2_ref(glm::f64, 3)
-	static_swizzle2_ref(glm::f64, 4)
-
-	static_swizzle2_ref(glm::i8, 2)
-	static_swizzle2_ref(glm::i8, 3)
-	static_swizzle2_ref(glm::i8, 4)
-	static_swizzle2_ref(glm::i16, 2)
-	static_swizzle2_ref(glm::i16, 3)
-	static_swizzle2_ref(glm::i16, 4)
-	static_swizzle2_ref(glm::i32, 2)
-	static_swizzle2_ref(glm::i32, 3)
-	static_swizzle2_ref(glm::i32, 4)
-	static_swizzle2_ref(glm::i64, 2)
-	static_swizzle2_ref(glm::i64, 3)
-	static_swizzle2_ref(glm::i64, 4)
-
-	static_swizzle2_ref(glm::u8, 2)
-	static_swizzle2_ref(glm::u8, 3)
-	static_swizzle2_ref(glm::u8, 4)
-	static_swizzle2_ref(glm::u16, 2)
-	static_swizzle2_ref(glm::u16, 3)
-	static_swizzle2_ref(glm::u16, 4)
-	static_swizzle2_ref(glm::u32, 2)
-	static_swizzle2_ref(glm::u32, 3)
-	static_swizzle2_ref(glm::u32, 4)
-	static_swizzle2_ref(glm::u64, 2)
-	static_swizzle2_ref(glm::u64, 3)
-	static_swizzle2_ref(glm::u64, 4)
-
-	static_swizzle3_ref(glm::f16, 3)
-	static_swizzle3_ref(glm::f16, 4)
-	static_swizzle3_ref(glm::f32, 3)
-	static_swizzle3_ref(glm::f32, 4)
-	static_swizzle3_ref(glm::f64, 3)
-	static_swizzle3_ref(glm::f64, 4)
-
-	static_swizzle3_ref(glm::i8, 3)
-	static_swizzle3_ref(glm::i8, 4)
-	static_swizzle3_ref(glm::i16, 3)
-	static_swizzle3_ref(glm::i16, 4)
-	static_swizzle3_ref(glm::i32, 3)
-	static_swizzle3_ref(glm::i32, 4)
-	static_swizzle3_ref(glm::i64, 3)
-	static_swizzle3_ref(glm::i64, 4)
-
-	static_swizzle3_ref(glm::u8, 3)
-	static_swizzle3_ref(glm::u8, 4)
-	static_swizzle3_ref(glm::u16, 3)
-	static_swizzle3_ref(glm::u16, 4)
-	static_swizzle3_ref(glm::u32, 3)
-	static_swizzle3_ref(glm::u32, 4)
-	static_swizzle3_ref(glm::u64, 3)
-	static_swizzle3_ref(glm::u64, 4)
-
-	static_swizzle4_ref(glm::f16, 4)
-	static_swizzle4_ref(glm::f32, 4)
-	static_swizzle4_ref(glm::f64, 4)
-
-	static_swizzle4_ref(glm::i8, 4)
-	static_swizzle4_ref(glm::i16, 4)
-	static_swizzle4_ref(glm::i32, 4)
-	static_swizzle4_ref(glm::i64, 4)
-
-	static_swizzle4_ref(glm::u8, 4)
-	static_swizzle4_ref(glm::u16, 4)
-	static_swizzle4_ref(glm::u32, 4)
-	static_swizzle4_ref(glm::u64, 4)
-
-	/// @}
-}//namespace glm
-
-#include "swizzle.inl"
-
-#endif//GLM_GTC_swizzle
diff --git a/include/gal/opengl/glm/gtc/swizzle.inl b/include/gal/opengl/glm/gtc/swizzle.inl
deleted file mode 100644
index 043b8fc880..0000000000
--- a/include/gal/opengl/glm/gtc/swizzle.inl
+++ /dev/null
@@ -1,116 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_swizzle
-/// @file glm/gtc/swizzle.inl
-/// @date 2011-01-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T, template <typename> class vecType>
-	GLM_FUNC_QUALIFIER T swizzle
-	(
-		vecType<T> const & v,
-		comp x
-	)
-	{
-		assert(int(x) < int(vecType<T>::value_size));
-		return v[x];
-	}
-
-	template <typename T, template <typename> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> swizzle
-	(
-		vecType<T> const & v,
-		comp x, comp y
-	)
-	{
-		return detail::tvec2<T>(
-			v[x],
-			v[y]);
-	}
-
-	template <typename T, template <typename> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> swizzle
-	(
-		vecType<T> const & v,
-		comp x, comp y, comp z
-	)
-	{
-		return detail::tvec3<T>(
-			v[x],
-			v[y],
-			v[z]);
-	}
-
-	template <typename T, template <typename> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> swizzle
-	(
-		vecType<T> const & v,
-		comp x, comp y, comp z, comp w
-	)
-	{
-		return detail::tvec4<T>(v[x], v[y],	v[z], v[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T& swizzle
-	(
-		detail::tvec4<T> & v,
-		comp x
-	)
-	{
-		return v[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tref2<T> swizzle
-	(
-		detail::tvec4<T> & v,
-		comp x, comp y
-	)
-	{
-		return detail::tref2<T>(v[x], v[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tref3<T> swizzle
-	(
-		detail::tvec4<T> & v,
-		comp x, comp y, comp z
-	)
-	{
-		return detail::tref3<T>(v[x], v[y],	v[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tref4<T> swizzle
-	(
-		detail::tvec4<T> & v,
-		comp x, comp y, comp z, comp w
-	)
-	{
-		return detail::tref4<T>(v[x], v[y],	v[z], v[w]);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtc/type_precision.hpp b/include/gal/opengl/glm/gtc/type_precision.hpp
deleted file mode 100644
index 80a96c30cf..0000000000
--- a/include/gal/opengl/glm/gtc/type_precision.hpp
+++ /dev/null
@@ -1,669 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-/// 
-/// @ref gtc_type_precision
-/// @file glm/gtc/type_precision.hpp
-/// @date 2009-06-04 / 2011-12-07
-/// @author Christophe Riccio
-/// 
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtc_quaternion (dependence)
-/// 
-/// @defgroup gtc_type_precision GLM_GTC_type_precision
-/// @ingroup gtc
-/// 
-/// @brief Defines specific C++-based precision types.
-/// 
-/// @ref core_precision defines types based on GLSL's precision qualifiers. This
-/// extension defines types based on explicitly-sized C++ data types.
-/// 
-/// <glm/gtc/type_precision.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_type_precision
-#define GLM_GTC_type_precision GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-#include "../gtc/quaternion.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_type_precision extension included")
-#endif
-
-namespace glm
-{
-	///////////////////////////
-	// Signed int vector types 
-
-	/// @addtogroup gtc_type_precision
-	/// @{
-
-	/// 8 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int8 int8;
-	
-	/// 16 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int16 int16;
-
-	/// 32 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int32 int32;
-
-	/// 64 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int64 int64;
-
-
-	/// 8 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int8 int8_t;
-	
-	/// 16 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int16 int16_t;
-
-	/// 32 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int32 int32_t;
-
-	/// 64 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int64 int64_t;
-
-
-	/// 8 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int8 i8;
-	
-	/// 16 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int16 i16;
-
-	/// 32 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int32 i32;
-
-	/// 64 bit signed integer type. 
-	/// @see gtc_type_precision
-	typedef detail::int64 i64;
-
-
-	/// 8 bit signed integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<i8> i8vec1;
-	
-	/// 8 bit signed integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<i8> i8vec2;
-
-	/// 8 bit signed integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<i8> i8vec3;
-
-	/// 8 bit signed integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<i8> i8vec4;
-
-
-	/// 16 bit signed integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<i16> i16vec1;
-	
-	/// 16 bit signed integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<i16> i16vec2;
-
-	/// 16 bit signed integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<i16> i16vec3;
-
-	/// 16 bit signed integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<i16> i16vec4;
-
-
-	/// 32 bit signed integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<i32> i32vec1;
-	
-	/// 32 bit signed integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<i32> i32vec2;
-
-	/// 32 bit signed integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<i32> i32vec3;
-
-	/// 32 bit signed integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<i32> i32vec4;
-
-
-	/// 64 bit signed integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<i64> i64vec1;
-	
-	/// 64 bit signed integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<i64> i64vec2;
-
-	/// 64 bit signed integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<i64> i64vec3;
-
-	/// 64 bit signed integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<i64> i64vec4;
-
-
-	/////////////////////////////
-	// Unsigned int vector types 
-
-	/// 8 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint8 uint8;
-	
-	/// 16 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint16 uint16;
-
-	/// 32 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint32 uint32;
-
-	/// 64 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint64 uint64;
-
-
-	/// 8 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint8 uint8_t;
-	
-	/// 16 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint16 uint16_t;
-
-	/// 32 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint32 uint32_t;
-
-	/// 64 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint64 uint64_t;
-
-
-	/// 8 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint8 u8;
-	
-	/// 16 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint16 u16;
-
-	/// 32 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint32 u32;
-
-	/// 64 bit unsigned integer type. 
-	/// @see gtc_type_precision
-	typedef detail::uint64 u64;
-
-
-	/// 8 bit unsigned integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<u8> u8vec1;
-	
-	/// 8 bit unsigned integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<u8> u8vec2;
-
-	/// 8 bit unsigned integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<u8> u8vec3;
-
-	/// 8 bit unsigned integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<u8> u8vec4;
-
-
-	/// 16 bit unsigned integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<u16> u16vec1;
-	
-	/// 16 bit unsigned integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<u16> u16vec2;
-
-	/// 16 bit unsigned integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<u16> u16vec3;
-
-	/// 16 bit unsigned integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<u16> u16vec4;
-
-
-	/// 32 bit unsigned integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<u32> u32vec1;
-	
-	/// 32 bit unsigned integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<u32> u32vec2;
-
-	/// 32 bit unsigned integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<u32> u32vec3;
-
-	/// 32 bit unsigned integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<u32> u32vec4;
-
-
-	/// 64 bit unsigned integer scalar type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<u64> u64vec1;
-	
-	/// 64 bit unsigned integer vector of 2 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<u64> u64vec2;
-
-	/// 64 bit unsigned integer vector of 3 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<u64> u64vec3;
-
-	/// 64 bit unsigned integer vector of 4 components type. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<u64> u64vec4;
-
-
-	//////////////////////
-	// Float vector types 
-
-	/// 16 bit half-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef detail::float16 float16;
-
-	/// 32 bit single-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef detail::float32 float32;
-
-	/// 64 bit double-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef detail::float64 float64;
-
-
-	/// 16 bit half-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef detail::float16 float16_t;
-
-	/// 32 bit single-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef detail::float32 float32_t;
-
-	/// 64 bit double-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef detail::float64 float64_t;
-
-
-	/// 16 bit half-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef float16 f16;
-
-	/// 32 bit single-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef float32 f32;
-
-	/// 64 bit double-precision floating-point scalar. 
-	/// @see gtc_type_precision
-	typedef float64 f64;
-
-
-	/// Single-precision floating-point vector of 1 component. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<float> fvec1;
-
-	/// Single-precision floating-point vector of 2 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<float> fvec2;
-
-	/// Single-precision floating-point vector of 3 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<float> fvec3;
-
-	/// Single-precision floating-point vector of 4 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<float> fvec4;
-
-
-	/// Half-precision floating-point vector of 1 component. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<f16> f16vec1;
-
-	/// Half-precision floating-point vector of 2 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<f16> f16vec2;
-
-	/// Half-precision floating-point vector of 3 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<f16> f16vec3;
-
-	/// Half-precision floating-point vector of 4 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<f16> f16vec4;
-
-	
-	/// Single-precision floating-point vector of 1 component. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<f32> f32vec1;
-
-	/// Single-precision floating-point vector of 2 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<f32> f32vec2;
-
-	/// Single-precision floating-point vector of 3 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<f32> f32vec3;
-
-	/// Single-precision floating-point vector of 4 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<f32> f32vec4;
-
-
-	/// Double-precision floating-point vector of 1 component. 
-	/// @see gtc_type_precision
-	typedef detail::tvec1<f64> f64vec1;
-
-	/// Double-precision floating-point vector of 2 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec2<f64> f64vec2;
-
-	/// Double-precision floating-point vector of 3 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec3<f64> f64vec3;
-
-	/// Double-precision floating-point vector of 4 components. 
-	/// @see gtc_type_precision
-	typedef detail::tvec4<f64> f64vec4;
-
-
-	//////////////////////
-	// Float matrix types 
-
-	/// Single-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f32> fmat1;
-
-	/// Single-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32> fmat2;
-
-	/// Single-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32> fmat3;
-
-	/// Single-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32> fmat4;
-
-
-	/// Single-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef f32 fmat1x1;
-
-	/// Single-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32> fmat2x2;
-
-	/// Single-precision floating-point 2x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32> fmat2x3;
-
-	/// Single-precision floating-point 2x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f32> fmat2x4;
-
-	/// Single-precision floating-point 3x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f32> fmat3x2;
-
-	/// Single-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32> fmat3x3;
-
-	/// Single-precision floating-point 3x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f32> fmat3x4;
-
-	/// Single-precision floating-point 4x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f32> fmat4x2;
-
-	/// Single-precision floating-point 4x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f32> fmat4x3;
-
-	/// Single-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32> fmat4x4;
-
-
-	/// Half-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f16> f16mat1;
-
-	/// Half-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f16> f16mat2;
-
-	/// Half-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f16> f16mat3;
-
-	/// Half-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f16> f16mat4;
-
-
-	/// Half-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef f16 f16mat1x1;
-
-	/// Half-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f16> f16mat2x2;
-
-	/// Half-precision floating-point 2x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f16> f16mat2x3;
-
-	/// Half-precision floating-point 2x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f16> f16mat2x4;
-
-	/// Half-precision floating-point 3x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f16> f16mat3x2;
-
-	/// Half-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f16> f16mat3x3;
-
-	/// Half-precision floating-point 3x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f16> f16mat3x4;
-
-	/// Half-precision floating-point 4x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f16> f16mat4x2;
-
-	/// Half-precision floating-point 4x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f16> f16mat4x3;
-
-	/// Half-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f16> f16mat4x4;
-
-
-	/// Single-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f32> f32mat1;
-
-	/// Single-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32> f32mat2;
-
-	/// Single-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32> f32mat3;
-
-	/// Single-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32> f32mat4;
-
-
-	/// Single-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef f32 f32mat1x1;
-
-	/// Single-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32> f32mat2x2;
-
-	/// Single-precision floating-point 2x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32> f32mat2x3;
-
-	/// Single-precision floating-point 2x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f32> f32mat2x4;
-
-	/// Single-precision floating-point 3x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f32> f32mat3x2;
-
-	/// Single-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32> f32mat3x3;
-
-	/// Single-precision floating-point 3x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f32> f32mat3x4;
-
-	/// Single-precision floating-point 4x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f32> f32mat4x2;
-
-	/// Single-precision floating-point 4x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f32> f32mat4x3;
-
-	/// Single-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32> f32mat4x4;
-
-
-	/// Double-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f64> f64mat1;
-
-	/// Double-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f64> f64mat2;
-
-	/// Double-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64> f64mat3;
-
-	/// Double-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f64> f64mat4;
-
-
-	/// Double-precision floating-point 1x1 matrix. 
-	/// @see gtc_type_precision
-	//typedef f64 f64mat1x1;
-
-	/// Double-precision floating-point 2x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f64> f64mat2x2;
-
-	/// Double-precision floating-point 2x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f64> f64mat2x3;
-
-	/// Double-precision floating-point 2x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f64> f64mat2x4;
-
-	/// Double-precision floating-point 3x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f64> f64mat3x2;
-
-	/// Double-precision floating-point 3x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64> f64mat3x3;
-
-	/// Double-precision floating-point 3x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f64> f64mat3x4;
-
-	/// Double-precision floating-point 4x2 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f64> f64mat4x2;
-
-	/// Double-precision floating-point 4x3 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f64> f64mat4x3;
-
-	/// Double-precision floating-point 4x4 matrix. 
-	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f64> f64mat4x4;
-
-
-	//////////////////////////
-	// Quaternion types 
-
-	/// Half-precision floating-point quaternion. 
-	/// @see gtc_type_precision
-	typedef detail::tquat<f16> f16quat;
-
-	/// Single-precision floating-point quaternion. 
-	/// @see gtc_type_precision
-	typedef detail::tquat<f32> f32quat;
-
-	/// Double-precision floating-point quaternion. 
-	/// @see gtc_type_precision
-	typedef detail::tquat<f64> f64quat;
-
-	/// @}
-}//namespace glm
-
-#include "type_precision.inl"
-
-#endif//GLM_GTC_type_precision
diff --git a/include/gal/opengl/glm/gtc/type_precision.inl b/include/gal/opengl/glm/gtc/type_precision.inl
deleted file mode 100644
index 5bb4ab8955..0000000000
--- a/include/gal/opengl/glm/gtc/type_precision.inl
+++ /dev/null
@@ -1,32 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_swizzle
-/// @file glm/gtc/swizzle.inl
-/// @date 2009-06-14 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-
-}
diff --git a/include/gal/opengl/glm/gtc/type_ptr.hpp b/include/gal/opengl/glm/gtc/type_ptr.hpp
deleted file mode 100644
index 4939573358..0000000000
--- a/include/gal/opengl/glm/gtc/type_ptr.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_type_ptr
-/// @file glm/gtc/type_ptr.hpp
-/// @date 2009-05-06 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtc_quaternion (dependence)
-///
-/// @defgroup gtc_type_ptr GLM_GTC_type_ptr
-/// @ingroup gtc
-///
-/// @brief Handles the interaction between pointers and vector, matrix types.
-/// 
-/// This extension defines an overloaded function, glm::value_ptr, which
-/// takes any of the \ref core_template "core template types". It returns
-/// a pointer to the memory layout of the object. Matrix types store their values
-/// in column-major order.
-/// 
-/// This is useful for uploading data to matrices or copying data to buffer objects.
-///
-/// Example:
-/// @code
-/// #include <glm/glm.hpp>
-/// #include <glm/gtc/type_ptr.hpp>
-/// 
-/// glm::vec3 aVector(3);
-/// glm::mat4 someMatrix(1.0);
-/// 
-/// glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector));
-/// glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));
-/// @endcode
-/// 
-/// <glm/gtc/type_ptr.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_type_ptr
-#define GLM_GTC_type_ptr GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-#include "../gtc/quaternion.hpp"
-#include <cstring>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_type_ptr extension included")
-#endif
-
-namespace glm
-{ 
-	/// @addtogroup gtc_type_ptr
-	/// @{
-    
-	/// Return the constant address to the data of the input parameter.
-    /// @see gtc_type_ptr
-	template<typename genType>
-    typename genType::value_type const * value_ptr(genType const & vec);
-
-	/// Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tvec2<T> make_vec2(T const * const ptr);
-
-	/// Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tvec3<T> make_vec3(T const * const ptr);
-
-	/// Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tvec4<T> make_vec4(T const * const ptr);
-
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x2<T> make_mat2x2(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x3<T> make_mat2x3(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x4<T> make_mat2x4(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x2<T> make_mat3x2(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x3<T> make_mat3x3(T const * const ptr);
-
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x4<T> make_mat3x4(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x2<T> make_mat4x2(
-        T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x3<T> make_mat4x3(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x4<T> make_mat4x4(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x2<T> make_mat2(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x3<T> make_mat3(T const * const ptr);
-		
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x4<T> make_mat4(T const * const ptr);
- 
-	/// Build a quaternion from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tquat<T> make_quat(T const * const ptr);
-    
-	/// @}
-}//namespace glm
-
-#include "type_ptr.inl"
-
-#endif//GLM_GTC_type_ptr
-
diff --git a/include/gal/opengl/glm/gtc/type_ptr.inl b/include/gal/opengl/glm/gtc/type_ptr.inl
deleted file mode 100644
index 6c5a15774e..0000000000
--- a/include/gal/opengl/glm/gtc/type_ptr.inl
+++ /dev/null
@@ -1,473 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_type_ptr
-/// @file glm/gtc/type_ptr.inl
-/// @date 2011-06-15 / 2011-12-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{ 
-	/// @addtogroup gtc_type_ptr
-	/// @{
-
-	/// Return the constant address to the data of the input parameter.
-    /// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tvec2<T> const & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tvec2<T> & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tvec3<T> const & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tvec3<T> & vec
-	)
-	{
-		return &(vec.x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(	
-		detail::tvec4<T> const & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	//! From GLM_GTC_type_ptr extension.
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(	
-		detail::tvec4<T> & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat2x2<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat2x2<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat3x3<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat3x3<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat4x4<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	//! From GLM_GTC_type_ptr extension.
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat4x4<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat2x3<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat2x3<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat3x2<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat3x2<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat2x4<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat2x4<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat4x2<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(	
-		detail::tmat4x2<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat3x4<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat3x4<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat4x3<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-    
-	//! Get the address of the matrix content.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
-	{
-		return &(mat[0].x);
-	}
-    
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-        detail::tquat<T> const & q
-    )
-	{
-		return &(q[0]);
-	}
-    
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-        detail::tquat<T> & q
-    )
-	{
-		return &(q[0]);
-	}
-
-	//! Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
-	{
-		detail::tvec2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
-		return Result;
-	}
-
-	//! Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
-	{
-		detail::tvec3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
-		return Result;
-	}
-
-	//! Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
-	{
-		detail::tvec4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
-		return Result;
-	}
-
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
-	{
-		detail::tmat2x2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
-	{
-		detail::tmat2x3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
-	{
-		detail::tmat2x4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
-	{
-		detail::tmat3x2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
-	{
-		detail::tmat3x3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
-		return Result;
-	}
-
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
-	{
-		detail::tmat3x4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
-	{
-		detail::tmat4x2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
-	{
-		detail::tmat4x3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
-	{
-		detail::tmat4x4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
-	{
-		return make_mat2x2(ptr);
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
-	{
-		return make_mat3x3(ptr);
-	}
-		
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
-	{
-		return make_mat4x4(ptr);
-	}
- 
-	//! Build a quaternion from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> make_quat(T const * const ptr)
-	{
-		detail::tquat<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T>));
-		return Result;
-	}
-    
-	/// @}
-}//namespace glm
-
diff --git a/include/gal/opengl/glm/gtc/ulp.hpp b/include/gal/opengl/glm/gtc/ulp.hpp
deleted file mode 100644
index 7ab0d6a2c4..0000000000
--- a/include/gal/opengl/glm/gtc/ulp.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_ulp
-/// @file glm/gtc/ulp.hpp
-/// @date 2011-02-21 / 2011-12-12
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtc_ulp GLM_GTC_ulp
-/// @ingroup gtc
-/// 
-/// @brief Allow the measurement of the accuracy of a function against a reference 
-/// implementation. This extension works on floating-point data and provide results 
-/// in ULP.
-/// <glm/gtc/ulp.hpp> need to be included to use these features.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_ulp
-#define GLM_GTC_ulp GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_ulp extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_ulp
-	/// @{
-
-	/// Return the next ULP value(s) after the input value(s).
-	/// @see gtc_ulp
-    template <typename genType>
-    genType next_float(genType const & x);
-        
-	/// Return the previous ULP value(s) before the input value(s).
-	/// @see gtc_ulp
-    template <typename genType>
-    genType prev_float(genType const & x);
-
-	/// Return the value(s) ULP distance after the input value(s).
-	/// @see gtc_ulp
-    template <typename genType>
-    genType next_float(genType const & x, uint const & Distance);
-        
-    /// Return the value(s) ULP distance before the input value(s).
-	/// @see gtc_ulp
-    template <typename genType>
-    genType prev_float(genType const & x, uint const & Distance);
-        
-    /// Return the distance in the number of ULP between 2 scalars.
-	/// @see gtc_ulp
-    template <typename T>
-    uint float_distance(T const & x, T const & y);
-        
-    /// Return the distance in the number of ULP between 2 vectors.
-	/// @see gtc_ulp
-    template<typename T, template<typename> class vecType>
-    vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
-        
-	/// @}
-}// namespace glm
-
-#include "ulp.inl"
-
-#endif//GLM_GTC_ulp
-
diff --git a/include/gal/opengl/glm/gtc/ulp.inl b/include/gal/opengl/glm/gtc/ulp.inl
deleted file mode 100644
index 997a816374..0000000000
--- a/include/gal/opengl/glm/gtc/ulp.inl
+++ /dev/null
@@ -1,318 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtc_ulp
-/// @file glm/gtc/ulp.inl
-/// @date 2011-03-07 / 2012-04-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-/// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
-///
-/// Developed at SunPro, a Sun Microsystems, Inc. business.
-/// Permission to use, copy, modify, and distribute this
-/// software is freely granted, provided that this notice
-/// is preserved.
-///////////////////////////////////////////////////////////////////////////////////
-
-#include <cmath>
-#include <cfloat>
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#	pragma warning(push)
-#	pragma warning(disable : 4127)
-#endif
-
-typedef union
-{
-	float value;
-	/* FIXME: Assumes 32 bit int.  */
-	unsigned int word;
-} ieee_float_shape_type;
-
-typedef union
-{
-	double value;
-	struct
-	{
-		glm::detail::int32 lsw;
-		glm::detail::int32 msw;
-	} parts;
-} ieee_double_shape_type;
-
-#define GLM_EXTRACT_WORDS(ix0,ix1,d)                                \
-	do {                                                            \
-	  ieee_double_shape_type ew_u;                                  \
-	  ew_u.value = (d);                                             \
-	  (ix0) = ew_u.parts.msw;                                       \
-	  (ix1) = ew_u.parts.lsw;                                       \
-	} while (0)
-
-#define GLM_GET_FLOAT_WORD(i,d)                                     \
-	do {                                                            \
-	  ieee_float_shape_type gf_u;                                   \
-	  gf_u.value = (d);                                             \
-	  (i) = gf_u.word;                                              \
-	} while (0)
-
-#define GLM_SET_FLOAT_WORD(d,i)                                     \
-	do {                                                            \
-	  ieee_float_shape_type sf_u;                                   \
-	  sf_u.word = (i);                                              \
-	  (d) = sf_u.value;                                             \
-	} while (0)
-
-#define GLM_INSERT_WORDS(d,ix0,ix1)                                 \
-	do {                                                            \
-	  ieee_double_shape_type iw_u;                                  \
-	  iw_u.parts.msw = (ix0);                                       \
-	  iw_u.parts.lsw = (ix1);                                       \
-	  (d) = iw_u.value;                                             \
-	} while (0)
-
-namespace glm{
-namespace detail
-{
-	GLM_FUNC_QUALIFIER float nextafterf(float x, float y)
-	{
-		volatile float t;
-		glm::detail::int32 hx, hy, ix, iy;
-
-		GLM_GET_FLOAT_WORD(hx, x);
-		GLM_GET_FLOAT_WORD(hy, y);
-		ix = hx&0x7fffffff;             // |x|
-		iy = hy&0x7fffffff;             // |y|
-
-		if((ix>0x7f800000) ||   // x is nan 
-			(iy>0x7f800000))     // y is nan 
-			return x+y;
-		if(x==y) return y;              // x=y, return y
-		if(ix==0) {                             // x == 0
-			GLM_SET_FLOAT_WORD(x,(hy&0x80000000)|1);// return +-minsubnormal
-			t = x*x;
-			if(t==x) return t; else return x;   // raise underflow flag
-		}
-		if(hx>=0) {                             // x > 0 
-			if(hx>hy) {                         // x > y, x -= ulp
-				hx -= 1;
-			} else {                            // x < y, x += ulp
-				hx += 1;
-			}
-		} else {                                // x < 0
-			if(hy>=0||hx>hy){                   // x < y, x -= ulp
-				hx -= 1;
-			} else {                            // x > y, x += ulp
-				hx += 1;
-			}
-		}
-		hy = hx&0x7f800000;
-		if(hy>=0x7f800000) return x+x;  // overflow
-		if(hy<0x00800000) {             // underflow
-			t = x*x;
-			if(t!=x) {          // raise underflow flag
-				GLM_SET_FLOAT_WORD(y,hx);
-				return y;
-			}
-		}
-		GLM_SET_FLOAT_WORD(x,hx);
-		return x;
-	}
-
-	GLM_FUNC_QUALIFIER double nextafter(double x, double y)
-	{
-		volatile double t;
-		glm::detail::int32 hx, hy, ix, iy;
-		glm::detail::uint32 lx, ly;
-
-		GLM_EXTRACT_WORDS(hx, lx, x);
-		GLM_EXTRACT_WORDS(hy, ly, y);
-		ix = hx & 0x7fffffff;             // |x| 
-		iy = hy & 0x7fffffff;             // |y| 
-
-		if(((ix>=0x7ff00000)&&((ix-0x7ff00000)|lx)!=0) ||   // x is nan
-			((iy>=0x7ff00000)&&((iy-0x7ff00000)|ly)!=0))     // y is nan
-			return x+y;
-		if(x==y) return y;              // x=y, return y
-		if((ix|lx)==0) {                        // x == 0 
-			GLM_INSERT_WORDS(x, hy & 0x80000000, 1);    // return +-minsubnormal
-			t = x*x;
-			if(t==x) return t; else return x;   // raise underflow flag 
-		}
-		if(hx>=0) {                             // x > 0 
-			if(hx>hy||((hx==hy)&&(lx>ly))) {    // x > y, x -= ulp 
-				if(lx==0) hx -= 1;
-				lx -= 1;
-			} else {                            // x < y, x += ulp
-				lx += 1;
-				if(lx==0) hx += 1;
-			}
-		} else {                                // x < 0 
-			if(hy>=0||hx>hy||((hx==hy)&&(lx>ly))){// x < y, x -= ulp
-				if(lx==0) hx -= 1;
-				lx -= 1;
-			} else {                            // x > y, x += ulp
-				lx += 1;
-				if(lx==0) hx += 1;
-			}
-		}
-		hy = hx&0x7ff00000;
-		if(hy>=0x7ff00000) return x+x;  // overflow
-		if(hy<0x00100000) {             // underflow
-			t = x*x;
-			if(t!=x) {          // raise underflow flag
-				GLM_INSERT_WORDS(y,hx,lx);
-				return y;
-			}
-		}
-		GLM_INSERT_WORDS(x,hx,lx);
-		return x;
-	}
-}//namespace detail
-}//namespace glm
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#	pragma warning(pop)
-#endif
-
-#if((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
-#	define GLM_NEXT_AFTER_FLT(x, toward) glm::detail::nextafterf((x), (toward))
-#	define GLM_NEXT_AFTER_DBL(x, toward) _nextafter((x), (toward))
-#else
-#	define GLM_NEXT_AFTER_FLT(x, toward) nextafterf((x), (toward))
-#	define GLM_NEXT_AFTER_DBL(x, toward) nextafter((x), (toward))
-#endif
-
-namespace glm
-{
-	GLM_FUNC_QUALIFIER float next_float(float const & x)
-	{
-		return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::max());
-	}
-
-	GLM_FUNC_QUALIFIER double next_float(double const & x)
-	{
-		return GLM_NEXT_AFTER_DBL(x, std::numeric_limits<double>::max());
-	}
-
-	template<typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> next_float(vecType<T> const & x)
-	{
-		vecType<T> Result;
-		for(std::size_t i = 0; i < Result.length(); ++i)
-			Result[i] = next_float(x[i]);
-		return Result;
-	}
-
-	GLM_FUNC_QUALIFIER float prev_float(float const & x)
-	{
-		return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::min());
-	}
-
-	GLM_FUNC_QUALIFIER double prev_float(double const & x)
-	{
-		return GLM_NEXT_AFTER_DBL(x, std::numeric_limits<double>::min());
-	}
-
-	template<typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> prev_float(vecType<T> const & x)
-	{
-		vecType<T> Result;
-		for(std::size_t i = 0; i < Result.length(); ++i)
-			Result[i] = prev_float(x[i]);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T next_float(T const & x, uint const & ulps)
-	{
-		T temp = x;
-		for(std::size_t i = 0; i < ulps; ++i)
-			temp = next_float(temp);
-		return temp;
-	}
-
-	template<typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> next_float(vecType<T> const & x, vecType<uint> const & ulps)
-	{
-		vecType<T> Result;
-		for(std::size_t i = 0; i < Result.length(); ++i)
-			Result[i] = next_float(x[i], ulps[i]);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T prev_float(T const & x, uint const & ulps)
-	{
-		T temp = x;
-		for(std::size_t i = 0; i < ulps; ++i)
-			temp = prev_float(temp);
-		return temp;
-	}
-
-	template<typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> prev_float(vecType<T> const & x, vecType<uint> const & ulps)
-	{
-		vecType<T> Result;
-		for(std::size_t i = 0; i < Result.length(); ++i)
-			Result[i] = prev_float(x[i], ulps[i]);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint float_distance(T const & x, T const & y)
-	{
-		uint ulp = 0;
-
-		if(x < y)
-		{
-			T temp = x;
-			while(temp != y && ulp < std::numeric_limits<std::size_t>::max())
-			{
-				++ulp;
-				temp = next_float(temp);
-			}
-		}
-		else if(y < x)
-		{
-			T temp = y;
-			while(temp != x && ulp < std::numeric_limits<std::size_t>::max())
-			{
-				++ulp;
-				temp = next_float(temp);
-			}
-		}
-		else // ==
-		{
-
-		}
-
-		return ulp;
-	}
-
-	template<typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y)
-	{
-		vecType<uint> Result;
-		for(std::size_t i = 0; i < Result.length(); ++i)
-			Result[i] = float_distance(x[i], y[i]);
-		return Result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/associated_min_max.hpp b/include/gal/opengl/glm/gtx/associated_min_max.hpp
deleted file mode 100644
index 7283b6952c..0000000000
--- a/include/gal/opengl/glm/gtx/associated_min_max.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_associated_min_max
-/// @file glm/gtx/associated_min_max.hpp
-/// @date 2008-03-10 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_associated_min_max GLM_GTX_associated_min_max
-/// @ingroup gtx
-/// 
-/// @brief Min and max functions that return associated values not the compared onces.
-/// <glm/gtx/associated_min_max.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_associated_min_max
-#define GLM_GTX_associated_min_max GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_associated_min_max extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_associated_min_max
-	/// @{
-
-	/// Min comparison between 2 variables
-	/// @see gtx_associated_min_max
-	template<typename genTypeT, typename genTypeU>
-	genTypeU associatedMin(
-		const genTypeT& x, const genTypeU& a, 
-		const genTypeT& y, const genTypeU& b);
-
-	/// Min comparison between 3 variables
-	/// @see gtx_associated_min_max
-	template<typename genTypeT, typename genTypeU>
-	genTypeU associatedMin(
-		const genTypeT& x, const genTypeU& a, 
-		const genTypeT& y, const genTypeU& b, 
-		const genTypeT& z, const genTypeU& c);
-
-	/// Min comparison between 4 variables
-	/// @see gtx_associated_min_max
-	template<typename genTypeT, typename genTypeU>
-	genTypeU associatedMin(
-		const genTypeT& x, const genTypeU& a, 
-		const genTypeT& y, const genTypeU& b, 
-		const genTypeT& z, const genTypeU& c, 
-		const genTypeT& w, const genTypeU& d);
-
-	/// Max comparison between 2 variables
-	/// @see gtx_associated_min_max
-	template<typename genTypeT, typename genTypeU>
-	genTypeU associatedMax(
-		const genTypeT& x, const genTypeU& a, 
-		const genTypeT& y, const genTypeU& b);
-
-	/// Max comparison between 3 variables
-	/// @see gtx_associated_min_max
-	template<typename genTypeT, typename genTypeU>
-	genTypeU associatedMax(
-		const genTypeT& x, const genTypeU& a, 
-		const genTypeT& y, const genTypeU& b, 
-		const genTypeT& z, const genTypeU& c);
-
-	/// Max comparison between 4 variables
-	/// @see gtx_associated_min_max
-	template<typename genTypeT, typename genTypeU>
-	genTypeU associatedMax(
-		const genTypeT& x, const genTypeU& a, 
-		const genTypeT& y, const genTypeU& b, 
-		const genTypeT& z, const genTypeU& c, 
-		const genTypeT& w, const genTypeU& d);
-
-	/// @}
-} //namespace glm
-
-#include "associated_min_max.inl"
-
-#endif//GLM_GTX_associated_min_max
diff --git a/include/gal/opengl/glm/gtx/associated_min_max.inl b/include/gal/opengl/glm/gtx/associated_min_max.inl
deleted file mode 100644
index ffaa1efb80..0000000000
--- a/include/gal/opengl/glm/gtx/associated_min_max.inl
+++ /dev/null
@@ -1,912 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2008-03-10
-// Updated : 2008-03-15
-// Licence : This source is under MIT License
-// File    : gtx_associated_min_max.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-
-// Min comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
-{
-	return x < y ? a : b;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-	const detail::tvec2<T>& y, const detail::tvec2<U>& b
-)
-{
-	detail::tvec2<U> Result;
-	//Result.x = x[0] < y[0] ? a[0] : b[0];
-	//Result.y = x[1] < y[1] ? a[1] : b[1];
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x[i] < y[i] ? a[i] : b[i];
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-	const detail::tvec3<T>& y, const detail::tvec3<U>& b
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x[i] < y[i] ? a[i] : b[i];
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-	const detail::tvec4<T>& y, const detail::tvec4<U>& b
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x[i] < y[i] ? a[i] : b[i];
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	T x, const detail::tvec2<U>& a,
-	T y, const detail::tvec2<U>& b
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x < y ? a[i] : b[i];
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	T x, const detail::tvec3<U>& a,
-	T y, const detail::tvec3<U>& b
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x < y ? a[i] : b[i];
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	T x, const detail::tvec4<U>& a,
-	T y, const detail::tvec4<U>& b
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x < y ? a[i] : b[i];
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	const detail::tvec2<T>& x, U a,
-	const detail::tvec2<T>& y, U b
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-		Result[i] = x[i] < y[i] ? a : b;
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	const detail::tvec3<T>& x, U a,
-	const detail::tvec3<T>& y, U b
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-		Result[i] = x[i] < y[i] ? a : b;
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	const detail::tvec4<T>& x, U a,
-	const detail::tvec4<T>& y, U b
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-		Result[i] = x[i] < y[i] ? a : b;
-	return Result;
-}
-
-// Min comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER U associatedMin
-(
-	T x, U a,
-	T y, U b,
-	T z, U c
-)
-{
-	U Result = x < y ? (x < z ? a : c) : (y < z ? b : c);
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-	const detail::tvec2<T>& z, const detail::tvec2<U>& c
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-	const detail::tvec3<T>& z, const detail::tvec3<U>& c
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
-	return Result;
-}
-
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-	const detail::tvec4<T>& z, const detail::tvec4<U>& c
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER U associatedMin
-(
-	T x, U a,
-	T y, U b,
-	T z, U c,
-	T w, U d
-)
-{
-	T Test1 = min(x, y);
-	T Test2 = min(z, w);;
-	U Result1 = x < y ? a : b;
-	U Result2 = z < w ? c : d;
-	U Result = Test1 < Test2 ? Result1 : Result2;
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-	const detail::tvec2<T>& z, const detail::tvec2<U>& c,
-	const detail::tvec2<T>& w, const detail::tvec2<U>& d
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-	{
-		T Test1 = min(x[i], y[i]);
-		T Test2 = min(z[i], w[i]);
-		U Result1 = x[i] < y[i] ? a[i] : b[i];
-		U Result2 = z[i] < w[i] ? c[i] : d[i];
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-	const detail::tvec3<T>& z, const detail::tvec3<U>& c,
-	const detail::tvec3<T>& w, const detail::tvec3<U>& d
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-	{
-		T Test1 = min(x[i], y[i]);
-		T Test2 = min(z[i], w[i]);
-		U Result1 = x[i] < y[i] ? a[i] : b[i];
-		U Result2 = z[i] < w[i] ? c[i] : d[i];
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-	const detail::tvec4<T>& z, const detail::tvec4<U>& c,
-	const detail::tvec4<T>& w, const detail::tvec4<U>& d
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-	{
-		T Test1 = min(x[i], y[i]);
-		T Test2 = min(z[i], w[i]);
-		U Result1 = x[i] < y[i] ? a[i] : b[i];
-		U Result2 = z[i] < w[i] ? c[i] : d[i];
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	T x, const detail::tvec2<U>& a,
-	T y, const detail::tvec2<U>& b,
-	T z, const detail::tvec2<U>& c,
-	T w, const detail::tvec2<U>& d
-)
-{
-	T Test1 = min(x, y);
-	T Test2 = min(z, w);
-
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-	{
-		U Result1 = x < y ? a[i] : b[i];
-		U Result2 = z < w ? c[i] : d[i];
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	T x, const detail::tvec3<U>& a,
-	T y, const detail::tvec3<U>& b,
-	T z, const detail::tvec3<U>& c,
-	T w, const detail::tvec3<U>& d
-)
-{
-	T Test1 = min(x, y);
-	T Test2 = min(z, w);
-
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-	{
-		U Result1 = x < y ? a[i] : b[i];
-		U Result2 = z < w ? c[i] : d[i];
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	T x, const detail::tvec4<U>& a,
-	T y, const detail::tvec4<U>& b,
-	T z, const detail::tvec4<U>& c,
-	T w, const detail::tvec4<U>& d
-)
-{
-	T Test1 = min(x, y);
-	T Test2 = min(z, w);
-
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-	{
-		U Result1 = x < y ? a[i] : b[i];
-		U Result2 = z < w ? c[i] : d[i];
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-(
-	const detail::tvec2<T>& x, U a,
-	const detail::tvec2<T>& y, U b,
-	const detail::tvec2<T>& z, U c,
-	const detail::tvec2<T>& w, U d
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-	{
-		T Test1 = min(x[i], y[i]);
-		T Test2 = min(z[i], w[i]);;
-		U Result1 = x[i] < y[i] ? a : b;
-		U Result2 = z[i] < w[i] ? c : d;
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-(
-	const detail::tvec3<T>& x, U a,
-	const detail::tvec3<T>& y, U b,
-	const detail::tvec3<T>& z, U c,
-	const detail::tvec3<T>& w, U d
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-	{
-		T Test1 = min(x[i], y[i]);
-		T Test2 = min(z[i], w[i]);;
-		U Result1 = x[i] < y[i] ? a : b;
-		U Result2 = z[i] < w[i] ? c : d;
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Min comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-(
-	const detail::tvec4<T>& x, U a,
-	const detail::tvec4<T>& y, U b,
-	const detail::tvec4<T>& z, U c,
-	const detail::tvec4<T>& w, U d
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-	{
-		T Test1 = min(x[i], y[i]);
-		T Test2 = min(z[i], w[i]);;
-		U Result1 = x[i] < y[i] ? a : b;
-		U Result2 = z[i] < w[i] ? c : d;
-		Result[i] = Test1 < Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
-{
-	return x > y ? a : b;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-	const detail::tvec2<T>& y, const detail::tvec2<U>& b
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x[i] > y[i] ? a[i] : b[i];
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-	const detail::tvec3<T>& y, const detail::tvec3<U>& b
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x[i] > y[i] ? a[i] : b[i];
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-	const detail::tvec4<T>& y, const detail::tvec4<U>& b
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x[i] > y[i] ? a[i] : b[i];
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	T x, const detail::tvec2<U>& a,
-	T y, const detail::tvec2<U>& b
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x > y ? a[i] : b[i];
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	T x, const detail::tvec3<U>& a,
-	T y, const detail::tvec3<U>& b
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x > y ? a[i] : b[i];
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	T x, const detail::tvec4<U>& a,
-	T y, const detail::tvec4<U>& b
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x > y ? a[i] : b[i];
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	const detail::tvec2<T>& x, U a,
-	const detail::tvec2<T>& y, U b
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-		Result[i] = x[i] > y[i] ? a : b;
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	const detail::tvec3<T>& x, U a,
-	const detail::tvec3<T>& y, U b
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-		Result[i] = x[i] > y[i] ? a : b;
-	return Result;
-}
-
-// Max comparison between 2 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	const detail::tvec4<T>& x, U a,
-	const detail::tvec4<T>& y, U b
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-		Result[i] = x[i] > y[i] ? a : b;
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER U associatedMax
-(
-	T x, U a,
-	T y, U b,
-	T z, U c
-)
-{
-	U Result = x > y ? (x > z ? a : c) : (y > z ? b : c);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-	const detail::tvec2<T>& z, const detail::tvec2<U>& c
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-	const detail::tvec3<T>& z, const detail::tvec3<U>& c
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-	const detail::tvec4<T>& z, const detail::tvec4<U>& c
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	T x, const detail::tvec2<U>& a,
-	T y, const detail::tvec2<U>& b,
-	T z, const detail::tvec2<U>& c
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	T x, const detail::tvec3<U>& a,
-	T y, const detail::tvec3<U>& b,
-	T z, const detail::tvec3<U>& c
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	T x, const detail::tvec4<U>& a,
-	T y, const detail::tvec4<U>& b,
-	T z, const detail::tvec4<U>& c
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	const detail::tvec2<T>& x, U a,
-	const detail::tvec2<T>& y, U b,
-	const detail::tvec2<T>& z, U c
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	const detail::tvec3<T>& x, U a,
-	const detail::tvec3<T>& y, U b,
-	const detail::tvec3<T>& z, U c
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
-	return Result;
-}
-
-// Max comparison between 3 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	const detail::tvec4<T>& x, U a,
-	const detail::tvec4<T>& y, U b,
-	const detail::tvec4<T>& z, U c
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER U associatedMax
-(
-	T x, U a,
-	T y, U b,
-	T z, U c,
-	T w, U d
-)
-{
-	T Test1 = max(x, y);
-	T Test2 = max(z, w);;
-	U Result1 = x > y ? a : b;
-	U Result2 = z > w ? c : d;
-	U Result = Test1 > Test2 ? Result1 : Result2;
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-	const detail::tvec2<T>& z, const detail::tvec2<U>& c,
-	const detail::tvec2<T>& w, const detail::tvec2<U>& d
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-	{
-		T Test1 = max(x[i], y[i]);
-		T Test2 = max(z[i], w[i]);
-		U Result1 = x[i] > y[i] ? a[i] : b[i];
-		U Result2 = z[i] > w[i] ? c[i] : d[i];
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-	const detail::tvec3<T>& z, const detail::tvec3<U>& c,
-	const detail::tvec3<T>& w, const detail::tvec3<U>& d
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-	{
-		T Test1 = max(x[i], y[i]);
-		T Test2 = max(z[i], w[i]);
-		U Result1 = x[i] > y[i] ? a[i] : b[i];
-		U Result2 = z[i] > w[i] ? c[i] : d[i];
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-	const detail::tvec4<T>& z, const detail::tvec4<U>& c,
-	const detail::tvec4<T>& w, const detail::tvec4<U>& d
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-	{
-		T Test1 = max(x[i], y[i]);
-		T Test2 = max(z[i], w[i]);
-		U Result1 = x[i] > y[i] ? a[i] : b[i];
-		U Result2 = z[i] > w[i] ? c[i] : d[i];
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	T x, const detail::tvec2<U>& a,
-	T y, const detail::tvec2<U>& b,
-	T z, const detail::tvec2<U>& c,
-	T w, const detail::tvec2<U>& d
-)
-{
-	T Test1 = max(x, y);
-	T Test2 = max(z, w);
-
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-	{
-		U Result1 = x > y ? a[i] : b[i];
-		U Result2 = z > w ? c[i] : d[i];
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	T x, const detail::tvec3<U>& a,
-	T y, const detail::tvec3<U>& b,
-	T z, const detail::tvec3<U>& c,
-	T w, const detail::tvec3<U>& d
-)
-{
-	T Test1 = max(x, y);
-	T Test2 = max(z, w);
-
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-	{
-		U Result1 = x > y ? a[i] : b[i];
-		U Result2 = z > w ? c[i] : d[i];
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	T x, const detail::tvec4<U>& a,
-	T y, const detail::tvec4<U>& b,
-	T z, const detail::tvec4<U>& c,
-	T w, const detail::tvec4<U>& d
-)
-{
-	T Test1 = max(x, y);
-	T Test2 = max(z, w);
-
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-	{
-		U Result1 = x > y ? a[i] : b[i];
-		U Result2 = z > w ? c[i] : d[i];
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-(
-	const detail::tvec2<T>& x, U a,
-	const detail::tvec2<T>& y, U b,
-	const detail::tvec2<T>& z, U c,
-	const detail::tvec2<T>& w, U d
-)
-{
-	detail::tvec2<U> Result;
-	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-	{
-		T Test1 = max(x[i], y[i]);
-		T Test2 = max(z[i], w[i]);;
-		U Result1 = x[i] > y[i] ? a : b;
-		U Result2 = z[i] > w[i] ? c : d;
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-(
-	const detail::tvec3<T>& x, U a,
-	const detail::tvec3<T>& y, U b,
-	const detail::tvec3<T>& z, U c,
-	const detail::tvec3<T>& w, U d
-)
-{
-	detail::tvec3<U> Result;
-	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-	{
-		T Test1 = max(x[i], y[i]);
-		T Test2 = max(z[i], w[i]);;
-		U Result1 = x[i] > y[i] ? a : b;
-		U Result2 = z[i] > w[i] ? c : d;
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-// Max comparison between 4 variables
-template<typename T, typename U>
-GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-(
-	const detail::tvec4<T>& x, U a,
-	const detail::tvec4<T>& y, U b,
-	const detail::tvec4<T>& z, U c,
-	const detail::tvec4<T>& w, U d
-)
-{
-	detail::tvec4<U> Result;
-	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-	{
-		T Test1 = max(x[i], y[i]);
-		T Test2 = max(z[i], w[i]);;
-		U Result1 = x[i] > y[i] ? a : b;
-		U Result2 = z[i] > w[i] ? c : d;
-		Result[i] = Test1 > Test2 ? Result1 : Result2;
-	}
-	return Result;
-}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/bit.hpp b/include/gal/opengl/glm/gtx/bit.hpp
deleted file mode 100644
index 94aaae5712..0000000000
--- a/include/gal/opengl/glm/gtx/bit.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_bit
-/// @file glm/gtx/bit.hpp
-/// @date 2007-03-14 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-///
-/// @defgroup gtx_bit GLM_GTX_bit
-/// @ingroup gtx
-/// 
-/// @brief Allow to perform bit operations on integer values
-/// 
-/// <glm/gtx/bit.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_bit
-#define GLM_GTX_bit GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_bit extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_bit
-	/// @{
-
-	/// Build a mask of 'count' bits
-	/// @see gtx_bit
-	template <typename genIType>
-	genIType mask(genIType const & count);
-
-	/// Component wise extraction of bit fields.
-	/// genType and genIType could be a scalar or a vector.
-	/// @see gtx_bit
-	template <typename genIUType, typename sizeType>
-	GLM_DEPRECATED genIUType extractField(
-		genIUType const & v, 
-		sizeType const & first, 
-		sizeType const & count);
-
-	//! Find the lowest bit set to 1 in a integer variable.
-	/// @see gtx_bit
-	template <typename genType> 
-	GLM_DEPRECATED int lowestBit(genType const & value);
-
-	//! Find the highest bit set to 1 in a integer variable.
-	/// @see gtx_bit
-	template <typename genType> 
-	GLM_DEPRECATED int highestBit(genType const & value);
-
-	//! Find the highest bit set to 1 in a integer variable and return its value. 
-	/// @see gtx_bit
-	template <typename genType> 
-	genType highestBitValue(genType const & value);
-
-	//! Return true if the value is a power of two number. 
-	/// @see gtx_bit
-	template <typename genType> 
-	bool isPowerOfTwo(genType const & value);
-
-	//! Return the power of two number which value is just higher the input value.
-	/// @see gtx_bit
-	template <typename genType> 
-	genType powerOfTwoAbove(genType const & value);
-
-	//! Return the power of two number which value is just lower the input value. 
-	/// @see gtx_bit
-	template <typename genType> 
-	genType powerOfTwoBelow(genType const & value);
-
-	//! Return the power of two number which value is the closet to the input value. 
-	/// @see gtx_bit
-	template <typename genType> 
-	genType powerOfTwoNearest(genType const & value);
-
-	//! Revert all bits of any integer based type. 
-	/// @see gtx_bit
-	template <typename genType> 
-	GLM_DEPRECATED genType bitRevert(genType const & value);
-
-	//! Rotate all bits to the right.
-	/// @see gtx_bit
-	template <typename genType>
-	genType bitRotateRight(genType const & In, std::size_t Shift);
-
-	//! Rotate all bits to the left.
-	/// @see gtx_bit
-	template <typename genType>
-	genType bitRotateLeft(genType const & In, std::size_t Shift);
-
-	//! Set to 1 a range of bits.
-	/// @see gtx_bit
-	template <typename genIUType>
-	genIUType fillBitfieldWithOne(
-		genIUType const & Value,
-		int const & FromBit, 
-		int const & ToBit);
-
-	//! Set to 0 a range of bits.
-	/// @see gtx_bit
-	template <typename genIUType>
-	genIUType fillBitfieldWithZero(
-		genIUType const & Value,
-		int const & FromBit, 
-		int const & ToBit);
-
-	/// @}
-} //namespace glm
-
-#include "bit.inl"
-
-#endif//GLM_GTX_bit
diff --git a/include/gal/opengl/glm/gtx/bit.inl b/include/gal/opengl/glm/gtx/bit.inl
deleted file mode 100644
index 27647ae895..0000000000
--- a/include/gal/opengl/glm/gtx/bit.inl
+++ /dev/null
@@ -1,600 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-03-14
-// Updated : 2008-11-14
-// Licence : This source is under MIT License
-// File    : glm/gtx/bit.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genIType>
-	GLM_FUNC_QUALIFIER genIType mask
-	(
-		genIType const & count
-	)
-	{
-		return ((genIType(1) << (count)) - genIType(1));
-	}
-
-	VECTORIZE_VEC(mask)
-
-	// extractField
-	template <typename genIType>
-	GLM_FUNC_QUALIFIER genIType extractField
-	(
-		half const & value, 
-		genIType const & first, 
-		genIType const & count
-	)
-	{
-		assert(first + count < sizeof(half));
-		return (value._data() << first) >> ((sizeof(half) << 3) - count);
-	}
-
-	template <typename genIType>
-	GLM_FUNC_QUALIFIER genIType extractField
-	(
-		float const & value, 
-		genIType const & first, 
-		genIType const & count
-	)
-	{
-		assert(first + count < sizeof(float));
-		return (detail::uif32(value).i << first) >> ((sizeof(float) << 3) - count);
-	}
-
-	template <typename genIType>
-	GLM_FUNC_QUALIFIER genIType extractField
-	(
-		double const & value, 
-		genIType const & first, 
-		genIType const & count
-	)
-	{
-		assert(first + count < sizeof(double));
-		return (detail::uif64(value).i << first) >> ((sizeof(double) << genIType(3)) - count);
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER genIUType extractField
-	(
-		genIUType const & Value, 
-		sizeType const & First, 
-		sizeType const & Count
-	)
-	{
-		sizeType GenSize = sizeof(genIUType) << 3;
-
-		assert(First + Count <= GenSize);
-
-		genIUType ShiftLeft = Count ? Value << (GenSize - (Count + First)) : 0;
-		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Count);
-
-		return ShiftBack;
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
-	(
-		detail::tvec2<genIUType> const & value, 
-		sizeType const & first, 
-		sizeType const & count
-	)
-	{
-		return detail::tvec2<genIUType>(
-			extractField(value[0], first, count),
-			extractField(value[1], first, count));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
-	(
-		detail::tvec3<genIUType> const & value, 
-		sizeType const & first, 
-		sizeType const & count
-	)
-	{
-		return detail::tvec3<genIUType>(
-			extractField(value[0], first, count),
-			extractField(value[1], first, count),
-			extractField(value[2], first, count));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
-	(
-		detail::tvec4<genIUType> const & value, 
-		sizeType const & first, 
-		sizeType const & count
-	)
-	{
-		return detail::tvec4<genIUType>(
-			extractField(value[0], first, count),
-			extractField(value[1], first, count),
-			extractField(value[2], first, count),
-			extractField(value[3], first, count));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
-	(
-		detail::tvec2<genIUType> const & value, 
-		detail::tvec2<sizeType> const & first, 
-		detail::tvec2<sizeType> const & count
-	)
-	{
-		return detail::tvec2<genIUType>(
-			extractField(value[0], first[0], count[0]),
-			extractField(value[1], first[1], count[1]));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
-	(
-		detail::tvec3<genIUType> const & value, 
-		detail::tvec3<sizeType> const & first, 
-		detail::tvec3<sizeType> const & count
-	)
-	{
-		return detail::tvec3<genIUType>(
-			extractField(value[0], first[0], count[0]),
-			extractField(value[1], first[1], count[1]),
-			extractField(value[2], first[2], count[2]));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
-	(
-		detail::tvec4<genIUType> const & value, 
-		detail::tvec4<sizeType> const & first, 
-		detail::tvec4<sizeType> const & count
-	)
-	{
-		return detail::tvec4<genIUType>(
-			extractField(value[0], first[0], count[0]),
-			extractField(value[1], first[1], count[1]),
-			extractField(value[2], first[2], count[2]),
-			extractField(value[3], first[3], count[3]));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
-	(
-		genIUType const & value, 
-		detail::tvec2<sizeType> const & first, 
-		detail::tvec2<sizeType> const & count
-	)
-	{
-		return detail::tvec2<genIUType>(
-			extractField(value, first[0], count[0]),
-			extractField(value, first[1], count[1]));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
-	(
-		genIUType const & value, 
-		detail::tvec3<sizeType> const & first, 
-		detail::tvec3<sizeType> const & count
-	)
-	{
-		return detail::tvec3<genIUType>(
-			extractField(value, first[0], count[0]),
-			extractField(value, first[1], count[1]),
-			extractField(value, first[2], count[2]));
-	}
-
-	template <typename genIUType, typename sizeType>
-	GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
-	(
-		genIUType const & value, 
-		detail::tvec4<sizeType> const & first, 
-		detail::tvec4<sizeType> const & count
-	)
-	{
-		return detail::tvec4<genIUType>(
-			extractField(value, first[0], count[0]),
-			extractField(value, first[1], count[1]),
-			extractField(value, first[2], count[2]),
-			extractField(value, first[3], count[3]));
-	}
-
-	// lowestBit
-	template <typename genType>
-	GLM_FUNC_QUALIFIER int lowestBit
-	(
-		genType const & Value
-	)
-	{
-		assert(Value != genType(0)); // not valid call
-
-		genType Bit;
-		for(Bit = genType(0); !(Value & (1 << Bit)); ++Bit){}
-		return Bit;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> lowestBit
-	(
-		detail::tvec2<valType> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			lowestBit(value[0]),
-			lowestBit(value[1]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> lowestBit
-	(
-		detail::tvec3<valType> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			lowestBit(value[0]),
-			lowestBit(value[1]),
-			lowestBit(value[2]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> lowestBit
-	(
-		detail::tvec4<valType> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			lowestBit(value[0]),
-			lowestBit(value[1]),
-			lowestBit(value[2]),
-			lowestBit(value[3]));
-	}
-
-	// highestBit
-	template <typename genType>
-	GLM_FUNC_QUALIFIER int highestBit
-	(
-		genType const & value
-	)
-	{
-		assert(value != genType(0)); // not valid call
-
-		genType bit = genType(-1);
-		for(genType tmp = value; tmp; tmp >>= 1, ++bit){}
-		return bit;
-	}
-
-	//template <>
-	//GLM_FUNC_QUALIFIER int highestBit<int>
-	//(
-	//	int value
-	//)
-	//{
-	//	int bit = -1;
-	//	for(int tmp = value; tmp; tmp >>= 1, ++bit);
-	//	return bit;
-	//}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> highestBit
-	(
-		detail::tvec2<valType> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			highestBit(value[0]),
-			highestBit(value[1]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> highestBit
-	(
-		detail::tvec3<valType> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			highestBit(value[0]),
-			highestBit(value[1]),
-			highestBit(value[2]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> highestBit
-	(
-		detail::tvec4<valType> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			highestBit(value[0]),
-			highestBit(value[1]),
-			highestBit(value[2]),
-			highestBit(value[3]));
-	}
-
-	// highestBitValue
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType highestBitValue
-	(
-		genType const & value
-	)
-	{
-		genType tmp = value;
-		genType result = genType(0);
-		while(tmp)
-		{
-			result = (tmp & (~tmp + 1)); // grab lowest bit
-			tmp &= ~result; // clear lowest bit
-		}
-		return result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> highestBitValue
-	(
-		detail::tvec2<valType> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			highestBitValue(value[0]),
-			highestBitValue(value[1]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> highestBitValue
-	(
-		detail::tvec3<valType> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			highestBitValue(value[0]),
-			highestBitValue(value[1]),
-			highestBitValue(value[2]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> highestBitValue
-	(
-		detail::tvec4<valType> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			highestBitValue(value[0]),
-			highestBitValue(value[1]),
-			highestBitValue(value[2]),
-			highestBitValue(value[3]));
-	}
-
-	// isPowerOfTwo
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType const & Value)
-	{
-		//detail::If<std::numeric_limits<genType>::is_signed>::apply(abs, Value);
-		//return !(Value & (Value - 1));
-
-		// For old complier?
-		genType Result = Value;
-		if(std::numeric_limits<genType>::is_signed)
-			Result = abs(Result);
-		return !(Result & (Result - 1));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> isPowerOfTwo
-	(
-		detail::tvec2<valType> const & value
-	)
-	{
-		return detail::tvec2<bool>(
-			isPowerOfTwo(value[0]),
-			isPowerOfTwo(value[1]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> isPowerOfTwo
-	(
-		detail::tvec3<valType> const & value
-	)
-	{
-		return detail::tvec3<bool>(
-			isPowerOfTwo(value[0]),
-			isPowerOfTwo(value[1]),
-			isPowerOfTwo(value[2]));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> isPowerOfTwo
-	(
-		detail::tvec4<valType> const & value
-	)
-	{
-		return detail::tvec4<bool>(
-			isPowerOfTwo(value[0]),
-			isPowerOfTwo(value[1]),
-			isPowerOfTwo(value[2]),
-			isPowerOfTwo(value[3]));
-	}
-
-	// powerOfTwoAbove
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType const & value)
-	{
-		return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
-	}
-
-	VECTORIZE_VEC(powerOfTwoAbove)
-
-	// powerOfTwoBelow
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType powerOfTwoBelow
-	(
-		genType const & value
-	)
-	{
-		return isPowerOfTwo(value) ? value : highestBitValue(value);
-	}
-
-	VECTORIZE_VEC(powerOfTwoBelow)
-
-	// powerOfTwoNearest
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType powerOfTwoNearest
-	(
-		genType const & value
-	)
-	{
-		if(isPowerOfTwo(value))
-			return value;
-
-		genType prev = highestBitValue(value);
-		genType next = prev << 1;
-		return (next - value) < (value - prev) ? next : prev;
-	}
-
-	VECTORIZE_VEC(powerOfTwoNearest)
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType bitRevert(genType const & In)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRevert' only accept integer values");
-
-		genType Out = 0;
-		std::size_t BitSize = sizeof(genType) * 8;
-		for(std::size_t i = 0; i < BitSize; ++i)
-			if(In & (genType(1) << i))
-				Out |= genType(1) << (BitSize - 1 - i);
-		return Out;
-	}
-
-	VECTORIZE_VEC(bitRevert)
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType bitRotateRight(genType const & In, std::size_t Shift)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateRight' only accept integer values");
-
-		std::size_t BitSize = sizeof(genType) * 8;
-		return (In << Shift) | (In >> (BitSize - Shift));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateRight
-	(
-		detail::tvec2<valType> const & Value, 
-		std::size_t Shift
-	)
-	{
-		return detail::tvec2<valType>(
-			bitRotateRight(Value[0], Shift),
-			bitRotateRight(Value[1], Shift));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateRight
-	(
-		detail::tvec3<valType> const & Value, 
-		std::size_t Shift
-	)
-	{
-		return detail::tvec3<valType>(
-			bitRotateRight(Value[0], Shift),
-			bitRotateRight(Value[1], Shift),
-			bitRotateRight(Value[2], Shift));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateRight
-	(
-		detail::tvec4<valType> const & Value, 
-		std::size_t Shift
-	)
-	{
-		return detail::tvec4<valType>(
-			bitRotateRight(Value[0], Shift),
-			bitRotateRight(Value[1], Shift),
-			bitRotateRight(Value[2], Shift),
-			bitRotateRight(Value[3], Shift));
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType bitRotateLeft(genType const & In, std::size_t Shift)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateLeft' only accept integer values");
-
-		std::size_t BitSize = sizeof(genType) * 8;
-		return (In >> Shift) | (In << (BitSize - Shift));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateLeft
-	(
-		detail::tvec2<valType> const & Value, 
-		std::size_t Shift
-	)
-	{
-		return detail::tvec2<valType>(
-			bitRotateLeft(Value[0], Shift),
-			bitRotateLeft(Value[1], Shift));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateLeft
-	(
-		detail::tvec3<valType> const & Value, 
-		std::size_t Shift
-	)
-	{
-		return detail::tvec3<valType>(
-			bitRotateLeft(Value[0], Shift),
-			bitRotateLeft(Value[1], Shift),
-			bitRotateLeft(Value[2], Shift));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateLeft
-	(
-		detail::tvec4<valType> const & Value, 
-		std::size_t Shift
-	)
-	{
-		return detail::tvec4<valType>(
-			bitRotateLeft(Value[0], Shift),
-			bitRotateLeft(Value[1], Shift),
-			bitRotateLeft(Value[2], Shift),
-			bitRotateLeft(Value[3], Shift));
-	}
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType fillBitfieldWithOne
-	(
-		genIUType const & Value,
-		int const & FromBit, 
-		int const & ToBit
-	)
-	{
-		assert(FromBit <= ToBit);
-		assert(ToBit <= sizeof(genIUType) * std::size_t(8));
-
-		genIUType Result = Value;
-		for(std::size_t i = 0; i <= ToBit; ++i)
-			Result |= (1 << i);
-		return Result;
-	}
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
-	(
-		genIUType const & Value,
-		int const & FromBit, 
-		int const & ToBit
-	)
-	{
-		assert(FromBit <= ToBit);
-		assert(ToBit <= sizeof(genIUType) * std::size_t(8));
-
-		genIUType Result = Value;
-		for(std::size_t i = 0; i <= ToBit; ++i)
-			Result &= ~(1 << i);
-		return Result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/closest_point.hpp b/include/gal/opengl/glm/gtx/closest_point.hpp
deleted file mode 100644
index 7f795560bd..0000000000
--- a/include/gal/opengl/glm/gtx/closest_point.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_bit
-/// @file glm/gtx/bit.hpp
-/// @date 2005-12-30 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_closest_point GLM_GTX_closest_point
-/// @ingroup gtx
-///
-/// @brief Find the point on a straight line which is the closet of a point.
-/// 
-/// <glm/gtx/closest_point.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_closest_point
-#define GLM_GTX_closest_point GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_closest_point extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_closest_point
-	/// @{
-
-	/// Find the point on a straight line which is the closet of a point. 
-	/// @see gtx_closest_point
-	template <typename T> 
-	detail::tvec3<T> closestPointOnLine(
-		detail::tvec3<T> const & point, 
-		detail::tvec3<T> const & a, 
-		detail::tvec3<T> const & b);
-
-	/// @}
-}// namespace glm
-
-#include "closest_point.inl"
-
-#endif//GLM_GTX_closest_point
diff --git a/include/gal/opengl/glm/gtx/closest_point.inl b/include/gal/opengl/glm/gtx/closest_point.inl
deleted file mode 100644
index d018c1d16f..0000000000
--- a/include/gal/opengl/glm/gtx/closest_point.inl
+++ /dev/null
@@ -1,36 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-30
-// Updated : 2008-10-05
-// Licence : This source is under MIT License
-// File    : glm/gtx/closest_point.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_gtx_closest_point
-#define glm_gtx_closest_point
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
-	(
-		detail::tvec3<valType> const & point, 
-		detail::tvec3<valType> const & a, 
-		detail::tvec3<valType> const & b
-	)
-	{
-		valType LineLength = distance(a, b);
-		detail::tvec3<valType> Vector = point - a;
-		detail::tvec3<valType> LineDirection = (b - a) / LineLength;
-
-		// Project Vector to LineDirection to get the distance of point from a
-		valType Distance = dot(Vector, LineDirection);
-
-		if(Distance <= valType(0)) return a;
-		if(Distance >= LineLength) return b;
-		return a + LineDirection * Distance;
-	}
-}//namespace glm
-
-#endif//glm_gtx_closest_point
diff --git a/include/gal/opengl/glm/gtx/color_cast.hpp b/include/gal/opengl/glm/gtx/color_cast.hpp
deleted file mode 100644
index 5dada88e51..0000000000
--- a/include/gal/opengl/glm/gtx/color_cast.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_color_cast
-/// @file glm/gtx/color_cast.hpp
-/// @date 2007-06-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_number_precision (dependence)
-///
-/// @defgroup gtx_color_cast GLM_GTX_color_cast
-/// @ingroup gtx
-///
-/// @brief Conversion between two color types.
-/// 
-/// <glm/gtx/color_cast.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_color_cast
-#define GLM_GTX_color_cast GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/number_precision.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_color_cast extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_color_cast
-	/// @{
-
-	//! Conversion of a floating value into a 8bit unsigned int value. 
-	/// @see gtx_color_cast
-	template <typename valType> uint8 u8channel_cast(valType a);
-
-	/// Conversion of a floating value into a 16bit unsigned int value. 
-	/// @see gtx_color_cast
-	template <typename valType>	uint16 u16channel_cast(valType a);
-
-	template <typename T> uint32 u32_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint32 u32_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint32 u32_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint32 u32_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> uint32 u32_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint32 u32_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint32 u32_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint32 u32_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> uint64 u64_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint64 u64_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint64 u64_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint64 u64_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> uint64 u64_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint64 u64_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint64 u64_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> uint64 u64_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f16 f16_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f16vec3 f16_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f16vec3 f16_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f16vec3 f16_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f16vec3 f16_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f16vec4 f16_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f16vec4 f16_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f16vec4 f16_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f16vec4 f16_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f32 f32_channel_cast(T a);		//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f32vec3 f32_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f32vec3 f32_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f32vec3 f32_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f32vec3 f32_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f32vec4 f32_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f32vec4 f32_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f32vec4 f32_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f32vec4 f32_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f64 f64_channel_cast(T a);		//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f64vec3 f64_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f64vec3 f64_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f64vec3 f64_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f64vec3 f64_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T> f64vec4 f64_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-
-	/// @}
-}//namespace glm
-
-#include "color_cast.inl"
-
-#endif//GLM_GTX_color_cast
diff --git a/include/gal/opengl/glm/gtx/color_cast.inl b/include/gal/opengl/glm/gtx/color_cast.inl
deleted file mode 100644
index 55fd1ce608..0000000000
--- a/include/gal/opengl/glm/gtx/color_cast.inl
+++ /dev/null
@@ -1,733 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-06-21
-// Updated : 2007-08-03
-// Licence : This source is under MIT License
-// File    : glm/gtx/color_cast.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER uint8 u8channel_cast(T a)
-	{
-		return static_cast<uint8>(a * T(255));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER uint16 u16channel_cast(T a)
-	{
-		return static_cast<uint16>(a * T(65535));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_rgbx_cast(const detail::tvec3<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  0;
-		result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) << 16;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_xrgb_cast(const detail::tvec3<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) << 24;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_bgrx_cast(const detail::tvec3<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_xbgr_cast(const detail::tvec3<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) << 24;
-		result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.w * detail::tvec3<T>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_rgba_cast(const detail::tvec4<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  0;
-		result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_argb_cast(const detail::tvec4<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) << 24;
-		result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_bgra_cast(const detail::tvec4<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  0;
-		result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_abgr_cast(const detail::tvec4<T>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) << 24;
-		result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_rgbx_cast(const detail::tvec3<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) <<  0;
-		result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 32;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u32_xrgb_cast(const detail::tvec3<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 48;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u32_bgrx_cast(const detail::tvec3<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u32_xbgr_cast(const detail::tvec3<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 48;
-		result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.w * detail::tvec3<T>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_rgba_cast(const detail::tvec4<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) <<  0;
-		result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_argb_cast(const detail::tvec4<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 48;
-		result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_bgra_cast(const detail::tvec4<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) <<  0;
-		result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_abgr_cast(const detail::tvec4<T>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 48;
-		result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16 f16_channel_cast<uint32>(uint32 color)
-	{
-		return f16(static_cast<float>(color >>  0) / static_cast<float>(255));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_rgbx_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_xrgb_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_bgrx_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_xbgr_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_rgba_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_argb_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_bgra_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_abgr_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER float f32_channel_cast<uint8>(uint8 color)
-	{
-		return static_cast<float>(color >>  0) / static_cast<float>(255);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER double f64_channel_cast<uint8>(uint8 color)
-	{
-		return static_cast<double>(color >>  0) / static_cast<double>(255);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::half f16_channel_cast<uint16>(uint16 color)
-	{
-		return detail::half(static_cast<float>(color >>  0) / static_cast<float>(65535));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_rgbx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_xrgb_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_bgrx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_xbgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_rgba_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_argb_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_bgra_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_abgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER float f32_channel_cast<uint16>(uint16 color)
-	{
-		return static_cast<float>(color >>  0) / static_cast<float>(65535);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER double f64_channel_cast<uint16>(uint16 color)
-	{
-		return static_cast<double>(color >>  0) / static_cast<double>(65535);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/color_space.hpp b/include/gal/opengl/glm/gtx/color_space.hpp
deleted file mode 100644
index f144378f1b..0000000000
--- a/include/gal/opengl/glm/gtx/color_space.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_color_space
-/// @file glm/gtx/color_space.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_color_space GLM_GTX_color_space
-/// @ingroup gtx
-/// 
-/// @brief Related to RGB to HSV conversions and operations.
-/// 
-/// <glm/gtx/color_space.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_color_space
-#define GLM_GTX_color_space GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_color_space extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_color_space
-	/// @{
-
-	/// Converts a color from HSV color space to its color in RGB color space.
-	/// @see gtx_color_space
-    template <typename valType> 
-	detail::tvec3<valType> rgbColor(
-		detail::tvec3<valType> const & hsvValue);
-
-	/// Converts a color from RGB color space to its color in HSV color space.
-	/// @see gtx_color_space
-    template <typename valType> 
-	detail::tvec3<valType> hsvColor(
-		detail::tvec3<valType> const & rgbValue);
-		
-	/// Build a saturation matrix.
-	/// @see gtx_color_space
-    template <typename valType> 
-	detail::tmat4x4<valType> saturation(
-		valType const s);
-
-    /// Modify the saturation of a color.
-	/// @see gtx_color_space
-	template <typename valType> 
-	detail::tvec3<valType> saturation(
-		valType const s, 
-		detail::tvec3<valType> const & color);
-		
-	/// Modify the saturation of a color.
-	/// @see gtx_color_space
-    template <typename valType> 
-	detail::tvec4<valType> saturation(
-		valType const s, 
-		detail::tvec4<valType> const & color);
-		
-	/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
-	/// @see gtx_color_space
-	template <typename valType> 
-	valType luminosity(
-		detail::tvec3<valType> const & color);
-
-	/// @}
-}//namespace glm
-
-#include "color_space.inl"
-
-#endif//GLM_GTX_color_space
diff --git a/include/gal/opengl/glm/gtx/color_space.inl b/include/gal/opengl/glm/gtx/color_space.inl
deleted file mode 100644
index 15cdc35481..0000000000
--- a/include/gal/opengl/glm/gtx/color_space.inl
+++ /dev/null
@@ -1,149 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2007-02-22
-// Licence : This source is under MIT License
-// File    : glm/gtx/color_space.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
-	{
-		detail::tvec3<T> hsv = hsvColor;
-		detail::tvec3<T> rgbColor;
-
-		if(hsv.y == T(0))
-			// achromatic (grey)
-			rgbColor = detail::tvec3<T>(hsv.z);
-		else
-		{
-			T sector = floor(hsv.x / T(60));
-			T frac = (hsv.x / T(60)) - sector;
-			// factorial part of h
-			T o = hsv.z * (T(1) - hsv.y);
-			T p = hsv.z * (T(1) - hsv.y * frac);
-			T q = hsv.z * (T(1) - hsv.y * (T(1) - frac));
-
-			switch(int(sector))
-			{
-			default:
-			case 0:
-				rgbColor.r = hsv.z;
-				rgbColor.g = q;
-				rgbColor.b = o;
-				break;
-			case 1:
-				rgbColor.r = p;
-				rgbColor.g = hsv.z;
-				rgbColor.b = o;
-				break;
-			case 2:
-				rgbColor.r = o;
-				rgbColor.g = hsv.z;
-				rgbColor.b = q;
-				break;
-			case 3:
-				rgbColor.r = o;
-				rgbColor.g = p;
-				rgbColor.b = hsv.z;
-				break;
-			case 4:
-				rgbColor.r = q; 
-				rgbColor.g = o; 
-				rgbColor.b = hsv.z;
-				break;
-			case 5:
-				rgbColor.r = hsv.z; 
-				rgbColor.g = o; 
-				rgbColor.b = p;
-				break;
-			}
-		}
-
-		return rgbColor;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
-	{
-		detail::tvec3<T> hsv = rgbColor;
-		float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
-		float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
-		float Delta = Max - Min;
-
-		hsv.z = Max;                               
-    	
-		if(Max != T(0))
-		{
-			hsv.y = Delta / hsv.z;    
-			T h = T(0);
-
-			if(rgbColor.r == Max)
-				// between yellow & magenta
-				h = T(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta;
-			else if(rgbColor.g == Max)
-				// between cyan & yellow
-				h = T(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta;
-			else
-				// between magenta & cyan
-				h = T(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta;
-            
-			if(h < T(0)) 
-				hsv.x = h + T(360);
-			else
-				hsv.x = h;
-		}
-		else
-		{
-			// If r = g = b = 0 then s = 0, h is undefined
-			hsv.y = T(0);
-			hsv.x = T(0);
-		}
-
-		return hsv;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
-	{
-		detail::tvec3<T> rgbw = detail::tvec3<T>(T(0.2126), T(0.7152), T(0.0722));
-
-		T col0 = (T(1) - s) * rgbw.r;
-		T col1 = (T(1) - s) * rgbw.g;
-		T col2 = (T(1) - s) * rgbw.b;
-
-		detail::tmat4x4<T> result(T(1));
-		result[0][0] = col0 + s;
-		result[0][1] = col0;
-		result[0][2] = col0;
-		result[1][0] = col1;
-		result[1][1] = col1 + s;
-		result[1][2] = col1;
-		result[2][0] = col2;
-		result[2][1] = col2;
-		result[2][2] = col2 + s;
-		return result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> saturation(const T s, const detail::tvec3<T>& color)
-	{
-		return detail::tvec3<T>(saturation(s) * detail::tvec4<T>(color, T(0)));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> saturation(const T s, const detail::tvec4<T>& color)
-	{
-		return saturation(s) * color;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T>& color)
-	{
-		const detail::tvec3<T> tmp = detail::tvec3<T>(0.33, 0.59, 0.11);
-		return dot(color, tmp);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/color_space_YCoCg.hpp b/include/gal/opengl/glm/gtx/color_space_YCoCg.hpp
deleted file mode 100644
index 8ca4b1025d..0000000000
--- a/include/gal/opengl/glm/gtx/color_space_YCoCg.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_color_space_YCoCg
-/// @file glm/gtx/color_space_YCoCg.hpp
-/// @date 2008-10-28 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg
-/// @ingroup gtx
-///
-/// @brief RGB to YCoCg conversions and operations
-/// 
-/// <glm/gtx/color_space_YCoCg.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_gtx_color_space_YCoCg
-#define glm_gtx_color_space_YCoCg GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_color_space_YCoCg
-	/// @{
-
-    /// Convert a color from RGB color space to YCoCg color space.
-	/// @see gtx_color_space_YCoCg
-	template <typename valType> 
-	detail::tvec3<valType> rgb2YCoCg(
-		detail::tvec3<valType> const & rgbColor);
-
-    /// Convert a color from YCoCg color space to RGB color space.
-	/// @see gtx_color_space_YCoCg
-    template <typename valType> 
-	detail::tvec3<valType> YCoCg2rgb(
-		detail::tvec3<valType> const & YCoCgColor);
-
-    /// Convert a color from RGB color space to YCoCgR color space.
-	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
-	/// @see gtx_color_space_YCoCg
-	template <typename valType> 
-	detail::tvec3<valType> rgb2YCoCgR(
-		detail::tvec3<valType> const & rgbColor);
-
-    /// Convert a color from YCoCgR color space to RGB color space.
-	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
-	/// @see gtx_color_space_YCoCg
-    template <typename valType> 
-	detail::tvec3<valType> YCoCgR2rgb(
-		detail::tvec3<valType> const & YCoCgColor);
-
-	/// @}
-}//namespace glm
-
-#include "color_space_YCoCg.inl"
-
-#endif//glm_gtx_color_space_YCoCg
diff --git a/include/gal/opengl/glm/gtx/color_space_YCoCg.inl b/include/gal/opengl/glm/gtx/color_space_YCoCg.inl
deleted file mode 100644
index 08d8440789..0000000000
--- a/include/gal/opengl/glm/gtx/color_space_YCoCg.inl
+++ /dev/null
@@ -1,64 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2008-10-28
-// Updated : 2008-10-28
-// Licence : This source is under MIT License
-// File    : glm/gtx/color_space_YCoCg.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
-	(
-		detail::tvec3<valType> const & rgbColor
-	)
-	{
-		detail::tvec3<valType> result;
-		result.x/*Y */ =   rgbColor.r / valType(4) + rgbColor.g / valType(2) + rgbColor.b / valType(4);
-		result.y/*Co*/ =   rgbColor.r / valType(2) + rgbColor.g * valType(0) - rgbColor.b / valType(2);
-		result.z/*Cg*/ = - rgbColor.r / valType(4) + rgbColor.g / valType(2) - rgbColor.b / valType(4);
-		return result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCgR
-	(
-		detail::tvec3<valType> const & rgbColor
-	)
-	{
-		detail::tvec3<valType> result;
-		result.x/*Y */ = rgbColor.g / valType(2) + (rgbColor.r + rgbColor.b) / valType(4);
-		result.y/*Co*/ = rgbColor.r - rgbColor.b;
-		result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / valType(2);
-		return result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCg2rgb
-	(
-		detail::tvec3<valType> const & YCoCgColor
-	)
-	{
-		detail::tvec3<valType> result;
-		result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
-		result.g = YCoCgColor.x                + YCoCgColor.z;
-		result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
-		return result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
-	(
-		detail::tvec3<valType> const & YCoCgRColor
-	)
-	{
-		detail::tvec3<valType> result;
-		valType tmp = YCoCgRColor.x - (YCoCgRColor.z / valType(2));
-		result.g = YCoCgRColor.z + tmp;
-		result.b = tmp - (YCoCgRColor.y / valType(2));
-		result.r = result.b + YCoCgRColor.y;
-		return result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/compatibility.hpp b/include/gal/opengl/glm/gtx/compatibility.hpp
deleted file mode 100644
index c394a4396c..0000000000
--- a/include/gal/opengl/glm/gtx/compatibility.hpp
+++ /dev/null
@@ -1,176 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_compatibility
-/// @file glm/gtx/compatibility.hpp
-/// @date 2007-01-24 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-///
-/// @defgroup gtx_compatibility GLM_GTX_compatibility
-/// @ingroup gtx
-/// 
-/// @brief Provide functions to increase the compatibility with Cg and HLSL languages
-/// 
-/// <glm/gtx/compatibility.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_compatibility
-#define GLM_GTX_compatibility GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"  
-#include "../gtc/half_float.hpp"
-#include "../gtc/quaternion.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_compatibility extension included")
-#endif
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#	include <cfloat>
-#elif(GLM_COMPILER & GLM_COMPILER_GCC)
-#	include <cmath>
-#	if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-#		undef isfinite
-#	endif
-#endif//GLM_COMPILER
-
-namespace glm
-{
-	/// @addtogroup gtx_compatibility
-	/// @{
-
-	template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-
-	template <typename T> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T> const & x, detail::tquat<T> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
-
-	template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> saturate(const detail::tvec3<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> saturate(const detail::tvec4<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-
-	template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> atan2(const detail::tvec2<T>& x, const detail::tvec2<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> atan2(const detail::tvec3<T>& x, const detail::tvec3<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> atan2(const detail::tvec4<T>& x, const detail::tvec4<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-
-	template <typename genType> bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-
-	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<bool>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<bool>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<bool>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<bool>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<bool>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<bool>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<bool>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<bool>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<bool>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<bool>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<bool>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<bool>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<int>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<int>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<int>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<int>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<int>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<int>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<int>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<int>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<int>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<int>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<int>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<int>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef detail::half					half1;			//!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<detail::half>	half2;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<detail::half>	half3;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<detail::half>	half4;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-
-	typedef detail::half					half1x1;		//!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<detail::half>	half2x2;		//!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<detail::half>	half2x3;		//!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<detail::half>	half2x4;		//!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<detail::half>	half3x2;		//!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<detail::half>	half3x3;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<detail::half>	half3x4;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<detail::half>	half4x2;		//!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<detail::half>	half4x3;		//!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<detail::half>	half4x4;		//!< \brief half-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef float						float1;			//!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<float>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<float>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<float>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef float						float1x1;		//!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<float>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<float>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<float>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<float>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<float>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<float>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<float>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<float>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<float>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef double						double1;		//!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<double>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<double>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<double>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
-
-	typedef double						double1x1;		//!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<double>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<double>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<double>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<double>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<double>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<double>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<double>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-	/// @}
-}//namespace glm
-
-#include "compatibility.inl"
-
-#endif//GLM_GTX_compatibility
-
diff --git a/include/gal/opengl/glm/gtx/compatibility.inl b/include/gal/opengl/glm/gtx/compatibility.inl
deleted file mode 100644
index 073c6941b2..0000000000
--- a/include/gal/opengl/glm/gtx/compatibility.inl
+++ /dev/null
@@ -1,60 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-03-16
-// Updated : 2008-10-24
-// Licence : This source is under MIT License
-// File    : glm/gtx/compatibility.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// isfinite
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER bool isfinite(
-		genType const & x)
-	{
-#		if(GLM_COMPILER & GLM_COMPILER_VC)
-			return _finite(x);
-#		elif(GLM_COMPILER & GLM_COMPILER_GCC)
-#			if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-				return _isfinite(x) != 0;
-#			else
-				return std::isfinite(x) != 0;
-#			endif
-#		else
-			return std::isfinite(x) != 0;
-#		endif
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> isfinite(
-		detail::tvec2<valType> const & x)
-	{
-		return detail::tvec2<bool>(
-			isfinite(x.x),
-			isfinite(x.y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> isfinite(
-		detail::tvec3<valType> const & x)
-	{
-		return detail::tvec3<bool>(
-			isfinite(x.x),
-			isfinite(x.y),
-			isfinite(x.z));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> isfinite(
-		detail::tvec4<valType> const & x)
-	{
-		return detail::tvec4<bool>(
-			isfinite(x.x),
-			isfinite(x.y),
-			isfinite(x.z),
-			isfinite(x.w));
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/component_wise.hpp b/include/gal/opengl/glm/gtx/component_wise.hpp
deleted file mode 100644
index d3274be7ca..0000000000
--- a/include/gal/opengl/glm/gtx/component_wise.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_component_wise
-/// @file glm/gtx/component_wise.hpp
-/// @date 2007-05-21 / 2011-06-07
-/// @author Christophe Riccio
-/// 
-/// @see core (dependence)
-///
-/// @defgroup gtx_component_wise GLM_GTX_component_wise
-/// @ingroup gtx
-/// 
-/// @brief Operations between components of a type
-/// 
-/// <glm/gtx/component_wise.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_component_wise
-#define GLM_GTX_component_wise GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_component_wise extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_component_wise
-	/// @{
-
-	/// Add all vector components together. 
-	/// @see gtx_component_wise
-	template <typename genType> 
-	typename genType::value_type compAdd(
-		genType const & v);
-
-	/// Multiply all vector components together. 
-	/// @see gtx_component_wise
-	template <typename genType> 
-	typename genType::value_type compMul(
-		genType const & v);
-
-	/// Find the minimum value between single vector components.
-	/// @see gtx_component_wise
-	template <typename genType> 
-	typename genType::value_type compMin(
-		genType const & v);
-
-	/// Find the maximum value between single vector components.
-	/// @see gtx_component_wise
-	template <typename genType> 
-	typename genType::value_type compMax(
-		genType const & v);
-
-	/// @}
-}//namespace glm
-
-#include "component_wise.inl"
-
-#endif//GLM_GTX_component_wise
diff --git a/include/gal/opengl/glm/gtx/component_wise.inl b/include/gal/opengl/glm/gtx/component_wise.inl
deleted file mode 100644
index 8baea62b25..0000000000
--- a/include/gal/opengl/glm/gtx/component_wise.inl
+++ /dev/null
@@ -1,47 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-05-21
-// Updated : 2010-02-12
-// Licence : This source is under MIT License
-// File    : gtx_component_wise.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
-	{
-		typename genType::value_type result = typename genType::value_type(0);
-		for(typename genType::size_type i = 0; i < v.length(); ++i)
-			result += v[i];
-		return result;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compMul(genType const & v)
-	{
-		typename genType::value_type result = typename genType::value_type(1);
-		for(typename genType::size_type i = 0; i < v.length(); ++i)
-			result *= v[i];
-		return result;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compMin(genType const & v)
-	{
-		typename genType::value_type result = typename genType::value_type(v[0]);
-		for(typename genType::size_type i = 1; i < v.length(); ++i)
-			result = min(result, v[i]);
-		return result;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compMax(genType const & v)
-	{
-		typename genType::value_type result = typename genType::value_type(v[0]);
-		for(typename genType::size_type i = 1; i < v.length(); ++i)
-			result = max(result, v[i]);
-		return result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/constants.hpp b/include/gal/opengl/glm/gtx/constants.hpp
deleted file mode 100644
index 78356ffae4..0000000000
--- a/include/gal/opengl/glm/gtx/constants.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_constants
-#define GLM_GTX_constants GLM_VERSION
-
-#include "../gtc/constants.hpp"
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_constants extension is deprecated, include GLM_GTC_constants (glm/gtc/constants.hpp) instead")
-#endif
-
-#endif//GLM_GTX_constants
diff --git a/include/gal/opengl/glm/gtx/epsilon.hpp b/include/gal/opengl/glm/gtx/epsilon.hpp
deleted file mode 100644
index 9cb91cb601..0000000000
--- a/include/gal/opengl/glm/gtx/epsilon.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_epsilon extension is deprecated, include GLM_GTC_epsilon (glm/gtc/epsilon) instead")
-#endif
-
-// Promoted:
-#include "../gtc/epsilon.hpp"
diff --git a/include/gal/opengl/glm/gtx/euler_angles.hpp b/include/gal/opengl/glm/gtx/euler_angles.hpp
deleted file mode 100644
index ab040425d0..0000000000
--- a/include/gal/opengl/glm/gtx/euler_angles.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_euler_angles
-/// @file glm/gtx/euler_angles.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-///
-/// @defgroup gtx_euler_angles GLM_GTX_euler_angles
-/// @ingroup gtx
-/// 
-/// @brief Build matrices from Euler angles.
-/// 
-/// <glm/gtx/euler_angles.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_euler_angles
-#define GLM_GTX_euler_angles GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_euler_angles extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_euler_angles
-	/// @{
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleX(
-		valType const & angleX);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleY(
-		valType const & angleY);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleZ(
-		valType const & angleZ);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleXY(
-		valType const & angleX, 
-		valType const & angleY);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleYX(
-		valType const & angleY, 
-		valType const & angleX);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleXZ(
-		valType const & angleX, 
-		valType const & angleZ);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleZX(
-		valType const & angleZ, 
-		valType const & angleX);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleYZ(
-		valType const & angleY, 
-		valType const & angleZ);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleZY(
-		valType const & angleZ, 
-		valType const & angleY);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> eulerAngleYXZ(
-		valType const & yaw, 
-		valType const & pitch, 
-		valType const & roll);
-
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
-	/// @see gtx_euler_angles
-	template <typename valType> 
-	detail::tmat4x4<valType> yawPitchRoll(
-		valType const & yaw, 
-		valType const & pitch, 
-		valType const & roll);
-
-	/// Creates a 2D 2 * 2 rotation matrix from an euler angle.
-	/// @see gtx_euler_angles
-	template <typename T> 
-	detail::tmat2x2<T> orientate2(T const & angle);
-
-	/// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
-	/// @see gtx_euler_angles
-	template <typename T> 
-	detail::tmat3x3<T> orientate3(T const & angle);
-
-	/// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). 
-	/// @see gtx_euler_angles
-	template <typename T> 
-	detail::tmat3x3<T> orientate3(detail::tvec3<T> const & angles);
-		
-	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
-	/// @see gtx_euler_angles
-	template <typename T> 
-	detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
-
-	/// @}
-}//namespace glm
-
-#include "euler_angles.inl"
-
-#endif//GLM_GTX_euler_angles
diff --git a/include/gal/opengl/glm/gtx/euler_angles.inl b/include/gal/opengl/glm/gtx/euler_angles.inl
deleted file mode 100644
index a6ca0ab686..0000000000
--- a/include/gal/opengl/glm/gtx/euler_angles.inl
+++ /dev/null
@@ -1,244 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2007-08-14
-// Licence : This source is under MIT License
-// File    : glm/gtx/euler_angles.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
-	(
-		valType const & angleX
-	)
-	{
-		valType cosX = glm::cos(angleX);
-		valType sinX = glm::sin(angleX);
-	
-		return detail::tmat4x4<valType>(
-			valType(1), valType(0), valType(0), valType(0),
-			valType(0), cosX,		sinX,		valType(0),
-			valType(0),-sinX,		cosX,		valType(0),
-			valType(0), valType(0), valType(0), valType(1));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleY
-	(
-		valType const & angleY
-	)
-	{
-		valType cosY = glm::cos(angleY);
-		valType sinY = glm::sin(angleY);
-
-		return detail::tmat4x4<valType>(
-			cosY,		valType(0),-sinY,		valType(0),
-			valType(0),	valType(1),	valType(0), valType(0),
-			sinY,		valType(0),	cosY,		valType(0),
-			valType(0),	valType(0),	valType(0), valType(1));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZ
-	(
-		valType const & angleZ
-	)
-	{
-		valType cosZ = glm::cos(angleZ); 
-		valType sinZ = glm::sin(angleZ);
-
-		return detail::tmat4x4<valType>(
-			cosZ,		sinZ,		valType(0), valType(0),
-			-sinZ,		cosZ,		valType(0), valType(0),
-			valType(0),	valType(0),	valType(1), valType(0),
-			valType(0),	valType(0),	valType(0), valType(1));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXY
-	(
-		valType const & angleX, 
-		valType const & angleY
-	)
-	{
-		valType cosX = glm::cos(angleX);
-		valType sinX = glm::sin(angleX);
-		valType cosY = glm::cos(angleY);
-		valType sinY = glm::sin(angleY);
-
-		return detail::tmat4x4<valType>(
-			cosY,		-sinX * sinY,	cosX * sinY,	valType(0),
-			valType(0), cosX,			sinX,			valType(0),
-			-sinY ,		-sinX * cosY,	cosX * cosY,	valType(0),
-			valType(0), valType(0),     valType(0),		valType(1));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYX
-	(
-		valType const & angleY, 
-		valType const & angleX
-	)
-	{
-		valType cosX = glm::cos(angleX); 
-		valType sinX = glm::sin(angleX); 
-		valType cosY = glm::cos(angleY); 
-		valType sinY = glm::sin(angleY);
-
-		return detail::tmat4x4<valType>(
-			cosY,			valType(0),		sinY,			valType(0),
-			-sinX * sinY,	cosX,			sinX * cosY,	valType(0),
-			-cosX * sinY,	-sinX,			cosX * cosY,	valType(0),
-			valType(0),		valType(0),		valType(0),		valType(1));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXZ
-	(
-		valType const & angleX, 
-		valType const & angleZ
-	)
-	{
-		return eulerAngleX(angleX) * eulerAngleZ(angleZ);
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZX
-	(
-		valType const & angleZ, 
-		valType const & angleX
-	)
-	{
-		return eulerAngleZ(angleZ) * eulerAngleX(angleX);
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYXZ
-	(
-		valType const & yaw, 
-		valType const & pitch, 
-		valType const & roll
-	)
-	{
-		valType tmp_ch = glm::cos(yaw);
-		valType tmp_sh = glm::sin(yaw);
-		valType tmp_cp = glm::cos(pitch);
-		valType tmp_sp = glm::sin(pitch);
-		valType tmp_cb = glm::cos(roll);
-		valType tmp_sb = glm::sin(roll);
-
-		detail::tmat4x4<valType> Result;
-		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
-		Result[0][1] = tmp_sb * tmp_cp;
-		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
-		Result[0][3] = valType(0);
-		Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
-		Result[1][1] = tmp_cb * tmp_cp;
-		Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
-		Result[1][3] = valType(0);
-		Result[2][0] = tmp_sh * tmp_cp;
-		Result[2][1] = -tmp_sp;
-		Result[2][2] = tmp_ch * tmp_cp;
-		Result[2][3] = valType(0);
-		Result[3][0] = valType(0);
-		Result[3][1] = valType(0);
-		Result[3][2] = valType(0);
-		Result[3][3] = valType(1);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> yawPitchRoll
-	(
-		valType const & yaw, 
-		valType const & pitch, 
-		valType const & roll
-	)
-	{
-		valType tmp_ch = glm::cos(yaw);
-		valType tmp_sh = glm::sin(yaw);
-		valType tmp_cp = glm::cos(pitch);
-		valType tmp_sp = glm::sin(pitch);
-		valType tmp_cb = glm::cos(roll);
-		valType tmp_sb = glm::sin(roll);
-
-		detail::tmat4x4<valType> Result;
-		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
-		Result[0][1] = tmp_sb * tmp_cp;
-		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
-		Result[0][3] = valType(0);
-		Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
-		Result[1][1] = tmp_cb * tmp_cp;
-		Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
-		Result[1][3] = valType(0);
-		Result[2][0] = tmp_sh * tmp_cp;
-		Result[2][1] = -tmp_sp;
-		Result[2][2] = tmp_ch * tmp_cp;
-		Result[2][3] = valType(0);
-		Result[3][0] = valType(0);
-		Result[3][1] = valType(0);
-		Result[3][2] = valType(0);
-		Result[3][3] = valType(1);
-		return Result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> orientate2
-	(
-		valType const & angle
-	)
-	{
-		valType c = glm::cos(angle);
-		valType s = glm::sin(angle);
-
-		detail::tmat2x2<valType> Result;
-		Result[0][0] = c;
-		Result[0][1] = s;
-		Result[1][0] = -s;
-		Result[1][1] = c;
-		return Result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
-	(
-		valType const & angle
-	)
-	{
-		valType c = glm::cos(angle);
-		valType s = glm::sin(angle);
-
-		detail::tmat3x3<valType> Result;
-		Result[0][0] = c;
-		Result[0][1] = s;
-		Result[0][2] = 0.0f;
-		Result[1][0] = -s;
-		Result[1][1] = c;
-		Result[1][2] = 0.0f;
-		Result[2][0] = 0.0f;
-		Result[2][1] = 0.0f;
-		Result[2][2] = 1.0f;
-		return Result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
-	(
-		detail::tvec3<valType> const & angles
-	)
-	{
-		return detail::tmat3x3<valType>(yawPitchRoll(angles.x, angles.y, angles.z));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
-	(
-		detail::tvec3<valType> const & angles
-	)
-	{
-		return yawPitchRoll(angles.z, angles.x, angles.y);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/extend.hpp b/include/gal/opengl/glm/gtx/extend.hpp
deleted file mode 100644
index d23bebadc6..0000000000
--- a/include/gal/opengl/glm/gtx/extend.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_extend
-/// @file glm/gtx/extend.hpp
-/// @date 2006-01-07 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_extend GLM_GTX_extend
-/// @ingroup gtx
-/// 
-/// @brief Extend a position from a source to a position at a defined length.
-/// 
-/// <glm/gtx/extend.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_extend
-#define GLM_GTX_extend GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_extend extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_extend
-	/// @{
-
-	/// Extends of Length the Origin position using the (Source - Origin) direction.
-	/// @see gtx_extend
-	template <typename genType> 
-	genType extend(
-		genType const & Origin, 
-		genType const & Source, 
-		typename genType::value_type const Length);
-
-	/// @}
-}//namespace glm
-
-#include "extend.inl"
-
-#endif//GLM_GTX_extend
diff --git a/include/gal/opengl/glm/gtx/extend.inl b/include/gal/opengl/glm/gtx/extend.inl
deleted file mode 100644
index 9827401ee2..0000000000
--- a/include/gal/opengl/glm/gtx/extend.inl
+++ /dev/null
@@ -1,55 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-01-07
-// Updated : 2008-10-05
-// Licence : This source is under MIT License
-// File    : glm/gtx/extend.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType>
-	genType extend
-	(
-		genType const & Origin, 
-		genType const & Source, 
-		genType const & Distance
-	)
-	{
-		return Origin + (Source - Origin) * Distance;
-	}
-
-	template <typename valType>
-	detail::tvec2<valType> extend
-	(
-		detail::tvec2<valType> const & Origin, 
-		detail::tvec2<valType> const & Source, 
-		valType const & Distance
-	)
-	{
-		return Origin + (Source - Origin) * Distance;
-	}
-
-	template <typename valType>
-	detail::tvec3<valType> extend
-	(
-		detail::tvec3<valType> const & Origin, 
-		detail::tvec3<valType> const & Source, 
-		valType const & Distance
-	)
-	{
-		return Origin + (Source - Origin) * Distance;
-	}
-
-	template <typename valType>
-	detail::tvec4<valType> extend
-	(
-		detail::tvec4<valType> const & Origin, 
-		detail::tvec4<valType> const & Source, 
-		valType const & Distance
-	)
-	{
-		return Origin + (Source - Origin) * Distance;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/extented_min_max.hpp b/include/gal/opengl/glm/gtx/extented_min_max.hpp
deleted file mode 100644
index c623409984..0000000000
--- a/include/gal/opengl/glm/gtx/extented_min_max.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_extented_min_max
-/// @file glm/gtx/extented_min_max.hpp
-/// @date 2007-03-14 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_half_float (dependence)
-///
-/// @defgroup gtx_extented_min_max GLM_GTX_extented_min_max
-/// @ingroup gtx
-/// 
-/// Min and max functions for 3 to 4 parameters.
-/// 
-/// <glm/gtx/extented_min_max.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_extented_min_max
-#define GLM_GTX_extented_min_max GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_extented_min_max extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_extented_min_max
-	/// @{
-
-	/// Return the minimum component-wise values of 3 inputs 
-	/// @see gtx_extented_min_max
-	template <typename T>
-	T min(
-		T const & x, 
-		T const & y, 
-		T const & z);
-
-	/// Return the minimum component-wise values of 3 inputs
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> min(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z);
-
-	/// Return the minimum component-wise values of 3 inputs 
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> min(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z);
-
-	/// Return the minimum component-wise values of 4 inputs 
-	/// @see gtx_extented_min_max
-	template <typename T>
-	T min(
-		T const & x, 
-		T const & y, 
-		T const & z, 
-		T const & w);
-
-	/// Return the minimum component-wise values of 4 inputs 
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> min(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z, 
-		typename C<T>::value_type const & w);
-
-	/// Return the minimum component-wise values of 4 inputs
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> min(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z,
-		C<T> const & w);
-
-	/// Return the maximum component-wise values of 3 inputs 
-	/// @see gtx_extented_min_max
-	template <typename T>
-	T max(
-		T const & x, 
-		T const & y, 
-		T const & z);
-
-	/// Return the maximum component-wise values of 3 inputs
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> max(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z);
-
-	/// Return the maximum component-wise values of 3 inputs 
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> max(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z);
-
-	/// Return the maximum component-wise values of 4 inputs
-	/// @see gtx_extented_min_max
-	template <typename T>
-	T max(
-		T const & x, 
-		T const & y, 
-		T const & z, 
-		T const & w);
-
-	/// Return the maximum component-wise values of 4 inputs 
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> max(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z, 
-		typename C<T>::value_type const & w);
-
-	/// Return the maximum component-wise values of 4 inputs 
-	/// @see gtx_extented_min_max
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	C<T> max(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z, 
-		C<T> const & w);
-
-	/// @}
-}//namespace glm
-
-#include "extented_min_max.inl"
-
-#endif//GLM_GTX_extented_min_max
diff --git a/include/gal/opengl/glm/gtx/extented_min_max.inl b/include/gal/opengl/glm/gtx/extented_min_max.inl
deleted file mode 100644
index d0a74ef8dd..0000000000
--- a/include/gal/opengl/glm/gtx/extented_min_max.inl
+++ /dev/null
@@ -1,178 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-03-14
-// Updated : 2010-02-19
-// Licence : This source is under MIT License
-// File    : gtx_extented_min_max.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER T min(
-		T const & x, 
-		T const & y, 
-		T const & z)
-	{
-		return glm::min(glm::min(x, y), z);
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> min
-	(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z
-	)
-	{
-		return glm::min(glm::min(x, y), z);
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> min
-	(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z
-	)
-	{
-		return glm::min(glm::min(x, y), z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T min
-	(
-		T const & x, 
-		T const & y, 
-		T const & z, 
-		T const & w
-	)
-	{
-		return glm::min(glm::min(x, y), glm::min(z, w));
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> min
-	(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z, 
-		typename C<T>::value_type const & w
-	)
-	{
-		return glm::min(glm::min(x, y), glm::min(z, w));
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> min
-	(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z, 
-		C<T> const & w
-	)
-	{
-		return glm::min(glm::min(x, y), glm::min(z, w));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T max(
-		T const & x, 
-		T const & y, 
-		T const & z)
-	{
-		return glm::max(glm::max(x, y), z);
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> max
-	(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z
-	)
-	{
-		return glm::max(glm::max(x, y), z);
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> max
-	(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z
-	)
-	{
-		return glm::max(glm::max(x, y), z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T max
-	(
-		T const & x, 
-		T const & y, 
-		T const & z, 
-		T const & w
-	)
-	{
-		return glm::max(glm::max(x, y), glm::max(z, w));
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> max
-	(
-		C<T> const & x, 
-		typename C<T>::value_type const & y, 
-		typename C<T>::value_type const & z, 
-		typename C<T>::value_type const & w
-	)
-	{
-		return glm::max(glm::max(x, y), glm::max(z, w));
-	}
-
-	template 
-	<
-		typename T, 
-		template <typename> class C
-	>
-	GLM_FUNC_QUALIFIER C<T> max
-	(
-		C<T> const & x, 
-		C<T> const & y, 
-		C<T> const & z, 
-		C<T> const & w
-	)
-	{
-		return glm::max(glm::max(x, y), glm::max(z, w));
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/fast_exponential.hpp b/include/gal/opengl/glm/gtx/fast_exponential.hpp
deleted file mode 100644
index ff50eecbf1..0000000000
--- a/include/gal/opengl/glm/gtx/fast_exponential.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_fast_exponential
-/// @file glm/gtx/fast_exponential.hpp
-/// @date 2006-01-09 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_half_float (dependence)
-///
-/// @defgroup gtx_fast_exponential GLM_GTX_fast_exponential
-/// @ingroup gtx
-/// 
-/// @brief Fast but less accurate implementations of exponential based functions.
-/// 
-/// <glm/gtx/fast_exponential.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_fast_exponential
-#define GLM_GTX_fast_exponential GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_fast_exponential extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_fast_exponential
-	/// @{
-
-	/// Faster than the common pow function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename genType> 
-	genType fastPow(
-		genType const & x, 
-		genType const & y);
-
-	/// Faster than the common pow function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename genTypeT, typename genTypeU> 
-	genTypeT fastPow(
-		genTypeT const & x, 
-		genTypeU const & y);
-		
-	/// Faster than the common exp function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename T> 
-	T fastExp(const T& x);
-		
-	/// Faster than the common log function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename T> 
-	T fastLog(const T& x);
-
-	/// Faster than the common exp2 function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename T> 
-	T fastExp2(const T& x);
-		
-	/// Faster than the common log2 function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename T> 
-	T fastLog2(const T& x);
-
-	/// Faster than the common ln function but less accurate.
-	/// @see gtx_fast_exponential
-	template <typename T> 
-	T fastLn(const T& x);
-
-	/// @}
-}//namespace glm
-
-#include "fast_exponential.inl"
-
-#endif//GLM_GTX_fast_exponential
diff --git a/include/gal/opengl/glm/gtx/fast_exponential.inl b/include/gal/opengl/glm/gtx/fast_exponential.inl
deleted file mode 100644
index 80837ff878..0000000000
--- a/include/gal/opengl/glm/gtx/fast_exponential.inl
+++ /dev/null
@@ -1,148 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-01-09
-// Updated : 2006-01-09
-// Licence : This source is under MIT License
-// File    : glm/gtx/fast_exponential.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// fastPow:
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastPow(genType const & x, genType const & y)
-	{
-		return exp(y * log(x));
-	}
-
-	VECTORIZE_VEC_VEC(fastPow)
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
-	{
-		T f = T(1);
-		for(int i = 0; i < y; ++i)
-			f *= x;
-		return f;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
-		const detail::tvec2<T>& x, 
-		const detail::tvec2<int>& y)
-	{
-		return detail::tvec2<T>(
-			fastPow(x.x, y.x),
-			fastPow(x.y, y.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
-		const detail::tvec3<T>& x, 
-		const detail::tvec3<int>& y)
-	{
-		return detail::tvec3<T>(
-			fastPow(x.x, y.x),
-			fastPow(x.y, y.y),
-			fastPow(x.z, y.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
-		const detail::tvec4<T>& x, 
-		const detail::tvec4<int>& y)
-	{
-		return detail::tvec4<T>(
-			fastPow(x.x, y.x),
-			fastPow(x.y, y.y),
-			fastPow(x.z, y.z),
-			fastPow(x.w, y.w));
-	}
-
-	// fastExp
-	// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
-	template <typename T>
-	GLM_FUNC_QUALIFIER T fastExp(const T x)
-	{
-		// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
-		// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
-		T x2 = x * x;
-		T x3 = x2 * x;
-		T x4 = x3 * x;
-		T x5 = x4 * x;
-		return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333));
-	}
-	/*  // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance
-	GLM_FUNC_QUALIFIER float fastExp(float x)
-	{
-		const float e = 2.718281828f;
-		const float IntegerPart = floor(x);
-		const float FloatPart = x - IntegerPart;
-		float z = 1.f;
-
-		for(int i = 0; i < int(IntegerPart); ++i)
-			z *= e;
-
-		const float x2 = FloatPart * FloatPart;
-		const float x3 = x2 * FloatPart;
-		const float x4 = x3 * FloatPart;
-		const float x5 = x4 * FloatPart;
-		return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f));
-	}
-
-	// Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
-	GLM_FUNC_QUALIFIER float fastExp(float x)
-	{
-		// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
-		// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
-		float x2 = x * x;
-		float x3 = x2 * x;
-		float x4 = x3 * x;
-		float x5 = x4 * x;
-		float x6 = x5 * x;
-		float x7 = x6 * x;
-		float x8 = x7 * x;
-		return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);;
-	}
-	*/
-
-	VECTORIZE_VEC(fastExp)
-
-	// fastLog
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastLog(genType const & x)
-	{
-		return std::log(x);
-	}
-
-	/* Slower than the VC7.1 function...
-	GLM_FUNC_QUALIFIER float fastLog(float x)
-	{
-		float y1 = (x - 1.0f) / (x + 1.0f);
-		float y2 = y1 * y1;
-		return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f)));
-	}
-	*/
-
-	VECTORIZE_VEC(fastLog)
-
-	//fastExp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastExp2(genType const & x)
-	{
-		return fastExp(0.69314718055994530941723212145818f * x);
-	}
-
-	VECTORIZE_VEC(fastExp2)
-
-	// fastLog2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastLog2(genType const & x)
-	{
-		return fastLog(x) / 0.69314718055994530941723212145818f;
-	}
-
-	VECTORIZE_VEC(fastLog2)
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/fast_square_root.hpp b/include/gal/opengl/glm/gtx/fast_square_root.hpp
deleted file mode 100644
index a49ae94736..0000000000
--- a/include/gal/opengl/glm/gtx/fast_square_root.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_fast_square_root
-/// @file glm/gtx/fast_square_root.hpp
-/// @date 2006-01-04 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_fast_square_root GLM_GTX_fast_square_root
-/// @ingroup gtx
-/// 
-/// @brief Fast but less accurate implementations of square root based functions.
-/// - Sqrt optimisation based on Newton's method, 
-/// www.gamedev.net/community/forums/topic.asp?topic id=139956
-/// 
-/// <glm/gtx/fast_square_root.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_fast_square_root
-#define GLM_GTX_fast_square_root GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_fast_square_root extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_fast_square_root
-	/// @{
-
-	//! Faster than the common sqrt function but less accurate.
-	//! From GLM_GTX_fast_square_root extension.
-	template <typename genType> 
-	genType fastSqrt(genType const & x);
-
-	//! Faster than the common inversesqrt function but less accurate.
-	//! From GLM_GTX_fast_square_root extension.
-	template <typename genType> 
-	genType fastInverseSqrt(genType const & x);
-		
-	//! Faster than the common length function but less accurate.
-	//! From GLM_GTX_fast_square_root extension.
-	template <typename genType> 
-	typename genType::value_type fastLength(genType const & x);
-
-	//! Faster than the common distance function but less accurate.
-	//! From GLM_GTX_fast_square_root extension.
-	template <typename genType> 
-	typename genType::value_type fastDistance(genType const & x, genType const & y);
-
-	//! Faster than the common normalize function but less accurate.
-	//! From GLM_GTX_fast_square_root extension.
-	template <typename genType> 
-	genType fastNormalize(genType const & x);
-
-	/// @}
-}// namespace glm
-
-#include "fast_square_root.inl"
-
-#endif//GLM_GTX_fast_square_root
diff --git a/include/gal/opengl/glm/gtx/fast_square_root.inl b/include/gal/opengl/glm/gtx/fast_square_root.inl
deleted file mode 100644
index 0f51fbbd15..0000000000
--- a/include/gal/opengl/glm/gtx/fast_square_root.inl
+++ /dev/null
@@ -1,136 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-01-04
-// Updated : 2011-10-14
-// Licence : This source is under MIT License
-// File    : glm/gtx/fast_square_root.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// fastSqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastSqrt
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'fastSqrt' only accept floating-point input");
-
-		return genType(1) / fastInverseSqrt(x);
-	}
-
-	VECTORIZE_VEC(fastSqrt)
-
-	// fastInversesqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastInverseSqrt
-	(
-		genType const & x
-	)
-	{
-		genType tmp = x;
-		float xhalf = 0.5f * float(tmp);
-		uint i = *(uint*)&x;
-		i = 0x5f375a86 - (i >> 1);
-		//x = *(float*)&i;
-		//x = *((float*)(char*)&i);
-		tmp = detail::uif(i).f;
-		tmp = tmp * (1.5f - xhalf * tmp * tmp);
-		return genType(tmp);
-	}
-
-	VECTORIZE_VEC(fastInverseSqrt)
-
-	// fastLength
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastLength
-	(
-		genType const & x
-	)
-	{
-		return abs(x);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER valType fastLength
-	(
-		detail::tvec2<valType> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y;
-		return fastSqrt(sqr);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER valType fastLength
-	(
-		detail::tvec3<valType> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-		return fastSqrt(sqr);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER valType fastLength
-	(
-		detail::tvec4<valType> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return fastSqrt(sqr);
-	}
-
-	// fastDistance
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastDistance
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		return fastLength(y - x);
-	}
-
-	// fastNormalize
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fastNormalize
-	(
-		genType const & x
-	)
-	{
-		return x > genType(0) ? genType(1) : -genType(1);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> fastNormalize
-	(
-		detail::tvec2<valType> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y;
-		return x * fastInverseSqrt(sqr);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> fastNormalize
-	(
-		detail::tvec3<valType> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-		return x * fastInverseSqrt(sqr);
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> fastNormalize
-	(
-		detail::tvec4<valType> const & x
-	)
-	{
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return x * fastInverseSqrt(sqr);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/fast_trigonometry.hpp b/include/gal/opengl/glm/gtx/fast_trigonometry.hpp
deleted file mode 100644
index 16f326d80f..0000000000
--- a/include/gal/opengl/glm/gtx/fast_trigonometry.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_fast_trigonometry
-/// @file glm/gtx/fast_trigonometry.hpp
-/// @date 2006-01-08 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry
-/// @ingroup gtx
-/// 
-/// @brief Fast but less accurate implementations of trigonometric functions.
-/// 
-/// <glm/gtx/fast_trigonometry.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_fast_trigonometry
-#define GLM_GTX_fast_trigonometry GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_fast_trigonometry
-	/// @{
-
-	//! Faster than the common sin function but less accurate. 
-	//! Defined between -2pi and 2pi. 
-	//! From GLM_GTX_fast_trigonometry extension.
-    template <typename T> 
-	T fastSin(const T& angle);
-
-    //! Faster than the common cos function but less accurate.
-	//! Defined between -2pi and 2pi.
-	//! From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
-	T fastCos(const T& angle);
-
-    //! Faster than the common tan function but less accurate. 
-	//! Defined between -2pi and 2pi. 
-	//! From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
-	T fastTan(const T& angle);
-
-    //! Faster than the common asin function but less accurate. 
-	//! Defined between -2pi and 2pi.
-	//! From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
-	T fastAsin(const T& angle);
-
-	//! Faster than the common acos function but less accurate. 
-	//! Defined between -2pi and 2pi. 
-	//! From GLM_GTX_fast_trigonometry extension.
-    template <typename T> 
-	T fastAcos(const T& angle);
-
-	//! Faster than the common atan function but less accurate.
-	//! Defined between -2pi and 2pi. 
-	//! From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
-	T fastAtan(const T& y, const T& x);
-
-	//! Faster than the common atan function but less accurate. 
-	//! Defined between -2pi and 2pi.
-	//! From GLM_GTX_fast_trigonometry extension.
-    template <typename T> 
-	T fastAtan(const T& angle);
-
-	/// @}
-}//namespace glm
-
-#include "fast_trigonometry.inl"
-
-#endif//GLM_GTX_fast_trigonometry
diff --git a/include/gal/opengl/glm/gtx/fast_trigonometry.inl b/include/gal/opengl/glm/gtx/fast_trigonometry.inl
deleted file mode 100644
index b2179a6152..0000000000
--- a/include/gal/opengl/glm/gtx/fast_trigonometry.inl
+++ /dev/null
@@ -1,75 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-01-08
-// Updated : 2011-10-14
-// Licence : This source is under MIT License
-// File    : glm/gtx/fast_trigonometry.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// sin
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastSin(T const & x)
-	{
-		return x - ((x * x * x) / T(6)) + ((x * x * x * x * x) / T(120)) - ((x * x * x * x * x * x * x) / T(5040));
-	}
-
-	VECTORIZE_VEC(fastSin)
-
-	// cos
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastCos(T const & x)
-	{
-		return T(1) - (x * x * T(0.5)) + (x * x * x * x * T(0.041666666666)) - (x * x * x * x * x * x * T(0.00138888888888));
-	}
-
-	VECTORIZE_VEC(fastCos)
-
-	// tan
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastTan(T const & x)
-	{
-		return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
-	}
-
-	VECTORIZE_VEC(fastTan)
-
-	// asin
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAsin(T const & x)
-	{
-		return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
-	}
-
-	VECTORIZE_VEC(fastAsin)
-
-	// acos
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAcos(T const & x)
-	{
-		return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
-	}
-
-	VECTORIZE_VEC(fastAcos)
-
-	// atan
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAtan(T const & y, T const & x)
-	{
-		T sgn = sign(y) * sign(x);
-		return abs(fastAtan(y / x)) * sgn;
-	}
-
-	VECTORIZE_VEC_VEC(fastAtan)
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T fastAtan(T const & x)
-	{
-		return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
-	}
-
-	VECTORIZE_VEC(fastAtan)
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/gradient_paint.hpp b/include/gal/opengl/glm/gtx/gradient_paint.hpp
deleted file mode 100644
index f3bfde7a7d..0000000000
--- a/include/gal/opengl/glm/gtx/gradient_paint.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_gradient_paint
-/// @file glm/gtx/gradient_paint.hpp
-/// @date 2009-03-06 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_optimum_pow (dependence)
-///
-/// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint
-/// @ingroup gtx
-/// 
-/// @brief Functions that return the color of procedural gradient for specific coordinates.
-/// <glm/gtx/gradient_paint.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_gradient_paint
-#define GLM_GTX_gradient_paint GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/optimum_pow.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_gradient_paint extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_gradient_paint
-	/// @{
-
-	/// Return a color from a radial gradient.
-	/// @see - gtx_gradient_paint
-	template <typename valType>
-	valType radialGradient(
-		detail::tvec2<valType> const & Center,
-		valType const & Radius,
-		detail::tvec2<valType> const & Focal,
-		detail::tvec2<valType> const & Position);
-
-	/// Return a color from a linear gradient.
-	/// @see - gtx_gradient_paint
-	template <typename valType>
-	valType linearGradient(
-		detail::tvec2<valType> const & Point0,
-		detail::tvec2<valType> const & Point1,
-		detail::tvec2<valType> const & Position);
-
-	/// @}
-}// namespace glm
-
-#include "gradient_paint.inl"
-
-#endif//GLM_GTX_gradient_paint
diff --git a/include/gal/opengl/glm/gtx/gradient_paint.inl b/include/gal/opengl/glm/gtx/gradient_paint.inl
deleted file mode 100644
index bdf5a656fb..0000000000
--- a/include/gal/opengl/glm/gtx/gradient_paint.inl
+++ /dev/null
@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2009-03-06
-// Updated : 2009-03-09
-// Licence : This source is under MIT License
-// File    : glm/gtx/gradient_paint.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename valType>
-	valType radialGradient
-	(
-		detail::tvec2<valType> const & Center,
-		valType const & Radius,
-		detail::tvec2<valType> const & Focal,
-		detail::tvec2<valType> const & Position
-	)
-	{
-		detail::tvec2<valType> F = Focal - Center;
-		detail::tvec2<valType> D = Position - Focal;
-		valType Radius2 = pow2(Radius);
-		valType Fx2 = pow2(F.x);
-		valType Fy2 = pow2(F.y);
-
-		valType Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x));
-		valType Denominator = Radius2 - (Fx2 + Fy2);
-		return Numerator / Denominator;
-	}
-
-	template <typename valType>
-	valType linearGradient
-	(
-		detail::tvec2<valType> const & Point0,
-		detail::tvec2<valType> const & Point1,
-		detail::tvec2<valType> const & Position
-	)
-	{
-		detail::tvec2<valType> Dist = Point1 - Point0;
-		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/handed_coordinate_space.hpp b/include/gal/opengl/glm/gtx/handed_coordinate_space.hpp
deleted file mode 100644
index 5ed0b0bc52..0000000000
--- a/include/gal/opengl/glm/gtx/handed_coordinate_space.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_handed_coordinate_space
-/// @file glm/gtx/handed_coordinate_space.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space
-/// @ingroup gtx
-/// 
-/// @brief To know if a set of three basis vectors defines a right or left-handed coordinate system.
-/// 
-/// <glm/gtx/handed_coordinate_system.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_handed_coordinate_space
-#define GLM_GTX_handed_coordinate_space GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_handed_coordinate_space
-	/// @{
-
-	//! Return if a trihedron right handed or not.
-	//! From GLM_GTX_handed_coordinate_space extension.
-	template <typename T> 
-	bool rightHanded(
-		detail::tvec3<T> const & tangent, 
-		detail::tvec3<T> const & binormal, 
-		detail::tvec3<T> const & normal);
-
-	//! Return if a trihedron left handed or not.
-	//! From GLM_GTX_handed_coordinate_space extension.
-	template <typename T> 
-	bool leftHanded(
-		detail::tvec3<T> const & tangent, 
-		detail::tvec3<T> const & binormal, 
-		detail::tvec3<T> const & normal);
-
-	/// @}
-}// namespace glm
-
-#include "handed_coordinate_space.inl"
-
-#endif//GLM_GTX_handed_coordinate_space
diff --git a/include/gal/opengl/glm/gtx/handed_coordinate_space.inl b/include/gal/opengl/glm/gtx/handed_coordinate_space.inl
deleted file mode 100644
index 51a0553156..0000000000
--- a/include/gal/opengl/glm/gtx/handed_coordinate_space.inl
+++ /dev/null
@@ -1,33 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2009-02-19
-// Licence : This source is under MIT License
-// File    : glm/gtx/handed_coordinate_space.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool rightHanded
-	(
-		detail::tvec3<T> const & tangent, 
-		detail::tvec3<T> const & binormal,
-		detail::tvec3<T> const & normal
-	)
-	{
-		return dot(cross(normal, tangent), binormal) > T(0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool leftHanded
-	(
-		detail::tvec3<T> const & tangent, 
-		detail::tvec3<T> const & binormal, 
-		detail::tvec3<T> const & normal
-	)
-	{
-		return dot(cross(normal, tangent), binormal) < T(0);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/inertia.hpp b/include/gal/opengl/glm/gtx/inertia.hpp
deleted file mode 100644
index 9133299e94..0000000000
--- a/include/gal/opengl/glm/gtx/inertia.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_inertia
-/// @file glm/gtx/inertia.hpp
-/// @date 2006-04-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_inertia GLM_GTX_inertia
-/// @ingroup gtx
-/// 
-/// @brief Create inertia matrices
-/// 
-/// <glm/gtx/inertia.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_inertia
-#define GLM_GTX_inertia GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_inertia extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_inertia
-	/// @{
-
-	//! Build an inertia matrix for a box.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat3x3<T> boxInertia3(
-		T const & Mass, 
-		detail::tvec3<T> const & Scale);
-		
-	//! Build an inertia matrix for a box.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat4x4<T> boxInertia4(
-		T const & Mass, 
-		detail::tvec3<T> const & Scale);
-		
-	//! Build an inertia matrix for a disk.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat3x3<T> diskInertia3(
-		T const & Mass, 
-		T const & Radius);
-
-	//! Build an inertia matrix for a disk.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat4x4<T> diskInertia4(
-		T const & Mass, 
-		T const & Radius);
-
-	//! Build an inertia matrix for a ball.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat3x3<T> ballInertia3(
-		T const & Mass, 
-		T const & Radius);
-		
-	//! Build an inertia matrix for a ball.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat4x4<T> ballInertia4(
-		T const & Mass, 
-		T const & Radius);
-
-	//! Build an inertia matrix for a sphere.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat3x3<T> sphereInertia3(
-		T const & Mass, 
-		T const & Radius);
-
-	//! Build an inertia matrix for a sphere.
-	//! From GLM_GTX_inertia extension.
-	template <typename T> 
-	detail::tmat4x4<T> sphereInertia4(
-		T const & Mass, 
-		T const & Radius);
-
-	/// @}
-}// namespace glm
-
-#include "inertia.inl"
-
-#endif//GLM_GTX_inertia
diff --git a/include/gal/opengl/glm/gtx/inertia.inl b/include/gal/opengl/glm/gtx/inertia.inl
deleted file mode 100644
index a8f2ad7ab1..0000000000
--- a/include/gal/opengl/glm/gtx/inertia.inl
+++ /dev/null
@@ -1,114 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-04-21
-// Updated : 2006-12-06
-// Licence : This source is under MIT License
-// File    : glm/gtx/inertia.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> boxInertia3
-	(
-		T const & Mass, 
-		detail::tvec3<T> const & Scale
-	)
-	{
-		detail::tmat3x3<T> Result(T(1));
-		Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
-		Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
-		Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> boxInertia4
-	(
-		T const & Mass, 
-		detail::tvec3<T> const & Scale
-	)
-	{
-		detail::tmat4x4<T> Result(T(1));
-		Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
-		Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
-		Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> diskInertia3
-	(
-		T const & Mass, 
-		T const & Radius
-	)
-	{
-		T a = Mass * Radius * Radius / T(2);
-		detail::tmat3x3<T> Result(a);
-		Result[2][2] *= T(2);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> diskInertia4
-	(
-		T const & Mass, 
-		T const & Radius
-	)
-	{
-		T a = Mass * Radius * Radius / T(2);
-		detail::tmat4x4<T> Result(a);
-		Result[2][2] *= T(2);
-		Result[3][3] = T(1);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> ballInertia3
-	(
-		T const & Mass, 
-		T const & Radius
-	)
-	{
-		T a = T(2) * Mass * Radius * Radius / T(5);
-		return detail::tmat3x3<T>(a);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> ballInertia4
-	(
-		T const & Mass, 
-		T const & Radius
-	)
-	{
-		T a = T(2) * Mass * Radius * Radius / T(5);
-		detail::tmat4x4<T> Result(a);
-		Result[3][3] = T(1);
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> sphereInertia3
-	(
-		T const & Mass, 
-		T const & Radius
-	)
-	{
-		T a = T(2) * Mass * Radius * Radius / T(3);
-		return detail::tmat3x3<T>(a);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> sphereInertia4
-	(
-		T const & Mass, 
-		T const & Radius
-	)
-	{
-		T a = T(2) * Mass * Radius * Radius / T(3);
-		detail::tmat4x4<T> Result(a);
-		Result[3][3] = T(1);
-		return Result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/int_10_10_10_2.hpp b/include/gal/opengl/glm/gtx/int_10_10_10_2.hpp
deleted file mode 100644
index 1270481621..0000000000
--- a/include/gal/opengl/glm/gtx/int_10_10_10_2.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_int_10_10_10_2
-/// @file glm/gtx/int_10_10_10_2.hpp
-/// @date 2010-07-07 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_raw_data (dependence)
-///
-/// @defgroup gtx_int_10_10_10_2 GLM_GTX_int_10_10_10_2
-/// @ingroup gtx
-/// 
-/// @brief Pack vector to 1010102 integers. Storage only.
-/// 
-/// <glm/gtx/int_10_10_10_2.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_int_10_10_10_2
-#define GLM_GTX_int_10_10_10_2 GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/raw_data.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_int_10_10_10_2
-	/// @{
-
-	//! From GLM_GTX_int_10_10_10_2 extension.
-	//! Cast a vec4 to an u_10_10_10_2.
-	dword uint10_10_10_2_cast(glm::vec4 const & v);
-
-	/// @}
-}//namespace glm
-
-#include "int_10_10_10_2.inl"
-
-#endif//GLM_GTX_int_10_10_10_2
diff --git a/include/gal/opengl/glm/gtx/int_10_10_10_2.inl b/include/gal/opengl/glm/gtx/int_10_10_10_2.inl
deleted file mode 100644
index c1ec201f29..0000000000
--- a/include/gal/opengl/glm/gtx/int_10_10_10_2.inl
+++ /dev/null
@@ -1,19 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2010-07-07
-// Updated : 2010-07-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/int_10_10_10_2.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast
-	(
-		glm::vec4 const & v
-	)
-	{
-		return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/integer.hpp b/include/gal/opengl/glm/gtx/integer.hpp
deleted file mode 100644
index b3e21fd6cf..0000000000
--- a/include/gal/opengl/glm/gtx/integer.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_integer
-/// @file glm/gtx/integer.hpp
-/// @date 2005-12-24 / 2011-10-13
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_integer GLM_GTX_integer
-/// @ingroup gtx
-/// 
-/// @brief Add support for integer for core functions
-/// 
-/// <glm/gtx/integer.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_integer
-#define GLM_GTX_integer GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_integer extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_integer
-	/// @{
-
-	//! Returns x raised to the y power. 
-	//! From GLM_GTX_integer extension.
-	int pow(int x, int y);
-
-	//! Returns the positive square root of x.
-	//! From GLM_GTX_integer extension.
-	int sqrt(int x);
-
-	//! Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
-	//! From GLM_GTX_integer extension.
-	template <typename genIUType>
-	genIUType log2(genIUType const & x);
-
-	//! Returns the floor log2 of x.
-	//! From GLM_GTX_integer extension.
-	unsigned int floor_log2(unsigned int x);
-
-	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
-	//! From GLM_GTX_integer extension.
-	int mod(int x, int y);
-
-	//! Return the factorial value of a number (!12 max, integer only)
-	//! From GLM_GTX_integer extension.
-	template <typename genType> 
-	genType factorial(genType const & x);
-
-	//! 32bit signed integer. 
-	//! From GLM_GTX_integer extension.
-	typedef signed int					sint;
-
-	//! Returns x raised to the y power.
-	//! From GLM_GTX_integer extension.
-	uint pow(uint x, uint y);
-
-	//! Returns the positive square root of x. 
-	//! From GLM_GTX_integer extension.
-	uint sqrt(uint x);
-
-	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
-	//! From GLM_GTX_integer extension.
-	uint mod(uint x, uint y);
-
-	//! Returns the number of leading zeros.
-	//! From GLM_GTX_integer extension.
-	uint nlz(uint x);
-
-	/// @}
-}//namespace glm
-
-#include "integer.inl"
-
-#endif//GLM_GTX_integer
diff --git a/include/gal/opengl/glm/gtx/integer.inl b/include/gal/opengl/glm/gtx/integer.inl
deleted file mode 100644
index 24786165b3..0000000000
--- a/include/gal/opengl/glm/gtx/integer.inl
+++ /dev/null
@@ -1,203 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-24
-// Updated : 2011-10-13
-// Licence : This source is under MIT License
-// File    : glm/gtx/integer.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	// pow
-	GLM_FUNC_QUALIFIER int pow(int x, int y)
-	{
-		if(y == 0)
-			return 1;
-		int result = x;
-		for(int i = 1; i < y; ++i)
-			result *= x;
-		return result;
-	}
-
-	// sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387
-	GLM_FUNC_QUALIFIER int sqrt(int x)
-	{
-		if(x <= 1) return x;
-
-		int NextTrial = x >> 1;
-		int CurrentAnswer;
-
-		do
-		{
-			CurrentAnswer = NextTrial;
-			NextTrial = (NextTrial + x / NextTrial) >> 1;
-		} while(NextTrial < CurrentAnswer);
-
-		return CurrentAnswer;
-	}
-
-// Henry Gordon Dietz: http://aggregate.org/MAGIC/
-namespace _detail
-{
-	GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x)
-	{
-		/* 32-bit recursive reduction using SWAR...
-		but first step is mapping 2-bit values
-		into sum of 2 1-bit values in sneaky way
-		*/
-		x -= ((x >> 1) & 0x55555555);
-		x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
-		x = (((x >> 4) + x) & 0x0f0f0f0f);
-		x += (x >> 8);
-		x += (x >> 16);
-		return(x & 0x0000003f);
-	}
-
-	template <>
-	struct _compute_log2<detail::float_or_int_value::GLM_INT>
-	{
-		template <typename T>
-		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
-		{
-#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
-			return Value <= T(1) ? T(0) : T(32) - nlz(Value - T(1));
-#else
-			return T(32) - nlz(Value - T(1));
-#endif
-		}
-	};
-
-}//namespace _detail
-
-	// Henry Gordon Dietz: http://aggregate.org/MAGIC/
-/*
-	GLM_FUNC_QUALIFIER unsigned int floor_log2(unsigned int x)
-	{
-		x |= (x >> 1);
-		x |= (x >> 2);
-		x |= (x >> 4);
-		x |= (x >> 8);
-		x |= (x >> 16);
-
-		return _detail::ones32(x) >> 1;
-	}
-*/
-	// mod
-	GLM_FUNC_QUALIFIER int mod(int x, int y)
-	{
-		return x - y * (x / y);
-	}
-
-	// factorial (!12 max, integer only)
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType factorial(genType const & x)
-	{
-		genType Temp = x;
-		genType Result;
-		for(Result = 1; Temp > 1; --Temp)
-			Result *= Temp;
-		return Result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> factorial(
-		detail::tvec2<valType> const & x)
-	{
-		return detail::tvec2<valType>(
-			factorial(x.x),
-			factorial(x.y));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> factorial(
-		detail::tvec3<valType> const & x)
-	{
-		return detail::tvec3<valType>(
-			factorial(x.x),
-			factorial(x.y),
-			factorial(x.z));
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> factorial(
-		detail::tvec4<valType> const & x)
-	{
-		return detail::tvec4<valType>(
-			factorial(x.x),
-			factorial(x.y),
-			factorial(x.z),
-			factorial(x.w));
-	}
-
-	GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
-	{
-		uint result = x;
-		for(uint i = 1; i < y; ++i)
-			result *= x;
-		return result;
-	}
-
-	GLM_FUNC_QUALIFIER uint sqrt(uint x)
-	{
-		if(x <= 1) return x;
-
-		uint NextTrial = x >> 1;
-		uint CurrentAnswer;
-
-		do
-		{
-			CurrentAnswer = NextTrial;
-			NextTrial = (NextTrial + x / NextTrial) >> 1;
-		} while(NextTrial < CurrentAnswer);
-
-		return CurrentAnswer;
-	}
-
-	GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
-	{
-		return x - y * (x / y);
-	}
-
-#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
-
-	GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) 
-	{
-		return 31u - findMSB(x);
-	}
-
-#else
-
-	// Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt
-	GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) 
-	{
-	   int y, m, n;
-
-	   y = -int(x >> 16);      // If left half of x is 0,
-	   m = (y >> 16) & 16;  // set n = 16.  If left half
-	   n = 16 - m;          // is nonzero, set n = 0 and
-	   x = x >> m;          // shift x right 16.
-							// Now x is of the form 0000xxxx.
-	   y = x - 0x100;       // If positions 8-15 are 0,
-	   m = (y >> 16) & 8;   // add 8 to n and shift x left 8.
-	   n = n + m;
-	   x = x << m;
-
-	   y = x - 0x1000;      // If positions 12-15 are 0,
-	   m = (y >> 16) & 4;   // add 4 to n and shift x left 4.
-	   n = n + m;
-	   x = x << m;
-
-	   y = x - 0x4000;      // If positions 14-15 are 0,
-	   m = (y >> 16) & 2;   // add 2 to n and shift x left 2.
-	   n = n + m;
-	   x = x << m;
-
-	   y = x >> 14;         // Set y = 0, 1, 2, or 3.
-	   m = y & ~(y >> 1);   // Set m = 0, 1, 2, or 2 resp.
-	   return unsigned(n + 2 - m);
-	}
-
-#endif//(GLM_COMPILER)
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/intersect.hpp b/include/gal/opengl/glm/gtx/intersect.hpp
deleted file mode 100644
index e3319eec4a..0000000000
--- a/include/gal/opengl/glm/gtx/intersect.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_intersect
-/// @file glm/gtx/intersect.hpp
-/// @date 2007-04-03 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_closest_point (dependence)
-///
-/// @defgroup gtx_intersect GLM_GTX_intersect
-/// @ingroup gtx
-/// 
-/// @brief Add intersection functions
-/// 
-/// <glm/gtx/intersect.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_intersect
-#define GLM_GTX_intersect GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/closest_point.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_closest_point extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_intersect
-	/// @{
-
-	//! Compute the intersection of a ray and a triangle.
-	//! From GLM_GTX_intersect extension.
-	template <typename genType>
-	bool intersectRayTriangle(
-		genType const & orig, genType const & dir,
-		genType const & vert0, genType const & vert1, genType const & vert2,
-		genType & baryPosition);
-
-	//! Compute the intersection of a line and a triangle.
-	//! From GLM_GTX_intersect extension.
-	template <typename genType>
-	bool intersectLineTriangle(
-		genType const & orig, genType const & dir,
-		genType const & vert0, genType const & vert1, genType const & vert2,
-		genType & position);
-
-	//! Compute the intersection distance of a ray and a sphere. 
-	//! The ray direction vector is unit length.
-	//! From GLM_GTX_intersect extension.
-	template <typename genType>
-	bool intersectRaySphere(
-		genType const & rayStarting, genType const & rayNormalizedDirection,
-		genType const & sphereCenter, const typename genType::value_type sphereRadiusSquered,
-		typename genType::value_type & intersectionDistance);
-
-	//! Compute the intersection of a ray and a sphere.
-	//! From GLM_GTX_intersect extension.
-	template <typename genType>
-	bool intersectRaySphere(
-		genType const & rayStarting, genType const & rayNormalizedDirection,
-		genType const & sphereCenter, const typename genType::value_type sphereRadius,
-		genType & intersectionPosition, genType & intersectionNormal);
-
-	//! Compute the intersection of a line and a sphere.
-	//! From GLM_GTX_intersect extension
-	template <typename genType>
-	bool intersectLineSphere(
-		genType const & point0, genType const & point1,
-		genType const & sphereCenter, typename genType::value_type sphereRadius,
-		genType & intersectionPosition1, genType & intersectionNormal1, 
-		genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType());
-
-	/// @}
-}//namespace glm
-
-#include "intersect.inl"
-
-#endif//GLM_GTX_intersect
diff --git a/include/gal/opengl/glm/gtx/intersect.inl b/include/gal/opengl/glm/gtx/intersect.inl
deleted file mode 100644
index 3fd8cea30e..0000000000
--- a/include/gal/opengl/glm/gtx/intersect.inl
+++ /dev/null
@@ -1,196 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-04-03
-// Updated : 2009-01-20
-// Licence : This source is under MIT licence
-// File    : glm/gtx/intersect.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include <cfloat>
-#include <limits>
-
-namespace glm
-{
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool intersectRayTriangle
-	(
-		genType const & orig, genType const & dir,
-		genType const & v0, genType const & v1, genType const & v2,
-		genType & baryPosition
-	)
-	{
-		genType e1 = v1 - v0;
-		genType e2 = v2 - v0;
-
-		genType p = glm::cross(dir, e2);
-
-		typename genType::value_type a = glm::dot(e1, p);
-
-		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
-		if(a < Epsilon)
-			return false;
-
-		typename genType::value_type f = typename genType::value_type(1.0f) / a;
-
-		genType s = orig - v0;
-		baryPosition.x = f * glm::dot(s, p);
-		if(baryPosition.x < typename genType::value_type(0.0f))
-			return false;
-		if(baryPosition.x > typename genType::value_type(1.0f))
-			return false;
-
-		genType q = glm::cross(s, e1);
-		baryPosition.y = f * glm::dot(dir, q);
-		if(baryPosition.y < typename genType::value_type(0.0f))
-			return false;
-		if(baryPosition.y + baryPosition.x > typename genType::value_type(1.0f))
-			return false;
-
-		baryPosition.z = f * glm::dot(e2, q);
-
-		return baryPosition.z >= typename genType::value_type(0.0f);
-	}
-
-	//template <typename genType>
-	//GLM_FUNC_QUALIFIER bool intersectRayTriangle
-	//(
-	//	genType const & orig, genType const & dir,
-	//	genType const & vert0, genType const & vert1, genType const & vert2,
-	//	genType & position
-	//)
-	//{
-	//	typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
-	//
-	//	genType edge1 = vert1 - vert0;
-	//	genType edge2 = vert2 - vert0;
-	//
-	//	genType pvec = cross(dir, edge2);
-	//
-	//	float det = dot(edge1, pvec);
-	//	if(det < Epsilon)
-	//		return false;
-	//
-	//	genType tvec = orig - vert0;
-	//
-	//	position.y = dot(tvec, pvec);
-	//	if (position.y < typename genType::value_type(0) || position.y > det)
-	//		return typename genType::value_type(0);
-	//
-	//	genType qvec = cross(tvec, edge1);
-	//
-	//	position.z = dot(dir, qvec);
-	//	if (position.z < typename genType::value_type(0) || position.y + position.z > det)
-	//		return typename genType::value_type(0);
-	//
-	//	position.x = dot(edge2, qvec);
-	//	position *= typename genType::value_type(1) / det;
-	//
-	//	return typename genType::value_type(1);
-	//}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool intersectLineTriangle
-	(
-		genType const & orig, genType const & dir,
-		genType const & vert0, genType const & vert1, genType const & vert2,
-		genType & position
-	)
-	{
-		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
-
-		genType edge1 = vert1 - vert0;
-		genType edge2 = vert2 - vert0;
-
-		genType pvec = cross(dir, edge2);
-
-		float det = dot(edge1, pvec);
-
-		if (det > -Epsilon && det < Epsilon)
-			return false;
-		float inv_det = typename genType::value_type(1) / det;
-
-		genType tvec = orig - vert0;
-
-		position.y = dot(tvec, pvec) * inv_det;
-		if (position.y < typename genType::value_type(0) || position.y > typename genType::value_type(1))
-			return false;
-
-		genType qvec = cross(tvec, edge1);
-
-		position.z = dot(dir, qvec) * inv_det;
-		if (position.z < typename genType::value_type(0) || position.y + position.z > typename genType::value_type(1))
-			return false;
-
-		position.x = dot(edge2, qvec) * inv_det;
-
-		return true;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool intersectRaySphere
-	(
-		genType const & rayStarting, genType const & rayNormalizedDirection,
-		genType const & sphereCenter, const typename genType::value_type sphereRadiusSquered,
-		typename genType::value_type & intersectionDistance
-	)
-	{
-		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
-		genType diff = sphereCenter - rayStarting;
-		typename genType::value_type t0 = dot(diff, rayNormalizedDirection);
-		typename genType::value_type dSquared = dot(diff, diff) - t0 * t0;
-		if( dSquared > sphereRadiusSquered )
-		{
-			return false;
-		}
-		typename genType::value_type t1 = sqrt( sphereRadiusSquered - dSquared );
-		intersectionDistance = t0 > t1 + Epsilon ? t0 - t1 : t0 + t1;
-		return intersectionDistance > Epsilon;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool intersectRaySphere
-	(
-		genType const & rayStarting, genType const & rayNormalizedDirection,
-		genType const & sphereCenter, const typename genType::value_type sphereRadius,
-		genType & intersectionPosition, genType & intersectionNormal
-	)
-	{
-		typename genType::value_type distance;
-		if( intersectRaySphere( rayStarting, rayNormalizedDirection, sphereCenter, sphereRadius * sphereRadius, distance ) )
-		{
-			intersectionPosition = rayStarting + rayNormalizedDirection * distance;
-			intersectionNormal = (intersectionPosition - sphereCenter) / sphereRadius;
-			return true;
-		}
-		return false;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool intersectLineSphere
-	(
-		genType const & point0, genType const & point1,
-		genType const & sphereCenter, typename genType::value_type sphereRadius,
-		genType & intersectionPoint1, genType & intersectionNormal1, 
-		genType & intersectionPoint2, genType & intersectionNormal2
-	)
-	{
-		typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
-		genType dir = normalize(point1 - point0);
-		genType diff = sphereCenter - point0;
-		typename genType::value_type t0 = dot(diff, dir);
-		typename genType::value_type dSquared = dot(diff, diff) - t0 * t0;
-		if( dSquared > sphereRadius * sphereRadius )
-		{
-			return false;
-		}
-		typename genType::value_type t1 = sqrt( sphereRadius * sphereRadius - dSquared );
-		if( t0 < t1 + Epsilon )
-			t1 = -t1;
-		intersectionPoint1 = point0 + dir * (t0 - t1);
-		intersectionNormal1 = (intersectionPoint1 - sphereCenter) / sphereRadius;
-		intersectionPoint2 = point0 + dir * (t0 + t1);
-		intersectionNormal2 = (intersectionPoint2 - sphereCenter) / sphereRadius;
-		return true;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/log_base.hpp b/include/gal/opengl/glm/gtx/log_base.hpp
deleted file mode 100644
index 0f2033e948..0000000000
--- a/include/gal/opengl/glm/gtx/log_base.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_log_base
-/// @file glm/gtx/log_base.hpp
-/// @date 2008-10-24 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_log_base GLM_GTX_log_base
-/// @ingroup gtx
-/// 
-/// @brief Logarithm for any base. base can be a vector or a scalar.
-/// 
-/// <glm/gtx/log_base.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_log_base
-#define GLM_GTX_log_base GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_log_base extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_log_base
-	/// @{
-
-	//! Logarithm for any base.
-	//! From GLM_GTX_log_base.
-	template <typename genType> 
-	genType log(
-		genType const & x, 
-		genType const & base);
-
-	/// @}
-}//namespace glm
-
-#include "log_base.inl"
-
-#endif//GLM_GTX_log_base
diff --git a/include/gal/opengl/glm/gtx/log_base.inl b/include/gal/opengl/glm/gtx/log_base.inl
deleted file mode 100644
index d8be51e45e..0000000000
--- a/include/gal/opengl/glm/gtx/log_base.inl
+++ /dev/null
@@ -1,24 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2008-10-24
-// Updated : 2008-10-24
-// Licence : This source is under MIT License
-// File    : glm/gtx/log_base.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType log(
-		genType const & x, 
-		genType const & base)
-	{
-		assert(x != genType(0));
-
-		return glm::log(x) / glm::log(base);
-	}
-
-	VECTORIZE_VEC_SCA(log)
-	VECTORIZE_VEC_VEC(log)
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/matrix_cross_product.hpp b/include/gal/opengl/glm/gtx/matrix_cross_product.hpp
deleted file mode 100644
index a298ab8964..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_cross_product.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_matrix_cross_product
-/// @file glm/gtx/matrix_cross_product.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product
-/// @ingroup gtx
-/// 
-/// @brief Build cross product matrices
-/// 
-/// <glm/gtx/matrix_cross_product.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_matrix_cross_product
-#define GLM_GTX_matrix_cross_product GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_matrix_cross_product
-	/// @{
-
-	//! Build a cross product matrix.
-	//! From GLM_GTX_matrix_cross_product extension.
-	template <typename T> 
-	detail::tmat3x3<T> matrixCross3(
-		detail::tvec3<T> const & x);
-		
-	//! Build a cross product matrix.
-	//! From GLM_GTX_matrix_cross_product extension.
-	template <typename T> 
-	detail::tmat4x4<T> matrixCross4(
-		detail::tvec3<T> const & x);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_cross_product.inl"
-
-#endif//GLM_GTX_matrix_cross_product
diff --git a/include/gal/opengl/glm/gtx/matrix_cross_product.inl b/include/gal/opengl/glm/gtx/matrix_cross_product.inl
deleted file mode 100644
index 5da440303e..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_cross_product.inl
+++ /dev/null
@@ -1,44 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2005-12-21
-// Licence : This source is under MIT License
-// File    : glm/gtx/matrix_cross_product.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3
-	(
-		detail::tvec3<T> const & x
-	)
-	{
-		detail::tmat3x3<T> Result(T(0));
-		Result[0][1] = x.z;
-		Result[1][0] = -x.z;
-		Result[0][2] = -x.y;
-		Result[2][0] = x.y;
-		Result[1][2] = x.x;
-		Result[2][1] = -x.x;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4
-	(
-		detail::tvec3<T> const & x
-	)
-	{
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][1] = x.z;
-		Result[1][0] = -x.z;
-		Result[0][2] = -x.y;
-		Result[2][0] = x.y;
-		Result[1][2] = x.x;
-		Result[2][1] = -x.x;
-		return Result;
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/matrix_interpolation.hpp b/include/gal/opengl/glm/gtx/matrix_interpolation.hpp
deleted file mode 100644
index 75f2047efd..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_interpolation.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_matrix_interpolation
-/// @file glm/gtx/matrix_interpolation.hpp
-/// @date 2011-03-05 / 2011-06-07
-/// @author Ghenadii Ursachi (the.asteroth@gmail.com)
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation
-/// @ingroup gtx
-/// 
-/// @brief Allows to directly interpolate two exiciting matrices.
-/// 
-/// <glm/gtx/matrix_interpolation.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_matrix_interpolation
-#define GLM_GTX_matrix_interpolation GLM_VERSION
-
-// Dependency:
-//#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_matrix_interpolation
-	/// @{
-
-	//! Get the axis and angle of the rotation from a matrix.
-    //! From GLM_GTX_matrix_interpolation extension.
-	template <typename T>
-    void axisAngle(
-        detail::tmat4x4<T> const & mat,
-        detail::tvec3<T> & axis,
-        T & angle);
-
-    //! Build a matrix from axis and angle.
-    //! From GLM_GTX_matrix_interpolation extension.
-	template <typename T>
-    detail::tmat4x4<T> axisAngleMatrix(
-        detail::tvec3<T> const & axis,
-        T const angle);
-
-	//! Extracts the rotation part of a matrix.
-    //! From GLM_GTX_matrix_interpolation extension.
-	template <typename T>
-	detail::tmat4x4<T> extractMatrixRotation(
-		detail::tmat4x4<T> const & mat);
-
-	//! Build a interpolation of 4 * 4 matrixes.
-    //! From GLM_GTX_matrix_interpolation extension.
-    //! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
-	template <typename T>
-    detail::tmat4x4<T> interpolate(
-        detail::tmat4x4<T> const & m1,
-        detail::tmat4x4<T> const & m2,
-        T const delta);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_interpolation.inl"
-
-#endif//GLM_GTX_matrix_interpolation
diff --git a/include/gal/opengl/glm/gtx/matrix_interpolation.inl b/include/gal/opengl/glm/gtx/matrix_interpolation.inl
deleted file mode 100644
index 8ab13435aa..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_interpolation.inl
+++ /dev/null
@@ -1,131 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2011-03-05
-// Updated : 2011-03-05
-// Licence : This source is under MIT License
-// File    : glm/gtx/matrix_interpolation.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER void axisAngle
-	(
-		detail::tmat4x4<T> const & mat,
-		detail::tvec3<T> & axis,
-		T & angle
-	)
-	{
-		T epsilon = (T)0.01;
-		T epsilon2 = (T)0.1;
-
-		if ((fabs(mat[1][0] - mat[0][1]) < epsilon) && (fabs(mat[2][0] - mat[0][2]) < epsilon) && (fabs(mat[2][1] - mat[1][2]) < epsilon)) {
-			if ((fabs(mat[1][0] + mat[0][1]) < epsilon2) && (fabs(mat[2][0] + mat[0][2]) < epsilon2) && (fabs(mat[2][1] + mat[1][2]) < epsilon2) && (fabs(mat[0][0] + mat[1][1] + mat[2][2] - (T)3.0) < epsilon2)) {
-				angle = (T)0.0;
-				axis.x = (T)1.0;
-				axis.y = (T)0.0;
-				axis.z = (T)0.0;
-				return;
-			}
-			angle = T(3.1415926535897932384626433832795);
-			T xx = (mat[0][0] + (T)1.0) / (T)2.0;
-			T yy = (mat[1][1] + (T)1.0) / (T)2.0;
-			T zz = (mat[2][2] + (T)1.0) / (T)2.0;
-			T xy = (mat[1][0] + mat[0][1]) / (T)4.0;
-			T xz = (mat[2][0] + mat[0][2]) / (T)4.0;
-			T yz = (mat[2][1] + mat[1][2]) / (T)4.0;
-			if ((xx > yy) && (xx > zz)) {
-				if (xx < epsilon) {
-					axis.x = (T)0.0;
-					axis.y = (T)0.7071;
-					axis.z = (T)0.7071;
-				} else {
-					axis.x = sqrt(xx);
-					axis.y = xy / axis.x;
-					axis.z = xz / axis.x;
-				}
-			} else if (yy > zz) {
-				if (yy < epsilon) {
-					axis.x = (T)0.7071;
-					axis.y = (T)0.0;
-					axis.z = (T)0.7071;
-				} else {
-					axis.y = sqrt(yy);
-					axis.x = xy / axis.y;
-					axis.z = yz / axis.y;
-				}
-			} else {
-				if (zz < epsilon) {
-					axis.x = (T)0.7071;
-					axis.y = (T)0.7071;
-					axis.z = (T)0.0;
-				} else {
-					axis.z = sqrt(zz);
-					axis.x = xz / axis.z;
-					axis.y = yz / axis.z;
-				}
-			}
-			return;
-		}
-		T s = sqrt((mat[2][1] - mat[1][2]) * (mat[2][1] - mat[1][2]) + (mat[2][0] - mat[0][2]) * (mat[2][0] - mat[0][2]) + (mat[1][0] - mat[0][1]) * (mat[1][0] - mat[0][1]));
-		if (glm::abs(s) < T(0.001))
-			s = (T)1.0;
-		angle = acos((mat[0][0] + mat[1][1] + mat[2][2] - (T)1.0) / (T)2.0);
-		axis.x = (mat[1][2] - mat[2][1]) / s;
-		axis.y = (mat[2][0] - mat[0][2]) / s;
-		axis.z = (mat[0][1] - mat[1][0]) / s;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> axisAngleMatrix
-	(
-		detail::tvec3<T> const & axis,
-		T const angle
-	)
-	{
-		T c = cos(angle);
-		T s = sin(angle);
-		T t = T(1) - c;
-		detail::tvec3<T> n = normalize(axis);
-
-		return detail::tmat4x4<T>(
-			t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    T(0),
-			t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    T(0),
-			t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          T(0),
-			T(0),                        T(0),                        T(0),                     T(1)
-		);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> extractMatrixRotation(
-		detail::tmat4x4<T> const & mat)
-	{
-		return detail::tmat4x4<T>(
-			mat[0][0], mat[0][1], mat[0][2], 0.0,
-			mat[1][0], mat[1][1], mat[1][2], 0.0,
-			mat[2][0], mat[2][1], mat[2][2], 0.0,
-			0.0,       0.0,       0.0,       1.0
-		);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> interpolate
-	(
-		detail::tmat4x4<T> const & m1,
-		detail::tmat4x4<T> const & m2,
-		T const delta
-	)
-	{
-		detail::tmat4x4<T> m1rot = extractMatrixRotation(m1);
-		detail::tmat4x4<T> dltRotation = m2 * transpose(m1rot);
-		detail::tvec3<T> dltAxis;
-		T dltAngle;
-		axisAngle(dltRotation, dltAxis, dltAngle);
-		detail::tmat4x4<T> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
-		out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
-		out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
-		out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
-		return out;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/matrix_major_storage.hpp b/include/gal/opengl/glm/gtx/matrix_major_storage.hpp
deleted file mode 100644
index 74b5db063a..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_major_storage.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_matrix_major_storage
-/// @file glm/gtx/matrix_major_storage.hpp
-/// @date 2006-04-19 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage
-/// @ingroup gtx
-/// 
-/// @brief Build matrices with specific matrix order, row or column
-/// 
-/// <glm/gtx/matrix_major_storage.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_matrix_major_storage
-#define GLM_GTX_matrix_major_storage GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_matrix_major_storage
-	/// @{
-
-	//! Build a row major matrix from row vectors.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat2x2<T> rowMajor2(
-		detail::tvec2<T> const & v1, 
-		detail::tvec2<T> const & v2);
-		
-	//! Build a row major matrix from other matrix.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat2x2<T> rowMajor2(
-		detail::tmat2x2<T> const & m);
-
-	//! Build a row major matrix from row vectors.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat3x3<T> rowMajor3(
-		detail::tvec3<T> const & v1, 
-		detail::tvec3<T> const & v2, 
-		detail::tvec3<T> const & v3);
-
-	//! Build a row major matrix from other matrix.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat3x3<T> rowMajor3(
-		detail::tmat3x3<T> const & m);
-
-	//! Build a row major matrix from row vectors.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat4x4<T> rowMajor4(
-		detail::tvec4<T> const & v1, 
-		detail::tvec4<T> const & v2,
-		detail::tvec4<T> const & v3, 
-		detail::tvec4<T> const & v4);
-
-	//! Build a row major matrix from other matrix.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat4x4<T> rowMajor4(
-		detail::tmat4x4<T> const & m);
-
-	//! Build a column major matrix from column vectors.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat2x2<T> colMajor2(
-		detail::tvec2<T> const & v1, 
-		detail::tvec2<T> const & v2);
-		
-	//! Build a column major matrix from other matrix.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat2x2<T> colMajor2(
-		detail::tmat2x2<T> const & m);
-
-	//! Build a column major matrix from column vectors.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat3x3<T> colMajor3(
-		detail::tvec3<T> const & v1, 
-		detail::tvec3<T> const & v2, 
-		detail::tvec3<T> const & v3);
-		
-	//! Build a column major matrix from other matrix.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat3x3<T> colMajor3(
-		detail::tmat3x3<T> const & m);
-		
-	//! Build a column major matrix from column vectors.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat4x4<T> colMajor4(
-		detail::tvec4<T> const & v1, 
-		detail::tvec4<T> const & v2, 
-		detail::tvec4<T> const & v3, 
-		detail::tvec4<T> const & v4);
-				
-	//! Build a column major matrix from other matrix.
-	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T> 
-	detail::tmat4x4<T> colMajor4(
-		detail::tmat4x4<T> const & m);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_major_storage.inl"
-
-#endif//GLM_GTX_matrix_major_storage
diff --git a/include/gal/opengl/glm/gtx/matrix_major_storage.inl b/include/gal/opengl/glm/gtx/matrix_major_storage.inl
deleted file mode 100644
index a12ed36fed..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_major_storage.inl
+++ /dev/null
@@ -1,173 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-04-19
-// Updated : 2009-02-19
-// Licence : This source is under MIT License
-// File    : glm/gtx/matrix_major_storage.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2
-	(
-		detail::tvec2<T> const & v1, 
-		detail::tvec2<T> const & v2
-	)
-	{
-		detail::tmat2x2<T> Result;
-		Result[0][0] = v1.x;
-		Result[1][0] = v1.y;
-		Result[0][1] = v2.x;
-		Result[1][1] = v2.y;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
-		const detail::tmat2x2<T>& m)
-	{
-		detail::tmat2x2<T> Result;
-		Result[0][0] = m[0][0];
-		Result[0][1] = m[1][0];
-		Result[1][0] = m[0][1];
-		Result[1][1] = m[1][1];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
-		const detail::tvec3<T>& v1, 
-		const detail::tvec3<T>& v2, 
-		const detail::tvec3<T>& v3)
-	{
-		detail::tmat3x3<T> Result;
-		Result[0][0] = v1.x;
-		Result[1][0] = v1.y;
-		Result[2][0] = v1.z;
-		Result[0][1] = v2.x;
-		Result[1][1] = v2.y;
-		Result[2][1] = v2.z;
-		Result[0][2] = v3.x;
-		Result[1][2] = v3.y;
-		Result[2][2] = v3.z;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
-		const detail::tmat3x3<T>& m)
-	{
-		detail::tmat3x3<T> Result;
-		Result[0][0] = m[0][0];
-		Result[0][1] = m[1][0];
-		Result[0][2] = m[2][0];
-		Result[1][0] = m[0][1];
-		Result[1][1] = m[1][1];
-		Result[1][2] = m[2][1];
-		Result[2][0] = m[0][2];
-		Result[2][1] = m[1][2];
-		Result[2][2] = m[2][2];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
-		const detail::tvec4<T>& v1, 
-		const detail::tvec4<T>& v2, 
-		const detail::tvec4<T>& v3, 
-		const detail::tvec4<T>& v4)
-	{
-		detail::tmat4x4<T> Result;
-		Result[0][0] = v1.x;
-		Result[1][0] = v1.y;
-		Result[2][0] = v1.z;
-		Result[3][0] = v1.w;
-		Result[0][1] = v2.x;
-		Result[1][1] = v2.y;
-		Result[2][1] = v2.z;
-		Result[3][1] = v2.w;
-		Result[0][2] = v3.x;
-		Result[1][2] = v3.y;
-		Result[2][2] = v3.z;
-		Result[3][2] = v3.w;
-		Result[0][3] = v4.x;
-		Result[1][3] = v4.y;
-		Result[2][3] = v4.z;
-		Result[3][3] = v4.w;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
-		const detail::tmat4x4<T>& m)
-	{
-		detail::tmat4x4<T> Result;
-		Result[0][0] = m[0][0];
-		Result[0][1] = m[1][0];
-		Result[0][2] = m[2][0];
-		Result[0][3] = m[3][0];
-		Result[1][0] = m[0][1];
-		Result[1][1] = m[1][1];
-		Result[1][2] = m[2][1];
-		Result[1][3] = m[3][1];
-		Result[2][0] = m[0][2];
-		Result[2][1] = m[1][2];
-		Result[2][2] = m[2][2];
-		Result[2][3] = m[3][2];
-		Result[3][0] = m[0][3];
-		Result[3][1] = m[1][3];
-		Result[3][2] = m[2][3];
-		Result[3][3] = m[3][3];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
-		const detail::tvec2<T>& v1, 
-		const detail::tvec2<T>& v2)
-	{
-		return detail::tmat2x2<T>(v1, v2);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
-		const detail::tmat2x2<T>& m)
-	{
-		return detail::tmat2x2<T>(m);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
-		const detail::tvec3<T>& v1, 
-		const detail::tvec3<T>& v2, 
-		const detail::tvec3<T>& v3)
-	{
-		return detail::tmat3x3<T>(v1, v2, v3);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
-		const detail::tmat3x3<T>& m)
-	{
-		return detail::tmat3x3<T>(m);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
-		const detail::tvec4<T>& v1, 
-		const detail::tvec4<T>& v2, 
-		const detail::tvec4<T>& v3, 
-		const detail::tvec4<T>& v4)
-	{
-		return detail::tmat4x4<T>(v1, v2, v3, v4);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
-		const detail::tmat4x4<T>& m)
-	{
-		return detail::tmat4x4<T>(m);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/matrix_operation.hpp b/include/gal/opengl/glm/gtx/matrix_operation.hpp
deleted file mode 100644
index 8a57324ecc..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_operation.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_matrix_operation
-/// @file glm/gtx/matrix_operation.hpp
-/// @date 2009-08-29 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation
-/// @ingroup gtx
-/// 
-/// @brief Build diagonal matrices from vectors.
-/// 
-/// <glm/gtx/matrix_operation.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_matrix_operation
-#define GLM_GTX_matrix_operation GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_matrix_operation extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_matrix_operation
-	/// @{
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat2x2<valType> diagonal2x2(
-		detail::tvec2<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat2x3<valType> diagonal2x3(
-		detail::tvec2<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat2x4<valType> diagonal2x4(
-		detail::tvec2<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat3x2<valType> diagonal3x2(
-		detail::tvec2<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat3x3<valType> diagonal3x3(
-		detail::tvec3<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat3x4<valType> diagonal3x4(
-		detail::tvec3<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat4x2<valType> diagonal4x2(
-		detail::tvec2<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat4x3<valType> diagonal4x3(
-		detail::tvec3<valType> const & v);
-
-	//! Build a diagonal matrix.
-	//! From GLM_GTX_matrix_operation extension.
-	template <typename valType> 
-	detail::tmat4x4<valType> diagonal4x4(
-		detail::tvec4<valType> const & v);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_operation.inl"
-
-#endif//GLM_GTX_matrix_operation
diff --git a/include/gal/opengl/glm/gtx/matrix_operation.inl b/include/gal/opengl/glm/gtx/matrix_operation.inl
deleted file mode 100644
index 37b2b02d84..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_operation.inl
+++ /dev/null
@@ -1,124 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2009-08-29
-// Updated : 2009-08-29
-// Licence : This source is under MIT License
-// File    : glm/gtx/matrix_operation.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> diagonal2x2
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat2x2<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x3<valType> diagonal2x3
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat2x3<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x4<valType> diagonal2x4
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat2x4<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x2<valType> diagonal3x2
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat3x2<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> diagonal3x3
-	(
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tmat3x3<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x4<valType> diagonal3x4
-	(
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tmat3x4<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> diagonal4x4
-	(
-		detail::tvec4<valType> const & v
-	)
-	{
-		detail::tmat4x4<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		Result[3][3] = v[3];
-		return Result;		
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x3<valType> diagonal4x3
-	(
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tmat4x3<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		return Result;		
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x2<valType> diagonal4x2
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat4x2<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;		
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/matrix_query.hpp b/include/gal/opengl/glm/gtx/matrix_query.hpp
deleted file mode 100644
index bba233b361..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_query.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_matrix_query
-/// @file glm/gtx/matrix_query.hpp
-/// @date 2007-03-05 / 2011-08-28
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_vector_query (dependence)
-///
-/// @defgroup gtx_matrix_query GLM_GTX_matrix_query
-/// @ingroup gtx
-/// 
-/// @brief Query to evaluate matrix properties
-/// 
-/// <glm/gtx/matrix_query.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_matrix_query
-#define GLM_GTX_matrix_query GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/vector_query.hpp"
-#include <limits>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_matrix_query extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_matrix_query
-	/// @{
-
-	/// Return whether a matrix a null matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename T> 
-	bool isNull(
-		detail::tmat2x2<T> const & m, 
-		T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
-		
-	/// Return whether a matrix a null matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename T> 
-	bool isNull(
-		detail::tmat3x3<T> const & m, 
-		T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
-		
-	/// Return whether a matrix is a null matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename T> 
-	bool isNull(
-		detail::tmat4x4<T> const & m, 
-		T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
-			
-	/// Return whether a matrix is an identity matrix. 
-	/// From GLM_GTX_matrix_query extension.
-	template<typename genType> 
-	bool isIdentity(
-		genType const & m, 
-		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-
-	/// Return whether a matrix is a normalized matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename valType>   
-	bool isNormalized(
-		detail::tmat2x2<valType> const & m, 
-		valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
-
-	/// Return whether a matrix is a normalized matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename valType>   
-	bool isNormalized(
-		detail::tmat3x3<valType> const & m, 
-		valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
-
-	/// Return whether a matrix is a normalized matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename valType>   
-	bool isNormalized(
-		detail::tmat4x4<valType> const & m, 
-		valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
-
-	/// Return whether a matrix is an orthonormalized matrix.
-	/// From GLM_GTX_matrix_query extension.
-	template<typename valType, template <typename> class matType> 
-	bool isOrthogonal(
-		matType<valType> const & m, 
-		valType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_query.inl"
-
-#endif//GLM_GTX_matrix_query
diff --git a/include/gal/opengl/glm/gtx/matrix_query.inl b/include/gal/opengl/glm/gtx/matrix_query.inl
deleted file mode 100644
index 6db3391502..0000000000
--- a/include/gal/opengl/glm/gtx/matrix_query.inl
+++ /dev/null
@@ -1,154 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-03-05
-// Updated : 2007-03-05
-// Licence : This source is under MIT License
-// File    : glm/gtx/matrix_query.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Dependency:
-// - GLM core
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNull
-	(
-		detail::tmat2x2<T> const & m, 
-		T const & epsilon)
-	{
-		bool result = true;
-		for(int i = 0; result && i < 2 ; ++i)
-			result = isNull(m[i], epsilon);
-		return result;
-	}
-
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNull
-	(
-		detail::tmat3x3<T> const & m, 
-		T const & epsilon
-	)
-	{
-		bool result = true;
-		for(int i = 0; result && i < 3 ; ++i)
-			result = isNull(m[i], epsilon);
-		return result;
-	}
-
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNull
-	(
-		detail::tmat4x4<T> const & m, 
-		T const & epsilon
-	)
-	{
-		bool result = true;
-		for(int i = 0; result && i < 4 ; ++i)
-			result = isNull(m[i], epsilon);
-		return result;
-	}
-
-	template<typename genType> 
-	GLM_FUNC_QUALIFIER bool isIdentity
-	(
-		genType const & m, 
-		typename genType::value_type const & epsilon
-	)
-	{
-		bool result = true;
-		for(typename genType::size_type i = typename genType::size_type(0); result && i < genType::col_size(); ++i)
-		{
-			for(typename genType::size_type j = typename genType::size_type(0); result && j < i ; ++j)
-				result = abs(m[i][j]) <= epsilon;
-			if(result)
-				result = abs(m[i][i] - typename genType::value_type(1)) <= epsilon;
-			for(typename genType::size_type j = i + typename genType::size_type(1); result && j < genType::row_size(); ++j)
-				result = abs(m[i][j]) <= epsilon;
-		}
-		return result;
-	}
-
-	template<typename genType>  
-	GLM_FUNC_QUALIFIER bool isNormalized
-	(
-		detail::tmat2x2<genType> const & m, 
-		genType const & epsilon
-	)
-	{
-		bool result(true);
-                for(typename detail::tmat2x2<genType>::size_type i(0); result && i < m.length(); ++i)
-			result = isNormalized(m[i], epsilon);
-                for(typename detail::tmat2x2<genType>::size_type i(0); result && i < m.length(); ++i)
-		{
-                        typename detail::tmat2x2<genType>::col_type v;
-                        for(typename detail::tmat2x2<genType>::size_type j(0); j < m.length(); ++j)
-				v[j] = m[j][i];
-			result = isNormalized(v, epsilon);
-		}
-		return result;
-	}
-
-	template<typename genType>  
-	GLM_FUNC_QUALIFIER bool isNormalized
-	(
-		detail::tmat3x3<genType> const & m, 
-		genType const & epsilon
-	)
-	{
-		bool result(true);
-                for(typename detail::tmat3x3<genType>::size_type i(0); result && i < m.length(); ++i)
-			result = isNormalized(m[i], epsilon);
-                for(typename detail::tmat3x3<genType>::size_type i(0); result && i < m.length(); ++i)
-		{
-                        typename detail::tmat3x3<genType>::col_type v;
-                        for(typename detail::tmat3x3<genType>::size_type j(0); j < m.length(); ++j)
-				v[j] = m[j][i];
-			result = isNormalized(v, epsilon);
-		}
-		return result;
-	}
-
-	template<typename genType>  
-	GLM_FUNC_QUALIFIER bool isNormalized
-	(
-		detail::tmat4x4<genType> const & m, 
-		genType const & epsilon
-	)
-	{
-		bool result(true);
-                for(typename detail::tmat4x4<genType>::size_type i(0); result && i < m.length(); ++i)
-			result = isNormalized(m[i], epsilon);
-                for(typename detail::tmat4x4<genType>::size_type i(0); result && i < m.length(); ++i)
-		{
-                        typename detail::tmat4x4<genType>::col_type v;
-                        for(typename detail::tmat4x4<genType>::size_type j(0); j < m.length(); ++j)
-				v[j] = m[j][i];
-			result = isNormalized(v, epsilon);
-		}
-		return result;
-	}
-
-	template<typename genType, template <typename> class matType>  
-	GLM_FUNC_QUALIFIER bool isOrthogonal
-	(
-		matType<genType> const & m, 
-		genType const & epsilon
-	)
-	{
-		bool result(true);
-		for(typename matType<genType>::size_type i(0); result && i < m.length() - 1; ++i)
-		for(typename matType<genType>::size_type j(i + 1); result && j < m.length(); ++j)
-			result = areOrthogonal(m[i], m[j], epsilon);
-
-		if(result)
-		{
-			matType<genType> tmp = transpose(m);
-			for(typename matType<genType>::size_type i(0); result && i < m.length() - 1 ; ++i)
-			for(typename matType<genType>::size_type j(i + 1); result && j < m.length(); ++j)
-				result = areOrthogonal(tmp[i], tmp[j], epsilon);
-		}
-		return result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/mixed_product.hpp b/include/gal/opengl/glm/gtx/mixed_product.hpp
deleted file mode 100644
index b222271469..0000000000
--- a/include/gal/opengl/glm/gtx/mixed_product.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_mixed_product
-/// @file glm/gtx/mixed_product.hpp
-/// @date 2007-04-03 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_mixed_product GLM_GTX_mixed_producte
-/// @ingroup gtx
-/// 
-/// @brief Mixed product of 3 vectors.
-/// 
-/// <glm/gtx/mixed_product.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_mixed_product
-#define GLM_GTX_mixed_product GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_mixed_product extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_mixed_product
-	/// @{
-
-	/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
-	template <typename valType> 
-	valType mixedProduct(
-		detail::tvec3<valType> const & v1, 
-		detail::tvec3<valType> const & v2, 
-		detail::tvec3<valType> const & v3);
-
-	/// @}
-}// namespace glm
-
-#include "mixed_product.inl"
-
-#endif//GLM_GTX_mixed_product
diff --git a/include/gal/opengl/glm/gtx/mixed_product.inl b/include/gal/opengl/glm/gtx/mixed_product.inl
deleted file mode 100644
index 9c3a1793e2..0000000000
--- a/include/gal/opengl/glm/gtx/mixed_product.inl
+++ /dev/null
@@ -1,22 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-04-03
-// Updated : 2008-09-17
-// Licence : This source is under MIT License
-// File    : glm/gtx/mixed_product.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType mixedProduct
-	(
-		detail::tvec3<valType> const & v1, 
-		detail::tvec3<valType> const & v2, 
-		detail::tvec3<valType> const & v3
-	)
-	{
-		return dot(cross(v1, v2), v3);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/multiple.hpp b/include/gal/opengl/glm/gtx/multiple.hpp
deleted file mode 100644
index 0092802902..0000000000
--- a/include/gal/opengl/glm/gtx/multiple.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_multiple
-/// @file glm/gtx/multiple.hpp
-/// @date 2009-10-26 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_multiple GLM_GTX_multiple
-/// @ingroup gtx
-/// 
-/// @brief Find the closest number of a number multiple of other number.
-/// 
-/// <glm/gtx/multiple.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_multiple
-#define GLM_GTX_multiple GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_multiple extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_multiple
-	/// @{
-
-	//! Higher Multiple number of Source.
-	//! From GLM_GTX_multiple extension.
-	template <typename genType> 
-	genType higherMultiple(
-		genType const & Source, 
-		genType const & Multiple);
-
-	//! Lower Multiple number of Source.
-	//! From GLM_GTX_multiple extension.
-	template <typename genType> 
-	genType lowerMultiple(
-		genType const & Source, 
-		genType const & Multiple);
-
-	/// @}
-}//namespace glm
-
-#include "multiple.inl"
-
-#endif//GLM_GTX_multiple
diff --git a/include/gal/opengl/glm/gtx/multiple.inl b/include/gal/opengl/glm/gtx/multiple.inl
deleted file mode 100644
index e7d25b0f18..0000000000
--- a/include/gal/opengl/glm/gtx/multiple.inl
+++ /dev/null
@@ -1,128 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2009-10-26
-// Updated : 2011-06-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/multiple.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Dependency:
-// - GLM core
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	//////////////////////
-	// higherMultiple
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType higherMultiple
-	(
-		genType const & Source, 
-		genType const & Multiple
-	)
-	{
-		if (Source > 0)
-		{
-			genType Tmp = Source - 1;
-			return Tmp + (Multiple - (Tmp % Multiple));
-		}
-		else
-			return Source + (-Source % Multiple);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER detail::half higherMultiple
-	(
-		detail::half const & SourceH, 
-		detail::half const & MultipleH
-	)
-	{
-		float Source = SourceH.toFloat();
-		float Multiple = MultipleH.toFloat();
-
-		int Tmp = int(float(Source)) % int(Multiple);
-		return detail::half(Tmp ? Source + Multiple - float(Tmp) : Source);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER float higherMultiple
-	(	
-		float const & Source, 
-		float const & Multiple
-	)
-	{
-		int Tmp = int(Source) % int(Multiple);
-		return Tmp ? Source + Multiple - float(Tmp) : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER double higherMultiple
-	(
-		double const & Source, 
-		double const & Multiple
-	)
-	{
-		long Tmp = long(Source) % long(Multiple);
-		return Tmp ? Source + Multiple - double(Tmp) : Source;
-	}
-
-	VECTORIZE_VEC_VEC(higherMultiple)
-
-	//////////////////////
-	// lowerMultiple
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType lowerMultiple
-	(
-		genType const & Source, 
-		genType const & Multiple
-	)
-	{
-		if (Source >= 0)
-			return Source - Source % Multiple;
-		else
-		{
-			genType Tmp = Source + 1;
-			return Tmp - Tmp % Multiple - Multiple;
-		}
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER detail::half lowerMultiple
-	(
-		detail::half const & SourceH, 
-		detail::half const & MultipleH
-	)
-	{
-		float Source = SourceH.toFloat();
-		float Multiple = MultipleH.toFloat();
-
-		int Tmp = int(float(Source)) % int(float(Multiple));
-		return detail::half(Tmp ? Source - float(Tmp) : Source);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER float lowerMultiple
-	(
-		float const & Source, 
-		float const & Multiple
-	)
-	{
-		int Tmp = int(Source) % int(Multiple);
-		return Tmp ? Source - float(Tmp) : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER double lowerMultiple
-	(
-		double const & Source, 
-		double const & Multiple
-	)
-	{
-		long Tmp = long(Source) % long(Multiple);
-		return Tmp ? Source - double(Tmp) : Source;
-	}
-
-	VECTORIZE_VEC_VEC(lowerMultiple)
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/noise.hpp b/include/gal/opengl/glm/gtx/noise.hpp
deleted file mode 100644
index f081daca8a..0000000000
--- a/include/gal/opengl/glm/gtx/noise.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_random extension is deprecated, include GLM_GTC_random (glm/gtc/noise.hpp) instead")
-#endif
-
-// Promoted:
-#include "../gtc/noise.hpp"
diff --git a/include/gal/opengl/glm/gtx/norm.hpp b/include/gal/opengl/glm/gtx/norm.hpp
deleted file mode 100644
index 2b065f4c0d..0000000000
--- a/include/gal/opengl/glm/gtx/norm.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_norm
-/// @file glm/gtx/norm.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_quaternion (dependence)
-///
-/// @defgroup gtx_norm GLM_GTX_norm
-/// @ingroup gtx
-/// 
-/// @brief Various ways to compute vector norms.
-/// 
-/// <glm/gtx/norm.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_norm
-#define GLM_GTX_norm GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/quaternion.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_norm extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_norm
-	/// @{
-
-	//! Returns the squared length of x.
-	//! From GLM_GTX_norm extension.
-	template <typename T> 
-	T length2(
-		T const & x);
-
-	//! Returns the squared length of x.
-	//! From GLM_GTX_norm extension.
-	template <typename genType> 
-	typename genType::value_type length2(
-		genType const & x);
-		
-	//! Returns the squared length of x.
-	//! From GLM_GTX_norm extension.
-	template <typename T>
-	T length2(
-		detail::tquat<T> const & q);
-
-	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
-	//! From GLM_GTX_norm extension.
-	template <typename T>
-	T distance2(
-		T const & p0, 
-		T const & p1);
-		
-	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
-	//! From GLM_GTX_norm extension.
-	template <typename genType> 
-	typename genType::value_type distance2(
-		genType const & p0, 
-		genType const & p1);
-
-	//! Returns the L1 norm between x and y.
-	//! From GLM_GTX_norm extension.
-	template <typename T>
-	T l1Norm(
-		detail::tvec3<T> const & x,
-		detail::tvec3<T> const & y);
-		
-	//! Returns the L1 norm of v.
-	//! From GLM_GTX_norm extension.
-	template <typename T> 
-	T l1Norm(
-		detail::tvec3<T> const & v);
-		
-	//! Returns the L2 norm between x and y.
-	//! From GLM_GTX_norm extension.
-	template <typename T> 
-	T l2Norm(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y);
-		
-	//! Returns the L2 norm of v.
-	//! From GLM_GTX_norm extension.
-	template <typename T> 
-	T l2Norm(
-		detail::tvec3<T> const & x);
-		
-	//! Returns the L norm between x and y.
-	//! From GLM_GTX_norm extension.
-	template <typename T> 
-	T lxNorm(
-		detail::tvec3<T> const & x,
-		detail::tvec3<T> const & y,
-		unsigned int Depth);
-
-	//! Returns the L norm of v.
-	//! From GLM_GTX_norm extension.
-	template <typename T>
-	T lxNorm(
-		detail::tvec3<T> const & x,
-		unsigned int Depth);
-
-	/// @}
-}//namespace glm
-
-#include "norm.inl"
-
-#endif//GLM_GTX_norm
diff --git a/include/gal/opengl/glm/gtx/norm.inl b/include/gal/opengl/glm/gtx/norm.inl
deleted file mode 100644
index 427a5a1680..0000000000
--- a/include/gal/opengl/glm/gtx/norm.inl
+++ /dev/null
@@ -1,156 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2008-07-24
-// Licence : This source is under MIT License
-// File    : glm/gtx/norm.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER T length2
-	(
-		T const & x
-	)
-	{
-		return x * x;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T length2
-	(
-		detail::tvec2<T> const & x
-	)
-	{
-		return dot(x, x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T length2
-	(
-		detail::tvec3<T> const & x
-	)
-	{
-		return dot(x, x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T length2
-	(
-		detail::tvec4<T> const & x
-	)
-	{
-		return dot(x, x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T length2
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T distance2
-	(
-		T const & p0, 
-		T const & p1
-	)
-	{
-		return length2(p1 - p0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T distance2
-	(
-		detail::tvec2<T> const & p0, 
-		detail::tvec2<T> const & p1
-	)
-	{
-		return length2(p1 - p0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T distance2
-	(
-		detail::tvec3<T> const & p0, 
-		detail::tvec3<T> const & p1
-	)
-	{
-		return length2(p1 - p0);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T distance2
-	(
-		detail::tvec4<T> const & p0, 
-		detail::tvec4<T> const & p1
-	)
-	{
-		return length2(p1 - p0);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T l1Norm
-	(
-		detail::tvec3<T> const & a, 
-		detail::tvec3<T> const & b
-	)
-	{
-		return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T l1Norm
-	(
-		detail::tvec3<T> const & v
-	)
-	{
-		return abs(v.x) + abs(v.y) + abs(v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T l2Norm
-	(
-		detail::tvec3<T> const & a, 
-		detail::tvec3<T> const & b
-	)
-	{
-		return length(b - a);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T l2Norm
-	(
-		detail::tvec3<T> const & v
-	)
-	{
-		return length(v);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T lxNorm
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		unsigned int Depth
-	)
-	{
-		return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T lxNorm
-	(
-		detail::tvec3<T> const & v, 
-		unsigned int Depth
-	)
-	{
-		return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/normal.hpp b/include/gal/opengl/glm/gtx/normal.hpp
deleted file mode 100644
index a04e304a1c..0000000000
--- a/include/gal/opengl/glm/gtx/normal.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_normal
-/// @file glm/gtx/normal.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_normal GLM_GTX_normal
-/// @ingroup gtx
-/// 
-/// @brief Compute the normal of a triangle.
-/// 
-/// <glm/gtx/normal.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_normal
-#define GLM_GTX_normal GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_normal extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_normal
-	/// @{
-
-	//! Computes triangle normal from triangle points. 
-	//! From GLM_GTX_normal extension.
-    template <typename T> 
-	detail::tvec3<T> triangleNormal(
-		detail::tvec3<T> const & p1, 
-		detail::tvec3<T> const & p2, 
-		detail::tvec3<T> const & p3);
-
-	/// @}
-}//namespace glm
-
-#include "normal.inl"
-
-#endif//GLM_GTX_normal
diff --git a/include/gal/opengl/glm/gtx/normal.inl b/include/gal/opengl/glm/gtx/normal.inl
deleted file mode 100644
index 5aedcc7d7c..0000000000
--- a/include/gal/opengl/glm/gtx/normal.inl
+++ /dev/null
@@ -1,22 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2011-06-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/normal.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
-	(
-		detail::tvec3<T> const & p1, 
-		detail::tvec3<T> const & p2, 
-		detail::tvec3<T> const & p3
-	)
-	{
-		return normalize(cross(p1 - p2, p1 - p3));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/normalize_dot.hpp b/include/gal/opengl/glm/gtx/normalize_dot.hpp
deleted file mode 100644
index 1ba027acdd..0000000000
--- a/include/gal/opengl/glm/gtx/normalize_dot.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_normalize_dot
-/// @file glm/gtx/normalize_dot.hpp
-/// @date 2007-09-28 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_fast_square_root (dependence)
-///
-/// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot
-/// @ingroup gtx
-/// 
-/// @brief Dot product of vectors that need to be normalize with a single square root.
-/// 
-/// <glm/gtx/normalized_dot.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_normalize_dot
-#define GLM_GTX_normalize_dot GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/fast_square_root.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_normalize_dot extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_normalize_dot
-	/// @{
-
-	//! Normalize parameters and returns the dot product of x and y.
-	//! It's faster that dot(normalize(x), normalize(y)).
-	//! From GLM_GTX_normalize_dot extension.
-	template <typename genType> 
-	typename genType::value_type normalizeDot(
-		genType const & x, 
-		genType const & y);
-
-	//! Normalize parameters and returns the dot product of x and y.
-	//! Faster that dot(fastNormalize(x), fastNormalize(y)).
-	//! From GLM_GTX_normalize_dot extension.
-	template <typename genType> 
-	typename genType::value_type fastNormalizeDot(
-		genType const & x, 
-		genType const & y);
-
-	/// @}
-}//namespace glm
-
-#include "normalize_dot.inl"
-
-#endif//GLM_GTX_normalize_dot
diff --git a/include/gal/opengl/glm/gtx/normalize_dot.inl b/include/gal/opengl/glm/gtx/normalize_dot.inl
deleted file mode 100644
index 5058eacc13..0000000000
--- a/include/gal/opengl/glm/gtx/normalize_dot.inl
+++ /dev/null
@@ -1,115 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-//////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-09-28
-// Updated : 2008-10-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/normalize_dot.inl
-//////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType normalizeDot
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			glm::inversesqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType normalizeDot
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			glm::inversesqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType normalizeDot
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			glm::inversesqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType normalizeDot
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			glm::inversesqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType fastNormalizeDot
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			fastInverseSqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType fastNormalizeDot
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			fastInverseSqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType fastNormalizeDot
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			fastInverseSqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType fastNormalizeDot
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> const & y
-	)
-	{
-		return 
-			glm::dot(x, y) * 
-			fastInverseSqrt(glm::dot(x, x) * 
-			glm::dot(y, y));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/number_precision.hpp b/include/gal/opengl/glm/gtx/number_precision.hpp
deleted file mode 100644
index 1597936b55..0000000000
--- a/include/gal/opengl/glm/gtx/number_precision.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_number_precision
-/// @file glm/gtx/number_precision.hpp
-/// @date 2007-05-10 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_type_precision (dependence)
-/// @see gtc_quaternion (dependence)
-///
-/// @defgroup gtx_number_precision GLM_GTX_number_precision
-/// @ingroup gtx
-/// 
-/// @brief Defined size types.
-/// 
-/// <glm/gtx/number_precision.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_number_precision
-#define GLM_GTX_number_precision GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/type_precision.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_number_precision extension included")
-#endif
-
-namespace glm{
-namespace gtx
-{
-	/////////////////////////////
-	// Unsigned int vector types 
-
-	/// @addtogroup gtx_number_precision
-	/// @{
-
-	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
-	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
-	typedef u32			u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
-	typedef u64			u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
-
-	//////////////////////
-	// Float vector types 
-
-	typedef f16			f16vec1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f32			f32vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f64			f64vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-
-	//////////////////////
-	// Float matrix types 
-
-	typedef f16			f16mat1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f16			f16mat1x1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f32			f32mat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f32			f32mat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f64			f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
-
-	/// @}
-}//namespace gtx
-}//namespace glm
-
-#include "number_precision.inl"
-
-#endif//GLM_GTX_number_precision
diff --git a/include/gal/opengl/glm/gtx/number_precision.inl b/include/gal/opengl/glm/gtx/number_precision.inl
deleted file mode 100644
index 3981856583..0000000000
--- a/include/gal/opengl/glm/gtx/number_precision.inl
+++ /dev/null
@@ -1,13 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-05-10
-// Updated : 2007-05-10
-// Licence : This source is under MIT License
-// File    : glm/gtx/number_precision.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-
-}
diff --git a/include/gal/opengl/glm/gtx/ocl_type.hpp b/include/gal/opengl/glm/gtx/ocl_type.hpp
deleted file mode 100644
index 7e8af095c6..0000000000
--- a/include/gal/opengl/glm/gtx/ocl_type.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_ocl_type
-/// @file glm/gtx/ocl_type.hpp
-/// @date 2009-05-07 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_ocl_type GLM_GTX_ocl_type
-/// @ingroup gtx
-/// 
-/// @brief OpenCL types.
-/// 
-/// <glm/gtx/ocl_type.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_ocl_type
-#define GLM_GTX_ocl_type GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_ocl_type extension included")
-#endif
-
-namespace glm{
-namespace gtx
-{
-	///////////////////////////
-	// Scalar types 
-
-	/// @addtogroup gtx_ocl_type
-	/// @{
-
-	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::int16						cl_short;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::int32						cl_int;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::int64						cl_long;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	typedef detail::uint8						cl_uchar;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::uint16						cl_ushort;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::uint32						cl_uint;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::uint64						cl_ulong;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	typedef detail::float16						cl_half;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-	typedef detail::float32						cl_float;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-
-
-	typedef detail::int8						cl_char1;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::int16						cl_short1;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::int32						cl_int1;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::int64						cl_long1;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	typedef detail::uint8						cl_uchar1;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::uint16						cl_ushort1;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::uint32						cl_uint1;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::uint64						cl_ulong1;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	//typedef detail::float16					cl_half1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-	typedef detail::float32						cl_float1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-
-
-	typedef detail::tvec2<detail::int8>			cl_char2;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::int16>		cl_short2;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::int32>		cl_int2;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::int64>		cl_long2;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	typedef detail::tvec2<detail::uint8>		cl_uchar2;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::uint16>		cl_ushort2;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::uint32>		cl_uint2;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::uint64>		cl_ulong2;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	//typedef detail::tvec2<detail::float16>	cl_half2;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec2<detail::float32>		cl_float2;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-
-
-	typedef detail::tvec3<detail::int8>			cl_char3;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::int16>		cl_short3;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::int32>		cl_int3;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::int64>		cl_long3;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	typedef detail::tvec3<detail::uint8>		cl_uchar3;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::uint16>		cl_ushort3;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::uint32>		cl_uint3;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::uint64>		cl_ulong3;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	//typedef detail::tvec3<detail::float16>	cl_half3;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec3<detail::float32>		cl_float3;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-
-
-	typedef detail::tvec4<detail::int8>			cl_char4;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::int16>		cl_short4;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::int32>		cl_int4;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::int64>		cl_long4;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::uint8>		cl_uchar4;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::uint16>		cl_ushort4;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::uint32>		cl_uint4;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::uint64>		cl_ulong4;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
-
-	//typedef detail::tvec4<detail::float16>	cl_half4;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-	typedef detail::tvec4<detail::float32>		cl_float4;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
-
-	/// @}
-}//namespace gtx
-}//namespace glm
-
-#include "ocl_type.inl"
-
-#endif//GLM_GTX_ocl_type
diff --git a/include/gal/opengl/glm/gtx/ocl_type.inl b/include/gal/opengl/glm/gtx/ocl_type.inl
deleted file mode 100644
index ac15145836..0000000000
--- a/include/gal/opengl/glm/gtx/ocl_type.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_ocl_type
-/// @file glm/gtx/ocl_type.inl
-/// @date 2013-03-16 / 2013-03-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/gtx/optimum_pow.hpp b/include/gal/opengl/glm/gtx/optimum_pow.hpp
deleted file mode 100644
index d348473332..0000000000
--- a/include/gal/opengl/glm/gtx/optimum_pow.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_optimum_pow
-/// @file glm/gtx/optimum_pow.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow
-/// @ingroup gtx
-/// 
-/// @brief Integer exponentiation of power functions.
-/// 
-/// <glm/gtx/optimum_pow.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_optimum_pow
-#define GLM_GTX_optimum_pow GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_optimum_pow extension included")
-#endif
-
-namespace glm{
-namespace gtx
-{
-	/// @addtogroup gtx_optimum_pow
-	/// @{
-
-	//! Returns x raised to the power of 2.
-	//! From GLM_GTX_optimum_pow extension.
-    template <typename genType> 
-	genType pow2(const genType& x);
-
-	//! Returns x raised to the power of 3.
-	//! From GLM_GTX_optimum_pow extension.
-    template <typename genType> 
-	genType pow3(const genType& x);
-
-	//! Returns x raised to the power of 4.
-	//! From GLM_GTX_optimum_pow extension.
-	template <typename genType> 
-	genType pow4(const genType& x);
-        
-	//! Checks if the parameter is a power of 2 number. 
-	//! From GLM_GTX_optimum_pow extension.
-    bool powOfTwo(int num);
-
-	//! Checks to determine if the parameter component are power of 2 numbers.
-	//! From GLM_GTX_optimum_pow extension.
-    detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x);
-
-	//! Checks to determine if the parameter component are power of 2 numbers. 
-	//! From GLM_GTX_optimum_pow extension.
-    detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x);
-
-	//! Checks to determine if the parameter component are power of 2 numbers. 
-	//! From GLM_GTX_optimum_pow extension.
-    detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
-
-	/// @}
-}//namespace gtx
-}//namespace glm
-
-#include "optimum_pow.inl"
-
-#endif//GLM_GTX_optimum_pow
diff --git a/include/gal/opengl/glm/gtx/optimum_pow.inl b/include/gal/opengl/glm/gtx/optimum_pow.inl
deleted file mode 100644
index 1e6f226e89..0000000000
--- a/include/gal/opengl/glm/gtx/optimum_pow.inl
+++ /dev/null
@@ -1,58 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2005-12-27
-// Licence : This source is under MIT License
-// File    : glm/gtx/optimum_pow.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType pow2(const genType& x)
-	{
-		return x * x;
-	}
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType pow3(const genType& x)
-	{
-		return x * x * x;
-	}
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType pow4(const genType& x)
-	{
-		return x * x * x * x;
-	}
-
-	GLM_FUNC_QUALIFIER bool powOfTwo(int x)
-	{
-		return !(x & (x - 1));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x)
-	{
-		return detail::tvec2<bool>(
-			powOfTwo(x.x),
-			powOfTwo(x.y));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x)
-	{
-		return detail::tvec3<bool>(
-			powOfTwo(x.x),
-			powOfTwo(x.y),
-			powOfTwo(x.z));
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x)
-	{
-		return detail::tvec4<bool>(
-			powOfTwo(x.x),
-			powOfTwo(x.y),
-			powOfTwo(x.z),
-			powOfTwo(x.w));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/orthonormalize.hpp b/include/gal/opengl/glm/gtx/orthonormalize.hpp
deleted file mode 100644
index 9f97f66a2e..0000000000
--- a/include/gal/opengl/glm/gtx/orthonormalize.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_orthonormalize
-/// @file glm/gtx/orthonormalize.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize
-/// @ingroup gtx
-/// 
-/// @brief Orthonormalize matrices.
-/// 
-/// <glm/gtx/orthonormalize.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_orthonormalize
-#define GLM_GTX_orthonormalize GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_orthonormalize extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_orthonormalize
-	/// @{
-
-	//! Returns the orthonormalized matrix of m.
-	//! From GLM_GTX_orthonormalize extension.
-	template <typename T> 
-	detail::tmat3x3<T> orthonormalize(
-		const detail::tmat3x3<T>& m);
-		
-    //! Orthonormalizes x according y.
-	//! From GLM_GTX_orthonormalize extension.
-	template <typename T> 
-	detail::tvec3<T> orthonormalize(
-		const detail::tvec3<T>& x, 
-		const detail::tvec3<T>& y);
-
-	/// @}
-}//namespace glm
-
-#include "orthonormalize.inl"
-
-#endif//GLM_GTX_orthonormalize
diff --git a/include/gal/opengl/glm/gtx/orthonormalize.inl b/include/gal/opengl/glm/gtx/orthonormalize.inl
deleted file mode 100644
index ea9ff7fe1e..0000000000
--- a/include/gal/opengl/glm/gtx/orthonormalize.inl
+++ /dev/null
@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2005-12-21
-// Licence : This source is under MIT License
-// File    : glm/gtx/orthonormalize.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> orthonormalize
-	(
-		const detail::tmat3x3<T>& m
-	)
-	{
-		detail::tmat3x3<T> r = m;
-
-		r[0] = normalize(r[0]);
-
-		float d0 = dot(r[0], r[1]);
-		r[1] -= r[0] * d0;
-		r[1] = normalize(r[1]);
-
-		float d1 = dot(r[1], r[2]);
-		d0 = dot(r[0], r[2]);
-		r[2] -= r[0] * d0 + r[1] * d1;
-		r[2] = normalize(r[2]);
-
-		return r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> orthonormalize
-	(
-		const detail::tvec3<T>& x, 
-		const detail::tvec3<T>& y
-	)
-	{
-		return normalize(x - y * dot(y, x));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/perpendicular.hpp b/include/gal/opengl/glm/gtx/perpendicular.hpp
deleted file mode 100644
index f6515ab920..0000000000
--- a/include/gal/opengl/glm/gtx/perpendicular.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_perpendicular
-/// @file glm/gtx/perpendicular.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_projection (dependence)
-///
-/// @defgroup gtx_perpendicular GLM_GTX_perpendicular
-/// @ingroup gtx
-/// 
-/// @brief Perpendicular of a vector from other one
-/// 
-/// <glm/gtx/perpendicular.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_perpendicular
-#define GLM_GTX_perpendicular GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/projection.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_perpendicular extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_perpendicular
-	/// @{
-
-	//! Projects x a perpendicular axis of Normal.
-	//! From GLM_GTX_perpendicular extension.
-	template <typename vecType> 
-	vecType perp(
-		vecType const & x, 
-		vecType const & Normal);
-
-	/// @}
-}//namespace glm
-
-#include "perpendicular.inl"
-
-#endif//GLM_GTX_perpendicular
diff --git a/include/gal/opengl/glm/gtx/perpendicular.inl b/include/gal/opengl/glm/gtx/perpendicular.inl
deleted file mode 100644
index c96812a121..0000000000
--- a/include/gal/opengl/glm/gtx/perpendicular.inl
+++ /dev/null
@@ -1,21 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2009-03-06
-// Licence : This source is under MIT License
-// File    : glm/gtx/perpendicular.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename vecType> 
-	GLM_FUNC_QUALIFIER vecType perp
-	(
-		vecType const & x, 
-		vecType const & Normal
-	)
-	{
-		return x - proj(x, Normal);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/polar_coordinates.hpp b/include/gal/opengl/glm/gtx/polar_coordinates.hpp
deleted file mode 100644
index 1cba486d74..0000000000
--- a/include/gal/opengl/glm/gtx/polar_coordinates.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_polar_coordinates
-/// @file glm/gtx/polar_coordinates.hpp
-/// @date 2007-03-06 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates
-/// @ingroup gtx
-/// 
-/// @brief Conversion from Euclidean space to polar space and revert.
-/// 
-/// <glm/gtx/polar_coordinates.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_polar_coordinates
-#define GLM_GTX_polar_coordinates GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_polar_coordinates extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_polar_coordinates
-	/// @{
-
-	/// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
-	///
-	/// @see gtx_polar_coordinates
-	template <typename T> 
-	detail::tvec3<T> polar(
-		detail::tvec3<T> const & euclidean);
-
-	/// Convert Polar to Euclidean coordinates.
-	///
-	/// @see gtx_polar_coordinates
-	template <typename T> 
-	detail::tvec3<T> euclidean(
-		detail::tvec2<T> const & polar);
-
-	/// @}
-}//namespace glm
-
-#include "polar_coordinates.inl"
-
-#endif//GLM_GTX_polar_coordinates
diff --git a/include/gal/opengl/glm/gtx/polar_coordinates.inl b/include/gal/opengl/glm/gtx/polar_coordinates.inl
deleted file mode 100644
index 376a31ce6f..0000000000
--- a/include/gal/opengl/glm/gtx/polar_coordinates.inl
+++ /dev/null
@@ -1,55 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-03-06
-// Updated : 2009-05-01
-// Licence : This source is under MIT License
-// File    : glm/gtx/polar_coordinates.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> polar
-	(
-		detail::tvec3<T> const & euclidean
-	)
-	{
-		T const Length(length(euclidean));
-		detail::tvec3<T> const tmp(euclidean / Length);
-		T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z));
-
-#ifdef GLM_FORCE_RADIANS
-		return detail::tvec3<T>(
-			atan(xz_dist, tmp.y),	// latitude
-			atan(tmp.x, tmp.z),		// longitude
-			xz_dist);				// xz distance
-#else
-		return detail::tvec3<T>(
-			degrees(atan(xz_dist, tmp.y)),	// latitude
-			degrees(atan(tmp.x, tmp.z)),	// longitude
-			xz_dist);						// xz distance
-#endif
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> euclidean
-	(
-		detail::tvec2<T> const & polar
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		T const latitude(polar.x);
-		T const longitude(polar.y);
-#else
-		T const latitude(radians(polar.x));
-		T const longitude(radians(polar.y));
-#endif
-
-		return detail::tvec3<T>(
-			cos(latitude) * sin(longitude),
-			sin(latitude),
-			cos(latitude) * cos(longitude));
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/projection.hpp b/include/gal/opengl/glm/gtx/projection.hpp
deleted file mode 100644
index 6e209225a7..0000000000
--- a/include/gal/opengl/glm/gtx/projection.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_projection
-/// @file glm/gtx/projection.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_projection GLM_GTX_projection
-/// @ingroup gtx
-/// 
-/// @brief Projection of a vector to other one
-/// 
-/// <glm/gtx/projection.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_projection
-#define GLM_GTX_projection GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_projection extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_projection
-	/// @{
-
-	//! Projects x on Normal.
-	//! From GLM_GTX_projection extension.
-	template <typename vecType> 
-	vecType proj(
-		vecType const & x, 
-		vecType const & Normal);
-
-	/// @}
-}//namespace glm
-
-#include "projection.inl"
-
-#endif//GLM_GTX_projection
diff --git a/include/gal/opengl/glm/gtx/projection.inl b/include/gal/opengl/glm/gtx/projection.inl
deleted file mode 100644
index 4107d89982..0000000000
--- a/include/gal/opengl/glm/gtx/projection.inl
+++ /dev/null
@@ -1,21 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2009-03-06
-// Licence : This source is under MIT License
-// File    : glm/gtx/projection.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename vecType> 
-	GLM_FUNC_QUALIFIER vecType proj
-	(
-		vecType const & x, 
-		vecType const & Normal
-	)
-	{
-		return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/quaternion.hpp b/include/gal/opengl/glm/gtx/quaternion.hpp
deleted file mode 100644
index 3c9e8b0455..0000000000
--- a/include/gal/opengl/glm/gtx/quaternion.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_quaternion
-/// @file glm/gtx/quaternion.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_quaternion GLM_GTX_quaternion
-/// @ingroup gtx
-/// 
-/// @brief Extented quaternion types and functions
-/// 
-/// <glm/gtx/quaternion.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_quaternion
-#define GLM_GTX_quaternion GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/quaternion.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_quaternion extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_quaternion
-	/// @{
-
-	//! Compute a cross product between a quaternion and a vector. 
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tvec3<valType> cross(
-		detail::tquat<valType> const & q, 
-		detail::tvec3<valType> const & v);
-
-	//! Compute a cross product between a vector and a quaternion.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tvec3<valType> cross(
-		detail::tvec3<valType> const & v, 
-		detail::tquat<valType> const & q);
-
-	//! Compute a point on a path according squad equation. 
-	//! q1 and q2 are control points; s1 and s2 are intermediate control points.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tquat<valType> squad(
-		detail::tquat<valType> const & q1, 
-		detail::tquat<valType> const & q2, 
-		detail::tquat<valType> const & s1, 
-		detail::tquat<valType> const & s2, 
-		valType const & h);
-
-	//! Returns an intermediate control point for squad interpolation.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tquat<valType> intermediate(
-		detail::tquat<valType> const & prev, 
-		detail::tquat<valType> const & curr, 
-		detail::tquat<valType> const & next);
-
-	//! Returns a exp of a quaternion. 
-	///
-	/// @see gtx_quaternion
-    template <typename valType> 
-	detail::tquat<valType> exp(
-		detail::tquat<valType> const & q);
-
-	//! Returns a log of a quaternion. 
-	///
-	/// @see gtx_quaternion
-    template <typename valType> 
-	detail::tquat<valType> log(
-		detail::tquat<valType> const & q);
-
-	/// Returns x raised to the y power.
-	///
-	/// @see gtx_quaternion
-    template <typename valType> 
-	detail::tquat<valType> pow(
-		detail::tquat<valType> const & x, 
-		valType const & y);
-
-	//! Returns quarternion square root.
-	///
-	/// @see gtx_quaternion
-	//template <typename valType> 
-	//detail::tquat<valType> sqrt(
-	//	detail::tquat<valType> const & q);
-
-	//! Rotates a 3 components vector by a quaternion. 
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tvec3<valType> rotate(
-		detail::tquat<valType> const & q, 
-		detail::tvec3<valType> const & v);
-
-	/// Rotates a 4 components vector by a quaternion.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tvec4<valType> rotate(
-		detail::tquat<valType> const & q, 
-		detail::tvec4<valType> const & v);
-
-	/// Extract the real component of a quaternion.
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	valType extractRealComponent(
-		detail::tquat<valType> const & q);
-
-	/// Converts a quaternion to a 3 * 3 matrix. 
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tmat3x3<valType> toMat3(
-		detail::tquat<valType> const & x){return mat3_cast(x);}
-
-	/// Converts a quaternion to a 4 * 4 matrix. 
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tmat4x4<valType> toMat4(
-		detail::tquat<valType> const & x){return mat4_cast(x);}
-
-	/// Converts a 3 * 3 matrix to a quaternion. 
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tquat<valType> toQuat(
-		detail::tmat3x3<valType> const & x){return quat_cast(x);}
-
-	/// Converts a 4 * 4 matrix to a quaternion. 
-	///
-	/// @see gtx_quaternion
-	template <typename valType> 
-	detail::tquat<valType> toQuat(
-		detail::tmat4x4<valType> const & x){return quat_cast(x);}
-
-	/// Quaternion interpolation using the rotation short path. 
-	///
-	/// @see gtx_quaternion
-	template <typename T>
-	detail::tquat<T> shortMix(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a);
-
-	/// Quaternion normalized linear interpolation. 
-	///
-	/// @see gtx_quaternion
-	template <typename T>
-	detail::tquat<T> fastMix(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a);
-
-	/// @}
-}//namespace glm
-
-#include "quaternion.inl"
-
-#endif//GLM_GTX_quaternion
diff --git a/include/gal/opengl/glm/gtx/quaternion.inl b/include/gal/opengl/glm/gtx/quaternion.inl
deleted file mode 100644
index 32155ce5b3..0000000000
--- a/include/gal/opengl/glm/gtx/quaternion.inl
+++ /dev/null
@@ -1,208 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2008-11-27
-// Licence : This source is under MIT License
-// File    : glm/gtx/quaternion.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include <limits>
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> cross
-	(
-		detail::tvec3<valType> const & v, 
-		detail::tquat<valType> const & q
-	)
-	{
-		return inverse(q) * v;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> cross
-	(
-		detail::tquat<valType> const & q, 
-		detail::tvec3<valType> const & v
-	)
-	{
-		return q * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> squad
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2, 
-		detail::tquat<T> const & s1, 
-		detail::tquat<T> const & s2, 
-		T const & h)
-	{
-		return mix(mix(q1, q2, h), mix(s1, s2, h), T(2) * (T(1) - h) * h);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> intermediate
-	(
-		detail::tquat<T> const & prev, 
-		detail::tquat<T> const & curr, 
-		detail::tquat<T> const & next
-	)
-	{
-		detail::tquat<T> invQuat = inverse(curr);
-		return exp((log(next + invQuat) + log(prev + invQuat)) / T(-4)) * curr;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> exp
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		detail::tvec3<T> u(q.x, q.y, q.z);
-		float Angle = glm::length(u);
-		detail::tvec3<T> v(u / Angle);
-		return detail::tquat<T>(cos(Angle), sin(Angle) * v);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> log
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		if((q.x == T(0)) && (q.y == T(0)) && (q.z == T(0)))
-		{
-			if(q.w > T(0))
-				return detail::tquat<T>(log(q.w), T(0), T(0), T(0));
-			else if(q.w < T(0))
-				return detail::tquat<T>(log(-q.w), T(3.1415926535897932384626433832795), T(0),T(0));
-			else
-				return detail::tquat<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
-		} 
-		else 
-		{
-			T Vec3Len = sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
-			T QuatLen = sqrt(Vec3Len * Vec3Len + q.w * q.w);
-			T t = atan(Vec3Len, T(q.w)) / Vec3Len;
-			return detail::tquat<T>(t * q.x, t * q.y, t * q.z, log(QuatLen));
-		}
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> pow
-	(
-		detail::tquat<T> const & x, 
-		T const & y
-	)
-	{
-		if(abs(x.w) > T(0.9999))
-			return x;
-		float Angle = acos(y);
-		float NewAngle = Angle * y;
-		float Div = sin(NewAngle) / sin(Angle);
-		return detail::tquat<T>(
-			cos(NewAngle),
-			x.x * Div,
-			x.y * Div,
-			x.z * Div);
-	}
-
-	//template <typename T> 
-	//GLM_FUNC_QUALIFIER detail::tquat<T> sqrt
-	//(
-	//	detail::tquat<T> const & q
-	//)
-	//{
-	//	T q0 = T(1) - dot(q, q);
-	//	return T(2) * (T(1) + q0) * q;
-	//}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rotate
-	(
-		detail::tquat<T> const & q, 
-		detail::tvec3<T> const & v
-	)
-	{
-		return q * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> rotate
-	(
-		detail::tquat<T> const & q, 
-		detail::tvec4<T> const & v
-	)
-	{
-		return q * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T extractRealComponent
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		T w = T(1.0) - q.x * q.x - q.y * q.y - q.z * q.z;
-		if(w < T(0))
-			return T(0);
-		else
-			return -sqrt(w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> shortMix
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-	{
-		if(a <= typename detail::tquat<T>::value_type(0)) return x;
-		if(a >= typename detail::tquat<T>::value_type(1)) return y;
-
-		T fCos = dot(x, y);
-		detail::tquat<T> y2(y); //BUG!!! tquat<T> y2;
-		if(fCos < T(0))
-		{
-			y2 = -y;
-			fCos = -fCos;
-		}
-
-		//if(fCos > 1.0f) // problem
-		T k0, k1;
-		if(fCos > T(0.9999))
-		{
-			k0 = T(1) - a;
-			k1 = T(0) + a; //BUG!!! 1.0f + a;
-		}
-		else
-		{
-			T fSin = sqrt(T(1) - fCos * fCos);
-			T fAngle = atan(fSin, fCos);
-			T fOneOverSin = T(1) / fSin;
-			k0 = sin((T(1) - a) * fAngle) * fOneOverSin;
-			k1 = sin((T(0) + a) * fAngle) * fOneOverSin;
-		}
-
-		return detail::tquat<T>(
-			k0 * x.w + k1 * y2.w,
-			k0 * x.x + k1 * y2.x,
-			k0 * x.y + k1 * y2.y,
-			k0 * x.z + k1 * y2.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> fastMix
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-	{
-		return glm::normalize(x * (T(1) - a) + (y * a));
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/random.hpp b/include/gal/opengl/glm/gtx/random.hpp
deleted file mode 100644
index a23d89490d..0000000000
--- a/include/gal/opengl/glm/gtx/random.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_random extension is deprecated, include GLM_GTC_random instead")
-#endif
-
-// Promoted:
-#include "../gtc/random.hpp"
diff --git a/include/gal/opengl/glm/gtx/raw_data.hpp b/include/gal/opengl/glm/gtx/raw_data.hpp
deleted file mode 100644
index 4ec6cf010c..0000000000
--- a/include/gal/opengl/glm/gtx/raw_data.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_raw_data
-/// @file glm/gtx/raw_data.hpp
-/// @date 2008-11-19 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_raw_data GLM_GTX_raw_data
-/// @ingroup gtx
-/// 
-/// @brief Projection of a vector to other one
-/// 
-/// <glm/gtx/raw_data.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_raw_data
-#define GLM_GTX_raw_data GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/type_precision.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_raw_data extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_raw_data
-	/// @{
-
-	//! Type for byte numbers. 
-	//! From GLM_GTX_raw_data extension.
-	typedef uint8		byte;
-
-	//! Type for word numbers. 
-	//! From GLM_GTX_raw_data extension.
-	typedef uint16		word;
-
-	//! Type for dword numbers. 
-	//! From GLM_GTX_raw_data extension.
-	typedef uint32		dword;
-
-	//! Type for qword numbers. 
-	//! From GLM_GTX_raw_data extension.
-	typedef uint64		qword;
-
-	/// @}
-}// namespace glm
-
-#include "raw_data.inl"
-
-#endif//GLM_GTX_raw_data
diff --git a/include/gal/opengl/glm/gtx/raw_data.inl b/include/gal/opengl/glm/gtx/raw_data.inl
deleted file mode 100644
index 526e3cdfd2..0000000000
--- a/include/gal/opengl/glm/gtx/raw_data.inl
+++ /dev/null
@@ -1,11 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2008-11-19
-// Updated : 2008-11-19
-// Licence : This source is under MIT License
-// File    : glm/gtx/raw_data.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Dependency:
-// - GLM core
-///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/gtx/reciprocal.hpp b/include/gal/opengl/glm/gtx/reciprocal.hpp
deleted file mode 100644
index 351986172f..0000000000
--- a/include/gal/opengl/glm/gtx/reciprocal.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_reciprocal extension is deprecated, include GLM_GTC_reciprocal instead")
-#endif
diff --git a/include/gal/opengl/glm/gtx/rotate_vector.hpp b/include/gal/opengl/glm/gtx/rotate_vector.hpp
deleted file mode 100644
index 70c5e032dd..0000000000
--- a/include/gal/opengl/glm/gtx/rotate_vector.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_rotate_vector
-/// @file glm/gtx/rotate_vector.hpp
-/// @date 2006-11-02 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_transform (dependence)
-///
-/// @defgroup gtx_rotate_vector GLM_GTX_rotate_vector
-/// @ingroup gtx
-/// 
-/// @brief Function to directly rotate a vector
-/// 
-/// <glm/gtx/rotate_vector.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_rotate_vector
-#define GLM_GTX_rotate_vector GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/transform.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_rotate_vector extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_rotate_vector
-	/// @{
-
-	//! Rotate a two dimensional vector.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec2<T> rotate(
-        detail::tvec2<T> const & v, 
-		T const & angle);
-		
-	//! Rotate a three dimensional vector around an axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec3<T> rotate(
-        detail::tvec3<T> const & v, 
-		T const & angle, 
-        detail::tvec3<T> const & normal);
-		
-	//! Rotate a four dimensional vector around an axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec4<T> rotate(
-        detail::tvec4<T> const & v, 
-        T const & angle, 
-		detail::tvec3<T> const & normal);
-		
-	//! Rotate a three dimensional vector around the X axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec3<T> rotateX(
-        detail::tvec3<T> const & v, 
-		T const & angle);
-
-	//! Rotate a three dimensional vector around the Y axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec3<T> rotateY(
-		detail::tvec3<T> const & v, 
-		T const & angle);
-		
-	//! Rotate a three dimensional vector around the Z axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec3<T> rotateZ(
-        detail::tvec3<T> const & v, 
-		T const & angle);
-		
-	//! Rotate a four dimentionnals vector around the X axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec4<T> rotateX(
-        detail::tvec4<T> const & v, 
-		T const & angle);
-		
-	//! Rotate a four dimensional vector around the X axis.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec4<T> rotateY(
-        detail::tvec4<T> const & v, 
-		T const & angle);
-		
-	//! Rotate a four dimensional vector around the X axis. 
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tvec4<T> rotateZ(
-        detail::tvec4<T> const & v, 
-		T const & angle);
-		
-	//! Build a rotation matrix from a normal and a up vector.
-	//! From GLM_GTX_rotate_vector extension.
-	template <typename T> 
-	detail::tmat4x4<T> orientation(
-        detail::tvec3<T> const & Normal, 
-        detail::tvec3<T> const & Up);
-
-	/// @}
-}//namespace glm
-
-#include "rotate_vector.inl"
-
-#endif//GLM_GTX_rotate_vector
diff --git a/include/gal/opengl/glm/gtx/rotate_vector.inl b/include/gal/opengl/glm/gtx/rotate_vector.inl
deleted file mode 100644
index 1ec1717bde..0000000000
--- a/include/gal/opengl/glm/gtx/rotate_vector.inl
+++ /dev/null
@@ -1,215 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-11-02
-// Updated : 2009-02-19
-// Licence : This source is under MIT License
-// File    : glm/gtx/rotate_vector.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> rotate
-	(
-		detail::tvec2<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec2<T> Result;
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos = cos(radians(angle));
-		T const Sin = sin(radians(angle));
-#endif
-		Result.x = v.x * Cos - v.y * Sin;
-		Result.y = v.x * Sin + v.y * Cos;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rotate
-	(
-		detail::tvec3<T> const & v, 
-		T const & angle, 
-		detail::tvec3<T> const & normal
-	)
-	{
-		return detail::tmat3x3<T>(glm::rotate(angle, normal)) * v;
-	}
-	/*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateGTX(
-		const detail::tvec3<T>& x, 
-		T angle, 
-		const detail::tvec3<T>& normal)
-	{
-		const T Cos = cos(radians(angle));
-		const T Sin = sin(radians(angle));
-		return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin;
-	}
-	*/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> rotate
-	(
-		detail::tvec4<T> const & v, 
-		T const & angle, 
-		detail::tvec3<T> const & normal
-	)
-	{
-		return rotate(angle, normal) * v;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateX
-	(
-		detail::tvec3<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec3<T> Result(v);
-
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos = cos(radians(angle));
-		T const Sin = sin(radians(angle));
-#endif
-
-		Result.y = v.y * Cos - v.z * Sin;
-		Result.z = v.y * Sin + v.z * Cos;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateY
-	(
-		detail::tvec3<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec3<T> Result = v;
-
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos(cos(radians(angle)));
-		T const Sin(sin(radians(angle)));
-#endif
-
-		Result.x =  v.x * Cos + v.z * Sin;
-		Result.z = -v.x * Sin + v.z * Cos;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateZ
-	(
-		detail::tvec3<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec3<T> Result = v;
-
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos(cos(radians(angle)));
-		T const Sin(sin(radians(angle)));
-#endif
-
-		Result.x = v.x * Cos - v.y * Sin;
-		Result.y = v.x * Sin + v.y * Cos;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> rotateX
-	(
-		detail::tvec4<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec4<T> Result = v;
-
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos(cos(radians(angle)));
-		T const Sin(sin(radians(angle)));
-#endif
-
-		Result.y = v.y * Cos - v.z * Sin;
-		Result.z = v.y * Sin + v.z * Cos;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> rotateY
-	(
-		detail::tvec4<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec4<T> Result = v;
-
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos(cos(radians(angle)));
-		T const Sin(sin(radians(angle)));
-#endif
-
-		Result.x =  v.x * Cos + v.z * Sin;
-		Result.z = -v.x * Sin + v.z * Cos;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> rotateZ
-	(
-		detail::tvec4<T> const & v, 
-		T const & angle
-	)
-	{
-		detail::tvec4<T> Result = v;
-
-#ifdef GLM_FORCE_RADIANS
-		T const Cos(cos(angle));
-		T const Sin(sin(angle));
-#else
-		T const Cos(cos(radians(angle)));
-		T const Sin(sin(radians(angle)));
-#endif
-
-		Result.x = v.x * Cos - v.y * Sin;
-		Result.y = v.x * Sin + v.y * Cos;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> orientation
-	(
-		detail::tvec3<T> const & Normal, 
-		detail::tvec3<T> const & Up
-	)
-	{
-		if(all(equal(Normal, Up)))
-			return detail::tmat4x4<T>(T(1));
-
-		detail::tvec3<T> RotationAxis = cross(Up, Normal);
-#		ifdef GLM_FORCE_RADIANS
-			T Angle = acos(dot(Normal, Up));
-#		else
-			T Angle = degrees(acos(dot(Normal, Up)));
-#		endif
-		return rotate(Angle, RotationAxis);
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/simd_mat4.hpp b/include/gal/opengl/glm/gtx/simd_mat4.hpp
deleted file mode 100644
index b435b11e67..0000000000
--- a/include/gal/opengl/glm/gtx/simd_mat4.hpp
+++ /dev/null
@@ -1,206 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_simd_vec4
-/// @file glm/gtx/simd_vec4.hpp
-/// @date 2009-05-07 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_simd_mat4 GLM_GTX_simd_mat4
-/// @ingroup gtx
-/// 
-/// @brief SIMD implementation of mat4 type.
-/// 
-/// <glm/gtx/simd_mat4.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_simd_mat4
-#define GLM_GTX_simd_mat4 GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(GLM_ARCH != GLM_ARCH_PURE)
-
-#if(GLM_ARCH & GLM_ARCH_SSE2)
-#	include "../core/intrinsic_matrix.hpp"
-#	include "../gtx/simd_vec4.hpp"
-#else
-#	error "GLM: GLM_GTX_simd_mat4 requires compiler support of SSE2 through intrinsics"
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_simd_mat4 extension included")
-#endif
-
-namespace glm{
-namespace detail
-{
-	/// 4x4 Matrix implemented using SIMD SEE intrinsics.
-	/// \ingroup gtx_simd_mat4
-	GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
-	{
-		enum ctor{null};
-
-		typedef float value_type;
-		typedef fvec4SIMD col_type;
-		typedef fvec4SIMD row_type;
-		typedef std::size_t size_type;
-		static size_type value_size();
-		static size_type col_size();
-		static size_type row_size();
-		static bool is_matrix();
-
-		fvec4SIMD Data[4];
-
-		//////////////////////////////////////
-		// Constructors
-
-		fmat4x4SIMD();
-		explicit fmat4x4SIMD(float const & s);
-		explicit fmat4x4SIMD(
-			float const & x0, float const & y0, float const & z0, float const & w0,
-			float const & x1, float const & y1, float const & z1, float const & w1,
-			float const & x2, float const & y2, float const & z2, float const & w2,
-			float const & x3, float const & y3, float const & z3, float const & w3);
-		explicit fmat4x4SIMD(
-			fvec4SIMD const & v0,
-			fvec4SIMD const & v1,
-			fvec4SIMD const & v2,
-			fvec4SIMD const & v3);
-		explicit fmat4x4SIMD(
-			tmat4x4<float> const & m);
-        explicit fmat4x4SIMD(
-            __m128 const in[4]);
-
-		// Conversions
-		//template <typename U> 
-		//explicit tmat4x4(tmat4x4<U> const & m);
-
-		//explicit tmat4x4(tmat2x2<T> const & x);
-		//explicit tmat4x4(tmat3x3<T> const & x);
-		//explicit tmat4x4(tmat2x3<T> const & x);
-		//explicit tmat4x4(tmat3x2<T> const & x);
-		//explicit tmat4x4(tmat2x4<T> const & x);
-		//explicit tmat4x4(tmat4x2<T> const & x);
-		//explicit tmat4x4(tmat3x4<T> const & x);
-		//explicit tmat4x4(tmat4x3<T> const & x);
-
-		// Accesses
-		fvec4SIMD & operator[](size_type i);
-		fvec4SIMD const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
-		fmat4x4SIMD & operator+= (float const & s);
-		fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
-		fmat4x4SIMD & operator-= (float const & s);
-		fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
-		fmat4x4SIMD & operator*= (float const & s);
-		fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
-		fmat4x4SIMD & operator/= (float const & s);
-		fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
-		fmat4x4SIMD & operator++ ();
-		fmat4x4SIMD & operator-- ();
-	};
-
-	// Binary operators
-	fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
-	fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
-	fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
-	    
-	fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
-	fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
-	fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
-
-	fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
-	fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
-
-	fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
-	fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
-
-	fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
-
-	fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
-	fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
-
-	fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
-	fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
-
-	fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
-
-	// Unary constant operators
-	fmat4x4SIMD const operator-  (fmat4x4SIMD const & m);
-	fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
-	fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
-}//namespace detail
-
-	typedef detail::fmat4x4SIMD simdMat4;
-
-	/// @addtogroup gtx_simd_mat4
-	/// @{
-
-	//! Convert a simdMat4 to a mat4.
-	//! (From GLM_GTX_simd_mat4 extension)
-	detail::tmat4x4<float> mat4_cast(
-		detail::fmat4x4SIMD const & x);
-
-	//! Multiply matrix x by matrix y component-wise, i.e.,
-	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
-	//! (From GLM_GTX_simd_mat4 extension).
-	detail::fmat4x4SIMD matrixCompMult(
-		detail::fmat4x4SIMD const & x,
-		detail::fmat4x4SIMD const & y);
-
-	//! Treats the first parameter c as a column vector
-	//! and the second parameter r as a row vector
-	//! and does a linear algebraic matrix multiply c * r.
-	//! (From GLM_GTX_simd_mat4 extension).
-	detail::fmat4x4SIMD outerProduct(
-		detail::fvec4SIMD const & c,
-		detail::fvec4SIMD const & r);
-
-	//! Returns the transposed matrix of x
-	//! (From GLM_GTX_simd_mat4 extension).
-	detail::fmat4x4SIMD transpose(
-		detail::fmat4x4SIMD const & x);
-
-	//! Return the determinant of a mat4 matrix.
-	//! (From GLM_GTX_simd_mat4 extension).
-	float determinant(
-		detail::fmat4x4SIMD const & m);
-
-	//! Return the inverse of a mat4 matrix.
-	//! (From GLM_GTX_simd_mat4 extension).
-	detail::fmat4x4SIMD inverse(
-		detail::fmat4x4SIMD const & m);
-
-	/// @}
-}// namespace glm
-
-#include "simd_mat4.inl"
-
-#endif//(GLM_ARCH != GLM_ARCH_PURE)
-
-#endif//GLM_GTX_simd_mat4
diff --git a/include/gal/opengl/glm/gtx/simd_mat4.inl b/include/gal/opengl/glm/gtx/simd_mat4.inl
deleted file mode 100644
index d6ec8ca945..0000000000
--- a/include/gal/opengl/glm/gtx/simd_mat4.inl
+++ /dev/null
@@ -1,590 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2009-05-19
-// Updated : 2009-05-19
-// Licence : This source is under MIT License
-// File    : glm/gtx/simd_mat4.hpp
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::value_size()
-{
-	return sizeof(value_type);
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::col_size()
-{
-	return 4;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::row_size()
-{
-	return 4;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD()
-{
-#ifndef GLM_SIMD_ENABLE_DEFAULT_INIT
-    this->Data[0] = fvec4SIMD(1.0f, 0, 0, 0);
-	this->Data[1] = fvec4SIMD(0, 1.0f, 0, 0);
-	this->Data[2] = fvec4SIMD(0, 0, 1.0f, 0);
-	this->Data[3] = fvec4SIMD(0, 0, 0, 1.0f);
-#endif
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD(float const & s)
-{
-	this->Data[0] = fvec4SIMD(s, 0, 0, 0);
-	this->Data[1] = fvec4SIMD(0, s, 0, 0);
-	this->Data[2] = fvec4SIMD(0, 0, s, 0);
-	this->Data[3] = fvec4SIMD(0, 0, 0, s);
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
-(
-	float const & x0, float const & y0, float const & z0, float const & w0,
-	float const & x1, float const & y1, float const & z1, float const & w1,
-	float const & x2, float const & y2, float const & z2, float const & w2,
-	float const & x3, float const & y3, float const & z3, float const & w3
-)
-{
-	this->Data[0] = fvec4SIMD(x0, y0, z0, w0);
-	this->Data[1] = fvec4SIMD(x1, y1, z1, w1);
-	this->Data[2] = fvec4SIMD(x2, y2, z2, w2);
-	this->Data[3] = fvec4SIMD(x3, y3, z3, w3);
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
-(
-	fvec4SIMD const & v0,
-	fvec4SIMD const & v1,
-	fvec4SIMD const & v2,
-	fvec4SIMD const & v3
-)
-{
-	this->Data[0] = v0;
-	this->Data[1] = v1;
-	this->Data[2] = v2;
-	this->Data[3] = v3;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
-(
-	tmat4x4<float> const & m
-)
-{
-	this->Data[0] = fvec4SIMD(m[0]);
-	this->Data[1] = fvec4SIMD(m[1]);
-	this->Data[2] = fvec4SIMD(m[2]);
-	this->Data[3] = fvec4SIMD(m[3]);
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
-(
-    __m128 const in[4]
-)
-{
-    this->Data[0] = in[0];
-    this->Data[1] = in[1];
-    this->Data[2] = in[2];
-    this->Data[3] = in[3];
-}
-
-//////////////////////////////////////
-// Accesses
-
-GLM_FUNC_QUALIFIER fvec4SIMD & fmat4x4SIMD::operator[]
-(
-	fmat4x4SIMD::size_type i
-)
-{
-	assert(
-		//i >= fmat4x4SIMD::size_type(0) &&
-		i < fmat4x4SIMD::col_size());
-
-	return this->Data[i];
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD const & fmat4x4SIMD::operator[]
-(
-	fmat4x4SIMD::size_type i
-) const
-{
-	assert(
-		//i >= fmat4x4SIMD::size_type(0) &&
-		i < fmat4x4SIMD::col_size());
-
-	return this->Data[i];
-}
-
-//////////////////////////////////////////////////////////////
-// mat4 operators
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD& fmat4x4SIMD::operator= 
-(
-	fmat4x4SIMD const & m
-)
-{
-	this->Data[0] = m[0];
-	this->Data[1] = m[1];
-	this->Data[2] = m[2];
-	this->Data[3] = m[3];
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator+= 
-(
-	fmat4x4SIMD const & m
-)
-{
-	this->Data[0].Data = _mm_add_ps(this->Data[0].Data, m[0].Data);
-	this->Data[1].Data = _mm_add_ps(this->Data[1].Data, m[1].Data);
-	this->Data[2].Data = _mm_add_ps(this->Data[2].Data, m[2].Data);
-	this->Data[3].Data = _mm_add_ps(this->Data[3].Data, m[3].Data);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-= 
-(
-	fmat4x4SIMD const & m
-)
-{
-	this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, m[0].Data);
-	this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, m[1].Data);
-	this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, m[2].Data);
-	this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, m[3].Data);
-
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator*= 
-(
-	fmat4x4SIMD const & m
-)
-{
-	sse_mul_ps(&this->Data[0].Data, &m.Data[0].Data, &this->Data[0].Data);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator/= 
-(
-	fmat4x4SIMD const & m
-)
-{
-	__m128 Inv[4];
-	sse_inverse_ps(&m.Data[0].Data, Inv);
-	sse_mul_ps(&this->Data[0].Data, Inv, &this->Data[0].Data);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator+= 
-(
-	float const & s
-)
-{
-	__m128 Operand = _mm_set_ps1(s);
-	this->Data[0].Data = _mm_add_ps(this->Data[0].Data, Operand);
-	this->Data[1].Data = _mm_add_ps(this->Data[1].Data, Operand);
-	this->Data[2].Data = _mm_add_ps(this->Data[2].Data, Operand);
-	this->Data[3].Data = _mm_add_ps(this->Data[3].Data, Operand);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-= 
-(
-	float const & s
-)
-{
-	__m128 Operand = _mm_set_ps1(s);
-	this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, Operand);
-	this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, Operand);
-	this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, Operand);
-	this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, Operand);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator*= 
-(
-	float const & s
-)
-{
-	__m128 Operand = _mm_set_ps1(s);
-	this->Data[0].Data = _mm_mul_ps(this->Data[0].Data, Operand);
-	this->Data[1].Data = _mm_mul_ps(this->Data[1].Data, Operand);
-	this->Data[2].Data = _mm_mul_ps(this->Data[2].Data, Operand);
-	this->Data[3].Data = _mm_mul_ps(this->Data[3].Data, Operand);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator/= 
-(
-	float const & s
-)
-{
-	__m128 Operand = _mm_div_ps(one, _mm_set_ps1(s));
-	this->Data[0].Data = _mm_mul_ps(this->Data[0].Data, Operand);
-	this->Data[1].Data = _mm_mul_ps(this->Data[1].Data, Operand);
-	this->Data[2].Data = _mm_mul_ps(this->Data[2].Data, Operand);
-	this->Data[3].Data = _mm_mul_ps(this->Data[3].Data, Operand);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator++ ()
-{
-	this->Data[0].Data = _mm_add_ps(this->Data[0].Data, one);
-	this->Data[1].Data = _mm_add_ps(this->Data[1].Data, one);
-	this->Data[2].Data = _mm_add_ps(this->Data[2].Data, one);
-	this->Data[3].Data = _mm_add_ps(this->Data[3].Data, one);
-    return *this;
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-- ()
-{
-	this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, one);
-	this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, one);
-	this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, one);
-	this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, one);
-    return *this;
-}
-
-
-//////////////////////////////////////////////////////////////
-// Binary operators
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator+
-(
-    const fmat4x4SIMD &m,
-    float const & s
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] + s,
-        m[1] + s,
-        m[2] + s,
-        m[3] + s
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator+
-(
-    float const & s,
-    const fmat4x4SIMD &m
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] + s,
-        m[1] + s,
-        m[2] + s,
-        m[3] + s
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator+
-(
-    const fmat4x4SIMD &m1,
-    const fmat4x4SIMD &m2
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m1[0] + m2[0],
-        m1[1] + m2[1],
-        m1[2] + m2[2],
-        m1[3] + m2[3]
-    );
-}
-
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator-
-(
-    const fmat4x4SIMD &m,
-    float const & s
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] - s,
-        m[1] - s,
-        m[2] - s,
-        m[3] - s
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator-
-(
-    float const & s,
-    const fmat4x4SIMD &m
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        s - m[0],
-        s - m[1],
-        s - m[2],
-        s - m[3]
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator-
-(
-    const fmat4x4SIMD &m1,
-    const fmat4x4SIMD &m2
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m1[0] - m2[0],
-        m1[1] - m2[1],
-        m1[2] - m2[2],
-        m1[3] - m2[3]
-    );
-}
-
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator*
-(
-    const fmat4x4SIMD &m,
-    float const & s
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] * s,
-        m[1] * s,
-        m[2] * s,
-        m[3] * s
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator*
-(
-    float const & s,
-    const fmat4x4SIMD &m
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] * s,
-        m[1] * s,
-        m[2] * s,
-        m[3] * s
-    );
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator*
-(
-    const fmat4x4SIMD &m,
-    fvec4SIMD const & v
-)
-{
-    return sse_mul_ps(&m.Data[0].Data, v.Data);
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator*
-(
-    fvec4SIMD const & v,
-    const fmat4x4SIMD &m
-)
-{
-    return sse_mul_ps(v.Data, &m.Data[0].Data);
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator*
-(
-    const fmat4x4SIMD &m1,
-    const fmat4x4SIMD &m2
-)
-{
-    fmat4x4SIMD result;
-    sse_mul_ps(&m1.Data[0].Data, &m2.Data[0].Data, &result.Data[0].Data);
-    
-    return result;
-}
-    
-
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator/
-(
-    const fmat4x4SIMD &m,
-    float const & s
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] / s,
-        m[1] / s,
-        m[2] / s,
-        m[3] / s
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator/
-(
-    float const & s,
-    const fmat4x4SIMD &m
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        s / m[0],
-        s / m[1],
-        s / m[2],
-        s / m[3]
-    );
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator/
-(
-    const fmat4x4SIMD &m,
-    fvec4SIMD const & v
-)
-{
-    return inverse(m) * v;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator/
-(
-    fvec4SIMD const & v,
-    const fmat4x4SIMD &m
-)
-{
-    return v * inverse(m);
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD operator/
-(
-    const fmat4x4SIMD &m1,
-    const fmat4x4SIMD &m2
-)
-{
-    __m128 result[4];
-    __m128 inv[4];
-
-	sse_inverse_ps(&m2.Data[0].Data, inv);
-	sse_mul_ps(&m1.Data[0].Data, inv, result);
-
-    return fmat4x4SIMD(result);
-}
-
-
-//////////////////////////////////////////////////////////////
-// Unary constant operators
-GLM_FUNC_QUALIFIER fmat4x4SIMD const operator-
-(
-    fmat4x4SIMD const & m
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        -m[0],
-        -m[1],
-        -m[2],
-        -m[3]
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD const operator--
-(
-    fmat4x4SIMD const & m,
-    int
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] - 1.0f,
-        m[1] - 1.0f,
-        m[2] - 1.0f,
-        m[3] - 1.0f
-    );
-}
-
-GLM_FUNC_QUALIFIER fmat4x4SIMD const operator++
-(
-    fmat4x4SIMD const & m,
-    int
-)
-{
-    return detail::fmat4x4SIMD
-    (
-        m[0] + 1.0f,
-        m[1] + 1.0f,
-        m[2] + 1.0f,
-        m[3] + 1.0f
-    );
-}
-
-}//namespace detail
-
-GLM_FUNC_QUALIFIER detail::tmat4x4<float> mat4_cast
-(
-	detail::fmat4x4SIMD const & x
-)
-{
-	GLM_ALIGN(16) detail::tmat4x4<float> Result;
-	_mm_store_ps(&Result[0][0], x.Data[0].Data);
-	_mm_store_ps(&Result[1][0], x.Data[1].Data);
-	_mm_store_ps(&Result[2][0], x.Data[2].Data);
-	_mm_store_ps(&Result[3][0], x.Data[3].Data);
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER detail::fmat4x4SIMD matrixCompMult
-(
-	detail::fmat4x4SIMD const & x,
-	detail::fmat4x4SIMD const & y
-)
-{
-	detail::fmat4x4SIMD result;
-	result[0] = x[0] * y[0];
-	result[1] = x[1] * y[1];
-	result[2] = x[2] * y[2];
-	result[3] = x[3] * y[3];
-	return result;
-}
-
-GLM_FUNC_QUALIFIER detail::fmat4x4SIMD outerProduct
-(
-	detail::fvec4SIMD const & c,
-	detail::fvec4SIMD const & r
-)
-{
-	__m128 Shu0 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Shu1 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Shu2 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Shu3 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(3, 3, 3, 3));
-
-	detail::fmat4x4SIMD result(detail::fmat4x4SIMD::null);
-	result[0].Data = _mm_mul_ps(c.Data, Shu0);
-	result[1].Data = _mm_mul_ps(c.Data, Shu1);
-	result[2].Data = _mm_mul_ps(c.Data, Shu2);
-	result[3].Data = _mm_mul_ps(c.Data, Shu3);
-	return result;
-}
-
-GLM_FUNC_QUALIFIER detail::fmat4x4SIMD transpose(detail::fmat4x4SIMD const & m)
-{
-	detail::fmat4x4SIMD result;
-	detail::sse_transpose_ps(&m[0].Data, &result[0].Data);
-	return result;
-}
-
-GLM_FUNC_QUALIFIER float determinant(detail::fmat4x4SIMD const & m)
-{
-	float Result;
-	_mm_store_ss(&Result, detail::sse_det_ps(&m[0].Data));
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER detail::fmat4x4SIMD inverse(detail::fmat4x4SIMD const & m)
-{
-	detail::fmat4x4SIMD result;
-	detail::sse_inverse_ps(&m[0].Data, &result[0].Data);
-	return result;
-}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/simd_vec4.hpp b/include/gal/opengl/glm/gtx/simd_vec4.hpp
deleted file mode 100644
index 6f6006089d..0000000000
--- a/include/gal/opengl/glm/gtx/simd_vec4.hpp
+++ /dev/null
@@ -1,517 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_simd_vec4
-/// @file glm/gtx/simd_vec4.hpp
-/// @date 2009-05-07 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_simd_vec4 GLM_GTX_simd_vec4
-/// @ingroup gtx
-/// 
-/// @brief SIMD implementation of vec4 type.
-/// 
-/// <glm/gtx/simd_vec4.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_simd_vec4
-#define GLM_GTX_simd_vec4 GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(GLM_ARCH != GLM_ARCH_PURE)
-
-#if(GLM_ARCH & GLM_ARCH_SSE2)
-#	include "../core/intrinsic_common.hpp"
-#	include "../core/intrinsic_geometric.hpp"
-#else
-#	error "GLM: GLM_GTX_simd_vec4 requires compiler support of SSE2 through intrinsics"
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_simd_vec4 extension included")
-#endif
-
-
-// Warning silencer for nameless struct/union.
-#if (GLM_COMPILER & GLM_COMPILER_VC)
-#   pragma warning(push)
-#   pragma warning(disable:4201)   // warning C4201: nonstandard extension used : nameless struct/union
-#endif
-
-
-namespace glm{
-namespace detail
-{
-	/// 4-dimensional vector implemented using SIMD SEE intrinsics.
-	/// \ingroup gtx_simd_vec4
-	GLM_ALIGNED_STRUCT(16) fvec4SIMD
-	{
-		enum ctor{null};
-		typedef __m128 value_type;
-		typedef std::size_t size_type;
-		static size_type value_size();
-
-		typedef fvec4SIMD type;
-		typedef tvec4<bool> bool_type;
-
-#ifdef GLM_SIMD_ENABLE_XYZW_UNION
-        union
-        {
-		    __m128 Data;
-            struct {float x, y, z, w;};
-        };
-#else
-        __m128 Data;
-#endif
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		fvec4SIMD();
-		fvec4SIMD(__m128 const & Data);
-		fvec4SIMD(fvec4SIMD const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		explicit fvec4SIMD(
-			ctor);
-		explicit fvec4SIMD(
-			float const & s);
-		explicit fvec4SIMD(
-			float const & x, 
-			float const & y, 
-			float const & z, 
-			float const & w);
-		explicit fvec4SIMD(
-			tvec4<float> const & v);
-
-		////////////////////////////////////////
-		//// Convertion vector constructors
-
-		fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
-		fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
-		fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
-		fvec4SIMD(vec3 const & v, float const & s);
-		fvec4SIMD(float const & s, vec3 const & v);
-		fvec4SIMD(vec2 const & v1, vec2 const & v2);
-		//fvec4SIMD(ivec4SIMD const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		fvec4SIMD& operator= (fvec4SIMD const & v);
-		fvec4SIMD& operator+=(fvec4SIMD const & v);
-		fvec4SIMD& operator-=(fvec4SIMD const & v);
-		fvec4SIMD& operator*=(fvec4SIMD const & v);
-		fvec4SIMD& operator/=(fvec4SIMD const & v);
-
-		fvec4SIMD& operator+=(float const & s);
-		fvec4SIMD& operator-=(float const & s);
-		fvec4SIMD& operator*=(float const & s);
-		fvec4SIMD& operator/=(float const & s);
-
-		fvec4SIMD& operator++();
-		fvec4SIMD& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		template <comp X, comp Y, comp Z, comp W>
-		fvec4SIMD& swizzle();
-		template <comp X, comp Y, comp Z, comp W>
-		fvec4SIMD swizzle() const;
-		template <comp X, comp Y, comp Z>
-		fvec4SIMD swizzle() const;
-		template <comp X, comp Y>
-		fvec4SIMD swizzle() const;
-		template <comp X>
-		fvec4SIMD swizzle() const;
-	};
-}//namespace detail
-
-	typedef glm::detail::fvec4SIMD simdVec4;
-
-	/// @addtogroup gtx_simd_vec4
-	/// @{
-
-	//! Convert a simdVec4 to a vec4.
-	//! (From GLM_GTX_simd_vec4 extension)
-	detail::tvec4<float> vec4_cast(
-		detail::fvec4SIMD const & x);
-
-	//! Returns x if x >= 0; otherwise, it returns -x. 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
-
-	//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0. 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
-
-	//! Returns a value equal to the nearest integer that is less then or equal to x. 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
-
-	//! Returns a value equal to the nearest integer to x 
-	//! whose absolute value is not larger than the absolute value of x. 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
-
-	//! Returns a value equal to the nearest integer to x. 
-	//! The fraction 0.5 will round in a direction chosen by the 
-	//! implementation, presumably the direction that is fastest. 
-	//! This includes the possibility that round(x) returns the 
-	//! same value as roundEven(x) for all values of x. 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD round(detail::fvec4SIMD const & x);
-
-	//! Returns a value equal to the nearest integer to x.
-	//! A fractional part of 0.5 will round toward the nearest even
-	//! integer. (Both 3.5 and 4.5 for x will return 4.0.) 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
-
-	//! Returns a value equal to the nearest integer 
-	//! that is greater than or equal to x. 
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
-
-	//! Return x - floor(x).
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
-
-	//! Modulus. Returns x - y * floor(x / y) 
-	//! for each component in x using the floating point value y.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD mod(
-		detail::fvec4SIMD const & x, 
-		detail::fvec4SIMD const & y);
-
-	//! Modulus. Returns x - y * floor(x / y) 
-	//! for each component in x using the floating point value y.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD mod(
-		detail::fvec4SIMD const & x, 
-		float const & y);
-
-	//! Returns the fractional part of x and sets i to the integer
-	//! part (as a whole number floating point value). Both the
-	//! return value and the output parameter will have the same
-	//! sign as x.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//detail::fvec4SIMD modf(
-	//	detail::fvec4SIMD const & x, 
-	//	detail::fvec4SIMD & i);
-
-	//! Returns y if y < x; otherwise, it returns x.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD min(
-		detail::fvec4SIMD const & x, 
-		detail::fvec4SIMD const & y);
-
-	detail::fvec4SIMD min(
-		detail::fvec4SIMD const & x, 
-		float const & y);
-
-	//! Returns y if x < y; otherwise, it returns x.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD max(
-		detail::fvec4SIMD const & x, 
-		detail::fvec4SIMD const & y);
-
-	detail::fvec4SIMD max(
-		detail::fvec4SIMD const & x, 
-		float const & y);
-
-	//! Returns min(max(x, minVal), maxVal) for each component in x 
-	//! using the floating-point values minVal and maxVal.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD clamp(
-		detail::fvec4SIMD const & x, 
-		detail::fvec4SIMD const & minVal, 
-		detail::fvec4SIMD const & maxVal); 
-
-	detail::fvec4SIMD clamp(
-		detail::fvec4SIMD const & x, 
-		float const & minVal, 
-		float const & maxVal); 
-
-	//! \return If genTypeU is a floating scalar or vector: 
-	//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
-	//! x and y using the floating-point value a. 
-	//! The value for a is not restricted to the range [0, 1].
-	//!
-	//! \return If genTypeU is a boolean scalar or vector: 
-	//! Selects which vector each returned component comes
-	//! from. For a component of a that is false, the
-	//! corresponding component of x is returned. For a
-	//! component of a that is true, the corresponding
-	//! component of y is returned. Components of x and y that
-	//! are not selected are allowed to be invalid floating point
-	//! values and will have no effect on the results. Thus, this
-	//! provides different functionality than
-	//! genType mix(genType x, genType y, genType(a))
-	//! where a is a Boolean vector.
-	//! 
-	//! From GLSL 1.30.08 specification, section 8.3
-	//! 
-	//! \param[in]  x Floating point scalar or vector.
-	//! \param[in]  y Floating point scalar or vector.
-	//! \param[in]  a Floating point or boolean scalar or vector.
-	//!
-	// \todo Test when 'a' is a boolean.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD mix(
-		detail::fvec4SIMD const & x, 
-		detail::fvec4SIMD const & y, 
-		detail::fvec4SIMD const & a);
-
-	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD step(
-		detail::fvec4SIMD const & edge, 
-		detail::fvec4SIMD const & x);
-
-	detail::fvec4SIMD step(
-		float const & edge, 
-		detail::fvec4SIMD const & x);
-
-	//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
-	//! performs smooth Hermite interpolation between 0 and 1
-	//! when edge0 < x < edge1. This is useful in cases where
-	//! you would want a threshold function with a smooth
-	//! transition. This is equivalent to:
-	//! genType t;
-	//! t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
-	//! return t * t * (3 - 2 * t);
-	//! Results are undefined if edge0 >= edge1.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD smoothstep(
-		detail::fvec4SIMD const & edge0, 
-		detail::fvec4SIMD const & edge1, 
-		detail::fvec4SIMD const & x);
-
-	detail::fvec4SIMD smoothstep(
-		float const & edge0, 
-		float const & edge1, 
-		detail::fvec4SIMD const & x);
-
-	//! Returns true if x holds a NaN (not a number)
-	//! representation in the underlying implementation's set of
-	//! floating point representations. Returns false otherwise,
-	//! including for implementations with no NaN
-	//! representations.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//bvec4 isnan(detail::fvec4SIMD const & x);
-
-	//! Returns true if x holds a positive infinity or negative
-	//! infinity representation in the underlying implementation's
-	//! set of floating point representations. Returns false
-	//! otherwise, including for implementations with no infinity
-	//! representations.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//bvec4 isinf(detail::fvec4SIMD const & x);
-
-	//! Returns a signed or unsigned integer value representing
-	//! the encoding of a floating-point value. The floatingpoint
-	//! value's bit-level representation is preserved.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
-
-	//! Returns a floating-point value corresponding to a signed
-	//! or unsigned integer encoding of a floating-point value.
-	//! If an inf or NaN is passed in, it will not signal, and the
-	//! resulting floating point value is unspecified. Otherwise,
-	//! the bit-level representation is preserved.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
-
-	//! Computes and returns a * b + c.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	detail::fvec4SIMD fma(
-		detail::fvec4SIMD const & a, 
-		detail::fvec4SIMD const & b, 
-		detail::fvec4SIMD const & c);
-
-	//! Splits x into a floating-point significand in the range
-	//! [0.5, 1.0) and an integral exponent of two, such that:
-	//! x = significand * exp(2, exponent)
-	//! The significand is returned by the function and the
-	//! exponent is returned in the parameter exp. For a
-	//! floating-point value of zero, the significant and exponent
-	//! are both zero. For a floating-point value that is an
-	//! infinity or is not a number, the results are undefined.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
-
-	//! Builds a floating-point number from x and the
-	//! corresponding integral exponent of two in exp, returning:
-	//! significand * exp(2, exponent)
-	//! If this product is too large to be represented in the
-	//! floating-point type, the result is undefined.
-	//! (From GLM_GTX_simd_vec4 extension, common function)
-	//detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
-
-	//! Returns the length of x, i.e., sqrt(x * x).
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	float length(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the length of x, i.e., sqrt(x * x).
-	//! Less accurate but much faster than simdLength.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	float fastLength(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the length of x, i.e., sqrt(x * x).
-	//! Slightly more accurate but much slower than simdLength.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	float niceLength(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the length of x, i.e., sqrt(x * x).
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD length4(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the length of x, i.e., sqrt(x * x).
-	//! Less accurate but much faster than simdLength4.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD fastLength4(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the length of x, i.e., sqrt(x * x).
-	//! Slightly more accurate but much slower than simdLength4.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD niceLength4(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	float distance(
-		detail::fvec4SIMD const & p0,
-		detail::fvec4SIMD const & p1);
-
-	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD distance4(
-		detail::fvec4SIMD const & p0,
-		detail::fvec4SIMD const & p1);
-
-	//! Returns the dot product of x and y, i.e., result = x * y.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	float simdDot(
-		detail::fvec4SIMD const & x,
-		detail::fvec4SIMD const & y);
-
-	//! Returns the dot product of x and y, i.e., result = x * y.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD dot4(
-		detail::fvec4SIMD const & x,
-		detail::fvec4SIMD const & y);
-
-	//! Returns the cross product of x and y.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD cross(
-		detail::fvec4SIMD const & x,
-		detail::fvec4SIMD const & y);
-
-	//! Returns a vector in the same direction as x but with length of 1.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD normalize(
-		detail::fvec4SIMD const & x);
-
-	//! Returns a vector in the same direction as x but with length of 1.
-	//! Less accurate but much faster than simdNormalize.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD fastNormalize(
-		detail::fvec4SIMD const & x);
-
-	//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD simdFaceforward(
-		detail::fvec4SIMD const & N,
-		detail::fvec4SIMD const & I,
-		detail::fvec4SIMD const & Nref);
-
-	//! For the incident vector I and surface orientation N,
-	//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD reflect(
-		detail::fvec4SIMD const & I,
-		detail::fvec4SIMD const & N);
-
-	//! For the incident vector I and surface normal N,
-	//! and the ratio of indices of refraction eta,
-	//! return the refraction vector.
-	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-	detail::fvec4SIMD refract(
-		detail::fvec4SIMD const & I,
-		detail::fvec4SIMD const & N,
-		float const & eta);
-
-	//! Returns the positive square root of x.
-	//! (From GLM_GTX_simd_vec4 extension, exponential function)
-	detail::fvec4SIMD sqrt(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the positive square root of x with the nicest quality but very slow.
-	//! Slightly more accurate but much slower than simdSqrt.
-	//! (From GLM_GTX_simd_vec4 extension, exponential function)
-	detail::fvec4SIMD niceSqrt(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the positive square root of x
-	//! Less accurate but much faster than sqrt.
-	//! (From GLM_GTX_simd_vec4 extension, exponential function)
-	detail::fvec4SIMD fastSqrt(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the reciprocal of the positive square root of x.
-	//! (From GLM_GTX_simd_vec4 extension, exponential function)
-	detail::fvec4SIMD inversesqrt(
-		detail::fvec4SIMD const & x);
-
-	//! Returns the reciprocal of the positive square root of x.
-	//! Faster than inversesqrt but less accurate.
-	//! (From GLM_GTX_simd_vec4 extension, exponential function)
-	detail::fvec4SIMD fastInversesqrt(
-		detail::fvec4SIMD const & x);
-
-	/// @}
-}//namespace glm
-
-#include "simd_vec4.inl"
-
-
-#if (GLM_COMPILER & GLM_COMPILER_VC)
-#   pragma warning(pop)
-#endif
-
-
-#endif//(GLM_ARCH != GLM_ARCH_PURE)
-
-#endif//GLM_GTX_simd_vec4
diff --git a/include/gal/opengl/glm/gtx/simd_vec4.inl b/include/gal/opengl/glm/gtx/simd_vec4.inl
deleted file mode 100644
index 0b22115dc1..0000000000
--- a/include/gal/opengl/glm/gtx/simd_vec4.inl
+++ /dev/null
@@ -1,727 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2009-05-07
-// Updated : 2009-05-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/simd_vec4.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-template <int Value>
-struct mask
-{
-	enum{value = Value};
-};
-
-//////////////////////////////////////
-// Implicit basic constructors
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD()
-#ifdef GLM_SIMD_ENABLE_DEFAULT_INIT
-    : Data(_mm_set_ps(0.0f, 0.0f, 0.0f, 0.0f))
-#endif
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(__m128 const & Data) :
-	Data(Data)
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(fvec4SIMD const & v) :
-	Data(v.Data)
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(tvec4<float> const & v) :
-	Data(_mm_set_ps(v.w, v.z, v.y, v.x))
-{}
-
-//////////////////////////////////////
-// Explicit basic constructors
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s) :
-	Data(_mm_set1_ps(s))
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & x, float const & y, float const & z, float const & w) :
-//		Data(_mm_setr_ps(x, y, z, w))
-	Data(_mm_set_ps(w, z, y, x))
-{}
-/*
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const v[4]) :
-	Data(_mm_load_ps(v))
-{}
-*/
-//////////////////////////////////////
-// Swizzle constructors
-
-//fvec4SIMD(ref4<float> const & r);
-
-//////////////////////////////////////
-// Convertion vector constructors
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec2 const & v, float const & s1, float const & s2) :
-	Data(_mm_set_ps(s2, s1, v.y, v.x))
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s1, vec2 const & v, float const & s2) :
-	Data(_mm_set_ps(s2, v.y, v.x, s1))
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s1, float const & s2, vec2 const & v) :
-	Data(_mm_set_ps(v.y, v.x, s2, s1))
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec3 const & v, float const & s) :
-	Data(_mm_set_ps(s, v.z, v.y, v.x))
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s, vec3 const & v) :
-	Data(_mm_set_ps(v.z, v.y, v.x, s))
-{}
-
-GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec2 const & v1, vec2 const & v2) :
-	Data(_mm_set_ps(v2.y, v2.x, v1.y, v1.x))
-{}
-
-//GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(ivec4SIMD const & v) :
-//	Data(_mm_cvtepi32_ps(v.Data))
-//{}
-
-//////////////////////////////////////
-// Unary arithmetic operators
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator=(fvec4SIMD const & v)
-{
-	this->Data = v.Data;
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator+=(float const & s)
-{
-	this->Data = _mm_add_ps(Data, _mm_set_ps1(s));
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator+=(fvec4SIMD const & v)
-{
-	this->Data = _mm_add_ps(this->Data , v.Data);
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator-=(float const & s)
-{
-	this->Data = _mm_sub_ps(Data, _mm_set_ps1(s));
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator-=(fvec4SIMD const & v)
-{
-	this->Data = _mm_sub_ps(this->Data , v.Data);
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator*=(float const & s)
-{
-	this->Data = _mm_mul_ps(this->Data, _mm_set_ps1(s));
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator*=(fvec4SIMD const & v)
-{
-	this->Data = _mm_mul_ps(this->Data , v.Data);
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator/=(float const & s)
-{
-	this->Data = _mm_div_ps(Data, _mm_set1_ps(s));
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator/=(fvec4SIMD const & v)
-{
-	this->Data = _mm_div_ps(this->Data , v.Data);
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator++()
-{
-	this->Data = _mm_add_ps(this->Data , glm::detail::one);
-	return *this;
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator--()
-{
-	this->Data = _mm_sub_ps(this->Data, glm::detail::one);
-	return *this;
-}
-
-//////////////////////////////////////
-// Swizzle operators
-
-template <comp X, comp Y, comp Z, comp W>
-GLM_FUNC_QUALIFIER fvec4SIMD fvec4SIMD::swizzle() const
-{
-	__m128 Data = _mm_shuffle_ps(
-		this->Data, this->Data, 
-		mask<(W << 6) | (Z << 4) | (Y << 2) | (X << 0)>::value);
-	return fvec4SIMD(Data);
-}
-
-template <comp X, comp Y, comp Z, comp W>
-GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::swizzle()
-{
-	this->Data = _mm_shuffle_ps(
-		this->Data, this->Data, 
-		mask<(W << 6) | (Z << 4) | (Y << 2) | (X << 0)>::value);
-	return *this;
-}
-
-// operator+
-GLM_FUNC_QUALIFIER fvec4SIMD operator+ (fvec4SIMD const & v, float s)
-{
-	return fvec4SIMD(_mm_add_ps(v.Data, _mm_set1_ps(s)));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator+ (float s, fvec4SIMD const & v)
-{
-	return fvec4SIMD(_mm_add_ps(_mm_set1_ps(s), v.Data));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator+ (fvec4SIMD const & v1, fvec4SIMD const & v2)
-{
-	return fvec4SIMD(_mm_add_ps(v1.Data, v2.Data));
-}
-
-//operator-
-GLM_FUNC_QUALIFIER fvec4SIMD operator- (fvec4SIMD const & v, float s)
-{
-	return fvec4SIMD(_mm_sub_ps(v.Data, _mm_set1_ps(s)));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator- (float s, fvec4SIMD const & v)
-{
-	return fvec4SIMD(_mm_sub_ps(_mm_set1_ps(s), v.Data));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator- (fvec4SIMD const & v1, fvec4SIMD const & v2)
-{
-	return fvec4SIMD(_mm_sub_ps(v1.Data, v2.Data));
-}
-
-//operator*
-GLM_FUNC_QUALIFIER fvec4SIMD operator* (fvec4SIMD const & v, float s)
-{
-	__m128 par0 = v.Data;
-	__m128 par1 = _mm_set1_ps(s);
-	return fvec4SIMD(_mm_mul_ps(par0, par1));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator* (float s, fvec4SIMD const & v)
-{
-	__m128 par0 = _mm_set1_ps(s);
-	__m128 par1 = v.Data;
-	return fvec4SIMD(_mm_mul_ps(par0, par1));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator* (fvec4SIMD const & v1, fvec4SIMD const & v2)
-{
-	return fvec4SIMD(_mm_mul_ps(v1.Data, v2.Data));
-}
-
-//operator/
-GLM_FUNC_QUALIFIER fvec4SIMD operator/ (fvec4SIMD const & v, float s)
-{
-	__m128 par0 = v.Data;
-	__m128 par1 = _mm_set1_ps(s);
-	return fvec4SIMD(_mm_div_ps(par0, par1));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator/ (float s, fvec4SIMD const & v)
-{
-	__m128 par0 = _mm_set1_ps(s);
-	__m128 par1 = v.Data;
-	return fvec4SIMD(_mm_div_ps(par0, par1));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator/ (fvec4SIMD const & v1, fvec4SIMD const & v2)
-{
-	return fvec4SIMD(_mm_div_ps(v1.Data, v2.Data));
-}
-
-// Unary constant operators
-GLM_FUNC_QUALIFIER fvec4SIMD operator- (fvec4SIMD const & v)
-{
-	return fvec4SIMD(_mm_sub_ps(_mm_setzero_ps(), v.Data));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator++ (fvec4SIMD const & v, int)
-{
-	return fvec4SIMD(_mm_add_ps(v.Data, glm::detail::one));
-}
-
-GLM_FUNC_QUALIFIER fvec4SIMD operator-- (fvec4SIMD const & v, int)
-{
-	return fvec4SIMD(_mm_sub_ps(v.Data, glm::detail::one));
-}
-
-}//namespace detail
-
-GLM_FUNC_QUALIFIER detail::tvec4<float> vec4_cast
-(
-	detail::fvec4SIMD const & x
-)
-{
-	GLM_ALIGN(16) detail::tvec4<float> Result;
-	_mm_store_ps(&Result[0], x.Data);
-	return Result;
-}
-
-// Other possible implementation
-//float abs(float a)
-//{
-//  return max(-a, a);
-//}
-GLM_FUNC_QUALIFIER detail::fvec4SIMD abs
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_abs_ps(x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD sign
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_sgn_ps(x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD floor
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_flr_ps(x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD trunc
-(
-	detail::fvec4SIMD const & x
-)
-{
-    //return x < 0 ? -floor(-x) : floor(x);
-
-	__m128 Flr0 = detail::sse_flr_ps(_mm_sub_ps(_mm_setzero_ps(), x.Data));
-	__m128 Sub0 = _mm_sub_ps(Flr0, x.Data);
-	__m128 Flr1 = detail::sse_flr_ps(x.Data);
-
-	__m128 Cmp0 = _mm_cmplt_ps(x.Data, glm::detail::zero);
-	__m128 Cmp1 = _mm_cmpnlt_ps(x.Data, glm::detail::zero);
-
-	__m128 And0 = _mm_and_ps(Sub0, Cmp0);
-	__m128 And1 = _mm_and_ps(Flr1, Cmp1);
-
-	return _mm_or_ps(And0, And1);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD round
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_rnd_ps(x.Data);
-}
-
-//GLM_FUNC_QUALIFIER detail::fvec4SIMD roundEven
-//(
-//	detail::fvec4SIMD const & x
-//)
-//{
-
-//}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD ceil
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_ceil_ps(x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD fract
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_frc_ps(x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD mod
-(
-	detail::fvec4SIMD const & x, 
-	detail::fvec4SIMD const & y
-)
-{
-	return detail::sse_mod_ps(x.Data, y.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD mod
-(
-	detail::fvec4SIMD const & x, 
-	float const & y
-)
-{
-	return detail::sse_mod_ps(x.Data, _mm_set1_ps(y));
-}
-
-//GLM_FUNC_QUALIFIER detail::fvec4SIMD modf
-//(
-//	detail::fvec4SIMD const & x, 
-//	detail::fvec4SIMD & i
-//)
-//{
-
-//}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD min
-(
-	detail::fvec4SIMD const & x, 
-	detail::fvec4SIMD const & y
-)
-{
-	return _mm_min_ps(x.Data, y.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD min
-(
-	detail::fvec4SIMD const & x, 
-	float const & y
-)
-{
-	return _mm_min_ps(x.Data, _mm_set1_ps(y));
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD max
-(
-	detail::fvec4SIMD const & x, 
-	detail::fvec4SIMD const & y
-)
-{
-	return _mm_max_ps(x.Data, y.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD max
-(
-	detail::fvec4SIMD const & x, 
-	float const & y
-)
-{
-	return _mm_max_ps(x.Data, _mm_set1_ps(y));
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD clamp
-(
-	detail::fvec4SIMD const & x, 
-	detail::fvec4SIMD const & minVal, 
-	detail::fvec4SIMD const & maxVal
-)
-{
-	return detail::sse_clp_ps(x.Data, minVal.Data, maxVal.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD clamp
-(
-	detail::fvec4SIMD const & x, 
-	float const & minVal, 
-	float const & maxVal
-) 
-{
-	return detail::sse_clp_ps(x.Data, _mm_set1_ps(minVal), _mm_set1_ps(maxVal));
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD mix
-(
-	detail::fvec4SIMD const & x, 
-	detail::fvec4SIMD const & y, 
-	detail::fvec4SIMD const & a
-)
-{
-	__m128 Sub0 = _mm_sub_ps(y.Data, x.Data);
-	__m128 Mul0 = _mm_mul_ps(a.Data, Sub0);
-	return _mm_add_ps(x.Data, Mul0);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD step
-(
-	detail::fvec4SIMD const & edge, 
-	detail::fvec4SIMD const & x
-)
-{
-	__m128 cmp0 = _mm_cmpngt_ps(x.Data, edge.Data);
-	return _mm_max_ps(_mm_min_ps(cmp0, _mm_setzero_ps()), detail::one);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD step
-(
-	float const & edge, 
-	detail::fvec4SIMD const & x
-)
-{
-	__m128 cmp0 = _mm_cmpngt_ps(x.Data, _mm_set1_ps(edge));
-	return _mm_max_ps(_mm_min_ps(cmp0, _mm_setzero_ps()), detail::one);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD smoothstep
-(
-	detail::fvec4SIMD const & edge0, 
-	detail::fvec4SIMD const & edge1, 
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_ssp_ps(edge0.Data, edge1.Data, x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD smoothstep
-(
-	float const & edge0, 
-	float const & edge1, 
-	detail::fvec4SIMD const & x
-)
-{
-	return detail::sse_ssp_ps(_mm_set1_ps(edge0), _mm_set1_ps(edge1), x.Data);
-}
-
-//GLM_FUNC_QUALIFIER bvec4 isnan(detail::fvec4SIMD const & x)
-//{
-
-//}
-
-//GLM_FUNC_QUALIFIER bvec4 isinf(detail::fvec4SIMD const & x)
-//{
-
-//}
-
-//GLM_FUNC_QUALIFIER detail::ivec4SIMD floatBitsToInt
-//(
-//	detail::fvec4SIMD const & value
-//)
-//{
-
-//}
-
-//GLM_FUNC_QUALIFIER detail::fvec4SIMD intBitsToFloat
-//(
-//	detail::ivec4SIMD const & value
-//)
-//{
-
-//}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD fma
-(
-	detail::fvec4SIMD const & a, 
-	detail::fvec4SIMD const & b, 
-	detail::fvec4SIMD const & c
-)
-{
-	return _mm_add_ps(_mm_mul_ps(a.Data, b.Data), c.Data);
-}
-
-GLM_FUNC_QUALIFIER float length
-(
-	detail::fvec4SIMD const & x
-)
-{
-	detail::fvec4SIMD dot0 = detail::sse_dot_ss(x.Data, x.Data);
-	detail::fvec4SIMD sqt0 = sqrt(dot0);
-	float Result = 0;
-	_mm_store_ss(&Result, sqt0.Data);
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER float fastLength
-(
-	detail::fvec4SIMD const & x
-)
-{
-	detail::fvec4SIMD dot0 = detail::sse_dot_ss(x.Data, x.Data);
-	detail::fvec4SIMD sqt0 = fastSqrt(dot0);
-	float Result = 0;
-	_mm_store_ss(&Result, sqt0.Data);
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER float niceLength
-(
-	detail::fvec4SIMD const & x
-)
-{
-	detail::fvec4SIMD dot0 = detail::sse_dot_ss(x.Data, x.Data);
-	detail::fvec4SIMD sqt0 = niceSqrt(dot0);
-	float Result = 0;
-	_mm_store_ss(&Result, sqt0.Data);
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD length4
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return sqrt(dot4(x, x));
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD fastLength4
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return fastSqrt(dot4(x, x));
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD niceLength4
-(
-	detail::fvec4SIMD const & x
-)
-{
-	return niceSqrt(dot4(x, x));
-}
-
-GLM_FUNC_QUALIFIER float distance
-(
-	detail::fvec4SIMD const & p0,
-	detail::fvec4SIMD const & p1
-)
-{
-	float Result = 0;
-	_mm_store_ss(&Result, detail::sse_dst_ps(p0.Data, p1.Data));
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD distance4
-(
-	detail::fvec4SIMD const & p0,
-	detail::fvec4SIMD const & p1
-)
-{
-	return detail::sse_dst_ps(p0.Data, p1.Data);
-}
-
-GLM_FUNC_QUALIFIER float dot
-(
-	detail::fvec4SIMD const & x,
-	detail::fvec4SIMD const & y
-)
-{
-	float Result = 0;
-	_mm_store_ss(&Result, detail::sse_dot_ss(x.Data, y.Data));
-	return Result;
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD dot4
-(
-	detail::fvec4SIMD const & x,
-	detail::fvec4SIMD const & y
-)
-{
-	return detail::sse_dot_ps(x.Data, y.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD cross
-(
-	detail::fvec4SIMD const & x,
-	detail::fvec4SIMD const & y
-)
-{
-	return detail::sse_xpd_ps(x.Data, y.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD normalize
-(
-	detail::fvec4SIMD const & x
-)
-{
-	__m128 dot0 = detail::sse_dot_ps(x.Data, x.Data);
-	__m128 isr0 = inversesqrt(detail::fvec4SIMD(dot0)).Data;
-	__m128 mul0 = _mm_mul_ps(x.Data, isr0);
-	return mul0;
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD fastNormalize
-(
-	detail::fvec4SIMD const & x
-)
-{
-	__m128 dot0 = detail::sse_dot_ps(x.Data, x.Data);
-	__m128 isr0 = fastInversesqrt(dot0).Data;
-	__m128 mul0 = _mm_mul_ps(x.Data, isr0);
-	return mul0;
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD faceforward
-(
-	detail::fvec4SIMD const & N,
-	detail::fvec4SIMD const & I,
-	detail::fvec4SIMD const & Nref
-)
-{
-	return detail::sse_ffd_ps(N.Data, I.Data, Nref.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD reflect
-(
-	detail::fvec4SIMD const & I,
-	detail::fvec4SIMD const & N
-)
-{
-	return detail::sse_rfe_ps(I.Data, N.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD refract
-(
-	detail::fvec4SIMD const & I,
-	detail::fvec4SIMD const & N,
-	float const & eta
-)
-{
-	return detail::sse_rfa_ps(I.Data, N.Data, _mm_set1_ps(eta));
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD sqrt(detail::fvec4SIMD const & x)
-{
-	return _mm_mul_ps(inversesqrt(x).Data, x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD niceSqrt(detail::fvec4SIMD const & x)
-{
-	return _mm_sqrt_ps(x.Data);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD fastSqrt(detail::fvec4SIMD const & x)
-{
-	return _mm_mul_ps(fastInversesqrt(x.Data).Data, x.Data);
-}
-
-// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
-// By Elan Ruskin, http://assemblyrequired.crashworks.org/
-GLM_FUNC_QUALIFIER detail::fvec4SIMD inversesqrt(detail::fvec4SIMD const & x)
-{
-	GLM_ALIGN(4) static const __m128 three = {3, 3, 3, 3}; // aligned consts for fast load
-	GLM_ALIGN(4) static const __m128 half = {0.5,0.5,0.5,0.5};
-
-	__m128 recip = _mm_rsqrt_ps(x.Data);  // "estimate" opcode
-	__m128 halfrecip = _mm_mul_ps(half, recip);
-	__m128 threeminus_xrr = _mm_sub_ps(three, _mm_mul_ps(x.Data, _mm_mul_ps(recip, recip)));
-	return _mm_mul_ps(halfrecip, threeminus_xrr);
-}
-
-GLM_FUNC_QUALIFIER detail::fvec4SIMD fastInversesqrt(detail::fvec4SIMD const & x)
-{
-	return _mm_rsqrt_ps(x.Data);
-}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/spline.hpp b/include/gal/opengl/glm/gtx/spline.hpp
deleted file mode 100644
index e9035ce15e..0000000000
--- a/include/gal/opengl/glm/gtx/spline.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_spline
-/// @file glm/gtx/spline.hpp
-/// @date 2007-01-25 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_spline GLM_GTX_spline
-/// @ingroup gtx
-/// 
-/// @brief Spline functions
-/// 
-/// <glm/gtx/spline.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_spline
-#define GLM_GTX_spline GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/optimum_pow.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_spline extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_spline
-	/// @{
-
-	//! Return a point from a catmull rom curve.
-	//! From GLM_GTX_spline extension.
-	template <typename genType> 
-	genType catmullRom(
-		genType const & v1, 
-		genType const & v2, 
-		genType const & v3, 
-		genType const & v4, 
-		typename genType::value_type const & s);
-		
-	//! Return a point from a hermite curve.
-	//! From GLM_GTX_spline extension.
-    template <typename genType> 
-	genType hermite(
-		genType const & v1, 
-		genType const & t1, 
-		genType const & v2, 
-		genType const & t2, 
-		typename genType::value_type const & s);
-		
-    //! Return a point from a cubic curve. 
-	//! From GLM_GTX_spline extension.
-	template <typename genType> 
-	genType cubic(
-		genType const & v1, 
-		genType const & v2, 
-		genType const & v3, 
-		genType const & v4, 
-		typename genType::value_type const & s);
-
-	/// @}
-}//namespace glm
-
-#include "spline.inl"
-
-#endif//GLM_GTX_spline
-
diff --git a/include/gal/opengl/glm/gtx/spline.inl b/include/gal/opengl/glm/gtx/spline.inl
deleted file mode 100644
index 6a6509ed93..0000000000
--- a/include/gal/opengl/glm/gtx/spline.inl
+++ /dev/null
@@ -1,70 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-01-25
-// Updated : 2009-02-19
-// Licence : This source is under MIT License
-// File    : glm/gtx/spline.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-
-template <typename genType>
-GLM_FUNC_QUALIFIER genType catmullRom
-(
-	genType const & v1, 
-	genType const & v2, 
-	genType const & v3, 
-	genType const & v4, 
-	typename genType::value_type const & s
-)
-{
-	typename genType::value_type s1 = s;
-	typename genType::value_type s2 = pow2(s);
-	typename genType::value_type s3 = pow3(s);
-
-	typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
-	typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
-	typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s;
-	typename genType::value_type f4 = s3 - s2;
-
-	return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2);
-
-}
-
-template <typename genType>
-GLM_FUNC_QUALIFIER genType hermite
-(
-	genType const & v1, 
-	genType const & t1, 
-	genType const & v2, 
-	genType const & t2, 
-	typename genType::value_type const & s
-)
-{
-	typename genType::value_type s1 = s;
-	typename genType::value_type s2 = pow2(s);
-	typename genType::value_type s3 = pow3(s);
-
-	typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
-	typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
-	typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s;
-	typename genType::value_type f4 = s3 - s2;
-
-	return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
-}
-
-template <typename genType>
-GLM_FUNC_QUALIFIER genType cubic
-(
-	genType const & v1, 
-	genType const & v2, 
-	genType const & v3, 
-	genType const & v4, 
-	typename genType::value_type const & s
-)
-{
-	return ((v1 * s + v2) * s + v3) * s + v4;
-}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/std_based_type.hpp b/include/gal/opengl/glm/gtx/std_based_type.hpp
deleted file mode 100644
index c5c04dc690..0000000000
--- a/include/gal/opengl/glm/gtx/std_based_type.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_std_based_type
-/// @file glm/gtx/std_based_type.hpp
-/// @date 2008-06-08 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_extented_min_max (dependence)
-///
-/// @defgroup gtx_std_based_type GLM_GTX_std_based_type
-/// @ingroup gtx
-/// 
-/// @brief Adds vector types based on STL value types.
-/// <glm/gtx/std_based_type.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_std_based_type
-#define GLM_GTX_std_based_type GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include <cstdlib>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_std_based_type extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_std_based_type
-	/// @{
-	
-	/// Vector type based of two std::size_t components.
-	/// @see GLM_GTX_std_based_type
-	typedef detail::tvec2<std::size_t>		size2;
-	
-	/// Vector type based of three std::size_t components.
-	/// @see GLM_GTX_std_based_type
-	typedef detail::tvec3<std::size_t>		size3;
-
-	/// Vector type based of four std::size_t components.
-	/// @see GLM_GTX_std_based_type
-	typedef detail::tvec4<std::size_t>		size4;
-
-	/// Vector type based of two std::size_t components.
-	/// @see GLM_GTX_std_based_type
-	typedef detail::tvec2<std::size_t>		size2_t;
-	
-	/// Vector type based of three std::size_t components.
-	/// @see GLM_GTX_std_based_type
-	typedef detail::tvec3<std::size_t>		size3_t;
-	
-	/// Vector type based of four std::size_t components.
-	/// @see GLM_GTX_std_based_type
-	typedef detail::tvec4<std::size_t>		size4_t;
-
-	/// @}
-}//namespace glm
-
-#include "std_based_type.inl"
-
-#endif//GLM_GTX_std_based_type
diff --git a/include/gal/opengl/glm/gtx/std_based_type.inl b/include/gal/opengl/glm/gtx/std_based_type.inl
deleted file mode 100644
index e349c4a43d..0000000000
--- a/include/gal/opengl/glm/gtx/std_based_type.inl
+++ /dev/null
@@ -1,13 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2008-06-08
-// Updated : 2008-06-08
-// Licence : This source is under MIT License
-// File    : glm/gtx/std_based_type.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-
-}
diff --git a/include/gal/opengl/glm/gtx/string_cast.hpp b/include/gal/opengl/glm/gtx/string_cast.hpp
deleted file mode 100644
index b306093158..0000000000
--- a/include/gal/opengl/glm/gtx/string_cast.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_string_cast
-/// @file glm/gtx/string_cast.hpp
-/// @date 2008-04-26 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtx_integer (dependence)
-/// @see gtx_quaternion (dependence)
-///
-/// @defgroup gtx_string_cast GLM_GTX_string_cast
-/// @ingroup gtx
-/// 
-/// @brief Setup strings for GLM type values
-/// 
-/// <glm/gtx/string_cast.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_string_cast
-#define GLM_GTX_string_cast GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-#include "../gtx/integer.hpp"
-#include "../gtx/quaternion.hpp"
-#include <string>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_string_cast extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_string_cast
-	/// @{
-
-	/// Create a string from a GLM type value.
-	/// From GLM_GTX_string_cast extension.
-	template <typename genType> 
-	std::string to_string(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "string_cast.inl"
-
-#endif//GLM_GTX_string_cast
diff --git a/include/gal/opengl/glm/gtx/string_cast.inl b/include/gal/opengl/glm/gtx/string_cast.inl
deleted file mode 100644
index d0e8f43fbe..0000000000
--- a/include/gal/opengl/glm/gtx/string_cast.inl
+++ /dev/null
@@ -1,588 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2006 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2008-04-27
-// Updated : 2008-05-24
-// Licence : This source is under MIT License
-// File    : glm/gtx/string_cast.hpp
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include <cstdarg>
-#include <cstdio>
-
-namespace glm{
-namespace detail
-{
-	GLM_FUNC_QUALIFIER std::string format(const char* msg, ...)
-	{
-		std::size_t const STRING_BUFFER(4096);
-		char text[STRING_BUFFER];
-		va_list list;
-
-		if(msg == 0)
-			return std::string();
-
-		va_start(list, msg);
-
-#if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
-			vsprintf_s(text, STRING_BUFFER, msg, list);
-#else//
-			vsprintf(text, msg, list);
-#endif//
-		va_end(list);
-
-		return std::string(text);
-	}
-
-	static const char* True = "true";
-	static const char* False = "false";
-}//namespace detail
-
-	////////////////////////////////
-	// Scalars
-
-	GLM_FUNC_QUALIFIER std::string to_string(detail::half const & x)
-	{
-		return detail::format("half(%2.4f)", float(x));
-	}
-
-	GLM_FUNC_QUALIFIER std::string to_string(float x)
-	{
-		return detail::format("float(%f)", x);
-	}
-
-	GLM_FUNC_QUALIFIER std::string to_string(double x)
-	{
-		return detail::format("double(%f)", x);
-	}
-
-	GLM_FUNC_QUALIFIER std::string to_string(int x)
-	{
-		return detail::format("int(%d)", x);
-	}
-
-	GLM_FUNC_QUALIFIER std::string to_string(unsigned int x)
-	{
-		return detail::format("uint(%d)", x);
-	}
-
-	////////////////////////////////
-	// Bool vectors
-
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec2<bool> const & v
-	)
-	{
-		return detail::format("bvec2(%s, %s)", 
-			v.x ? detail::True : detail::False, 
-			v.y ? detail::True : detail::False);
-	}
-
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec3<bool> const & v
-	)
-	{
-		return detail::format("bvec3(%s, %s, %s)", 
-			v.x ? detail::True : detail::False, 
-			v.y ? detail::True : detail::False, 
-			v.z ? detail::True : detail::False);
-	}
-
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec4<bool> const & v
-	)
-	{
-		return detail::format("bvec4(%s, %s, %s, %s)", 
-			v.x ? detail::True : detail::False, 
-			v.y ? detail::True : detail::False, 
-			v.z ? detail::True : detail::False, 
-			v.w ? detail::True : detail::False);
-	}
-
-	////////////////////////////////
-	// Half vectors
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec2<detail::half> const & v
-	)
-	{
-		return detail::format("hvec2(%2.4f, %2.4f)", v.x.toFloat(), v.y.toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec3<detail::half> const & v
-	)
-	{
-		return detail::format("hvec3(%2.4f, %2.4f, %2.4f)", v.x.toFloat(), v.y.toFloat(), v.z.toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec4<detail::half> const & v
-	)
-	{
-		return detail::format("hvec4(%2.4f, %2.4f, %2.4f, %2.4f)", v.x.toFloat(), v.y.toFloat(), v.z.toFloat(), v.w.toFloat());
-	}
-
-	////////////////////////////////
-	// Float vectors
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec2<float> const & v
-	)
-	{
-		return detail::format("fvec2(%f, %f)", v.x, v.y);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec3<float> const & v
-	)
-	{
-		return detail::format("fvec3(%f, %f, %f)", v.x, v.y, v.z);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec4<float> const & v
-	)
-	{
-		return detail::format("fvec4(%f, %f, %f, %f)", v.x, v.y, v.z, v.w);
-	}
-
-	////////////////////////////////
-	// Double vectors
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec2<double> const & v
-	)
-	{
-		return detail::format("dvec2(%f, %f)", v.x, v.y);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec3<double> const & v
-	)
-	{
-		return detail::format("dvec3(%f, %f, %f)", v.x, v.y, v.z);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec4<double> const & v
-	)
-	{
-		return detail::format("dvec4(%f, %f, %f, %f)", v.x, v.y, v.z, v.w);
-	}
-
-	////////////////////////////////
-	// Int vectors
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec2<int> const & v
-	)
-	{
-		return detail::format("ivec2(%d, %d)", v.x, v.y);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec3<int> const & v
-	)
-	{
-		return detail::format("ivec3(%d, %d, %d)", v.x, v.y, v.z);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec4<int> const & v
-	)
-	{
-		return detail::format("ivec4(%d, %d, %d, %d)", v.x, v.y, v.z, v.w);
-	}
-
-	////////////////////////////////
-	// Unsigned int vectors
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec2<unsigned int> const & v
-	)
-	{
-		return detail::format("uvec2(%d, %d)", v.x, v.y);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec3<unsigned int> const & v
-	)
-	{
-		return detail::format("uvec3(%d, %d, %d)", v.x, v.y, v.z);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tvec4<unsigned int> const & v
-	)
-	{
-		return detail::format("uvec4(%d, %d, %d, %d)", v.x, v.y, v.z, v.w);
-	}
-
-	////////////////////////////////
-	// Half matrices
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x2<detail::half> const & m
-	)
-	{
-		return detail::format("hmat2x2((%f, %f), (%f, %f))", 
-			m[0][0].toFloat(), m[0][1].toFloat(), 
-			m[1][0].toFloat(), m[1][1].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x3<detail::half> const & x
-	)
-	{
-		return detail::format("hmat2x3((%f, %f, %f), (%f, %f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), x[0][2].toFloat(), 
-			x[1][0].toFloat(), x[1][1].toFloat(), x[1][2].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x4<detail::half> const & x
-	)
-	{
-		return detail::format("hmat2x4((%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), x[0][2].toFloat(), x[0][3].toFloat(), 
-			x[1][0].toFloat(), x[1][1].toFloat(), x[1][2].toFloat(), x[1][3].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x2<detail::half> const & x
-	)
-	{
-		return detail::format("hmat3x2((%f, %f), (%f, %f), (%f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), 
-			x[1][0].toFloat(), x[1][1].toFloat(), 
-			x[2][0].toFloat(), x[2][1].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x3<detail::half> const & x
-	)
-	{
-		return detail::format("hmat3x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), x[0][2].toFloat(), 
-			x[1][0].toFloat(), x[1][1].toFloat(), x[1][2].toFloat(),
-			x[2][0].toFloat(), x[2][1].toFloat(), x[2][2].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x4<detail::half> const & x
-	)
-	{
-		return detail::format("hmat3x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), x[0][2].toFloat(), x[0][3].toFloat(), 
-			x[1][0].toFloat(), x[1][1].toFloat(), x[1][2].toFloat(), x[1][3].toFloat(), 
-			x[2][0].toFloat(), x[2][1].toFloat(), x[2][2].toFloat(), x[2][3].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x2<detail::half> const & x
-	)
-	{
-		return detail::format("hmat4x2((%f, %f), (%f, %f), (%f, %f), (%f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), 
-			x[1][0].toFloat(), x[1][1].toFloat(), 
-			x[2][0].toFloat(), x[2][1].toFloat(), 
-			x[3][0].toFloat(), x[3][1].toFloat());
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x3<detail::half> const & x
-	)
-	{
-		return detail::format("hmat4x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), x[0][2].toFloat(),
-			x[1][0].toFloat(), x[1][1].toFloat(), x[1][2].toFloat(), 
-			x[2][0].toFloat(), x[2][1].toFloat(), x[2][2].toFloat(),
-			x[3][0].toFloat(), x[3][1].toFloat(), x[3][2].toFloat());
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x4<detail::half> const & x
-	)
-	{
-		return detail::format("hmat4x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0].toFloat(), x[0][1].toFloat(), x[0][2].toFloat(), x[0][3].toFloat(),
-			x[1][0].toFloat(), x[1][1].toFloat(), x[1][2].toFloat(), x[1][3].toFloat(),
-			x[2][0].toFloat(), x[2][1].toFloat(), x[2][2].toFloat(), x[2][3].toFloat(),
-			x[3][0].toFloat(), x[3][1].toFloat(), x[3][2].toFloat(), x[3][3].toFloat());
-	}
-
-	////////////////////////////////
-	// Float matrices
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x2<float> const & x
-	)
-	{
-		return detail::format("mat2x2((%f, %f), (%f, %f))", 
-			x[0][0], x[0][1], 
-			x[1][0], x[1][1]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x3<float> const & x
-	)
-	{
-		return detail::format("mat2x3((%f, %f, %f), (%f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], 
-			x[1][0], x[1][1], x[1][2]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x4<float> const & x
-	)
-	{
-		return detail::format("mat2x4((%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], x[0][3], 
-			x[1][0], x[1][1], x[1][2], x[1][3]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x2<float> const & x
-	)
-	{
-		return detail::format("mat3x2((%f, %f), (%f, %f), (%f, %f))", 
-			x[0][0], x[0][1], 
-			x[1][0], x[1][1], 
-			x[2][0], x[2][1]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x3<float> const & x
-	)
-	{
-		return detail::format("mat3x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], 
-			x[1][0], x[1][1], x[1][2],
-			x[2][0], x[2][1], x[2][2]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x4<float> const & x
-	)
-	{
-		return detail::format("mat3x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], x[0][3], 
-			x[1][0], x[1][1], x[1][2], x[1][3], 
-			x[2][0], x[2][1], x[2][2], x[2][3]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x2<float> const & x
-	)
-	{
-		return detail::format("mat4x2((%f, %f), (%f, %f), (%f, %f), (%f, %f))", 
-			x[0][0], x[0][1], 
-			x[1][0], x[1][1], 
-			x[2][0], x[2][1], 
-			x[3][0], x[3][1]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x3<float> const & x
-	)
-	{
-		return detail::format("mat4x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2],
-			x[1][0], x[1][1], x[1][2], 
-			x[2][0], x[2][1], x[2][2],
-			x[3][0], x[3][1], x[3][2]);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x4<float> const & x
-	)
-	{
-		return detail::format("mat4x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], x[0][3],
-			x[1][0], x[1][1], x[1][2], x[1][3],
-			x[2][0], x[2][1], x[2][2], x[2][3],
-			x[3][0], x[3][1], x[3][2], x[3][3]);
-	}
-
-	////////////////////////////////
-	// Double matrices
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x2<double> const & x
-	)
-	{
-		return detail::format("dmat2x2((%f, %f), (%f, %f))", 
-			x[0][0], x[0][1], 
-			x[1][0], x[1][1]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x3<double> const & x
-	)
-	{
-		return detail::format("dmat2x3((%f, %f, %f), (%f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], 
-			x[1][0], x[1][1], x[1][2]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat2x4<double> const & x
-	)
-	{
-		return detail::format("dmat2x4((%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], x[0][3], 
-			x[1][0], x[1][1], x[1][2], x[1][3]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x2<double> const & x
-	)
-	{
-		return detail::format("dmat3x2((%f, %f), (%f, %f), (%f, %f))", 
-			x[0][0], x[0][1], 
-			x[1][0], x[1][1],
-			x[2][0], x[2][1]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x3<double> const & x
-	)
-	{
-		return detail::format("dmat3x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], 
-			x[1][0], x[1][1], x[1][2],
-			x[2][0], x[2][1], x[2][2]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat3x4<double> const & x
-	)
-	{
-		return detail::format("dmat3x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], x[0][3], 
-			x[1][0], x[1][1], x[1][2], x[1][3],
-			x[2][0], x[2][1], x[2][2], x[2][3]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x2<double> const & x
-	)
-	{
-		return detail::format("dmat4x2((%f, %f), (%f, %f), (%f, %f), (%f, %f))", 
-			x[0][0], x[0][1], 
-			x[1][0], x[1][1], 
-			x[2][0], x[2][1], 
-			x[3][0], x[3][1]);
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x3<double> const & x
-	)
-	{
-		return detail::format("dmat4x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], 
-			x[1][0], x[1][1], x[1][2], 
-			x[2][0], x[2][1], x[2][2], 
-			x[3][0], x[3][1], x[3][2]);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER std::string to_string
-	(
-		detail::tmat4x4<double> const & x
-	)
-	{
-		return detail::format("dmat4x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
-			x[0][0], x[0][1], x[0][2], x[0][3],
-			x[1][0], x[1][1], x[1][2], x[1][3],
-			x[2][0], x[2][1], x[2][2], x[2][3],
-			x[3][0], x[3][1], x[3][2], x[3][3]);
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/transform.hpp b/include/gal/opengl/glm/gtx/transform.hpp
deleted file mode 100644
index 8929e4651a..0000000000
--- a/include/gal/opengl/glm/gtx/transform.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_transform
-/// @file glm/gtx/transform.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_matrix_transform (dependence)
-/// @see gtx_transform
-/// @see gtx_transform2
-///
-/// @defgroup gtx_transform GLM_GTX_transform
-/// @ingroup gtx
-///
-/// @brief Add transformation matrices
-/// 
-/// <glm/gtx/transform.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_transform 
-#define GLM_GTX_transform GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/matrix_transform.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_transform extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_transform
-	/// @{
-
-	//! Builds a translation 4 * 4 matrix created from 3 scalars.
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::translate GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> translate(
-		T x, T y, T z);
-		
-	//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::translate GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> translate(
-		detail::tmat4x4<T> const & m, 
-		T x, T y, T z);
-		
-	//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::translate GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> translate(
-		detail::tvec3<T> const & v);
-
-	//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::rotate GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> rotate(
-		T angle, 
-		T x, T y, T z);
-
-	//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::rotate GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> rotate(
-		T angle, 
-		detail::tvec3<T> const & v);
-
-	//! Transforms a matrix with a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::rotate GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> rotate(
-		detail::tmat4x4<T> const & m, 
-		T angle, 
-		T x, T y, T z);
-		
-	//! Builds a scale 4 * 4 matrix created from 3 scalars. 
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::scale GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> scale(
-		T x, T y, T z);
-		
-	//! Transforms a matrix with a scale 4 * 4 matrix created from 3 scalars.
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::scale GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> scale(
-		detail::tmat4x4<T> const & m, 
-		T x, T y, T z);
-
-	//! Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
-	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-	// - See also: \link glm::scale GLM_GTC_matrix_transform \endlink
-	template <typename T> 
-	detail::tmat4x4<T> scale(
-		detail::tvec3<T> const & v);
-
-	/// @}
-}// namespace glm
-
-#include "transform.inl"
-
-#endif//GLM_GTX_transform
diff --git a/include/gal/opengl/glm/gtx/transform.inl b/include/gal/opengl/glm/gtx/transform.inl
deleted file mode 100644
index 8f8c921c73..0000000000
--- a/include/gal/opengl/glm/gtx/transform.inl
+++ /dev/null
@@ -1,90 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-21
-// Updated : 2009-04-29
-// Licence : This source is under MIT License
-// File    : glm/gtx/transform.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
-		T x, T y, T z)
-    {
-		return translate(
-			detail::tmat4x4<T>(1.0f), 
-			detail::tvec3<T>(x, y , z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
-		detail::tmat4x4<T> const & m, 
-		T x, T y, T z)
-    {
-        return translate(
-			m, detail::tvec3<T>(x, y , z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
-		detail::tvec3<T> const & v)
-    {
-		return translate(
-			detail::tmat4x4<T>(1.0f), v);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate(
-		T angle, 
-		T x, T y, T z)
-    {
-		return rotate(
-			detail::tmat4x4<T>(1), angle, detail::tvec3<T>(x, y, z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate(
-		T angle, 
-		detail::tvec3<T> const & v)
-    {
-		return rotate(
-			detail::tmat4x4<T>(1), angle, v);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate(
-		detail::tmat4x4<T> const & m, 
-		T angle, 
-		T x, T y, T z)
-    {
-		return rotate(
-			m, angle, detail::tvec3<T>(x, y, z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale(T x, T y, T z)
-    {
-		return scale(
-			detail::tmat4x4<T>(1), detail::tvec3<T>(x, y, z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale(
-		detail::tmat4x4<T> const & m, 
-		T x, T y, T z)
-    {
-        return scale(
-			m, detail::tvec3<T>(x, y, z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale(
-		detail::tvec3<T> const & v)
-    {
-        return scale(
-			detail::tmat4x4<T>(1.0f), v);
-    }
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/transform2.hpp b/include/gal/opengl/glm/gtx/transform2.hpp
deleted file mode 100644
index 4c6bd154bf..0000000000
--- a/include/gal/opengl/glm/gtx/transform2.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_transform2
-/// @file glm/gtx/transform2.hpp
-/// @date 2005-12-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_transform (dependence)
-///
-/// @defgroup gtx_transform2 GLM_GTX_transform2
-/// @ingroup gtx
-/// 
-/// @brief Add extra transformation matrices
-///
-/// <glm/gtx/transform2.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_transform2
-#define GLM_GTX_transform2 GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/transform.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_transform2 extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_transform2
-	/// @{
-
-	//! Transforms a matrix with a shearing on X axis.
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat3x3<T> shearX2D(
-		detail::tmat3x3<T> const & m, 
-		T y);
-
-	//! Transforms a matrix with a shearing on Y axis.
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat3x3<T> shearY2D(
-		detail::tmat3x3<T> const & m, 
-		T x);
-
-	//! Transforms a matrix with a shearing on X axis
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat4x4<T> shearX3D(
-		const detail::tmat4x4<T> & m,
-		T y, 
-		T z);
-		
-	//! Transforms a matrix with a shearing on Y axis.
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat4x4<T> shearY3D(
-		const detail::tmat4x4<T> & m, 
-		T x, 
-		T z);
-		
-	//! Transforms a matrix with a shearing on Z axis. 
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat4x4<T> shearZ3D(
-		const detail::tmat4x4<T> & m, 
-		T x, 
-		T y);
-
-	//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T> shear(const detail::tmat4x4<T> & m, shearPlane, planePoint, angle)
-	// Identity + tan(angle) * cross(Normal, OnPlaneVector)     0
-	// - dot(PointOnPlane, normal) * OnPlaneVector              1
-
-	// Reflect functions seem to don't work
-	//template <typename T> detail::tmat3x3<T> reflect2D(const detail::tmat3x3<T> & m, const detail::tvec3<T>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
-	//template <typename T> detail::tmat4x4<T> reflect3D(const detail::tmat4x4<T> & m, const detail::tvec3<T>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
-		
-	//! Build planar projection matrix along normal axis.
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat3x3<T> proj2D(
-		const detail::tmat3x3<T> & m, 
-		const detail::tvec3<T>& normal);
-				
-	//! Build planar projection matrix along normal axis.
-	//! From GLM_GTX_transform2 extension.
-	template <typename T> 
-	detail::tmat4x4<T> proj3D(
-		const detail::tmat4x4<T> & m, 
-		const detail::tvec3<T>& normal);
-
-	//! Build a scale bias matrix. 
-	//! From GLM_GTX_transform2 extension.
-	template <typename valType> 
-	detail::tmat4x4<valType> scaleBias(
-		valType scale, 
-		valType bias);
-
-	//! Build a scale bias matrix.
-	//! From GLM_GTX_transform2 extension.
-	template <typename valType> 
-	detail::tmat4x4<valType> scaleBias(
-		detail::tmat4x4<valType> const & m, 
-		valType scale, 
-		valType bias);
-
-	/// @}
-}// namespace glm
-
-#include "transform2.inl"
-
-#endif//GLM_GTX_transform2
diff --git a/include/gal/opengl/glm/gtx/transform2.inl b/include/gal/opengl/glm/gtx/transform2.inl
deleted file mode 100644
index 06b65f5283..0000000000
--- a/include/gal/opengl/glm/gtx/transform2.inl
+++ /dev/null
@@ -1,154 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-02-28
-// Updated : 2005-04-23
-// Licence : This source is under MIT License
-// File : glm/gtx/transform2.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> shearX2D(
-		const detail::tmat3x3<T>& m, 
-		T s)
-	{
-		detail::tmat3x3<T> r(1);
-		r[0][1] = s;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> shearY2D(
-		const detail::tmat3x3<T>& m, 
-		T s)
-	{
-		detail::tmat3x3<T> r(1);
-		r[1][0] = s;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> shearX3D(
-		const detail::tmat4x4<T>& m, 
-		T s, 
-		T t)
-	{
-		detail::tmat4x4<T> r(1);
-		r[1][0] = s;
-		r[2][0] = t;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> shearY3D(
-		const detail::tmat4x4<T>& m, 
-		T s, 
-		T t)
-	{
-		detail::tmat4x4<T> r(1);
-		r[0][1] = s;
-		r[2][1] = t;
-		return m * r;
-	}
-
-	template <typename T>     
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> shearZ3D(
-		const detail::tmat4x4<T>& m, 
-		T s, 
-		T t)
-	{
-		detail::tmat4x4<T> r(1);
-		r[0][2] = s;
-		r[1][2] = t;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> reflect2D(
-		const detail::tmat3x3<T>& m, 
-		const detail::tvec3<T>& normal)
-	{
-		detail::tmat3x3<T> r(1);
-		r[0][0] = 1 - 2 * normal.x * normal.x;
-		r[0][1] = -2 * normal.x * normal.y;
-		r[1][0] = -2 * normal.x * normal.y;
-		r[1][1] = 1 - 2 * normal.y * normal.y;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> reflect3D(
-		const detail::tmat4x4<T>& m, 
-		const detail::tvec3<T>& normal)
-	{
-		detail::tmat4x4<T> r(1);
-		r[0][0] = 1 - 2 * normal.x * normal.x;
-		r[0][1] = -2 * normal.x * normal.y;
-		r[0][2] = -2 * normal.x * normal.z;
-
-		r[1][0] = -2 * normal.x * normal.y;
-		r[1][1] = 1 - 2 * normal.y * normal.y;
-		r[1][2] = -2 * normal.y * normal.z;
-
-		r[2][0] = -2 * normal.x * normal.z;
-		r[2][1] = -2 * normal.y * normal.z;
-		r[2][2] = 1 - 2 * normal.z * normal.z;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> proj2D(
-		const detail::tmat3x3<T>& m, 
-		const detail::tvec3<T>& normal)
-	{
-		detail::tmat3x3<T> r(1);
-		r[0][0] = 1 - normal.x * normal.x;
-		r[0][1] = - normal.x * normal.y;
-		r[1][0] = - normal.x * normal.y;
-		r[1][1] = 1 - normal.y * normal.y;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> proj3D(
-		const detail::tmat4x4<T>& m, 
-		const detail::tvec3<T>& normal)
-	{
-		detail::tmat4x4<T> r(1);
-		r[0][0] = 1 - normal.x * normal.x;
-		r[0][1] = - normal.x * normal.y;
-		r[0][2] = - normal.x * normal.z;
-		r[1][0] = - normal.x * normal.y;
-		r[1][1] = 1 - normal.y * normal.y;
-		r[1][2] = - normal.y * normal.z;
-		r[2][0] = - normal.x * normal.z;
-		r[2][1] = - normal.y * normal.z;
-		r[2][2] = 1 - normal.z * normal.z;
-		return m * r;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scaleBias(
-		T scale, 
-		T bias)
-	{
-		detail::tmat4x4<T> result;
-		result[3] = detail::tvec4<T>(detail::tvec3<T>(bias), T(1));
-		result[0][0] = scale;
-		result[1][1] = scale;
-		result[2][2] = scale;
-		return result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scaleBias(
-		const detail::tmat4x4<T>& m, 
-		T scale, 
-		T bias)
-	{
-		return m * scaleBias(scale, bias);
-	}
-}//namespace glm
-
diff --git a/include/gal/opengl/glm/gtx/ulp.hpp b/include/gal/opengl/glm/gtx/ulp.hpp
deleted file mode 100644
index b74f480424..0000000000
--- a/include/gal/opengl/glm/gtx/ulp.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_ulp extension is deprecated, include GLM_GTC_ulp (glm/gtc/ulp.hpp) instead")
-#endif
-
-// Promoted:
-#include "../gtc/ulp.hpp"
diff --git a/include/gal/opengl/glm/gtx/unsigned_int.hpp b/include/gal/opengl/glm/gtx/unsigned_int.hpp
deleted file mode 100644
index 340cfd405d..0000000000
--- a/include/gal/opengl/glm/gtx/unsigned_int.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///////////////////////////////////////////////////////////////////////////////////
-
-#if(defined(GLM_MESSAGES))
-#	pragma message("GLM: GLM_GTX_unsigned_int extension is deprecated, include GLM_GTX_integer instead")
-#endif
diff --git a/include/gal/opengl/glm/gtx/unsigned_int.inl b/include/gal/opengl/glm/gtx/unsigned_int.inl
deleted file mode 100644
index b08a3878a9..0000000000
--- a/include/gal/opengl/glm/gtx/unsigned_int.inl
+++ /dev/null
@@ -1,13 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-24
-// Updated : 2008-10-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/unsigned_int.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/vec1.hpp b/include/gal/opengl/glm/gtx/vec1.hpp
deleted file mode 100644
index 7d37e6de9a..0000000000
--- a/include/gal/opengl/glm/gtx/vec1.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_vec1
-/// @file glm/gtx/vec1.hpp
-/// @date 2010-02-08 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_vec1 GLM_GTX_vec1
-/// @ingroup gtx
-/// 
-/// @brief Add vec1, ivec1, uvec1 and bvec1 types.
-/// <glm/gtx/vec1.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_vec1
-#define GLM_GTX_vec1 GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../core/type_vec1.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_vec1 extension included")
-#endif
-
-namespace glm
-{
-	//! 1 component vector of high precision floating-point numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::highp_vec1_t			highp_vec1;
-	//! 1 component vector of medium precision floating-point numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::mediump_vec1_t			mediump_vec1;
-	//! 1 component vector of low precision floating-point numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::lowp_vec1_t				lowp_vec1;
-
-	//! 1 component vector of high precision signed integer numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::highp_ivec1_t			highp_ivec1;
-	//! 1 component vector of medium precision signed integer numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::mediump_ivec1_t			mediump_ivec1;
-	//! 1 component vector of low precision signed integer numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::lowp_ivec1_t			lowp_ivec1;
-
-	//! 1 component vector of high precision unsigned integer numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::highp_uvec1_t			highp_uvec1;
-	//! 1 component vector of medium precision unsigned integer numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::mediump_uvec1_t			mediump_uvec1;
-	//! 1 component vector of low precision unsigned integer numbers. 
-	//! There is no guarantee on the actual precision.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::lowp_uvec1_t			lowp_uvec1;
-
-	//////////////////////////
-	// vec1 definition
-
-	//! 1 component vector of boolean.
-	//! From GLM_GTX_vec1 extension.
-	typedef detail::tvec1<bool>	bvec1;
-
-#if(defined(GLM_PRECISION_HIGHP_FLOAT))
-	typedef highp_vec1			vec1;
-#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
-	typedef mediump_vec1			vec1;
-#elif(defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef lowp_vec1			vec1;
-#else
-	//! 1 component vector of floating-point numbers.
-	//! From GLM_GTX_vec1 extension.
-	typedef mediump_vec1			vec1;
-#endif//GLM_PRECISION
-
-#if(defined(GLM_PRECISION_HIGHP_INT))
-	typedef highp_ivec1			ivec1;
-#elif(defined(GLM_PRECISION_MEDIUMP_INT))
-	typedef mediump_ivec1		ivec1;
-#elif(defined(GLM_PRECISION_LOWP_INT))
-	typedef lowp_ivec1			ivec1;
-#else
-	//! 1 component vector of signed integer numbers. 
-	//! From GLM_GTX_vec1 extension.
-	typedef mediump_ivec1		ivec1;
-#endif//GLM_PRECISION
-
-#if(defined(GLM_PRECISION_HIGHP_UINT))
-	typedef highp_uvec1			uvec1;
-#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
-	typedef mediump_uvec1		uvec1;
-#elif(defined(GLM_PRECISION_LOWP_UINT))
-	typedef lowp_uvec1			uvec1;
-#else
-	//! 1 component vector of unsigned integer numbers. 
-	//! From GLM_GTX_vec1 extension.
-	typedef mediump_uvec1		uvec1;
-#endif//GLM_PRECISION
-
-}// namespace glm
-
-#include "vec1.inl"
-
-#endif//GLM_GTX_vec1
-
diff --git a/include/gal/opengl/glm/gtx/vec1.inl b/include/gal/opengl/glm/gtx/vec1.inl
deleted file mode 100644
index 782a8ec211..0000000000
--- a/include/gal/opengl/glm/gtx/vec1.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_vec1
-/// @file glm/gtx/vec1.inl
-/// @date 2013-03-16 / 2013-03-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/include/gal/opengl/glm/gtx/vector_access.hpp b/include/gal/opengl/glm/gtx/vector_access.hpp
deleted file mode 100644
index 89426611b9..0000000000
--- a/include/gal/opengl/glm/gtx/vector_access.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_vector_access
-/// @file glm/gtx/vector_access.hpp
-/// @date 2006-01-16 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_vector_access GLM_GTX_vector_access
-/// @ingroup gtx
-/// 
-/// @brief Function to set values to vectors
-/// 
-/// <glm/gtx/vector_access.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_vector_access
-#define GLM_GTX_vector_access GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_vector_access extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_vector_access
-	/// @{
-
-	//! Set values to a 2 components vector.
-	//! From GLM_GTX_vector_access extension.
-    template <typename valType> 
-	void set(
-		detail::tvec2<valType> & v, 
-		valType const & x, 
-		valType const & y);
-
-	//! Set values to a 3 components vector.
-	//! From GLM_GTX_vector_access extension.
-    template <typename valType> 
-	void set(
-		detail::tvec3<valType> & v, 
-		valType const & x, 
-		valType const & y, 
-		valType const & z);
-
-	//! Set values to a 4 components vector.
-	//! From GLM_GTX_vector_access extension.
-    template <typename valType> 
-	void set(
-		detail::tvec4<valType> & v, 
-		valType const & x, 
-		valType const & y, 
-		valType const & z, 
-		valType const & w);
-
-	/// @}
-}//namespace glm
-
-#include "vector_access.inl"
-
-#endif//GLM_GTX_vector_access
diff --git a/include/gal/opengl/glm/gtx/vector_access.inl b/include/gal/opengl/glm/gtx/vector_access.inl
deleted file mode 100644
index b5a5603794..0000000000
--- a/include/gal/opengl/glm/gtx/vector_access.inl
+++ /dev/null
@@ -1,53 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-01-16
-// Updated : 2008-10-07
-// Licence : This source is under MIT License
-// File    : glm/gtx/vector_access.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER void set
-	(
-		detail::tvec2<valType>& v, 
-		valType const & x, 
-		valType const & y
-	)
-	{
-		v.x = x;
-		v.y = y;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER void set
-	(
-		detail::tvec3<valType>& v, 
-		valType const & x, 
-		valType const & y, 
-		valType const & z
-	)
-	{
-		v.x = x;
-		v.y = y;
-		v.z = z;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER void set
-	(
-		detail::tvec4<valType>& v, 
-		valType const & x, 
-		valType const & y, 
-		valType const & z, 
-		valType const & w
-	)
-	{
-		v.x = x;
-		v.y = y;
-		v.z = z;
-		v.w = w;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/vector_angle.hpp b/include/gal/opengl/glm/gtx/vector_angle.hpp
deleted file mode 100644
index fea8f65a81..0000000000
--- a/include/gal/opengl/glm/gtx/vector_angle.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_vector_angle
-/// @file glm/gtx/vector_angle.hpp
-/// @date 2005-12-30 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_quaternion (dependence)
-/// @see gtx_epsilon (dependence)
-///
-/// @defgroup gtx_vector_angle GLM_GTX_vector_angle
-/// @ingroup gtx
-/// 
-/// @brief Compute angle between vectors
-/// 
-/// <glm/gtx/vector_angle.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_vector_angle
-#define GLM_GTX_vector_angle GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/epsilon.hpp"
-#include "../gtx/quaternion.hpp"
-#include "../gtx/rotate_vector.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_vector_angle extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_vector_angle
-	/// @{
-
-	//! Returns the absolute angle between two vectors
-	//! Parameters need to be normalized.
-	//! From GLM_GTX_vector_angle extension
-	template <typename vecType> 
-	GLM_FUNC_QUALIFIER typename vecType::value_type angle(
-		vecType const & x, 
-		vecType const & y);
-
-	//! Returns the oriented angle between two 2d vectors 
-	//! Parameters need to be normalized.
-	//! From GLM_GTX_vector_angle extension.
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T orientedAngle(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y);
-
-	//! Returns the oriented angle between two 3d vectors based from a reference axis.
-	//! Parameters need to be normalized.
-	//! From GLM_GTX_vector_angle extension.
-	template <typename T>
-	GLM_FUNC_QUALIFIER T orientedAngle(
-		detail::tvec3<T> const & x,
-		detail::tvec3<T> const & y,
-		detail::tvec3<T> const & ref);
-
-	/// @}
-}// namespace glm
-
-#include "vector_angle.inl"
-
-#endif//GLM_GTX_vector_angle
diff --git a/include/gal/opengl/glm/gtx/vector_angle.inl b/include/gal/opengl/glm/gtx/vector_angle.inl
deleted file mode 100644
index ad221b15dd..0000000000
--- a/include/gal/opengl/glm/gtx/vector_angle.inl
+++ /dev/null
@@ -1,57 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2005-12-30
-// Updated : 2008-09-29
-// Licence : This source is under MIT License
-// File    : glm/gtx/vector_angle.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER typename genType::value_type angle
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		return degrees(acos(dot(x, y)));
-	}
-
-	//! \todo epsilon is hard coded to 0.01
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER valType orientedAngle
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> const & y
-	)
-	{
-#ifdef GLM_FORCE_RADIANS
-		valType const Angle(acos(dot(x, y)));
-#else
-		valType const Angle(glm::degrees(acos(dot(x, y))));
-#endif
-		detail::tvec2<valType> const TransformedVector(glm::rotate(x, Angle));
-		if(all(epsilonEqual(y, TransformedVector, valType(0.01))))
-			return Angle;
-		else
-			return -Angle;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER valType orientedAngle
-	(
-		detail::tvec3<valType> const & x,
-		detail::tvec3<valType> const & y,
-		detail::tvec3<valType> const & ref
-	)
-	{
-		valType const Angle(glm::degrees(glm::acos(glm::dot(x, y))));
-
-		if(glm::dot(ref, glm::cross(x, y)) < valType(0))
-			return -Angle;
-		else
-			return Angle;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/vector_query.hpp b/include/gal/opengl/glm/gtx/vector_query.hpp
deleted file mode 100644
index f49f9e9991..0000000000
--- a/include/gal/opengl/glm/gtx/vector_query.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_vector_query
-/// @file glm/gtx/vector_query.hpp
-/// @date 2008-03-10 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_vector_query GLM_GTX_vector_query
-/// @ingroup gtx
-/// 
-/// @brief Query informations of vector types
-///
-/// <glm/gtx/vector_query.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_vector_query
-#define GLM_GTX_vector_query GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include <cfloat>
-#include <limits>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_vector_query extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_vector_query
-	/// @{
-
-	//! Check whether two vectors are collinears.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename genType> 
-	bool areCollinear(
-		genType const & v0, 
-		genType const & v1, 
-		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-		
-    //! Check whether two vectors are orthogonals.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename genType> 
-	bool areOrthogonal(
-		genType const & v0, 
-		genType const & v1, 
-		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-
-	//! Check whether a vector is normalized.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename genType, template <typename> class vecType> 
-	bool isNormalized(
-		vecType<genType> const & v, 
-		genType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
-		
-	//! Check whether a vector is null.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename valType> 
-	bool isNull(
-		detail::tvec2<valType> const & v, 
-		valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-
-	//! Check whether a vector is null.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename valType> 
-	bool isNull(
-		detail::tvec3<valType> const & v, 
-		valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-
-	//! Check whether a vector is null.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename valType> 
-	bool isNull(
-		detail::tvec4<valType> const & v, 
-		valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-
-	//! Check whether two vectors are orthonormal.
-	//! From GLM_GTX_vector_query extensions.
-	template <typename genType>
-	bool areOrthonormal(
-		genType const & v0, 
-		genType const & v1, 
-		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
-
-	/// @}
-}// namespace glm
-
-#include "vector_query.inl"
-
-#endif//GLM_GTX_vector_query
diff --git a/include/gal/opengl/glm/gtx/vector_query.inl b/include/gal/opengl/glm/gtx/vector_query.inl
deleted file mode 100644
index c955315354..0000000000
--- a/include/gal/opengl/glm/gtx/vector_query.inl
+++ /dev/null
@@ -1,164 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-03-05
-// Updated : 2010-02-16
-// Licence : This source is under MIT License
-// File    : glm/gtx/vector_query.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Dependency:
-// - GLM core
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include <cassert>
-
-namespace glm
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER bool areCollinear
-	(
-		detail::tvec2<T> const & v0, 
-		detail::tvec2<T> const & v1, 
-		typename detail::tvec2<T>::value_type const & epsilon
-	)
-	{
-		return length(cross(detail::tvec3<T>(v0, T(0)), detail::tvec3<T>(v1, T(0)))) < epsilon;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER bool areCollinear
-	(
-		detail::tvec3<T> const & v0, 
-		detail::tvec3<T> const & v1, 
-		typename detail::tvec3<T>::value_type const & epsilon
-	)
-	{
-		return length(cross(v0, v1)) < epsilon;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER bool areCollinear
-	(
-		detail::tvec4<T> const & v0, 
-		detail::tvec4<T> const & v1, 
-		typename detail::tvec4<T>::value_type const & epsilon
-	)
-	{
-		return length(cross(detail::tvec3<T>(v0), detail::tvec3<T>(v1))) < epsilon;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool areOrthogonal
-	(
-		genType const & v0, 
-		genType const & v1, 
-		typename genType::value_type const & epsilon
-	)
-	{
-		return abs(dot(v0, v1)) <= max(
-			typename genType::value_type(1), 
-			length(v0)) * max(
-				typename genType::value_type(1), 
-				length(v1)) * epsilon;
-	}
-
-	template <typename genType, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER bool isNormalized
-	(
-		vecType<genType> const & v, 
-		genType const & epsilon
-	)
-	{
-		return abs(length(v) - genType(1)) <= genType(2) * epsilon;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER bool isNull
-	(
-		detail::tvec2<valType> const & v, 
-		valType const & epsilon
-	)
-	{
-		return length(v) <= epsilon;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER bool isNull
-	(
-		detail::tvec3<valType> const & v, 
-		valType const & epsilon
-	)
-	{
-		return length(v) <= epsilon;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER bool isNull
-	(
-		detail::tvec4<valType> const & v, 
-		valType const & epsilon
-	)
-	{
-		return length(v) <= epsilon;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool isCompNull
-	(
-		T const & s, 
-		T const & epsilon
-	)
-	{
-		return abs(s) < epsilon;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> isCompNull
-	(
-		detail::tvec2<T> const & v, 
-		T const & epsilon)
-	{
-		return detail::tvec2<bool>(
-			(abs(v.x) < epsilon),
-			(abs(v.y) < epsilon));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> isCompNull
-	(
-		detail::tvec3<T> const & v, 
-		T const & epsilon
-	)
-	{
-		return detail::tvec3<bool>(
-			abs(v.x) < epsilon,
-			abs(v.y) < epsilon,
-			abs(v.z) < epsilon);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> isCompNull
-	(
-		detail::tvec4<T> const & v, 
-		T const & epsilon
-	)
-	{
-		return detail::tvec4<bool>(
-			abs(v.x) < epsilon,
-			abs(v.y) < epsilon,
-			abs(v.z) < epsilon,
-			abs(v.w) < epsilon);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER bool areOrthonormal
-	(
-		genType const & v0, 
-		genType const & v1, 
-		typename genType::value_type const & epsilon
-	)
-	{
-		return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon);
-	}
-
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/verbose_operator.hpp b/include/gal/opengl/glm/gtx/verbose_operator.hpp
deleted file mode 100644
index 0a2f0e3160..0000000000
--- a/include/gal/opengl/glm/gtx/verbose_operator.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_verbose_operator
-/// @file glm/gtx/verbose_operator.hpp
-/// @date 2007-05-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_verbose_operator GLM_GTX_verbose_operator
-/// @ingroup gtx
-/// 
-/// @brief Use words to replace operators
-///
-/// <glm/gtx/verbose_operator.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_verbose_operator
-#define GLM_GTX_verbose_operator GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_verbose_operator extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_verbose_operator
-	/// @{
-
-	//! Addition of two values
-	//! From GLM_GTX_verbose_operator extension.
-	template <typename genTypeT, typename genTypeU> 
-	genTypeT add(genTypeT const & a, genTypeU const & b);
-
-	//! Substration of two values
-	//! From GLM_GTX_verbose_operator extension.
-	template <typename genTypeT, typename genTypeU> 
-	genTypeT sub(genTypeT const & a, genTypeU const & b);
-
-	//! Multiplication of two values
-	//! From GLM_GTX_verbose_operator extension.
-	template <typename genTypeT, typename genTypeU> 
-	genTypeT mul(genTypeT const & a, genTypeU const & b);
-
-	//! Division of two values
-	//! From GLM_GTX_verbose_operator extension.
-	template <typename genTypeT, typename genTypeU> 
-	genTypeT div(genTypeT const & a, genTypeU const & b);
-
-	//! Multiplication and addition of three values
-	//! From GLM_GTX_verbose_operator extension.
-	template <typename genTypeT, typename genTypeU, typename genTypeV> 
-	genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
-
-	/// @}
-}// namespace glm
-
-#include "verbose_operator.inl"
-
-#endif//GLM_GTX_verbose_operator
diff --git a/include/gal/opengl/glm/gtx/verbose_operator.inl b/include/gal/opengl/glm/gtx/verbose_operator.inl
deleted file mode 100644
index 468bdd4ee5..0000000000
--- a/include/gal/opengl/glm/gtx/verbose_operator.inl
+++ /dev/null
@@ -1,124 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2006-04-20
-// Updated : 2008-09-29
-// Licence : This source is under MIT License
-// File    : glm/gtx/verbose_operator.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType add(genType const & a, genType const & b)
-	{
-		return a + b;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sub(genType const & a, genType const & b)
-	{
-		return a - b;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> mul
-	(
-		detail::tmat2x2<T> const & a, 
-		detail::tmat2x2<T> const & b
-	)
-	{
-		return a * b;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> mul
-	(
-		detail::tmat3x3<T> const & a, 
-		detail::tmat3x3<T> const & b
-	)
-	{
-		return a * b;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> mul
-	(
-		detail::tmat4x4<T> const & a, 
-		detail::tmat4x4<T> const & b
-	)
-	{
-		return a * b;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> mul
-	(
-		detail::tmat2x2<T> const & m, 
-		detail::tvec2<T> const & v
-	)
-	{
-		return m * v;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> mul
-	(
-		detail::tmat3x3<T> const & m, 
-		detail::tvec3<T> const & v)
-	{
-		return m * v;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> mul
-	(
-		detail::tmat4x4<T> const & m, 
-		detail::tvec4<T> const & v
-	)
-	{
-		return m * v;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> mul
-	(
-		detail::tvec2<T> const & v, 
-		detail::tmat2x2<T> const & m
-	)
-	{
-		return v * m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> mul
-	(
-		detail::tvec3<T> const & v, 
-		detail::tmat3x3<T> const & m
-	)
-	{
-		return v * m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> mul
-	(
-		detail::tvec4<T> const & v, 
-		detail::tmat4x4<T> const & m
-	)
-	{
-		return v * m;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType div(genType const & a, genType const & b)
-	{
-		return a / b;
-	}
-
-	template <typename genTypeT, typename genTypeU, typename genTypeV> 
-	GLM_FUNC_QUALIFIER genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c)
-	{
-		return a * b + c;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/gtx/wrap.hpp b/include/gal/opengl/glm/gtx/wrap.hpp
deleted file mode 100644
index a67132735b..0000000000
--- a/include/gal/opengl/glm/gtx/wrap.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref gtx_wrap
-/// @file glm/gtx/wrap.hpp
-/// @date 2009-11-25 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtx_wrap GLM_GTX_wrap
-/// @ingroup gtx
-/// 
-/// @brief Wrapping mode of texture coordinates.
-/// 
-/// <glm/gtx/wrap.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_wrap
-#define GLM_GTX_wrap GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_wrap extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_wrap
-	/// @{
-
-	//! Simulate GL_CLAMP OpenGL wrap mode
-	//! From GLM_GTX_wrap extension.
-	template <typename genType> 
-	genType clamp(genType const & Texcoord);
-
-	//! Simulate GL_REPEAT OpenGL wrap mode
-	//! From GLM_GTX_wrap extension.
-	template <typename genType> 
-	genType repeat(genType const & Texcoord);
-
-	//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
-	//! From GLM_GTX_wrap extension.
-	template <typename genType> 
-	genType mirrorRepeat(genType const & Texcoord);
-
-	/// @}
-}// namespace glm
-
-#include "wrap.inl"
-
-#endif//GLM_GTX_wrap
diff --git a/include/gal/opengl/glm/gtx/wrap.inl b/include/gal/opengl/glm/gtx/wrap.inl
deleted file mode 100644
index 41c7d476d6..0000000000
--- a/include/gal/opengl/glm/gtx/wrap.inl
+++ /dev/null
@@ -1,165 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2009-11-25
-// Updated : 2010-02-13
-// Licence : This source is under MIT License
-// File    : glm/gtx/wrap.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Dependency:
-// - GLM core
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType clamp
-	(
-		genType const & Texcoord
-	)
-	{
-		return glm::clamp(Texcoord, genType(0), genType(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
-	(
-		detail::tvec2<T> const & Texcoord
-	)
-	{
-		detail::tvec2<T> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = clamp(Texcoord[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
-	(
-		detail::tvec3<T> const & Texcoord
-	)
-	{
-		detail::tvec3<T> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = clamp(Texcoord[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
-	(
-		detail::tvec4<T> const & Texcoord
-	)
-	{
-		detail::tvec4<T> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = clamp(Texcoord[i]);
-		return Result;
-	}
-
-	////////////////////////
-	// repeat
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType repeat
-	(
-		genType const & Texcoord
-	)
-	{
-		return glm::fract(Texcoord);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> repeat
-	(
-		detail::tvec2<T> const & Texcoord
-	)
-	{
-		detail::tvec2<T> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = repeat(Texcoord[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> repeat
-	(
-		detail::tvec3<T> const & Texcoord
-	)
-	{
-		detail::tvec3<T> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = repeat(Texcoord[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> repeat
-	(
-		detail::tvec4<T> const & Texcoord
-	)
-	{
-		detail::tvec4<T> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = repeat(Texcoord[i]);
-		return Result;
-	}
-
-	////////////////////////
-	// mirrorRepeat
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType mirrorRepeat
-	(
-		genType const & Texcoord
-	)
-	{
-		genType const Clamp = genType(int(glm::floor(Texcoord)) % 2);
-		genType const Floor = glm::floor(Texcoord);
-		genType const Rest = Texcoord - Floor;
-		genType const Mirror = Clamp + Rest;
-
-		genType Out;
-		if(Mirror >= genType(1))
-			Out = genType(1) - Rest;
-		else
-			Out = Rest;
-		return Out;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> mirrorRepeat
-	(
-		detail::tvec2<T> const & Texcoord
-	)
-	{
-		detail::tvec2<T> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = mirrorRepeat(Texcoord[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> mirrorRepeat
-	(
-		detail::tvec3<T> const & Texcoord
-	)
-	{
-		detail::tvec3<T> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = mirrorRepeat(Texcoord[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> mirrorRepeat
-	(
-		detail::tvec4<T> const & Texcoord
-	)
-	{
-		detail::tvec4<T> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = mirrorRepeat(Texcoord[i]);
-		return Result;
-	}
-}//namespace glm
diff --git a/include/gal/opengl/glm/virtrev/xstream.hpp b/include/gal/opengl/glm/virtrev/xstream.hpp
deleted file mode 100644
index 3be1f98a8c..0000000000
--- a/include/gal/opengl/glm/virtrev/xstream.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref virtrev_xstream
-/// @file glm/virtrev/xstream.hpp
-/// @date 2008-05-24 / 2008-05-26
-/// @author Mathieu Roumillac (matrem84.free.fr)
-///
-/// @see core (dependence)
-/// @see gtc_matrix_access (dependence)
-///
-/// @defgroup virtrev_xstream GLM_VIRTREV_xstream: xml like output
-/// @ingroup virtrev
-/// 
-/// @brief Streaming vector and matrix in a xml way.
-/// 
-/// Include <glm/virtrev/xstream.hpp> for this functionality.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_VIRTREV_xstream
-#define GLM_VIRTREV_xstream GLM_VERSION
-
-#include "../glm.hpp"
-#include "../gtc/matrix_access.hpp"
-#include <iostream>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_VIRTREV_xstream extension included")
-#endif
-/*
-namespace glm{
-namespace detail
-{
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tvec2<T> const & vec)
-	{
-		stream << "<glm_vec2 ";
-		stream << "x=\"" << vec.x << "\" ";
-		stream << "y=\"" << vec.y << "\" ";
-		stream << "/>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tvec3<T> const & vec)
-	{
-		stream << "<glm_vec3 ";
-		stream << "x=\"" << vec.x << "\" ";
-		stream << "y=\"" << vec.y << "\" ";
-		stream << "z=\"" << vec.z << "\" ";
-		stream << "/>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tvec4<T> const & vec)
-	{
-		stream << "<glm_vec4 ";
-		stream << "x=\"" << vec.x << "\" ";
-		stream << "y=\"" << vec.y << "\" ";
-		stream << "z=\"" << vec.z << "\" ";
-		stream << "w=\"" << vec.w << "\" ";
-		stream << "/>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tmat2x2<T> const & mat)
-	{
-		stream << "<glm_mat2>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "</glm_mat2>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tmat3x3<T> const & mat)
-	{
-		stream << "<glm_mat3>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 0)[2] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 1)[2] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 2)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 2)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 2)[2] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "</glm_mat3>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tmat4x4<T> const & mat)
-	{
-		stream << "<glm_mat4>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 0)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 0)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 1)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 1)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 2)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 2)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 2)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 2)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 3)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 3)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 3)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 3)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "</glm_mat4>";
-			
-		return stream;
-	}
-
-}//namespace detail
-}//namespace glm
-*/
-#endif//GLM_VIRTREV_xstream
diff --git a/include/gal/opengl/vertex_manager.h b/include/gal/opengl/vertex_manager.h
index 56c84a6beb..fe6c5e6433 100644
--- a/include/gal/opengl/vertex_manager.h
+++ b/include/gal/opengl/vertex_manager.h
@@ -32,8 +32,8 @@
 #define VERTEX_MANAGER_H_
 
 #define GLM_FORCE_RADIANS
-#include <gal/opengl/glm/gtc/matrix_transform.hpp>
-#include <gal/opengl/glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/glm.hpp>
 #include <gal/opengl/vertex_common.h>
 #include <gal/color4d.h>
 #include <stack>
diff --git a/include/plugins/3d/3d_plugin.h b/include/plugins/3d/3d_plugin.h
new file mode 100644
index 0000000000..abd00d293d
--- /dev/null
+++ b/include/plugins/3d/3d_plugin.h
@@ -0,0 +1,98 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_plugin.h
+ * describes the runtime-loadable interface to support loading
+ * and parsing of 3D models.
+ */
+
+#ifndef PLUGIN_3D_H
+#define PLUGIN_3D_H
+
+#include <wx/string.h>
+
+class SCENEGRAPH;
+
+class S3D_PLUGIN
+{
+public:
+    virtual ~S3D_PLUGIN()
+    {
+        return;
+    }
+
+    /**
+     * Function GetNExtensions
+     *
+     * @return the number of extensions supported by the plugin
+     */
+    virtual int GetNExtensions( void ) const = 0;
+
+    /**
+     * Function GetModelExtension
+     *
+     * @param aIndex is the extension to return; valid values are
+     * 0 to GetNExtensions() - 1.
+     * @return the requested extension or a null string if aIndex
+     * was invalid.
+     */
+    virtual const wxString GetModelExtension( int aIndex ) const = 0;
+
+    /**
+     * Function GetNFilters
+     * @returns the number of file filters
+     */
+    virtual int GetNFilters( void ) const = 0;
+
+    /**
+     * Function GetFileFilter
+     *
+     * @return the file filter string for the given index
+     */
+    virtual const wxString GetFileFilter( int aIndex ) const = 0;
+
+    /**
+     * Function CanRender
+     *
+     * @return true if the plugin can render a model, that is
+     * the Load() function is implemented
+     */
+    virtual bool CanRender( void ) const = 0;
+
+    /**
+     * Function Load
+     * reads the model file and creates a generic display structure
+     *
+     * @param aFileName is the full path of the model file
+     * @param aModel is a handle to a null pointer; on successful
+     * reading of the model data aModel will point to a representation
+     * for rendering
+     * @param returns true if the model was successfully loaded and false
+     * if there is no rendering support for the model or there were
+     * problems reading the model
+     */
+    virtual SCENEGRAPH* Load( const wxString& aFileName ) = 0;
+};
+
+#endif  // PLUGIN_3D_H
diff --git a/include/plugins/README b/include/plugins/README
new file mode 100644
index 0000000000..fc6a89ea94
--- /dev/null
+++ b/include/plugins/README
@@ -0,0 +1,61 @@
+This directory will contain headers for the various types of
+KiCad dynamic plugins and associated APIs.
+
+In a typical implementation a dynamic plugin will provide a simple interface to
+provide KiCad with a list of functions which can be invoked to provide the
+desired feature. For example the 3D plugins provide a function to list the
+file types supported by the plugin, the associated filters required for browsing
+files, and a Load() function to process a 3D file and return a data structure
+which KiCad can use in the 3D rendering process. The set of functions provided
+by a plugin shall be referred to here as the Plugin Interface. Every plugin
+must be a derived class of at least one type of plugin declared in the header
+files in this directory. All implementations of a plugin interface constitute
+an actual plugin; the various KiCad tools such as pcbnew and eeschema contain
+no actual implementation of the plugin interface.
+
+Plugins also need to interact with KiCad and its internal data while knowing
+essentially nothing of the complex structures within KiCad. To make this possible
+each type of dynamic plugin must interact with at least one type of API which
+provides functions to create, inspect, and manipulate the complex data structures
+within KiCad. These APIs shall be declared in the api subdirectory and must be
+implemented within each KiCad tool which services the related plugin type. For
+example the 3D plugins must produce the intermediate scene graph data for use
+by the 3D renderer; to accomplish this an API is required to provide each 3D
+plugin with a method for creating the data structures required by pcbnew and
+cvpcb. In the implementation detail the API may be implemented once in the common
+static library of pcbnew or it can be implemented as a runtime shared library
+which can then be linked to by pcbnew. cvpcb, or even eeschema.
+
+Plugin specialization: To keep APIs and plugin interfaces as simple as possible
+it is necessary for plugins to be specialized (have different types). While it
+is possible to define only one plugin interface and one API for any and all
+plugins to use, this would result in a very large API which is difficult to
+maintain. Having specialized plugins and APIs ensures better maintainability
+of the code; a specific plugin may implement multiple plugin interfaces or
+interact with multiple APIs if it makes sense to do so. At least two plugin
+interfaces have been identified for implementation at this point: the 3D
+Plugin Interface and the PCBExport interface. The 3D Plugin Interface shall
+provide a method for processing supported 3D model types and returning an
+intermediate scene graph representation which a renderer can use to create a
+visual representation of the model. The PCBExport interface shall provide a
+means of exporting PCB data to a variety of formats such as Specctra DSN for
+the consumption of autorouters, GenCAD, VRML for visualization of the board
+using external tools, and IDF and IGES for interacting with mechanical designers
+and MCAD software. Other exporters such as netlist exporters or even BoM
+exporters should be possible. A PCBImport Interface is also a possibility but
+is currently a low priority item since there are currently only two import
+functions implemented (Specctra result import and DXF import) and a significant
+amount of work is required to implement the PCBImport API.
+
+Plugin management: Since plugins are specialized, each type should also be
+loaded and managed by a specialized plugin manager which has responsibilities
+for ensuring integration of the plugin with KiCad.  For example the
+3d_plugin_manager searches a list of paths to identify and load plugins which
+implement the 3D Plugin Interface. The 3D manager extracts information from
+each 3D plugin such as the types of 3D formats supported and the associated
+file extensions; the manager also responds to a Load() request by activating
+the appropriate 3D plugin and executing that plugin's Load() function. In the
+case of the Export Plugin Interface, a specific exporter would enumerate the
+plugins, add a menu item to the File->Export list, load and invoke a plugin's
+Export() function at the user's request, and unload the plugin when the
+Export() function completes.
diff --git a/include/project.h b/include/project.h
index 5e5898f489..a6a31c4e4e 100644
--- a/include/project.h
+++ b/include/project.h
@@ -37,6 +37,7 @@ class PARAM_CFG_ARRAY;
 class FP_LIB_TABLE;
 class PART_LIBS;
 class SEARCH_STACK;
+class S3D_CACHE;
 
 #define VTBL_ENTRY      virtual
 
@@ -154,6 +155,7 @@ public:
         SCH_LIBEDIT_CUR_PART,        // eeschema/libeditframe.cpp
 
         VIEWER_3D_PATH,
+        VIEWER_3D_FILTER_INDEX,
 
         PCB_LIB_NICKNAME,
         PCB_FOOTPRINT,
@@ -189,6 +191,7 @@ public:
 
         ELEM_SCH_PART_LIBS,
         ELEM_SCH_SEARCH_STACK,
+        ELEM_3DCACHE,
 
         ELEM_COUNT
     };
@@ -248,6 +251,15 @@ public:
 #if defined(PCBNEW) || defined(CVPCB)
     // These are all prefaced with "Pcb"
     FP_LIB_TABLE* PcbFootprintLibs();
+
+    /**
+     * Function Get3DCacheManager
+     * returns a pointer to an instance of the 3D cache manager;
+     * an instance is created and initialized if appropriate.
+     *
+     * @return a pointer to an instance of the 3D cache manager or NULL on failure
+     */
+    S3D_CACHE* Get3DCacheManager( bool updateProjDir = false );
 #endif
 
 
diff --git a/pcbnew/CMakeLists.txt b/pcbnew/CMakeLists.txt
index 12490691be..ff99a93764 100644
--- a/pcbnew/CMakeLists.txt
+++ b/pcbnew/CMakeLists.txt
@@ -43,6 +43,7 @@ include_directories(
     ../lib_dxf
     ./import_dxf
     ../utils/idftools
+    ${GLM_INCLUDE_DIR}
     ${INC_AFTER}
     )
 
diff --git a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.cpp b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.cpp
index e5fad8ccbd..eaa1ca775a 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.cpp
+++ b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.cpp
@@ -40,6 +40,7 @@
 #include <3d_viewer.h>
 #include <wxPcbStruct.h>
 #include <base_units.h>
+#include <project.h>
 
 #include <class_module.h>
 #include <class_text_mod.h>
@@ -47,6 +48,8 @@
 
 #include <dialog_edit_module_for_BoardEditor.h>
 #include <wildcards_and_files_ext.h>
+#include <3d_cache/dialogs/panel_prev_model.h>
+#include <3d_cache/dialogs/3d_cache_dialogs.h>
 
 size_t DIALOG_MODULE_BOARD_EDITOR::m_page = 0;     // remember the last open page during session
 
@@ -65,14 +68,19 @@ DIALOG_MODULE_BOARD_EDITOR::DIALOG_MODULE_BOARD_EDITOR( PCB_EDIT_FRAME*  aParent
     icon.CopyFromBitmap( KiBitmap( icon_modedit_xpm ) );
     SetIcon( icon );
 
+    m_PreviewPane = new PANEL_PREV_3D( m_Panel3D, false );
+    m_PreviewPane->SetModelManager( Prj().Get3DCacheManager() );
+    bLowerSizer3D->Add( m_PreviewPane, 1, wxEXPAND, 5 );
+
     InitModeditProperties();
     InitBoardProperties();
 
     m_NoteBook->SetSelection( m_page );
-
     m_sdbSizerStdButtonsOK->SetDefault();
+
     GetSizer()->SetSizeHints( this );
     Centre();
+    Layout();
 }
 
 
@@ -88,9 +96,6 @@ DIALOG_MODULE_BOARD_EDITOR::~DIALOG_MODULE_BOARD_EDITOR()
 
     delete m_ReferenceCopy;
     delete m_ValueCopy;
-    delete m_3D_Scale;
-    delete m_3D_Offset;
-    delete m_3D_Rotation;
 }
 
 
@@ -250,7 +255,6 @@ void DIALOG_MODULE_BOARD_EDITOR::InitModeditProperties()
 #ifdef __WINDOWS__
     default_path.Replace( wxT( "/" ), wxT( "\\" ) );
 #endif
-    m_textCtrl3DDefaultPath->SetValue( default_path );
 
     m_LastSelected3DShapeIndex = -1;
 
@@ -327,11 +331,6 @@ void DIALOG_MODULE_BOARD_EDITOR::InitModeditProperties()
 
     m_CostRot180Ctrl->SetValue( m_CurrentModule->GetPlacementCost180() );
 
-    // Initialize 3D parameters
-    m_3D_Scale = new S3DPOINT_VALUE_CTRL( m_Panel3D, m_bSizerShapeScale );
-    m_3D_Offset = new S3DPOINT_VALUE_CTRL( m_Panel3D, m_bSizerShapeOffset );
-    m_3D_Rotation = new S3DPOINT_VALUE_CTRL( m_Panel3D, m_bSizerShapeRotation );
-
     // if m_3D_ShapeNameListBox is not empty, preselect first 3D shape
     if( m_3D_ShapeNameListBox->GetCount() > 0 )
     {
@@ -351,19 +350,26 @@ void DIALOG_MODULE_BOARD_EDITOR::InitModeditProperties()
 void DIALOG_MODULE_BOARD_EDITOR::Transfert3DValuesToDisplay(
     S3D_MASTER* aStruct3DSource )
 {
+    S3D_INFO params;
+
     if( aStruct3DSource )
     {
-        m_3D_Scale->SetValue( aStruct3DSource->m_MatScale );
+        params.filename = aStruct3DSource->GetShape3DName();
+        params.scale.x = aStruct3DSource->m_MatScale.x;
+        params.scale.y = aStruct3DSource->m_MatScale.y;
+        params.scale.z = aStruct3DSource->m_MatScale.z;
 
-        m_3D_Offset->SetValue( aStruct3DSource->m_MatPosition );
+        params.offset.x = aStruct3DSource->m_MatPosition.x;
+        params.offset.y = aStruct3DSource->m_MatPosition.y;
+        params.offset.z = aStruct3DSource->m_MatPosition.z;
 
-        m_3D_Rotation->SetValue( aStruct3DSource->m_MatRotation );
-    }
-    else
-    {
-        S3DPOINT dummy_vertex( 1.0, 1.0, 1.0 );
-        m_3D_Scale->SetValue( dummy_vertex );
+        params.rotation.x = aStruct3DSource->m_MatRotation.x;
+        params.rotation.y = aStruct3DSource->m_MatRotation.y;
+        params.rotation.z = aStruct3DSource->m_MatRotation.z;
     }
+
+    m_PreviewPane->SetModelData( &params );
+    return;
 }
 
 
@@ -377,9 +383,22 @@ void DIALOG_MODULE_BOARD_EDITOR::TransfertDisplayTo3DValues(
         return;
 
     S3D_MASTER* struct3DDest = m_Shapes3D_list[aIndexSelection];
-    struct3DDest->m_MatScale    = m_3D_Scale->GetValue();
-    struct3DDest->m_MatRotation = m_3D_Rotation->GetValue();
-    struct3DDest->m_MatPosition = m_3D_Offset->GetValue();
+    S3D_INFO params;
+    m_PreviewPane->GetModelData( &params );
+
+    struct3DDest->m_MatScale.x = params.scale.x;
+    struct3DDest->m_MatScale.y = params.scale.y;
+    struct3DDest->m_MatScale.z = params.scale.z;
+
+    struct3DDest->m_MatRotation.x = params.rotation.x;
+    struct3DDest->m_MatRotation.y = params.rotation.y;
+    struct3DDest->m_MatRotation.z = params.rotation.z;
+
+    struct3DDest->m_MatPosition.x = params.offset.x;
+    struct3DDest->m_MatPosition.y = params.offset.y;
+    struct3DDest->m_MatPosition.z = params.offset.z;
+
+    return;
 }
 
 
@@ -421,13 +440,20 @@ void DIALOG_MODULE_BOARD_EDITOR::Remove3DShape( wxCommandEvent& event )
         Transfert3DValuesToDisplay( NULL );
     else
     {
-        m_LastSelected3DShapeIndex = 0;
+        if( ii > 0 )
+            m_LastSelected3DShapeIndex = ii - 1;
+        else
+            m_LastSelected3DShapeIndex = 0;
+
         m_3D_ShapeNameListBox->SetSelection( m_LastSelected3DShapeIndex );
         Transfert3DValuesToDisplay(
             m_Shapes3D_list[m_LastSelected3DShapeIndex] );
     }
+
+    return;
 }
 
+
 void DIALOG_MODULE_BOARD_EDITOR::Edit3DShapeFileName()
 {
     int idx = m_3D_ShapeNameListBox->GetSelection();
@@ -456,82 +482,65 @@ void DIALOG_MODULE_BOARD_EDITOR::Edit3DShapeFileName()
     new3DShape->SetShape3DName( filename );
     delete m_Shapes3D_list[idx];
     m_Shapes3D_list[idx] = new3DShape;
+
+    return;
 }
 
 
 void DIALOG_MODULE_BOARD_EDITOR::BrowseAndAdd3DShapeFile()
 {
     PROJECT&        prj = Prj();
-
-    // here, the KISYS3DMOD default path for 3D shape files is expected
-    // to be already defined (when starting Pcbnew, it is defined
-    // from the user defined env variable, or set to a default value)
-    wxFileName fn( wxGetenv( KISYS3DMOD ), wxEmptyString );
-    wxString default3DPath = fn.GetPathWithSep();
+    S3D_INFO model;
 
     wxString initialpath = prj.GetRString( PROJECT::VIEWER_3D_PATH );
+    wxString sidx = prj.GetRString( PROJECT::VIEWER_3D_FILTER_INDEX );
+    int filter = 0;
 
-    if( !initialpath )
-        initialpath = default3DPath;
-
-    wxString    fileFilters = wxGetTranslation( Shapes3DFileWildcard );
-
-    fileFilters += wxChar( '|' );
-    fileFilters += wxGetTranslation( IDF3DFileWildcard );
-
-    wxString filename = EDA_FILE_SELECTOR( _( "3D Shape:" ), initialpath,
-                                           wxEmptyString, wxEmptyString,
-                                           fileFilters, this, wxFD_OPEN, true );
-
-    if( filename.IsEmpty() )
-        return;
-
-    fn = filename;
-
-    prj.SetRString( PROJECT::VIEWER_3D_PATH, fn.GetPath() );
-
-    /* If the file path is already in the 3D shape file default path
-     * just add the file name relative to this path to the list.
-     * Otherwise, add the file name with a full or relative path.
-     * The relative path, when possible, is preferable
-     * because it preserve use of default path, when the path is a sub path of this path
-     */
-    wxString rootpath = filename.SubString( 0, default3DPath.Length()-1 );
-    bool useRelPath = rootpath.IsSameAs( default3DPath, wxFileName::IsCaseSensitive() );
-
-    if( useRelPath )
-        fn.MakeRelativeTo( default3DPath );
-    else    // Absolute path given, not a subpath of the default path,
-            // therefore ask if the user wants a relative (to the default path) one
+    if( !sidx.empty() )
     {
-        wxString msg;
-        msg.Printf( _( "Use a path relative to '%s'?" ), GetChars( default3DPath ) );
-        int diag = wxMessageBox( msg, _( "Path type" ),
-                                 wxYES_NO | wxICON_QUESTION, this );
+        long tmp;
+        sidx.ToLong( &tmp );
 
-        if( diag == wxYES )     // Make it relative to the default 3D path
-            fn.MakeRelativeTo( default3DPath );
+        if( tmp > 0 && tmp <= 0x7FFFFFFF )
+            filter = (int) tmp;
     }
 
-    filename = fn.GetFullPath();
+    if( !S3D::Select3DModel( this, Prj().Get3DCacheManager(),
+        initialpath, filter, &model ) )
+    {
+        return;
+    }
+
+    prj.SetRString( PROJECT::VIEWER_3D_PATH, initialpath );
+    sidx = wxString::Format( wxT( "%i" ), filter );
+    prj.SetRString( PROJECT::VIEWER_3D_FILTER_INDEX, sidx );
 
     S3D_MASTER* new3DShape = new S3D_MASTER( NULL );
 
 #ifdef __WINDOWS__
     // In Kicad files, filenames and paths are stored using Unix notation
-    filename.Replace( wxT( "\\" ), wxT( "/" ) );
+    model.filename.Replace( wxT( "\\" ), wxT( "/" ) );
 #endif
 
-    new3DShape->SetShape3DName( filename );
-    m_Shapes3D_list.push_back( new3DShape );
-    m_3D_ShapeNameListBox->Append( filename );
+    new3DShape->SetShape3DName( model.filename );
+    new3DShape->m_MatScale.x = model.scale.x;
+    new3DShape->m_MatScale.y = model.scale.y;
+    new3DShape->m_MatScale.z = model.scale.z;
+    new3DShape->m_MatRotation.x = model.rotation.x;
+    new3DShape->m_MatRotation.y = model.rotation.y;
+    new3DShape->m_MatRotation.z = model.rotation.z;
+    new3DShape->m_MatPosition.x = model.offset.x;
+    new3DShape->m_MatPosition.y = model.offset.y;
+    new3DShape->m_MatPosition.z = model.offset.z;
 
-    if( m_LastSelected3DShapeIndex >= 0 )
-        TransfertDisplayTo3DValues( m_LastSelected3DShapeIndex );
+    m_Shapes3D_list.push_back( new3DShape );
+    m_3D_ShapeNameListBox->Append( model.filename );
 
     m_LastSelected3DShapeIndex = m_3D_ShapeNameListBox->GetCount() - 1;
     m_3D_ShapeNameListBox->SetSelection( m_LastSelected3DShapeIndex );
     Transfert3DValuesToDisplay( m_Shapes3D_list[m_LastSelected3DShapeIndex] );
+
+    return;
 }
 
 
diff --git a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.h b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.h
index ae299c9d7a..1a8c7282e8 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.h
+++ b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor.h
@@ -23,21 +23,22 @@
  */
 
 #include <dialog_edit_module_for_BoardEditor_base.h>
+#include <3d_struct.h>
+
+class PANEL_PREV_3D;
 
 class DIALOG_MODULE_BOARD_EDITOR: public DIALOG_MODULE_BOARD_EDITOR_BASE
 {
 private:
-    PCB_EDIT_FRAME * m_Parent;
-    wxDC * m_DC;
-    MODULE* m_CurrentModule;
-    TEXTE_MODULE* m_ReferenceCopy;
-    TEXTE_MODULE* m_ValueCopy;
+    PCB_EDIT_FRAME *            m_Parent;
+    wxDC *                      m_DC;
+    MODULE*                     m_CurrentModule;
+    TEXTE_MODULE*               m_ReferenceCopy;
+    TEXTE_MODULE*               m_ValueCopy;
     std::vector <S3D_MASTER*>   m_Shapes3D_list;
-    int m_LastSelected3DShapeIndex;
-    S3DPOINT_VALUE_CTRL * m_3D_Scale;
-    S3DPOINT_VALUE_CTRL * m_3D_Offset;
-    S3DPOINT_VALUE_CTRL * m_3D_Rotation;
-    static size_t m_page;     // remember the last open page during session
+    int                         m_LastSelected3DShapeIndex;
+    static size_t               m_page; // remember the last open page during session
+    PANEL_PREV_3D*              m_PreviewPane;
 
 public:
     // The dialog can be closed for several reasons.
diff --git a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.cpp b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.cpp
index 6b917b955b..0e6df2a7b4 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.cpp
+++ b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
-// C++ code generated with wxFormBuilder (version Jun  5 2014)
+// C++ code generated with wxFormBuilder (version Oct  5 2015)
 // http://www.wxformbuilder.org/
 //
 // PLEASE DO "NOT" EDIT THIS FILE!
@@ -32,7 +32,7 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	
 	m_ReferenceCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
 	m_ReferenceCtrl->SetMaxLength( 0 ); 
-	bSizerRef->Add( m_ReferenceCtrl, 1, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT, 5 );
+	bSizerRef->Add( m_ReferenceCtrl, 1, wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 	
 	m_button4 = new wxButton( m_PanelProperties, wxID_ANY, _("Edit"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 	bSizerRef->Add( m_button4, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
@@ -49,7 +49,7 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	
 	m_ValueCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
 	m_ValueCtrl->SetMaxLength( 0 ); 
-	bSizerVal->Add( m_ValueCtrl, 1, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT, 5 );
+	bSizerVal->Add( m_ValueCtrl, 1, wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 	
 	m_button5 = new wxButton( m_PanelProperties, wxID_ANY, _("Edit"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 	bSizerVal->Add( m_button5, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
@@ -158,11 +158,11 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	wxBoxSizer* bSizerRotOpt;
 	bSizerRotOpt = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticText11 = new wxStaticText( m_PanelProperties, wxID_ANY, _("Rotate 90 degrees"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticText11 = new wxStaticText( sbSizerAP->GetStaticBox(), wxID_ANY, _("Rotate 90 degrees"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticText11->Wrap( -1 );
 	bSizerRotOpt->Add( m_staticText11, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5 );
 	
-	m_CostRot90Ctrl = new wxSlider( m_PanelProperties, wxID_ANY, 0, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
+	m_CostRot90Ctrl = new wxSlider( sbSizerAP->GetStaticBox(), wxID_ANY, 0, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
 	bSizerRotOpt->Add( m_CostRot90Ctrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 	
 	
@@ -171,11 +171,11 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	wxBoxSizer* bSizerMoveOpt;
 	bSizerMoveOpt = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticText12 = new wxStaticText( m_PanelProperties, wxID_ANY, _("Rotate 180 degrees"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticText12 = new wxStaticText( sbSizerAP->GetStaticBox(), wxID_ANY, _("Rotate 180 degrees"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticText12->Wrap( -1 );
 	bSizerMoveOpt->Add( m_staticText12, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5 );
 	
-	m_CostRot180Ctrl = new wxSlider( m_PanelProperties, wxID_ANY, 0, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
+	m_CostRot180Ctrl = new wxSlider( sbSizerAP->GetStaticBox(), wxID_ANY, 0, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
 	bSizerMoveOpt->Add( m_CostRot180Ctrl, 0, wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND, 5 );
 	
 	
@@ -193,20 +193,20 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	wxBoxSizer* bSizer10;
 	bSizer10 = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_staticText16 = new wxStaticText( m_PanelProperties, wxID_ANY, _("Pad connection to zones:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticText16 = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("Pad connection to zones:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticText16->Wrap( -1 );
 	bSizer10->Add( m_staticText16, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 	
 	wxString m_ZoneConnectionChoiceChoices[] = { _("Use zone setting"), _("Solid"), _("Thermal relief"), _("None") };
 	int m_ZoneConnectionChoiceNChoices = sizeof( m_ZoneConnectionChoiceChoices ) / sizeof( wxString );
-	m_ZoneConnectionChoice = new wxChoice( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_ZoneConnectionChoiceNChoices, m_ZoneConnectionChoiceChoices, 0 );
+	m_ZoneConnectionChoice = new wxChoice( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, m_ZoneConnectionChoiceNChoices, m_ZoneConnectionChoiceChoices, 0 );
 	m_ZoneConnectionChoice->SetSelection( 0 );
 	bSizer10->Add( m_ZoneConnectionChoice, 1, wxALL|wxEXPAND, 5 );
 	
 	
 	bSizer11->Add( bSizer10, 1, wxEXPAND, 5 );
 	
-	m_staticTextInfo = new wxStaticText( m_PanelProperties, wxID_ANY, _("Set clearances to 0 to use global values"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextInfo = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("Set clearances to 0 to use global values"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextInfo->Wrap( -1 );
 	m_staticTextInfo->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 92, false, wxEmptyString ) );
 	
@@ -221,68 +221,68 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	fgSizerClearances->SetFlexibleDirection( wxBOTH );
 	fgSizerClearances->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 	
-	m_staticTextNetClearance = new wxStaticText( m_PanelProperties, wxID_ANY, _("Pad clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextNetClearance = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("Pad clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextNetClearance->Wrap( -1 );
 	m_staticTextNetClearance->SetToolTip( _("This is the local net clearance for all pad of this footprint\nIf 0, the Netclass values are used\nThis value can be superseded by a pad local value.") );
 	
 	fgSizerClearances->Add( m_staticTextNetClearance, 0, wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 	
-	m_NetClearanceValueCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_NetClearanceValueCtrl = new wxTextCtrl( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_NetClearanceValueCtrl->SetMaxLength( 0 ); 
 	fgSizerClearances->Add( m_NetClearanceValueCtrl, 1, wxALL|wxEXPAND, 5 );
 	
-	m_NetClearanceUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("unit"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_NetClearanceUnits = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("unit"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_NetClearanceUnits->Wrap( -1 );
 	fgSizerClearances->Add( m_NetClearanceUnits, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT, 5 );
 	
-	m_staticline1 = new wxStaticLine( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+	m_staticline1 = new wxStaticLine( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 	fgSizerClearances->Add( m_staticline1, 1, wxEXPAND, 5 );
 	
-	m_staticline2 = new wxStaticLine( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+	m_staticline2 = new wxStaticLine( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 	fgSizerClearances->Add( m_staticline2, 1, wxEXPAND, 5 );
 	
-	m_staticline3 = new wxStaticLine( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+	m_staticline3 = new wxStaticLine( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 	fgSizerClearances->Add( m_staticline3, 1, wxEXPAND, 5 );
 	
-	m_MaskClearanceTitle = new wxStaticText( m_PanelProperties, wxID_ANY, _("Solder mask clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_MaskClearanceTitle = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("Solder mask clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_MaskClearanceTitle->Wrap( -1 );
 	m_MaskClearanceTitle->SetToolTip( _("This is the local clearance between pads and the solder mask\nfor this footprint\nThis value can be superseded by a pad local value.\nIf 0, the global value is used") );
 	
 	fgSizerClearances->Add( m_MaskClearanceTitle, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_SolderMaskMarginCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderMaskMarginCtrl = new wxTextCtrl( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderMaskMarginCtrl->SetMaxLength( 0 ); 
 	fgSizerClearances->Add( m_SolderMaskMarginCtrl, 1, wxALL|wxEXPAND, 5 );
 	
-	m_SolderMaskMarginUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("unit"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderMaskMarginUnits = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("unit"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderMaskMarginUnits->Wrap( -1 );
 	fgSizerClearances->Add( m_SolderMaskMarginUnits, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT, 5 );
 	
-	m_staticTextSolderPaste = new wxStaticText( m_PanelProperties, wxID_ANY, _("Solder paste clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextSolderPaste = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("Solder paste clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextSolderPaste->Wrap( -1 );
 	m_staticTextSolderPaste->SetToolTip( _("This is the local clearance between pads and the solder paste\nfor this footprint.\nThis value can be superseded by a pad local values.\nThe final clearance value is the sum of this value and the clearance value ratio\nA negative value means a smaller mask size than pad size") );
 	
 	fgSizerClearances->Add( m_staticTextSolderPaste, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT, 5 );
 	
-	m_SolderPasteMarginCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteMarginCtrl = new wxTextCtrl( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteMarginCtrl->SetMaxLength( 0 ); 
 	fgSizerClearances->Add( m_SolderPasteMarginCtrl, 1, wxEXPAND|wxLEFT|wxRIGHT, 5 );
 	
-	m_SolderPasteMarginUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("unit"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteMarginUnits = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("unit"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteMarginUnits->Wrap( -1 );
 	fgSizerClearances->Add( m_SolderPasteMarginUnits, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 	
-	m_staticTextRatio = new wxStaticText( m_PanelProperties, wxID_ANY, _("Solder paste ratio clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextRatio = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("Solder paste ratio clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextRatio->Wrap( -1 );
 	m_staticTextRatio->SetToolTip( _("This is the local clearance ratio in per cent between pads and the solder paste\nfor this footprint.\nA value of 10 means the clearance value is 10 per cent of the pad size\nThis value can be superseded by a pad local value.\nThe final clearance value is the sum of this value and the clearance value\nA negative value means a smaller mask size than pad size.") );
 	
 	fgSizerClearances->Add( m_staticTextRatio, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_SolderPasteMarginRatioCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteMarginRatioCtrl = new wxTextCtrl( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteMarginRatioCtrl->SetMaxLength( 0 ); 
 	fgSizerClearances->Add( m_SolderPasteMarginRatioCtrl, 1, wxALL|wxEXPAND, 5 );
 	
-	m_SolderPasteRatioMarginUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("%"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteRatioMarginUnits = new wxStaticText( sbSizerLocalProperties->GetStaticBox(), wxID_ANY, _("%"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteRatioMarginUnits->Wrap( -1 );
 	fgSizerClearances->Add( m_SolderPasteRatioMarginUnits, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT, 5 );
 	
@@ -299,74 +299,49 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	m_PanelProperties->SetSizer( m_PanelPropertiesBoxSizer );
 	m_PanelProperties->Layout();
 	m_PanelPropertiesBoxSizer->Fit( m_PanelProperties );
-	m_NoteBook->AddPage( m_PanelProperties, _("Properties"), true );
+	m_NoteBook->AddPage( m_PanelProperties, _("Properties"), false );
 	m_Panel3D = new wxPanel( m_NoteBook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
-	wxBoxSizer* bSizerMain3D;
 	bSizerMain3D = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticText3Dname = new wxStaticText( m_Panel3D, wxID_ANY, _("3D Shape Name"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText3Dname->Wrap( -1 );
-	bSizerMain3D->Add( m_staticText3Dname, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+	wxStaticBoxSizer* sbSizer3;
+	sbSizer3 = new wxStaticBoxSizer( new wxStaticBox( m_Panel3D, wxID_ANY, _("3D Shape Name") ), wxHORIZONTAL );
 	
-	m_3D_ShapeNameListBox = new wxListBox( m_Panel3D, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE ); 
-	bSizerMain3D->Add( m_3D_ShapeNameListBox, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+	wxBoxSizer* bSizer18;
+	bSizer18 = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticTextDefault3DPath = new wxStaticText( m_Panel3D, wxID_ANY, _("Default Path (from KISYS3DMOD environment variable)"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextDefault3DPath->Wrap( -1 );
-	bSizerMain3D->Add( m_staticTextDefault3DPath, 0, wxRIGHT|wxLEFT, 5 );
+	m_3D_ShapeNameListBox = new wxListBox( sbSizer3->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE ); 
+	m_3D_ShapeNameListBox->SetMinSize( wxSize( 200,80 ) );
 	
-	m_textCtrl3DDefaultPath = new wxTextCtrl( m_Panel3D, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
-	bSizerMain3D->Add( m_textCtrl3DDefaultPath, 0, wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND, 5 );
-	
-	wxBoxSizer* bLowerSizer3D;
-	bLowerSizer3D = new wxBoxSizer( wxHORIZONTAL );
-	
-	m_Sizer3DValues = new wxStaticBoxSizer( new wxStaticBox( m_Panel3D, wxID_ANY, _("3D Scale and Position") ), wxVERTICAL );
-	
-	m_bSizerShapeScale = new wxBoxSizer( wxVERTICAL );
-	
-	m_staticTextShapeScale = new wxStaticText( m_Panel3D, wxID_ANY, _("Shape Scale:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextShapeScale->Wrap( -1 );
-	m_bSizerShapeScale->Add( m_staticTextShapeScale, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+	bSizer18->Add( m_3D_ShapeNameListBox, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 	
 	
-	m_Sizer3DValues->Add( m_bSizerShapeScale, 0, wxEXPAND, 5 );
+	sbSizer3->Add( bSizer18, 1, wxEXPAND, 5 );
 	
-	m_bSizerShapeOffset = new wxBoxSizer( wxVERTICAL );
-	
-	m_staticTextShapeOffset = new wxStaticText( m_Panel3D, wxID_ANY, _("Shape Offset (inch):"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextShapeOffset->Wrap( -1 );
-	m_bSizerShapeOffset->Add( m_staticTextShapeOffset, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
-	
-	
-	m_Sizer3DValues->Add( m_bSizerShapeOffset, 0, wxEXPAND, 5 );
-	
-	m_bSizerShapeRotation = new wxBoxSizer( wxVERTICAL );
-	
-	m_staticTextShapeRotation = new wxStaticText( m_Panel3D, wxID_ANY, _("Shape Rotation (degrees):"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextShapeRotation->Wrap( -1 );
-	m_bSizerShapeRotation->Add( m_staticTextShapeRotation, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
-	
-	
-	m_Sizer3DValues->Add( m_bSizerShapeRotation, 0, wxEXPAND, 5 );
-	
-	
-	bLowerSizer3D->Add( m_Sizer3DValues, 1, wxALL|wxEXPAND, 5 );
+	wxBoxSizer* bSizer19;
+	bSizer19 = new wxBoxSizer( wxHORIZONTAL );
 	
 	wxBoxSizer* bSizer3DButtons;
 	bSizer3DButtons = new wxBoxSizer( wxVERTICAL );
 	
-	m_buttonAdd = new wxButton( m_Panel3D, ID_ADD_3D_SHAPE, _("Add 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_buttonAdd = new wxButton( sbSizer3->GetStaticBox(), ID_ADD_3D_SHAPE, _("Add 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
 	bSizer3DButtons->Add( m_buttonAdd, 0, wxEXPAND|wxLEFT|wxRIGHT|wxTOP, 5 );
 	
-	m_buttonRemove = new wxButton( m_Panel3D, ID_REMOVE_3D_SHAPE, _("Remove 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_buttonRemove = new wxButton( sbSizer3->GetStaticBox(), ID_REMOVE_3D_SHAPE, _("Remove 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
 	bSizer3DButtons->Add( m_buttonRemove, 0, wxEXPAND|wxLEFT|wxRIGHT|wxTOP, 5 );
 	
-	m_buttonEdit = new wxButton( m_Panel3D, wxID_ANY, _("Edit Filename"), wxDefaultPosition, wxDefaultSize, 0 );
-	bSizer3DButtons->Add( m_buttonEdit, 0, wxALL|wxEXPAND, 5 );
+	m_buttonEdit = new wxButton( sbSizer3->GetStaticBox(), wxID_ANY, _("Edit Filename"), wxDefaultPosition, wxDefaultSize, 0 );
+	bSizer3DButtons->Add( m_buttonEdit, 0, wxEXPAND|wxLEFT|wxRIGHT|wxTOP, 5 );
 	
 	
-	bLowerSizer3D->Add( bSizer3DButtons, 0, wxALIGN_CENTER_VERTICAL, 5 );
+	bSizer19->Add( bSizer3DButtons, 0, wxALIGN_CENTER_VERTICAL, 5 );
+	
+	
+	sbSizer3->Add( bSizer19, 0, wxEXPAND, 5 );
+	
+	
+	bSizerMain3D->Add( sbSizer3, 1, wxEXPAND, 5 );
+	
+	bLowerSizer3D = new wxBoxSizer( wxHORIZONTAL );
 	
 	
 	bSizerMain3D->Add( bLowerSizer3D, 0, wxEXPAND, 5 );
@@ -375,7 +350,7 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	m_Panel3D->SetSizer( bSizerMain3D );
 	m_Panel3D->Layout();
 	bSizerMain3D->Fit( m_Panel3D );
-	m_NoteBook->AddPage( m_Panel3D, _("3D settings"), false );
+	m_NoteBook->AddPage( m_Panel3D, _("3D settings"), true );
 	
 	m_GeneralBoxSizer->Add( m_NoteBook, 1, wxEXPAND | wxALL, 5 );
 	
@@ -400,6 +375,7 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* pare
 	m_buttonExchange->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::ExchangeModule ), NULL, this );
 	m_buttonModuleEditor->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::GotoModuleEditor ), NULL, this );
 	m_3D_ShapeNameListBox->Connect( wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::On3DShapeNameSelected ), NULL, this );
+	m_3D_ShapeNameListBox->Connect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
 	m_buttonAdd->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Add3DShape ), NULL, this );
 	m_buttonRemove->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Remove3DShape ), NULL, this );
 	m_buttonEdit->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
@@ -416,6 +392,7 @@ DIALOG_MODULE_BOARD_EDITOR_BASE::~DIALOG_MODULE_BOARD_EDITOR_BASE()
 	m_buttonExchange->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::ExchangeModule ), NULL, this );
 	m_buttonModuleEditor->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::GotoModuleEditor ), NULL, this );
 	m_3D_ShapeNameListBox->Disconnect( wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::On3DShapeNameSelected ), NULL, this );
+	m_3D_ShapeNameListBox->Disconnect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
 	m_buttonAdd->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Add3DShape ), NULL, this );
 	m_buttonRemove->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Remove3DShape ), NULL, this );
 	m_buttonEdit->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_BOARD_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
diff --git a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.fbp b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.fbp
index ffbfa87329..3450cd41ca 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.fbp
+++ b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.fbp
@@ -175,11 +175,11 @@
                         <event name="OnSetFocus"></event>
                         <event name="OnSize"></event>
                         <event name="OnUpdateUI"></event>
-                        <object class="notebookpage" expanded="1">
+                        <object class="notebookpage" expanded="0">
                             <property name="bitmap"></property>
                             <property name="label">Properties</property>
-                            <property name="select">1</property>
-                            <object class="wxPanel" expanded="1">
+                            <property name="select">0</property>
+                            <object class="wxPanel" expanded="0">
                                 <property name="BottomDockable">1</property>
                                 <property name="LeftDockable">1</property>
                                 <property name="RightDockable">1</property>
@@ -253,7 +253,7 @@
                                 <event name="OnSetFocus"></event>
                                 <event name="OnSize"></event>
                                 <event name="OnUpdateUI"></event>
-                                <object class="wxBoxSizer" expanded="1">
+                                <object class="wxBoxSizer" expanded="0">
                                     <property name="minimum_size"></property>
                                     <property name="name">m_PanelPropertiesBoxSizer</property>
                                     <property name="orient">wxHORIZONTAL</property>
@@ -361,7 +361,7 @@
                                                     <property name="permission">none</property>
                                                     <object class="sizeritem" expanded="0">
                                                         <property name="border">5</property>
-                                                        <property name="flag">wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT</property>
+                                                        <property name="flag">wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT|wxLEFT</property>
                                                         <property name="proportion">1</property>
                                                         <object class="wxTextCtrl" expanded="0">
                                                             <property name="BottomDockable">1</property>
@@ -634,7 +634,7 @@
                                                     <property name="permission">none</property>
                                                     <object class="sizeritem" expanded="0">
                                                         <property name="border">5</property>
-                                                        <property name="flag">wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT</property>
+                                                        <property name="flag">wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT|wxLEFT</property>
                                                         <property name="proportion">1</property>
                                                         <object class="wxTextCtrl" expanded="0">
                                                             <property name="BottomDockable">1</property>
@@ -1958,11 +1958,11 @@
                                             </object>
                                         </object>
                                     </object>
-                                    <object class="sizeritem" expanded="1">
+                                    <object class="sizeritem" expanded="0">
                                         <property name="border">5</property>
                                         <property name="flag"></property>
                                         <property name="proportion">0</property>
-                                        <object class="wxBoxSizer" expanded="1">
+                                        <object class="wxBoxSizer" expanded="0">
                                             <property name="minimum_size"></property>
                                             <property name="name">m_PropRightSizer</property>
                                             <property name="orient">wxVERTICAL</property>
@@ -2143,11 +2143,11 @@
                                                     <event name="OnUpdateUI"></event>
                                                 </object>
                                             </object>
-                                            <object class="sizeritem" expanded="1">
+                                            <object class="sizeritem" expanded="0">
                                                 <property name="border">5</property>
                                                 <property name="flag">wxEXPAND</property>
                                                 <property name="proportion">0</property>
-                                                <object class="wxBoxSizer" expanded="1">
+                                                <object class="wxBoxSizer" expanded="0">
                                                     <property name="minimum_size"></property>
                                                     <property name="name">bSizerAttrib</property>
                                                     <property name="orient">wxHORIZONTAL</property>
@@ -2334,11 +2334,11 @@
                                                     </object>
                                                 </object>
                                             </object>
-                                            <object class="sizeritem" expanded="1">
+                                            <object class="sizeritem" expanded="0">
                                                 <property name="border">5</property>
                                                 <property name="flag">wxEXPAND|wxALL</property>
                                                 <property name="proportion">0</property>
-                                                <object class="wxStaticBoxSizer" expanded="1">
+                                                <object class="wxStaticBoxSizer" expanded="0">
                                                     <property name="id">wxID_ANY</property>
                                                     <property name="label">Auto Place</property>
                                                     <property name="minimum_size"></property>
@@ -2752,11 +2752,11 @@
                                                     </object>
                                                 </object>
                                             </object>
-                                            <object class="sizeritem" expanded="1">
+                                            <object class="sizeritem" expanded="0">
                                                 <property name="border">5</property>
                                                 <property name="flag">wxALL|wxEXPAND</property>
                                                 <property name="proportion">0</property>
-                                                <object class="wxStaticBoxSizer" expanded="1">
+                                                <object class="wxStaticBoxSizer" expanded="0">
                                                     <property name="id">wxID_ANY</property>
                                                     <property name="label">Local Settings</property>
                                                     <property name="minimum_size"></property>
@@ -2764,11 +2764,11 @@
                                                     <property name="orient">wxVERTICAL</property>
                                                     <property name="permission">none</property>
                                                     <event name="OnUpdateUI"></event>
-                                                    <object class="sizeritem" expanded="1">
+                                                    <object class="sizeritem" expanded="0">
                                                         <property name="border">5</property>
                                                         <property name="flag">wxEXPAND</property>
                                                         <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="1">
+                                                        <object class="wxBoxSizer" expanded="0">
                                                             <property name="minimum_size"></property>
                                                             <property name="name">bSizer11</property>
                                                             <property name="orient">wxVERTICAL</property>
@@ -3040,11 +3040,11 @@
                                                             </object>
                                                         </object>
                                                     </object>
-                                                    <object class="sizeritem" expanded="1">
+                                                    <object class="sizeritem" expanded="0">
                                                         <property name="border">5</property>
                                                         <property name="flag">wxEXPAND</property>
                                                         <property name="proportion">1</property>
-                                                        <object class="wxFlexGridSizer" expanded="1">
+                                                        <object class="wxFlexGridSizer" expanded="0">
                                                             <property name="cols">3</property>
                                                             <property name="flexible_direction">wxBOTH</property>
                                                             <property name="growablecols">1</property>
@@ -4339,7 +4339,7 @@
                         <object class="notebookpage" expanded="1">
                             <property name="bitmap"></property>
                             <property name="label">3D settings</property>
-                            <property name="select">0</property>
+                            <property name="select">1</property>
                             <object class="wxPanel" expanded="1">
                                 <property name="BottomDockable">1</property>
                                 <property name="LeftDockable">1</property>
@@ -4418,671 +4418,33 @@
                                     <property name="minimum_size"></property>
                                     <property name="name">bSizerMain3D</property>
                                     <property name="orient">wxVERTICAL</property>
-                                    <property name="permission">none</property>
-                                    <object class="sizeritem" expanded="0">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxStaticText" expanded="0">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="label">3D Shape Name</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_staticText3Dname</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style"></property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <property name="wrap">-1</property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
-                                    <object class="sizeritem" expanded="0">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT</property>
-                                        <property name="proportion">1</property>
-                                        <object class="wxListBox" expanded="0">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="choices"></property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_3D_ShapeNameListBox</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style">wxLB_SINGLE</property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="validator_data_type"></property>
-                                            <property name="validator_style">wxFILTER_NONE</property>
-                                            <property name="validator_type">wxDefaultValidator</property>
-                                            <property name="validator_variable"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnListBox">On3DShapeNameSelected</event>
-                                            <event name="OnListBoxDClick"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
-                                    <object class="sizeritem" expanded="0">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxRIGHT|wxLEFT</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxStaticText" expanded="0">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="label">Default Path (from KISYS3DMOD environment variable)</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_staticTextDefault3DPath</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style"></property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <property name="wrap">-1</property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
-                                    <object class="sizeritem" expanded="0">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxTextCtrl" expanded="0">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="maxlength"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_textCtrl3DDefaultPath</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style">wxTE_READONLY</property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="validator_data_type"></property>
-                                            <property name="validator_style">wxFILTER_NONE</property>
-                                            <property name="validator_type">wxDefaultValidator</property>
-                                            <property name="validator_variable"></property>
-                                            <property name="value"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnText"></event>
-                                            <event name="OnTextEnter"></event>
-                                            <event name="OnTextMaxLen"></event>
-                                            <event name="OnTextURL"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
+                                    <property name="permission">protected</property>
                                     <object class="sizeritem" expanded="1">
                                         <property name="border">5</property>
                                         <property name="flag">wxEXPAND</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxBoxSizer" expanded="1">
+                                        <property name="proportion">1</property>
+                                        <object class="wxStaticBoxSizer" expanded="1">
+                                            <property name="id">wxID_ANY</property>
+                                            <property name="label">3D Shape Name</property>
                                             <property name="minimum_size"></property>
-                                            <property name="name">bLowerSizer3D</property>
+                                            <property name="name">sbSizer3</property>
                                             <property name="orient">wxHORIZONTAL</property>
                                             <property name="permission">none</property>
-                                            <object class="sizeritem" expanded="0">
-                                                <property name="border">5</property>
-                                                <property name="flag">wxALL|wxEXPAND</property>
-                                                <property name="proportion">1</property>
-                                                <object class="wxStaticBoxSizer" expanded="0">
-                                                    <property name="id">wxID_ANY</property>
-                                                    <property name="label">3D Scale and Position</property>
-                                                    <property name="minimum_size"></property>
-                                                    <property name="name">m_Sizer3DValues</property>
-                                                    <property name="orient">wxVERTICAL</property>
-                                                    <property name="permission">public</property>
-                                                    <event name="OnUpdateUI"></event>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="0">
-                                                            <property name="minimum_size"></property>
-                                                            <property name="name">m_bSizerShapeScale</property>
-                                                            <property name="orient">wxVERTICAL</property>
-                                                            <property name="permission">protected</property>
-                                                            <object class="sizeritem" expanded="0">
-                                                                <property name="border">5</property>
-                                                                <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                                                <property name="proportion">0</property>
-                                                                <object class="wxStaticText" expanded="0">
-                                                                    <property name="BottomDockable">1</property>
-                                                                    <property name="LeftDockable">1</property>
-                                                                    <property name="RightDockable">1</property>
-                                                                    <property name="TopDockable">1</property>
-                                                                    <property name="aui_layer"></property>
-                                                                    <property name="aui_name"></property>
-                                                                    <property name="aui_position"></property>
-                                                                    <property name="aui_row"></property>
-                                                                    <property name="best_size"></property>
-                                                                    <property name="bg"></property>
-                                                                    <property name="caption"></property>
-                                                                    <property name="caption_visible">1</property>
-                                                                    <property name="center_pane">0</property>
-                                                                    <property name="close_button">1</property>
-                                                                    <property name="context_help"></property>
-                                                                    <property name="context_menu">1</property>
-                                                                    <property name="default_pane">0</property>
-                                                                    <property name="dock">Dock</property>
-                                                                    <property name="dock_fixed">0</property>
-                                                                    <property name="docking">Left</property>
-                                                                    <property name="enabled">1</property>
-                                                                    <property name="fg"></property>
-                                                                    <property name="floatable">1</property>
-                                                                    <property name="font"></property>
-                                                                    <property name="gripper">0</property>
-                                                                    <property name="hidden">0</property>
-                                                                    <property name="id">wxID_ANY</property>
-                                                                    <property name="label">Shape Scale:</property>
-                                                                    <property name="max_size"></property>
-                                                                    <property name="maximize_button">0</property>
-                                                                    <property name="maximum_size"></property>
-                                                                    <property name="min_size"></property>
-                                                                    <property name="minimize_button">0</property>
-                                                                    <property name="minimum_size"></property>
-                                                                    <property name="moveable">1</property>
-                                                                    <property name="name">m_staticTextShapeScale</property>
-                                                                    <property name="pane_border">1</property>
-                                                                    <property name="pane_position"></property>
-                                                                    <property name="pane_size"></property>
-                                                                    <property name="permission">protected</property>
-                                                                    <property name="pin_button">1</property>
-                                                                    <property name="pos"></property>
-                                                                    <property name="resize">Resizable</property>
-                                                                    <property name="show">1</property>
-                                                                    <property name="size"></property>
-                                                                    <property name="style"></property>
-                                                                    <property name="subclass"></property>
-                                                                    <property name="toolbar_pane">0</property>
-                                                                    <property name="tooltip"></property>
-                                                                    <property name="window_extra_style"></property>
-                                                                    <property name="window_name"></property>
-                                                                    <property name="window_style"></property>
-                                                                    <property name="wrap">-1</property>
-                                                                    <event name="OnChar"></event>
-                                                                    <event name="OnEnterWindow"></event>
-                                                                    <event name="OnEraseBackground"></event>
-                                                                    <event name="OnKeyDown"></event>
-                                                                    <event name="OnKeyUp"></event>
-                                                                    <event name="OnKillFocus"></event>
-                                                                    <event name="OnLeaveWindow"></event>
-                                                                    <event name="OnLeftDClick"></event>
-                                                                    <event name="OnLeftDown"></event>
-                                                                    <event name="OnLeftUp"></event>
-                                                                    <event name="OnMiddleDClick"></event>
-                                                                    <event name="OnMiddleDown"></event>
-                                                                    <event name="OnMiddleUp"></event>
-                                                                    <event name="OnMotion"></event>
-                                                                    <event name="OnMouseEvents"></event>
-                                                                    <event name="OnMouseWheel"></event>
-                                                                    <event name="OnPaint"></event>
-                                                                    <event name="OnRightDClick"></event>
-                                                                    <event name="OnRightDown"></event>
-                                                                    <event name="OnRightUp"></event>
-                                                                    <event name="OnSetFocus"></event>
-                                                                    <event name="OnSize"></event>
-                                                                    <event name="OnUpdateUI"></event>
-                                                                </object>
-                                                            </object>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="0">
-                                                            <property name="minimum_size"></property>
-                                                            <property name="name">m_bSizerShapeOffset</property>
-                                                            <property name="orient">wxVERTICAL</property>
-                                                            <property name="permission">protected</property>
-                                                            <object class="sizeritem" expanded="0">
-                                                                <property name="border">5</property>
-                                                                <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                                                <property name="proportion">0</property>
-                                                                <object class="wxStaticText" expanded="0">
-                                                                    <property name="BottomDockable">1</property>
-                                                                    <property name="LeftDockable">1</property>
-                                                                    <property name="RightDockable">1</property>
-                                                                    <property name="TopDockable">1</property>
-                                                                    <property name="aui_layer"></property>
-                                                                    <property name="aui_name"></property>
-                                                                    <property name="aui_position"></property>
-                                                                    <property name="aui_row"></property>
-                                                                    <property name="best_size"></property>
-                                                                    <property name="bg"></property>
-                                                                    <property name="caption"></property>
-                                                                    <property name="caption_visible">1</property>
-                                                                    <property name="center_pane">0</property>
-                                                                    <property name="close_button">1</property>
-                                                                    <property name="context_help"></property>
-                                                                    <property name="context_menu">1</property>
-                                                                    <property name="default_pane">0</property>
-                                                                    <property name="dock">Dock</property>
-                                                                    <property name="dock_fixed">0</property>
-                                                                    <property name="docking">Left</property>
-                                                                    <property name="enabled">1</property>
-                                                                    <property name="fg"></property>
-                                                                    <property name="floatable">1</property>
-                                                                    <property name="font"></property>
-                                                                    <property name="gripper">0</property>
-                                                                    <property name="hidden">0</property>
-                                                                    <property name="id">wxID_ANY</property>
-                                                                    <property name="label">Shape Offset (inch):</property>
-                                                                    <property name="max_size"></property>
-                                                                    <property name="maximize_button">0</property>
-                                                                    <property name="maximum_size"></property>
-                                                                    <property name="min_size"></property>
-                                                                    <property name="minimize_button">0</property>
-                                                                    <property name="minimum_size"></property>
-                                                                    <property name="moveable">1</property>
-                                                                    <property name="name">m_staticTextShapeOffset</property>
-                                                                    <property name="pane_border">1</property>
-                                                                    <property name="pane_position"></property>
-                                                                    <property name="pane_size"></property>
-                                                                    <property name="permission">protected</property>
-                                                                    <property name="pin_button">1</property>
-                                                                    <property name="pos"></property>
-                                                                    <property name="resize">Resizable</property>
-                                                                    <property name="show">1</property>
-                                                                    <property name="size"></property>
-                                                                    <property name="style"></property>
-                                                                    <property name="subclass"></property>
-                                                                    <property name="toolbar_pane">0</property>
-                                                                    <property name="tooltip"></property>
-                                                                    <property name="window_extra_style"></property>
-                                                                    <property name="window_name"></property>
-                                                                    <property name="window_style"></property>
-                                                                    <property name="wrap">-1</property>
-                                                                    <event name="OnChar"></event>
-                                                                    <event name="OnEnterWindow"></event>
-                                                                    <event name="OnEraseBackground"></event>
-                                                                    <event name="OnKeyDown"></event>
-                                                                    <event name="OnKeyUp"></event>
-                                                                    <event name="OnKillFocus"></event>
-                                                                    <event name="OnLeaveWindow"></event>
-                                                                    <event name="OnLeftDClick"></event>
-                                                                    <event name="OnLeftDown"></event>
-                                                                    <event name="OnLeftUp"></event>
-                                                                    <event name="OnMiddleDClick"></event>
-                                                                    <event name="OnMiddleDown"></event>
-                                                                    <event name="OnMiddleUp"></event>
-                                                                    <event name="OnMotion"></event>
-                                                                    <event name="OnMouseEvents"></event>
-                                                                    <event name="OnMouseWheel"></event>
-                                                                    <event name="OnPaint"></event>
-                                                                    <event name="OnRightDClick"></event>
-                                                                    <event name="OnRightDown"></event>
-                                                                    <event name="OnRightUp"></event>
-                                                                    <event name="OnSetFocus"></event>
-                                                                    <event name="OnSize"></event>
-                                                                    <event name="OnUpdateUI"></event>
-                                                                </object>
-                                                            </object>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="0">
-                                                            <property name="minimum_size"></property>
-                                                            <property name="name">m_bSizerShapeRotation</property>
-                                                            <property name="orient">wxVERTICAL</property>
-                                                            <property name="permission">protected</property>
-                                                            <object class="sizeritem" expanded="0">
-                                                                <property name="border">5</property>
-                                                                <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                                                <property name="proportion">0</property>
-                                                                <object class="wxStaticText" expanded="0">
-                                                                    <property name="BottomDockable">1</property>
-                                                                    <property name="LeftDockable">1</property>
-                                                                    <property name="RightDockable">1</property>
-                                                                    <property name="TopDockable">1</property>
-                                                                    <property name="aui_layer"></property>
-                                                                    <property name="aui_name"></property>
-                                                                    <property name="aui_position"></property>
-                                                                    <property name="aui_row"></property>
-                                                                    <property name="best_size"></property>
-                                                                    <property name="bg"></property>
-                                                                    <property name="caption"></property>
-                                                                    <property name="caption_visible">1</property>
-                                                                    <property name="center_pane">0</property>
-                                                                    <property name="close_button">1</property>
-                                                                    <property name="context_help"></property>
-                                                                    <property name="context_menu">1</property>
-                                                                    <property name="default_pane">0</property>
-                                                                    <property name="dock">Dock</property>
-                                                                    <property name="dock_fixed">0</property>
-                                                                    <property name="docking">Left</property>
-                                                                    <property name="enabled">1</property>
-                                                                    <property name="fg"></property>
-                                                                    <property name="floatable">1</property>
-                                                                    <property name="font"></property>
-                                                                    <property name="gripper">0</property>
-                                                                    <property name="hidden">0</property>
-                                                                    <property name="id">wxID_ANY</property>
-                                                                    <property name="label">Shape Rotation (degrees):</property>
-                                                                    <property name="max_size"></property>
-                                                                    <property name="maximize_button">0</property>
-                                                                    <property name="maximum_size"></property>
-                                                                    <property name="min_size"></property>
-                                                                    <property name="minimize_button">0</property>
-                                                                    <property name="minimum_size"></property>
-                                                                    <property name="moveable">1</property>
-                                                                    <property name="name">m_staticTextShapeRotation</property>
-                                                                    <property name="pane_border">1</property>
-                                                                    <property name="pane_position"></property>
-                                                                    <property name="pane_size"></property>
-                                                                    <property name="permission">protected</property>
-                                                                    <property name="pin_button">1</property>
-                                                                    <property name="pos"></property>
-                                                                    <property name="resize">Resizable</property>
-                                                                    <property name="show">1</property>
-                                                                    <property name="size"></property>
-                                                                    <property name="style"></property>
-                                                                    <property name="subclass"></property>
-                                                                    <property name="toolbar_pane">0</property>
-                                                                    <property name="tooltip"></property>
-                                                                    <property name="window_extra_style"></property>
-                                                                    <property name="window_name"></property>
-                                                                    <property name="window_style"></property>
-                                                                    <property name="wrap">-1</property>
-                                                                    <event name="OnChar"></event>
-                                                                    <event name="OnEnterWindow"></event>
-                                                                    <event name="OnEraseBackground"></event>
-                                                                    <event name="OnKeyDown"></event>
-                                                                    <event name="OnKeyUp"></event>
-                                                                    <event name="OnKillFocus"></event>
-                                                                    <event name="OnLeaveWindow"></event>
-                                                                    <event name="OnLeftDClick"></event>
-                                                                    <event name="OnLeftDown"></event>
-                                                                    <event name="OnLeftUp"></event>
-                                                                    <event name="OnMiddleDClick"></event>
-                                                                    <event name="OnMiddleDown"></event>
-                                                                    <event name="OnMiddleUp"></event>
-                                                                    <event name="OnMotion"></event>
-                                                                    <event name="OnMouseEvents"></event>
-                                                                    <event name="OnMouseWheel"></event>
-                                                                    <event name="OnPaint"></event>
-                                                                    <event name="OnRightDClick"></event>
-                                                                    <event name="OnRightDown"></event>
-                                                                    <event name="OnRightUp"></event>
-                                                                    <event name="OnSetFocus"></event>
-                                                                    <event name="OnSize"></event>
-                                                                    <event name="OnUpdateUI"></event>
-                                                                </object>
-                                                            </object>
-                                                        </object>
-                                                    </object>
-                                                </object>
-                                            </object>
+                                            <event name="OnUpdateUI"></event>
                                             <object class="sizeritem" expanded="1">
                                                 <property name="border">5</property>
-                                                <property name="flag">wxALIGN_CENTER_VERTICAL</property>
-                                                <property name="proportion">0</property>
+                                                <property name="flag">wxEXPAND</property>
+                                                <property name="proportion">1</property>
                                                 <object class="wxBoxSizer" expanded="1">
                                                     <property name="minimum_size"></property>
-                                                    <property name="name">bSizer3DButtons</property>
+                                                    <property name="name">bSizer18</property>
                                                     <property name="orient">wxVERTICAL</property>
                                                     <property name="permission">none</property>
                                                     <object class="sizeritem" expanded="0">
                                                         <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND|wxLEFT|wxRIGHT|wxTOP</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxButton" expanded="0">
+                                                        <property name="flag">wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT</property>
+                                                        <property name="proportion">1</property>
+                                                        <object class="wxListBox" expanded="0">
                                                             <property name="BottomDockable">1</property>
                                                             <property name="LeftDockable">1</property>
                                                             <property name="RightDockable">1</property>
@@ -5096,186 +4458,10 @@
                                                             <property name="caption"></property>
                                                             <property name="caption_visible">1</property>
                                                             <property name="center_pane">0</property>
+                                                            <property name="choices"></property>
                                                             <property name="close_button">1</property>
                                                             <property name="context_help"></property>
                                                             <property name="context_menu">1</property>
-                                                            <property name="default">0</property>
-                                                            <property name="default_pane">0</property>
-                                                            <property name="dock">Dock</property>
-                                                            <property name="dock_fixed">0</property>
-                                                            <property name="docking">Left</property>
-                                                            <property name="enabled">1</property>
-                                                            <property name="fg"></property>
-                                                            <property name="floatable">1</property>
-                                                            <property name="font"></property>
-                                                            <property name="gripper">0</property>
-                                                            <property name="hidden">0</property>
-                                                            <property name="id">ID_ADD_3D_SHAPE</property>
-                                                            <property name="label">Add 3D Shape</property>
-                                                            <property name="max_size"></property>
-                                                            <property name="maximize_button">0</property>
-                                                            <property name="maximum_size"></property>
-                                                            <property name="min_size"></property>
-                                                            <property name="minimize_button">0</property>
-                                                            <property name="minimum_size"></property>
-                                                            <property name="moveable">1</property>
-                                                            <property name="name">m_buttonAdd</property>
-                                                            <property name="pane_border">1</property>
-                                                            <property name="pane_position"></property>
-                                                            <property name="pane_size"></property>
-                                                            <property name="permission">protected</property>
-                                                            <property name="pin_button">1</property>
-                                                            <property name="pos"></property>
-                                                            <property name="resize">Resizable</property>
-                                                            <property name="show">1</property>
-                                                            <property name="size"></property>
-                                                            <property name="style"></property>
-                                                            <property name="subclass"></property>
-                                                            <property name="toolbar_pane">0</property>
-                                                            <property name="tooltip"></property>
-                                                            <property name="validator_data_type"></property>
-                                                            <property name="validator_style">wxFILTER_NONE</property>
-                                                            <property name="validator_type">wxDefaultValidator</property>
-                                                            <property name="validator_variable"></property>
-                                                            <property name="window_extra_style"></property>
-                                                            <property name="window_name"></property>
-                                                            <property name="window_style"></property>
-                                                            <event name="OnButtonClick">Add3DShape</event>
-                                                            <event name="OnChar"></event>
-                                                            <event name="OnEnterWindow"></event>
-                                                            <event name="OnEraseBackground"></event>
-                                                            <event name="OnKeyDown"></event>
-                                                            <event name="OnKeyUp"></event>
-                                                            <event name="OnKillFocus"></event>
-                                                            <event name="OnLeaveWindow"></event>
-                                                            <event name="OnLeftDClick"></event>
-                                                            <event name="OnLeftDown"></event>
-                                                            <event name="OnLeftUp"></event>
-                                                            <event name="OnMiddleDClick"></event>
-                                                            <event name="OnMiddleDown"></event>
-                                                            <event name="OnMiddleUp"></event>
-                                                            <event name="OnMotion"></event>
-                                                            <event name="OnMouseEvents"></event>
-                                                            <event name="OnMouseWheel"></event>
-                                                            <event name="OnPaint"></event>
-                                                            <event name="OnRightDClick"></event>
-                                                            <event name="OnRightDown"></event>
-                                                            <event name="OnRightUp"></event>
-                                                            <event name="OnSetFocus"></event>
-                                                            <event name="OnSize"></event>
-                                                            <event name="OnUpdateUI"></event>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND|wxLEFT|wxRIGHT|wxTOP</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxButton" expanded="0">
-                                                            <property name="BottomDockable">1</property>
-                                                            <property name="LeftDockable">1</property>
-                                                            <property name="RightDockable">1</property>
-                                                            <property name="TopDockable">1</property>
-                                                            <property name="aui_layer"></property>
-                                                            <property name="aui_name"></property>
-                                                            <property name="aui_position"></property>
-                                                            <property name="aui_row"></property>
-                                                            <property name="best_size"></property>
-                                                            <property name="bg"></property>
-                                                            <property name="caption"></property>
-                                                            <property name="caption_visible">1</property>
-                                                            <property name="center_pane">0</property>
-                                                            <property name="close_button">1</property>
-                                                            <property name="context_help"></property>
-                                                            <property name="context_menu">1</property>
-                                                            <property name="default">0</property>
-                                                            <property name="default_pane">0</property>
-                                                            <property name="dock">Dock</property>
-                                                            <property name="dock_fixed">0</property>
-                                                            <property name="docking">Left</property>
-                                                            <property name="enabled">1</property>
-                                                            <property name="fg"></property>
-                                                            <property name="floatable">1</property>
-                                                            <property name="font"></property>
-                                                            <property name="gripper">0</property>
-                                                            <property name="hidden">0</property>
-                                                            <property name="id">ID_REMOVE_3D_SHAPE</property>
-                                                            <property name="label">Remove 3D Shape</property>
-                                                            <property name="max_size"></property>
-                                                            <property name="maximize_button">0</property>
-                                                            <property name="maximum_size"></property>
-                                                            <property name="min_size"></property>
-                                                            <property name="minimize_button">0</property>
-                                                            <property name="minimum_size"></property>
-                                                            <property name="moveable">1</property>
-                                                            <property name="name">m_buttonRemove</property>
-                                                            <property name="pane_border">1</property>
-                                                            <property name="pane_position"></property>
-                                                            <property name="pane_size"></property>
-                                                            <property name="permission">protected</property>
-                                                            <property name="pin_button">1</property>
-                                                            <property name="pos"></property>
-                                                            <property name="resize">Resizable</property>
-                                                            <property name="show">1</property>
-                                                            <property name="size"></property>
-                                                            <property name="style"></property>
-                                                            <property name="subclass"></property>
-                                                            <property name="toolbar_pane">0</property>
-                                                            <property name="tooltip"></property>
-                                                            <property name="validator_data_type"></property>
-                                                            <property name="validator_style">wxFILTER_NONE</property>
-                                                            <property name="validator_type">wxDefaultValidator</property>
-                                                            <property name="validator_variable"></property>
-                                                            <property name="window_extra_style"></property>
-                                                            <property name="window_name"></property>
-                                                            <property name="window_style"></property>
-                                                            <event name="OnButtonClick">Remove3DShape</event>
-                                                            <event name="OnChar"></event>
-                                                            <event name="OnEnterWindow"></event>
-                                                            <event name="OnEraseBackground"></event>
-                                                            <event name="OnKeyDown"></event>
-                                                            <event name="OnKeyUp"></event>
-                                                            <event name="OnKillFocus"></event>
-                                                            <event name="OnLeaveWindow"></event>
-                                                            <event name="OnLeftDClick"></event>
-                                                            <event name="OnLeftDown"></event>
-                                                            <event name="OnLeftUp"></event>
-                                                            <event name="OnMiddleDClick"></event>
-                                                            <event name="OnMiddleDown"></event>
-                                                            <event name="OnMiddleUp"></event>
-                                                            <event name="OnMotion"></event>
-                                                            <event name="OnMouseEvents"></event>
-                                                            <event name="OnMouseWheel"></event>
-                                                            <event name="OnPaint"></event>
-                                                            <event name="OnRightDClick"></event>
-                                                            <event name="OnRightDown"></event>
-                                                            <event name="OnRightUp"></event>
-                                                            <event name="OnSetFocus"></event>
-                                                            <event name="OnSize"></event>
-                                                            <event name="OnUpdateUI"></event>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxALL|wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxButton" expanded="0">
-                                                            <property name="BottomDockable">1</property>
-                                                            <property name="LeftDockable">1</property>
-                                                            <property name="RightDockable">1</property>
-                                                            <property name="TopDockable">1</property>
-                                                            <property name="aui_layer"></property>
-                                                            <property name="aui_name"></property>
-                                                            <property name="aui_position"></property>
-                                                            <property name="aui_row"></property>
-                                                            <property name="best_size"></property>
-                                                            <property name="bg"></property>
-                                                            <property name="caption"></property>
-                                                            <property name="caption_visible">1</property>
-                                                            <property name="center_pane">0</property>
-                                                            <property name="close_button">1</property>
-                                                            <property name="context_help"></property>
-                                                            <property name="context_menu">1</property>
-                                                            <property name="default">0</property>
                                                             <property name="default_pane">0</property>
                                                             <property name="dock">Dock</property>
                                                             <property name="dock_fixed">0</property>
@@ -5287,15 +4473,14 @@
                                                             <property name="gripper">0</property>
                                                             <property name="hidden">0</property>
                                                             <property name="id">wxID_ANY</property>
-                                                            <property name="label">Edit Filename</property>
                                                             <property name="max_size"></property>
                                                             <property name="maximize_button">0</property>
-                                                            <property name="maximum_size"></property>
+                                                            <property name="maximum_size">-1,-1</property>
                                                             <property name="min_size"></property>
                                                             <property name="minimize_button">0</property>
-                                                            <property name="minimum_size"></property>
+                                                            <property name="minimum_size">200,80</property>
                                                             <property name="moveable">1</property>
-                                                            <property name="name">m_buttonEdit</property>
+                                                            <property name="name">m_3D_ShapeNameListBox</property>
                                                             <property name="pane_border">1</property>
                                                             <property name="pane_position"></property>
                                                             <property name="pane_size"></property>
@@ -5305,7 +4490,7 @@
                                                             <property name="resize">Resizable</property>
                                                             <property name="show">1</property>
                                                             <property name="size"></property>
-                                                            <property name="style"></property>
+                                                            <property name="style">wxLB_SINGLE</property>
                                                             <property name="subclass"></property>
                                                             <property name="toolbar_pane">0</property>
                                                             <property name="tooltip"></property>
@@ -5316,7 +4501,6 @@
                                                             <property name="window_extra_style"></property>
                                                             <property name="window_name"></property>
                                                             <property name="window_style"></property>
-                                                            <event name="OnButtonClick">Edit3DShapeFilename</event>
                                                             <event name="OnChar"></event>
                                                             <event name="OnEnterWindow"></event>
                                                             <event name="OnEraseBackground"></event>
@@ -5327,6 +4511,8 @@
                                                             <event name="OnLeftDClick"></event>
                                                             <event name="OnLeftDown"></event>
                                                             <event name="OnLeftUp"></event>
+                                                            <event name="OnListBox">On3DShapeNameSelected</event>
+                                                            <event name="OnListBoxDClick">Edit3DShapeFilename</event>
                                                             <event name="OnMiddleDClick"></event>
                                                             <event name="OnMiddleDown"></event>
                                                             <event name="OnMiddleUp"></event>
@@ -5344,6 +4530,303 @@
                                                     </object>
                                                 </object>
                                             </object>
+                                            <object class="sizeritem" expanded="1">
+                                                <property name="border">5</property>
+                                                <property name="flag">wxEXPAND</property>
+                                                <property name="proportion">0</property>
+                                                <object class="wxBoxSizer" expanded="1">
+                                                    <property name="minimum_size"></property>
+                                                    <property name="name">bSizer19</property>
+                                                    <property name="orient">wxHORIZONTAL</property>
+                                                    <property name="permission">none</property>
+                                                    <object class="sizeritem" expanded="0">
+                                                        <property name="border">5</property>
+                                                        <property name="flag">wxALIGN_CENTER_VERTICAL</property>
+                                                        <property name="proportion">0</property>
+                                                        <object class="wxBoxSizer" expanded="0">
+                                                            <property name="minimum_size"></property>
+                                                            <property name="name">bSizer3DButtons</property>
+                                                            <property name="orient">wxVERTICAL</property>
+                                                            <property name="permission">none</property>
+                                                            <object class="sizeritem" expanded="0">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxEXPAND|wxLEFT|wxRIGHT|wxTOP</property>
+                                                                <property name="proportion">0</property>
+                                                                <object class="wxButton" expanded="0">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default">0</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">ID_ADD_3D_SHAPE</property>
+                                                                    <property name="label">Add 3D Shape</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_buttonAdd</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style"></property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnButtonClick">Add3DShape</event>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                            <object class="sizeritem" expanded="0">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxEXPAND|wxLEFT|wxRIGHT|wxTOP</property>
+                                                                <property name="proportion">0</property>
+                                                                <object class="wxButton" expanded="0">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default">0</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">ID_REMOVE_3D_SHAPE</property>
+                                                                    <property name="label">Remove 3D Shape</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_buttonRemove</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style"></property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnButtonClick">Remove3DShape</event>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                            <object class="sizeritem" expanded="0">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxEXPAND|wxLEFT|wxRIGHT|wxTOP</property>
+                                                                <property name="proportion">0</property>
+                                                                <object class="wxButton" expanded="0">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default">0</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">wxID_ANY</property>
+                                                                    <property name="label">Edit Filename</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_buttonEdit</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style"></property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnButtonClick">Edit3DShapeFilename</event>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                        </object>
+                                                    </object>
+                                                </object>
+                                            </object>
+                                        </object>
+                                    </object>
+                                    <object class="sizeritem" expanded="0">
+                                        <property name="border">5</property>
+                                        <property name="flag">wxEXPAND</property>
+                                        <property name="proportion">0</property>
+                                        <object class="wxBoxSizer" expanded="0">
+                                            <property name="minimum_size"></property>
+                                            <property name="name">bLowerSizer3D</property>
+                                            <property name="orient">wxHORIZONTAL</property>
+                                            <property name="permission">protected</property>
                                         </object>
                                     </object>
                                 </object>
@@ -5351,11 +4834,11 @@
                         </object>
                     </object>
                 </object>
-                <object class="sizeritem" expanded="1">
+                <object class="sizeritem" expanded="0">
                     <property name="border">5</property>
                     <property name="flag">wxALL|wxEXPAND</property>
                     <property name="proportion">0</property>
-                    <object class="wxStdDialogButtonSizer" expanded="1">
+                    <object class="wxStdDialogButtonSizer" expanded="0">
                         <property name="Apply">0</property>
                         <property name="Cancel">1</property>
                         <property name="ContextHelp">0</property>
diff --git a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.h b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.h
index c0a6410eba..e322dde142 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.h
+++ b/pcbnew/dialogs/dialog_edit_module_for_BoardEditor_base.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
-// C++ code generated with wxFormBuilder (version Jun  5 2014)
+// C++ code generated with wxFormBuilder (version Oct  5 2015)
 // http://www.wxformbuilder.org/
 //
 // PLEASE DO "NOT" EDIT THIS FILE!
@@ -103,19 +103,12 @@ class DIALOG_MODULE_BOARD_EDITOR_BASE : public DIALOG_SHIM
 		wxTextCtrl* m_SolderPasteMarginRatioCtrl;
 		wxStaticText* m_SolderPasteRatioMarginUnits;
 		wxPanel* m_Panel3D;
-		wxStaticText* m_staticText3Dname;
+		wxBoxSizer* bSizerMain3D;
 		wxListBox* m_3D_ShapeNameListBox;
-		wxStaticText* m_staticTextDefault3DPath;
-		wxTextCtrl* m_textCtrl3DDefaultPath;
-		wxBoxSizer* m_bSizerShapeScale;
-		wxStaticText* m_staticTextShapeScale;
-		wxBoxSizer* m_bSizerShapeOffset;
-		wxStaticText* m_staticTextShapeOffset;
-		wxBoxSizer* m_bSizerShapeRotation;
-		wxStaticText* m_staticTextShapeRotation;
 		wxButton* m_buttonAdd;
 		wxButton* m_buttonRemove;
 		wxButton* m_buttonEdit;
+		wxBoxSizer* bLowerSizer3D;
 		wxStdDialogButtonSizer* m_sdbSizerStdButtons;
 		wxButton* m_sdbSizerStdButtonsOK;
 		wxButton* m_sdbSizerStdButtonsCancel;
@@ -127,15 +120,14 @@ class DIALOG_MODULE_BOARD_EDITOR_BASE : public DIALOG_SHIM
 		virtual void ExchangeModule( wxCommandEvent& event ) { event.Skip(); }
 		virtual void GotoModuleEditor( wxCommandEvent& event ) { event.Skip(); }
 		virtual void On3DShapeNameSelected( wxCommandEvent& event ) { event.Skip(); }
+		virtual void Edit3DShapeFilename( wxCommandEvent& event ) { event.Skip(); }
 		virtual void Add3DShape( wxCommandEvent& event ) { event.Skip(); }
 		virtual void Remove3DShape( wxCommandEvent& event ) { event.Skip(); }
-		virtual void Edit3DShapeFilename( wxCommandEvent& event ) { event.Skip(); }
 		virtual void OnCancelClick( wxCommandEvent& event ) { event.Skip(); }
 		virtual void OnOkClick( wxCommandEvent& event ) { event.Skip(); }
 		
 	
 	public:
-		wxStaticBoxSizer* m_Sizer3DValues;
 		
 		DIALOG_MODULE_BOARD_EDITOR_BASE( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("Footprint Properties"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER ); 
 		~DIALOG_MODULE_BOARD_EDITOR_BASE();
diff --git a/pcbnew/dialogs/dialog_edit_module_for_Modedit.cpp b/pcbnew/dialogs/dialog_edit_module_for_Modedit.cpp
index a2f4acb12f..5075fae14e 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_Modedit.cpp
+++ b/pcbnew/dialogs/dialog_edit_module_for_Modedit.cpp
@@ -50,6 +50,8 @@
 #include <module_editor_frame.h>
 #include <dialog_edit_module_for_Modedit.h>
 #include <wildcards_and_files_ext.h>
+#include <3d_cache/dialogs/panel_prev_model.h>
+#include <3d_cache/dialogs/3d_cache_dialogs.h>
 
 size_t DIALOG_MODULE_MODULE_EDITOR::m_page = 0;     // remember the last open page during session
 
@@ -66,6 +68,10 @@ DIALOG_MODULE_MODULE_EDITOR::DIALOG_MODULE_MODULE_EDITOR( FOOTPRINT_EDIT_FRAME*
     icon.CopyFromBitmap( KiBitmap( icon_modedit_xpm ) );
     SetIcon( icon );
 
+    m_PreviewPane = new PANEL_PREV_3D( m_Panel3D, false );
+    m_PreviewPane->SetModelManager( Prj().Get3DCacheManager() );
+    bLowerSizer3D->Add( m_PreviewPane, 1, wxEXPAND, 5 );
+
     m_FootprintNameCtrl->SetValidator( FILE_NAME_CHAR_VALIDATOR() );
     initModeditProperties();
 
@@ -74,6 +80,7 @@ DIALOG_MODULE_MODULE_EDITOR::DIALOG_MODULE_MODULE_EDITOR( FOOTPRINT_EDIT_FRAME*
     m_sdbSizerStdButtonsOK->SetDefault();
     GetSizer()->SetSizeHints( this );
     Centre();
+    Layout();
 }
 
 
@@ -88,9 +95,6 @@ DIALOG_MODULE_MODULE_EDITOR::~DIALOG_MODULE_MODULE_EDITOR()
 
     delete m_referenceCopy;
     delete m_valueCopy;
-    delete m_3D_Scale;
-    delete m_3D_Offset;
-    delete m_3D_Rotation;
 }
 
 
@@ -104,7 +108,6 @@ void DIALOG_MODULE_MODULE_EDITOR::initModeditProperties()
 #ifdef __WINDOWS__
     default_path.Replace( wxT( "/" ), wxT( "\\" ) );
 #endif
-    m_textCtrl3DDefaultPath->SetValue( default_path );
 
     m_lastSelected3DShapeIndex = -1;
 
@@ -166,11 +169,6 @@ void DIALOG_MODULE_MODULE_EDITOR::initModeditProperties()
     m_CostRot90Ctrl->SetValue( m_currentModule->GetPlacementCost90() );
     m_CostRot180Ctrl->SetValue( m_currentModule->GetPlacementCost180() );
 
-    // Initialize 3D parameters
-    m_3D_Scale = new S3DPOINT_VALUE_CTRL( m_Panel3D, m_bSizerShapeScale );
-    m_3D_Offset = new S3DPOINT_VALUE_CTRL( m_Panel3D, m_bSizerShapeOffset );
-    m_3D_Rotation = new S3DPOINT_VALUE_CTRL( m_Panel3D, m_bSizerShapeRotation );
-
     // Initialize dialog relative to masks clearances
     m_NetClearanceUnits->SetLabel( GetAbbreviatedUnitsLabel( g_UserUnit ) );
     m_SolderMaskMarginUnits->SetLabel( GetAbbreviatedUnitsLabel( g_UserUnit ) );
@@ -220,17 +218,27 @@ void DIALOG_MODULE_MODULE_EDITOR::initModeditProperties()
 // Initialize 3D info displayed in dialog box from values in aStruct3DSource
 void DIALOG_MODULE_MODULE_EDITOR::Transfert3DValuesToDisplay( S3D_MASTER * aStruct3DSource )
 {
+    S3D_INFO params;
+
     if( aStruct3DSource )
     {
-        m_3D_Scale->SetValue( aStruct3DSource->m_MatScale );
-        m_3D_Offset->SetValue( aStruct3DSource->m_MatPosition );
-        m_3D_Rotation->SetValue( aStruct3DSource->m_MatRotation );
-    }
-    else
-    {
-        S3DPOINT dummy_vertex( 1.0, 1.0, 1.0 );
-        m_3D_Scale->SetValue( dummy_vertex );
+        params.filename = aStruct3DSource->GetShape3DName();
+
+        params.scale.x = aStruct3DSource->m_MatScale.x;
+        params.scale.y = aStruct3DSource->m_MatScale.y;
+        params.scale.z = aStruct3DSource->m_MatScale.z;
+
+        params.offset.x = aStruct3DSource->m_MatPosition.x;
+        params.offset.y = aStruct3DSource->m_MatPosition.y;
+        params.offset.z = aStruct3DSource->m_MatPosition.z;
+
+        params.rotation.x = aStruct3DSource->m_MatRotation.x;
+        params.rotation.y = aStruct3DSource->m_MatRotation.y;
+        params.rotation.z = aStruct3DSource->m_MatRotation.z;
     }
+
+    m_PreviewPane->SetModelData( &params );
+    return;
 }
 
 
@@ -239,13 +247,26 @@ void DIALOG_MODULE_MODULE_EDITOR::Transfert3DValuesToDisplay( S3D_MASTER * aStru
  */
 void DIALOG_MODULE_MODULE_EDITOR::TransfertDisplayTo3DValues( int aIndexSelection  )
 {
-    if( aIndexSelection >= (int)m_shapes3D_list.size() )
+    if( aIndexSelection >= (int) m_shapes3D_list.size() )
         return;
 
-    S3D_MASTER * struct3DDest = m_shapes3D_list[aIndexSelection];
-    struct3DDest->m_MatScale    = m_3D_Scale->GetValue();
-    struct3DDest->m_MatRotation = m_3D_Rotation->GetValue();
-    struct3DDest->m_MatPosition = m_3D_Offset->GetValue();
+    S3D_MASTER* struct3DDest = m_shapes3D_list[aIndexSelection];
+    S3D_INFO params;
+    m_PreviewPane->GetModelData( &params );
+
+    struct3DDest->m_MatScale.x = params.scale.x;
+    struct3DDest->m_MatScale.y = params.scale.y;
+    struct3DDest->m_MatScale.z = params.scale.z;
+
+    struct3DDest->m_MatRotation.x = params.rotation.x;
+    struct3DDest->m_MatRotation.y = params.rotation.y;
+    struct3DDest->m_MatRotation.z = params.rotation.z;
+
+    struct3DDest->m_MatPosition.x = params.offset.x;
+    struct3DDest->m_MatPosition.y = params.offset.y;
+    struct3DDest->m_MatPosition.z = params.offset.z;
+
+    return;
 }
 
 
@@ -276,21 +297,27 @@ void DIALOG_MODULE_MODULE_EDITOR::Remove3DShape(wxCommandEvent& event)
         TransfertDisplayTo3DValues( m_lastSelected3DShapeIndex );
 
     int ii = m_3D_ShapeNameListBox->GetSelection();
-
     if( ii < 0 )
         return;
 
     m_shapes3D_list.erase( m_shapes3D_list.begin() + ii );
     m_3D_ShapeNameListBox->Delete( ii );
 
-    if( m_3D_ShapeNameListBox->GetCount() == 0)
+    if( m_3D_ShapeNameListBox->GetCount() == 0 )
         Transfert3DValuesToDisplay( NULL );
     else
     {
-        m_lastSelected3DShapeIndex = 0;
+        if( ii > 0 )
+            m_lastSelected3DShapeIndex = ii - 1;
+        else
+            m_lastSelected3DShapeIndex = 0;
+
         m_3D_ShapeNameListBox->SetSelection( m_lastSelected3DShapeIndex );
-        Transfert3DValuesToDisplay( m_shapes3D_list[m_lastSelected3DShapeIndex] );
+        Transfert3DValuesToDisplay(
+            m_shapes3D_list[m_lastSelected3DShapeIndex] );
     }
+
+    return;
 }
 
 
@@ -328,81 +355,57 @@ void DIALOG_MODULE_MODULE_EDITOR::Edit3DShapeFileName()
 void DIALOG_MODULE_MODULE_EDITOR::BrowseAndAdd3DShapeFile()
 {
     PROJECT&        prj = Prj();
-
-    // here, the KISYS3DMOD default path for 3D shape files is expected
-    // to be already defined (when starting Pcbnew, it is defined
-    // from the user defined env variable, or set to a default value)
-    wxFileName fn( wxGetenv( KISYS3DMOD ), wxEmptyString );
-    wxString default3DPath = fn.GetPathWithSep();
+    S3D_INFO model;
 
     wxString initialpath = prj.GetRString( PROJECT::VIEWER_3D_PATH );
+    wxString sidx = prj.GetRString( PROJECT::VIEWER_3D_FILTER_INDEX );
+    int filter = 0;
 
-    if( !initialpath )
-        initialpath = default3DPath;
-
-#ifdef __WINDOWS__
-    initialpath.Replace( wxT( "/" ), wxT( "\\" ) );
-#endif
-
-    wxString fileFilters = wxGetTranslation( Shapes3DFileWildcard );
-
-    fileFilters += wxChar(  '|' );
-    fileFilters += wxGetTranslation( IDF3DFileWildcard );
-
-    wxString filename = EDA_FILE_SELECTOR( _( "3D Shape:" ), initialpath,
-                                           wxEmptyString, wxEmptyString,
-                                           wxGetTranslation( fileFilters ),
-                                           this, wxFD_OPEN, true );
-
-    if( filename.IsEmpty() )
-        return;
-
-    fn = filename;
-
-    prj.SetRString( PROJECT::VIEWER_3D_PATH, fn.GetPath() );
-
-    /* If the file path is already in the 3D shape file default path
-     * just add the file name relative to this path to the list.
-     * Otherwise, add the file name with a full or relative path.
-     * The relative path, when possible, is preferable
-     * because it preserve use of default path, when the path is a sub path of this path
-     */
-    wxString rootpath = filename.SubString( 0, default3DPath.Length()-1 );
-    bool useRelPath = rootpath.IsSameAs( default3DPath, wxFileName::IsCaseSensitive() );
-
-    if( useRelPath )
-        fn.MakeRelativeTo( default3DPath );
-    else    // Absolute path given, not a subpath of the default path,
-            // therefore ask if the user wants a relative (to the default path) one
+    if( !sidx.empty() )
     {
-        wxString msg;
-        msg.Printf( _( "Use a path relative to '%s'?" ), GetChars( default3DPath ) );
-        int diag = wxMessageBox( msg, _( "Path type" ),
-                                 wxYES_NO | wxICON_QUESTION, this );
+        long tmp;
+        sidx.ToLong( &tmp );
 
-        if( diag == wxYES )     // Make it relative to the default 3D path
-            fn.MakeRelativeTo( default3DPath );
+        if( tmp > 0 && tmp <= 0x7FFFFFFF )
+            filter = (int) tmp;
     }
 
-    filename = fn.GetFullPath();
+    if( !S3D::Select3DModel( m_PreviewPane, Prj().Get3DCacheManager(),
+                             initialpath, filter, &model ) )
+    {
+        return;
+    }
 
-    S3D_MASTER* new3DShape = new S3D_MASTER(NULL);
+    prj.SetRString( PROJECT::VIEWER_3D_PATH, initialpath );
+    sidx = wxString::Format( wxT( "%i" ), filter );
+    prj.SetRString( PROJECT::VIEWER_3D_FILTER_INDEX, sidx );
+
+    S3D_MASTER* new3DShape = new S3D_MASTER( NULL );
 
 #ifdef __WINDOWS__
-    // Store filename in Unix notation
-    filename.Replace( wxT( "\\" ), wxT( "/" ) );
+    // In Kicad files, filenames and paths are stored using Unix notation
+    model.filename.Replace( wxT( "\\" ), wxT( "/" ) );
 #endif
 
-    new3DShape->SetShape3DName( filename );
-    m_shapes3D_list.push_back( new3DShape );
-    m_3D_ShapeNameListBox->Append( filename );
+    new3DShape->SetShape3DName( model.filename );
+    new3DShape->m_MatScale.x = model.scale.x;
+    new3DShape->m_MatScale.y = model.scale.y;
+    new3DShape->m_MatScale.z = model.scale.z;
+    new3DShape->m_MatRotation.x = model.rotation.x;
+    new3DShape->m_MatRotation.y = model.rotation.y;
+    new3DShape->m_MatRotation.z = model.rotation.z;
+    new3DShape->m_MatPosition.x = model.offset.x;
+    new3DShape->m_MatPosition.y = model.offset.y;
+    new3DShape->m_MatPosition.z = model.offset.z;
 
-    if( m_lastSelected3DShapeIndex >= 0 )
-        TransfertDisplayTo3DValues( m_lastSelected3DShapeIndex );
+    m_shapes3D_list.push_back( new3DShape );
+    m_3D_ShapeNameListBox->Append( model.filename );
 
     m_lastSelected3DShapeIndex = m_3D_ShapeNameListBox->GetCount() - 1;
     m_3D_ShapeNameListBox->SetSelection( m_lastSelected3DShapeIndex );
     Transfert3DValuesToDisplay( m_shapes3D_list[m_lastSelected3DShapeIndex] );
+
+    return;
 }
 
 
diff --git a/pcbnew/dialogs/dialog_edit_module_for_Modedit.h b/pcbnew/dialogs/dialog_edit_module_for_Modedit.h
index 06fac763b2..61a71ad4bc 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_Modedit.h
+++ b/pcbnew/dialogs/dialog_edit_module_for_Modedit.h
@@ -28,21 +28,22 @@
 // Include the wxFormBuider header base:
 #include <vector>
 #include <dialog_edit_module_for_Modedit_base.h>
+#include <3d_struct.h>
+
+class PANEL_PREV_3D;
 
 class DIALOG_MODULE_MODULE_EDITOR : public DIALOG_MODULE_MODULE_EDITOR_BASE
 {
 private:
 
-    FOOTPRINT_EDIT_FRAME*   m_parent;
-    MODULE* m_currentModule;
-    TEXTE_MODULE* m_referenceCopy;
-    TEXTE_MODULE* m_valueCopy;
-    std::vector <S3D_MASTER*> m_shapes3D_list;
-    int m_lastSelected3DShapeIndex;
-    S3DPOINT_VALUE_CTRL * m_3D_Scale;
-    S3DPOINT_VALUE_CTRL * m_3D_Offset;
-    S3DPOINT_VALUE_CTRL * m_3D_Rotation;
-    static size_t m_page;     // remember the last open page during session
+    FOOTPRINT_EDIT_FRAME*       m_parent;
+    MODULE*                     m_currentModule;
+    TEXTE_MODULE*               m_referenceCopy;
+    TEXTE_MODULE*               m_valueCopy;
+    std::vector <S3D_MASTER*>   m_shapes3D_list;
+    int                         m_lastSelected3DShapeIndex;
+    static size_t               m_page; // remember the last open page during session
+    PANEL_PREV_3D*              m_PreviewPane;
 
 public:
 
diff --git a/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.cpp b/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.cpp
index 535a6876f4..cea8ee12bd 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.cpp
+++ b/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
-// C++ code generated with wxFormBuilder (version Mar  9 2015)
+// C++ code generated with wxFormBuilder (version Oct  5 2015)
 // http://www.wxformbuilder.org/
 //
 // PLEASE DO "NOT" EDIT THIS FILE!
@@ -23,51 +23,51 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	wxStaticBoxSizer* PropLeftSizer;
 	PropLeftSizer = new wxStaticBoxSizer( new wxStaticBox( m_PanelProperties, wxID_ANY, _("Fields") ), wxVERTICAL );
 	
-	m_staticTextDoc = new wxStaticText( m_PanelProperties, wxID_ANY, _("Doc"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextDoc = new wxStaticText( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Doc"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextDoc->Wrap( -1 );
 	PropLeftSizer->Add( m_staticTextDoc, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	m_DocCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_DocCtrl = new wxTextCtrl( PropLeftSizer->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_DocCtrl->SetMaxLength( 0 ); 
 	PropLeftSizer->Add( m_DocCtrl, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxEXPAND, 5 );
 	
-	m_staticTextKeywords = new wxStaticText( m_PanelProperties, wxID_ANY, _("Keywords"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextKeywords = new wxStaticText( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Keywords"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextKeywords->Wrap( -1 );
 	PropLeftSizer->Add( m_staticTextKeywords, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	m_KeywordCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_KeywordCtrl = new wxTextCtrl( PropLeftSizer->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_KeywordCtrl->SetMaxLength( 0 ); 
 	PropLeftSizer->Add( m_KeywordCtrl, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxEXPAND, 5 );
 	
-	m_staticTextRef = new wxStaticText( m_PanelProperties, wxID_ANY, _("Reference"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextRef = new wxStaticText( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Reference"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextRef->Wrap( -1 );
 	PropLeftSizer->Add( m_staticTextRef, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 	
 	wxBoxSizer* bSizerRef;
 	bSizerRef = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_ReferenceCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
+	m_ReferenceCtrl = new wxTextCtrl( PropLeftSizer->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
 	m_ReferenceCtrl->SetMaxLength( 0 ); 
 	bSizerRef->Add( m_ReferenceCtrl, 1, wxBOTTOM|wxLEFT|wxRIGHT, 5 );
 	
-	m_button4 = new wxButton( m_PanelProperties, wxID_ANY, _("Edit"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
+	m_button4 = new wxButton( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Edit"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 	bSizerRef->Add( m_button4, 0, wxBOTTOM|wxRIGHT, 5 );
 	
 	
 	PropLeftSizer->Add( bSizerRef, 0, wxEXPAND, 5 );
 	
-	m_staticTextVal = new wxStaticText( m_PanelProperties, wxID_ANY, _("Value"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextVal = new wxStaticText( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Value"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextVal->Wrap( -1 );
 	PropLeftSizer->Add( m_staticTextVal, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 	
 	wxBoxSizer* bSizerVal;
 	bSizerVal = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_ValueCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
+	m_ValueCtrl = new wxTextCtrl( PropLeftSizer->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
 	m_ValueCtrl->SetMaxLength( 0 ); 
 	bSizerVal->Add( m_ValueCtrl, 1, wxBOTTOM|wxLEFT|wxRIGHT, 5 );
 	
-	m_button5 = new wxButton( m_PanelProperties, wxID_ANY, _("Edit"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
+	m_button5 = new wxButton( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Edit"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 	bSizerVal->Add( m_button5, 0, wxBOTTOM|wxRIGHT, 5 );
 	
 	
@@ -76,11 +76,11 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	
 	PropLeftSizer->Add( 0, 20, 0, 0, 5 );
 	
-	m_staticTextFp = new wxStaticText( m_PanelProperties, wxID_ANY, _("Footprint Name in Library"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextFp = new wxStaticText( PropLeftSizer->GetStaticBox(), wxID_ANY, _("Footprint Name in Library"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextFp->Wrap( -1 );
 	PropLeftSizer->Add( m_staticTextFp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	m_FootprintNameCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_FootprintNameCtrl = new wxTextCtrl( PropLeftSizer->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_FootprintNameCtrl->SetMaxLength( 0 ); 
 	PropLeftSizer->Add( m_FootprintNameCtrl, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxEXPAND, 5 );
 	
@@ -116,11 +116,11 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	wxBoxSizer* bSizerRot90;
 	bSizerRot90 = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticText11 = new wxStaticText( m_PanelProperties, wxID_ANY, _("Rotation 90 degree"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticText11 = new wxStaticText( sbSizerAutoplace->GetStaticBox(), wxID_ANY, _("Rotation 90 degree"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticText11->Wrap( -1 );
 	bSizerRot90->Add( m_staticText11, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5 );
 	
-	m_CostRot90Ctrl = new wxSlider( m_PanelProperties, wxID_ANY, 0, 0, 10, wxDefaultPosition, wxSize( -1,-1 ), wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
+	m_CostRot90Ctrl = new wxSlider( sbSizerAutoplace->GetStaticBox(), wxID_ANY, 0, 0, 10, wxDefaultPosition, wxSize( -1,-1 ), wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
 	bSizerRot90->Add( m_CostRot90Ctrl, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
 	
 	
@@ -129,11 +129,11 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	wxBoxSizer* bSizerRot180;
 	bSizerRot180 = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticText12 = new wxStaticText( m_PanelProperties, wxID_ANY, _("Rotation 180 degree"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticText12 = new wxStaticText( sbSizerAutoplace->GetStaticBox(), wxID_ANY, _("Rotation 180 degree"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticText12->Wrap( -1 );
 	bSizerRot180->Add( m_staticText12, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5 );
 	
-	m_CostRot180Ctrl = new wxSlider( m_PanelProperties, wxID_ANY, 0, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
+	m_CostRot180Ctrl = new wxSlider( sbSizerAutoplace->GetStaticBox(), wxID_ANY, 0, 0, 10, wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS|wxSL_HORIZONTAL|wxSL_LABELS );
 	bSizerRot180->Add( m_CostRot180Ctrl, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
 	
 	
@@ -145,7 +145,7 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	wxStaticBoxSizer* sbSizer8;
 	sbSizer8 = new wxStaticBoxSizer( new wxStaticBox( m_PanelProperties, wxID_ANY, _("Local Clearance Values") ), wxVERTICAL );
 	
-	m_staticTextInfo = new wxStaticText( m_PanelProperties, wxID_ANY, _("Set clearances to 0 to use global values"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextInfo = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Set clearances to 0 to use global values"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextInfo->Wrap( -1 );
 	m_staticTextInfo->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 92, false, wxEmptyString ) );
 	
@@ -157,66 +157,66 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	fgSizer1->SetFlexibleDirection( wxBOTH );
 	fgSizer1->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 	
-	m_staticTextNetClearance = new wxStaticText( m_PanelProperties, wxID_ANY, _("Pad clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextNetClearance = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Pad clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextNetClearance->Wrap( -1 );
 	fgSizer1->Add( m_staticTextNetClearance, 0, wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_NetClearanceValueCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_NetClearanceValueCtrl = new wxTextCtrl( sbSizer8->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_NetClearanceValueCtrl->SetMaxLength( 0 ); 
 	fgSizer1->Add( m_NetClearanceValueCtrl, 0, wxALL|wxEXPAND, 5 );
 	
-	m_NetClearanceUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_NetClearanceUnits = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_NetClearanceUnits->Wrap( -1 );
 	fgSizer1->Add( m_NetClearanceUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_staticline1 = new wxStaticLine( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+	m_staticline1 = new wxStaticLine( sbSizer8->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 	fgSizer1->Add( m_staticline1, 0, wxEXPAND, 5 );
 	
-	m_staticline2 = new wxStaticLine( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+	m_staticline2 = new wxStaticLine( sbSizer8->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 	fgSizer1->Add( m_staticline2, 0, wxEXPAND, 5 );
 	
-	m_staticline3 = new wxStaticLine( m_PanelProperties, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+	m_staticline3 = new wxStaticLine( sbSizer8->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 	fgSizer1->Add( m_staticline3, 0, wxEXPAND, 5 );
 	
-	m_MaskClearanceTitle = new wxStaticText( m_PanelProperties, wxID_ANY, _("Solder mask clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_MaskClearanceTitle = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Solder mask clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_MaskClearanceTitle->Wrap( -1 );
 	m_MaskClearanceTitle->SetToolTip( _("This is the local clearance between pads and the solder mask\nfor this footprint\nThis value can be superseded by a pad local value.\nIf 0, the global value is used") );
 	
 	fgSizer1->Add( m_MaskClearanceTitle, 0, wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 	
-	m_SolderMaskMarginCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderMaskMarginCtrl = new wxTextCtrl( sbSizer8->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderMaskMarginCtrl->SetMaxLength( 0 ); 
 	fgSizer1->Add( m_SolderMaskMarginCtrl, 0, wxALL|wxEXPAND, 5 );
 	
-	m_SolderMaskMarginUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("inch"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderMaskMarginUnits = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("inch"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderMaskMarginUnits->Wrap( -1 );
 	fgSizer1->Add( m_SolderMaskMarginUnits, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 	
-	m_staticTextSolderPaste = new wxStaticText( m_PanelProperties, wxID_ANY, _("Solder paste clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextSolderPaste = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Solder paste clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextSolderPaste->Wrap( -1 );
 	m_staticTextSolderPaste->SetToolTip( _("This is the local clearance between pads and the solder paste\nfor this footprint.\nThis value can be superseded by a pad local values.\nThe final clearance value is the sum of this value and the clearance value ratio\nA negative value means a smaller mask size than pad size") );
 	
 	fgSizer1->Add( m_staticTextSolderPaste, 0, wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 	
-	m_SolderPasteMarginCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteMarginCtrl = new wxTextCtrl( sbSizer8->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteMarginCtrl->SetMaxLength( 0 ); 
 	fgSizer1->Add( m_SolderPasteMarginCtrl, 0, wxTOP|wxRIGHT|wxLEFT|wxEXPAND, 5 );
 	
-	m_SolderPasteMarginUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteMarginUnits = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteMarginUnits->Wrap( -1 );
 	fgSizer1->Add( m_SolderPasteMarginUnits, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 	
-	m_staticTextRatio = new wxStaticText( m_PanelProperties, wxID_ANY, _("Solder paste ratio clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticTextRatio = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("Solder paste ratio clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticTextRatio->Wrap( -1 );
 	m_staticTextRatio->SetToolTip( _("This is the local clearance ratio in per cent between pads and the solder paste\nfor this footprint.\nA value of 10 means the clearance value is 10 per cent of the pad size\nThis value can be superseded by a pad local value.\nThe final clearance value is the sum of this value and the clearance value\nA negative value means a smaller mask size than pad size.") );
 	
 	fgSizer1->Add( m_staticTextRatio, 0, wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 	
-	m_SolderPasteMarginRatioCtrl = new wxTextCtrl( m_PanelProperties, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteMarginRatioCtrl = new wxTextCtrl( sbSizer8->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteMarginRatioCtrl->SetMaxLength( 0 ); 
 	fgSizer1->Add( m_SolderPasteMarginRatioCtrl, 0, wxALL|wxEXPAND, 5 );
 	
-	m_SolderPasteRatioMarginUnits = new wxStaticText( m_PanelProperties, wxID_ANY, _("%"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_SolderPasteRatioMarginUnits = new wxStaticText( sbSizer8->GetStaticBox(), wxID_ANY, _("%"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_SolderPasteRatioMarginUnits->Wrap( -1 );
 	fgSizer1->Add( m_SolderPasteRatioMarginUnits, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 	
@@ -233,74 +233,48 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	m_PanelProperties->SetSizer( m_PanelPropertiesBoxSizer );
 	m_PanelProperties->Layout();
 	m_PanelPropertiesBoxSizer->Fit( m_PanelProperties );
-	m_NoteBook->AddPage( m_PanelProperties, _("Properties"), true );
+	m_NoteBook->AddPage( m_PanelProperties, _("Properties"), false );
 	m_Panel3D = new wxPanel( m_NoteBook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
 	wxBoxSizer* bSizerMain3D;
 	bSizerMain3D = new wxBoxSizer( wxVERTICAL );
 	
-	m_staticText3Dname = new wxStaticText( m_Panel3D, wxID_ANY, _("3D Shape Names"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText3Dname->Wrap( -1 );
-	bSizerMain3D->Add( m_staticText3Dname, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+	wxStaticBoxSizer* sbSizer4;
+	sbSizer4 = new wxStaticBoxSizer( new wxStaticBox( m_Panel3D, wxID_ANY, _("3D Shape Names") ), wxVERTICAL );
 	
-	m_3D_ShapeNameListBox = new wxListBox( m_Panel3D, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE ); 
-	bSizerMain3D->Add( m_3D_ShapeNameListBox, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+	wxBoxSizer* bSizer15;
+	bSizer15 = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_staticTextDefault3DPath = new wxStaticText( m_Panel3D, wxID_ANY, _("Default Path (from KISYS3DMOD environment variable)"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextDefault3DPath->Wrap( -1 );
-	bSizerMain3D->Add( m_staticTextDefault3DPath, 0, wxRIGHT|wxLEFT, 5 );
+	wxBoxSizer* bSizer16;
+	bSizer16 = new wxBoxSizer( wxVERTICAL );
 	
-	m_textCtrl3DDefaultPath = new wxTextCtrl( m_Panel3D, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
-	bSizerMain3D->Add( m_textCtrl3DDefaultPath, 0, wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND, 5 );
-	
-	wxBoxSizer* bLowerSizer3D;
-	bLowerSizer3D = new wxBoxSizer( wxHORIZONTAL );
-	
-	m_Sizer3DValues = new wxStaticBoxSizer( new wxStaticBox( m_Panel3D, wxID_ANY, _("3D Scale and Position") ), wxVERTICAL );
-	
-	m_bSizerShapeScale = new wxBoxSizer( wxVERTICAL );
-	
-	m_staticTextShapeScale = new wxStaticText( m_Panel3D, wxID_ANY, _("Shape Scale:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextShapeScale->Wrap( -1 );
-	m_bSizerShapeScale->Add( m_staticTextShapeScale, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+	m_3D_ShapeNameListBox = new wxListBox( sbSizer4->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE ); 
+	bSizer16->Add( m_3D_ShapeNameListBox, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 	
 	
-	m_Sizer3DValues->Add( m_bSizerShapeScale, 0, wxEXPAND, 5 );
-	
-	m_bSizerShapeOffset = new wxBoxSizer( wxVERTICAL );
-	
-	m_staticTextShapeOffset = new wxStaticText( m_Panel3D, wxID_ANY, _("Shape Offset (inch):"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextShapeOffset->Wrap( -1 );
-	m_bSizerShapeOffset->Add( m_staticTextShapeOffset, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
-	
-	
-	m_Sizer3DValues->Add( m_bSizerShapeOffset, 0, wxEXPAND, 5 );
-	
-	m_bSizerShapeRotation = new wxBoxSizer( wxVERTICAL );
-	
-	m_staticTextShapeRotation = new wxStaticText( m_Panel3D, wxID_ANY, _("Shape Rotation (degrees):"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextShapeRotation->Wrap( -1 );
-	m_bSizerShapeRotation->Add( m_staticTextShapeRotation, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
-	
-	
-	m_Sizer3DValues->Add( m_bSizerShapeRotation, 0, wxEXPAND, 5 );
-	
-	
-	bLowerSizer3D->Add( m_Sizer3DValues, 1, wxEXPAND, 5 );
+	bSizer15->Add( bSizer16, 1, wxEXPAND, 5 );
 	
 	wxBoxSizer* bSizer3DButtons;
 	bSizer3DButtons = new wxBoxSizer( wxVERTICAL );
 	
-	m_buttonBrowse = new wxButton( m_Panel3D, ID_BROWSE_3D_LIB, _("Add 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_buttonBrowse = new wxButton( sbSizer4->GetStaticBox(), ID_BROWSE_3D_LIB, _("Add 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
 	bSizer3DButtons->Add( m_buttonBrowse, 0, wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	m_buttonRemove = new wxButton( m_Panel3D, ID_REMOVE_3D_SHAPE, _("Remove 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_buttonRemove = new wxButton( sbSizer4->GetStaticBox(), ID_REMOVE_3D_SHAPE, _("Remove 3D Shape"), wxDefaultPosition, wxDefaultSize, 0 );
 	bSizer3DButtons->Add( m_buttonRemove, 0, wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	m_buttonEdit = new wxButton( m_Panel3D, wxID_ANY, _("Edit Filename"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_buttonEdit = new wxButton( sbSizer4->GetStaticBox(), wxID_ANY, _("Edit Filename"), wxDefaultPosition, wxDefaultSize, 0 );
 	bSizer3DButtons->Add( m_buttonEdit, 0, wxALL|wxEXPAND, 5 );
 	
 	
-	bLowerSizer3D->Add( bSizer3DButtons, 0, wxALIGN_CENTER_VERTICAL, 5 );
+	bSizer15->Add( bSizer3DButtons, 0, wxALIGN_CENTER_VERTICAL, 5 );
+	
+	
+	sbSizer4->Add( bSizer15, 1, wxEXPAND, 5 );
+	
+	
+	bSizerMain3D->Add( sbSizer4, 1, wxEXPAND, 5 );
+	
+	bLowerSizer3D = new wxBoxSizer( wxHORIZONTAL );
 	
 	
 	bSizerMain3D->Add( bLowerSizer3D, 0, wxALL|wxEXPAND, 5 );
@@ -309,7 +283,7 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	m_Panel3D->SetSizer( bSizerMain3D );
 	m_Panel3D->Layout();
 	bSizerMain3D->Fit( m_Panel3D );
-	m_NoteBook->AddPage( m_Panel3D, _("3D settings"), false );
+	m_NoteBook->AddPage( m_Panel3D, _("3D settings"), true );
 	
 	m_GeneralBoxSizer->Add( m_NoteBook, 1, wxEXPAND | wxALL, 5 );
 	
@@ -330,6 +304,7 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::DIALOG_MODULE_MODULE_EDITOR_BASE( wxWindow* pa
 	m_button4->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::OnEditReference ), NULL, this );
 	m_button5->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::OnEditValue ), NULL, this );
 	m_3D_ShapeNameListBox->Connect( wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::On3DShapeNameSelected ), NULL, this );
+	m_3D_ShapeNameListBox->Connect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
 	m_buttonBrowse->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Add3DShape ), NULL, this );
 	m_buttonRemove->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Remove3DShape ), NULL, this );
 	m_buttonEdit->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
@@ -343,6 +318,7 @@ DIALOG_MODULE_MODULE_EDITOR_BASE::~DIALOG_MODULE_MODULE_EDITOR_BASE()
 	m_button4->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::OnEditReference ), NULL, this );
 	m_button5->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::OnEditValue ), NULL, this );
 	m_3D_ShapeNameListBox->Disconnect( wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::On3DShapeNameSelected ), NULL, this );
+	m_3D_ShapeNameListBox->Disconnect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
 	m_buttonBrowse->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Add3DShape ), NULL, this );
 	m_buttonRemove->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Remove3DShape ), NULL, this );
 	m_buttonEdit->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_MODULE_MODULE_EDITOR_BASE::Edit3DShapeFilename ), NULL, this );
diff --git a/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.fbp b/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.fbp
index 8757782efb..a6c8db804b 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.fbp
+++ b/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.fbp
@@ -178,7 +178,7 @@
                         <object class="notebookpage" expanded="1">
                             <property name="bitmap"></property>
                             <property name="label">Properties</property>
-                            <property name="select">1</property>
+                            <property name="select">0</property>
                             <object class="wxPanel" expanded="0">
                                 <property name="BottomDockable">1</property>
                                 <property name="LeftDockable">1</property>
@@ -3372,7 +3372,7 @@
                         <object class="notebookpage" expanded="1">
                             <property name="bitmap"></property>
                             <property name="label">3D settings</property>
-                            <property name="select">0</property>
+                            <property name="select">1</property>
                             <object class="wxPanel" expanded="1">
                                 <property name="BottomDockable">1</property>
                                 <property name="LeftDockable">1</property>
@@ -3454,347 +3454,401 @@
                                     <property name="permission">none</property>
                                     <object class="sizeritem" expanded="1">
                                         <property name="border">5</property>
-                                        <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxStaticText" expanded="1">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
+                                        <property name="flag">wxEXPAND</property>
+                                        <property name="proportion">1</property>
+                                        <object class="wxStaticBoxSizer" expanded="1">
                                             <property name="id">wxID_ANY</property>
                                             <property name="label">3D Shape Names</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
                                             <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_staticText3Dname</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style"></property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <property name="wrap">-1</property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
-                                    <object class="sizeritem" expanded="1">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT</property>
-                                        <property name="proportion">1</property>
-                                        <object class="wxListBox" expanded="1">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="choices"></property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_3D_ShapeNameListBox</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style">wxLB_SINGLE</property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="validator_data_type"></property>
-                                            <property name="validator_style">wxFILTER_NONE</property>
-                                            <property name="validator_type">wxDefaultValidator</property>
-                                            <property name="validator_variable"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnListBox">On3DShapeNameSelected</event>
-                                            <event name="OnListBoxDClick"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
-                                    <object class="sizeritem" expanded="1">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxRIGHT|wxLEFT</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxStaticText" expanded="1">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="label">Default Path (from KISYS3DMOD environment variable)</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_staticTextDefault3DPath</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style"></property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <property name="wrap">-1</property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnUpdateUI"></event>
-                                        </object>
-                                    </object>
-                                    <object class="sizeritem" expanded="1">
-                                        <property name="border">5</property>
-                                        <property name="flag">wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND</property>
-                                        <property name="proportion">0</property>
-                                        <object class="wxTextCtrl" expanded="1">
-                                            <property name="BottomDockable">1</property>
-                                            <property name="LeftDockable">1</property>
-                                            <property name="RightDockable">1</property>
-                                            <property name="TopDockable">1</property>
-                                            <property name="aui_layer"></property>
-                                            <property name="aui_name"></property>
-                                            <property name="aui_position"></property>
-                                            <property name="aui_row"></property>
-                                            <property name="best_size"></property>
-                                            <property name="bg"></property>
-                                            <property name="caption"></property>
-                                            <property name="caption_visible">1</property>
-                                            <property name="center_pane">0</property>
-                                            <property name="close_button">1</property>
-                                            <property name="context_help"></property>
-                                            <property name="context_menu">1</property>
-                                            <property name="default_pane">0</property>
-                                            <property name="dock">Dock</property>
-                                            <property name="dock_fixed">0</property>
-                                            <property name="docking">Left</property>
-                                            <property name="enabled">1</property>
-                                            <property name="fg"></property>
-                                            <property name="floatable">1</property>
-                                            <property name="font"></property>
-                                            <property name="gripper">0</property>
-                                            <property name="hidden">0</property>
-                                            <property name="id">wxID_ANY</property>
-                                            <property name="max_size"></property>
-                                            <property name="maximize_button">0</property>
-                                            <property name="maximum_size"></property>
-                                            <property name="maxlength"></property>
-                                            <property name="min_size"></property>
-                                            <property name="minimize_button">0</property>
-                                            <property name="minimum_size"></property>
-                                            <property name="moveable">1</property>
-                                            <property name="name">m_textCtrl3DDefaultPath</property>
-                                            <property name="pane_border">1</property>
-                                            <property name="pane_position"></property>
-                                            <property name="pane_size"></property>
-                                            <property name="permission">protected</property>
-                                            <property name="pin_button">1</property>
-                                            <property name="pos"></property>
-                                            <property name="resize">Resizable</property>
-                                            <property name="show">1</property>
-                                            <property name="size"></property>
-                                            <property name="style">wxTE_READONLY</property>
-                                            <property name="subclass"></property>
-                                            <property name="toolbar_pane">0</property>
-                                            <property name="tooltip"></property>
-                                            <property name="validator_data_type"></property>
-                                            <property name="validator_style">wxFILTER_NONE</property>
-                                            <property name="validator_type">wxDefaultValidator</property>
-                                            <property name="validator_variable"></property>
-                                            <property name="value"></property>
-                                            <property name="window_extra_style"></property>
-                                            <property name="window_name"></property>
-                                            <property name="window_style"></property>
-                                            <event name="OnChar"></event>
-                                            <event name="OnEnterWindow"></event>
-                                            <event name="OnEraseBackground"></event>
-                                            <event name="OnKeyDown"></event>
-                                            <event name="OnKeyUp"></event>
-                                            <event name="OnKillFocus"></event>
-                                            <event name="OnLeaveWindow"></event>
-                                            <event name="OnLeftDClick"></event>
-                                            <event name="OnLeftDown"></event>
-                                            <event name="OnLeftUp"></event>
-                                            <event name="OnMiddleDClick"></event>
-                                            <event name="OnMiddleDown"></event>
-                                            <event name="OnMiddleUp"></event>
-                                            <event name="OnMotion"></event>
-                                            <event name="OnMouseEvents"></event>
-                                            <event name="OnMouseWheel"></event>
-                                            <event name="OnPaint"></event>
-                                            <event name="OnRightDClick"></event>
-                                            <event name="OnRightDown"></event>
-                                            <event name="OnRightUp"></event>
-                                            <event name="OnSetFocus"></event>
-                                            <event name="OnSize"></event>
-                                            <event name="OnText"></event>
-                                            <event name="OnTextEnter"></event>
-                                            <event name="OnTextMaxLen"></event>
-                                            <event name="OnTextURL"></event>
+                                            <property name="name">sbSizer4</property>
+                                            <property name="orient">wxVERTICAL</property>
+                                            <property name="permission">none</property>
                                             <event name="OnUpdateUI"></event>
+                                            <object class="sizeritem" expanded="1">
+                                                <property name="border">5</property>
+                                                <property name="flag">wxEXPAND</property>
+                                                <property name="proportion">1</property>
+                                                <object class="wxBoxSizer" expanded="1">
+                                                    <property name="minimum_size"></property>
+                                                    <property name="name">bSizer15</property>
+                                                    <property name="orient">wxHORIZONTAL</property>
+                                                    <property name="permission">none</property>
+                                                    <object class="sizeritem" expanded="1">
+                                                        <property name="border">5</property>
+                                                        <property name="flag">wxEXPAND</property>
+                                                        <property name="proportion">1</property>
+                                                        <object class="wxBoxSizer" expanded="1">
+                                                            <property name="minimum_size"></property>
+                                                            <property name="name">bSizer16</property>
+                                                            <property name="orient">wxVERTICAL</property>
+                                                            <property name="permission">none</property>
+                                                            <object class="sizeritem" expanded="0">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT</property>
+                                                                <property name="proportion">1</property>
+                                                                <object class="wxListBox" expanded="0">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="choices"></property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">wxID_ANY</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_3D_ShapeNameListBox</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style">wxLB_SINGLE</property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnListBox">On3DShapeNameSelected</event>
+                                                                    <event name="OnListBoxDClick">Edit3DShapeFilename</event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                        </object>
+                                                    </object>
+                                                    <object class="sizeritem" expanded="0">
+                                                        <property name="border">5</property>
+                                                        <property name="flag">wxALIGN_CENTER_VERTICAL</property>
+                                                        <property name="proportion">0</property>
+                                                        <object class="wxBoxSizer" expanded="0">
+                                                            <property name="minimum_size"></property>
+                                                            <property name="name">bSizer3DButtons</property>
+                                                            <property name="orient">wxVERTICAL</property>
+                                                            <property name="permission">none</property>
+                                                            <object class="sizeritem" expanded="0">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxEXPAND|wxTOP|wxRIGHT|wxLEFT</property>
+                                                                <property name="proportion">0</property>
+                                                                <object class="wxButton" expanded="0">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default">0</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">ID_BROWSE_3D_LIB</property>
+                                                                    <property name="label">Add 3D Shape</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_buttonBrowse</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style"></property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnButtonClick">Add3DShape</event>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                            <object class="sizeritem" expanded="0">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxEXPAND|wxTOP|wxRIGHT|wxLEFT</property>
+                                                                <property name="proportion">0</property>
+                                                                <object class="wxButton" expanded="0">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default">0</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">ID_REMOVE_3D_SHAPE</property>
+                                                                    <property name="label">Remove 3D Shape</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_buttonRemove</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style"></property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnButtonClick">Remove3DShape</event>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                            <object class="sizeritem" expanded="1">
+                                                                <property name="border">5</property>
+                                                                <property name="flag">wxALL|wxEXPAND</property>
+                                                                <property name="proportion">0</property>
+                                                                <object class="wxButton" expanded="1">
+                                                                    <property name="BottomDockable">1</property>
+                                                                    <property name="LeftDockable">1</property>
+                                                                    <property name="RightDockable">1</property>
+                                                                    <property name="TopDockable">1</property>
+                                                                    <property name="aui_layer"></property>
+                                                                    <property name="aui_name"></property>
+                                                                    <property name="aui_position"></property>
+                                                                    <property name="aui_row"></property>
+                                                                    <property name="best_size"></property>
+                                                                    <property name="bg"></property>
+                                                                    <property name="caption"></property>
+                                                                    <property name="caption_visible">1</property>
+                                                                    <property name="center_pane">0</property>
+                                                                    <property name="close_button">1</property>
+                                                                    <property name="context_help"></property>
+                                                                    <property name="context_menu">1</property>
+                                                                    <property name="default">0</property>
+                                                                    <property name="default_pane">0</property>
+                                                                    <property name="dock">Dock</property>
+                                                                    <property name="dock_fixed">0</property>
+                                                                    <property name="docking">Left</property>
+                                                                    <property name="enabled">1</property>
+                                                                    <property name="fg"></property>
+                                                                    <property name="floatable">1</property>
+                                                                    <property name="font"></property>
+                                                                    <property name="gripper">0</property>
+                                                                    <property name="hidden">0</property>
+                                                                    <property name="id">wxID_ANY</property>
+                                                                    <property name="label">Edit Filename</property>
+                                                                    <property name="max_size"></property>
+                                                                    <property name="maximize_button">0</property>
+                                                                    <property name="maximum_size"></property>
+                                                                    <property name="min_size"></property>
+                                                                    <property name="minimize_button">0</property>
+                                                                    <property name="minimum_size"></property>
+                                                                    <property name="moveable">1</property>
+                                                                    <property name="name">m_buttonEdit</property>
+                                                                    <property name="pane_border">1</property>
+                                                                    <property name="pane_position"></property>
+                                                                    <property name="pane_size"></property>
+                                                                    <property name="permission">protected</property>
+                                                                    <property name="pin_button">1</property>
+                                                                    <property name="pos"></property>
+                                                                    <property name="resize">Resizable</property>
+                                                                    <property name="show">1</property>
+                                                                    <property name="size"></property>
+                                                                    <property name="style"></property>
+                                                                    <property name="subclass"></property>
+                                                                    <property name="toolbar_pane">0</property>
+                                                                    <property name="tooltip"></property>
+                                                                    <property name="validator_data_type"></property>
+                                                                    <property name="validator_style">wxFILTER_NONE</property>
+                                                                    <property name="validator_type">wxDefaultValidator</property>
+                                                                    <property name="validator_variable"></property>
+                                                                    <property name="window_extra_style"></property>
+                                                                    <property name="window_name"></property>
+                                                                    <property name="window_style"></property>
+                                                                    <event name="OnButtonClick">Edit3DShapeFilename</event>
+                                                                    <event name="OnChar"></event>
+                                                                    <event name="OnEnterWindow"></event>
+                                                                    <event name="OnEraseBackground"></event>
+                                                                    <event name="OnKeyDown"></event>
+                                                                    <event name="OnKeyUp"></event>
+                                                                    <event name="OnKillFocus"></event>
+                                                                    <event name="OnLeaveWindow"></event>
+                                                                    <event name="OnLeftDClick"></event>
+                                                                    <event name="OnLeftDown"></event>
+                                                                    <event name="OnLeftUp"></event>
+                                                                    <event name="OnMiddleDClick"></event>
+                                                                    <event name="OnMiddleDown"></event>
+                                                                    <event name="OnMiddleUp"></event>
+                                                                    <event name="OnMotion"></event>
+                                                                    <event name="OnMouseEvents"></event>
+                                                                    <event name="OnMouseWheel"></event>
+                                                                    <event name="OnPaint"></event>
+                                                                    <event name="OnRightDClick"></event>
+                                                                    <event name="OnRightDown"></event>
+                                                                    <event name="OnRightUp"></event>
+                                                                    <event name="OnSetFocus"></event>
+                                                                    <event name="OnSize"></event>
+                                                                    <event name="OnUpdateUI"></event>
+                                                                </object>
+                                                            </object>
+                                                        </object>
+                                                    </object>
+                                                </object>
+                                            </object>
                                         </object>
                                     </object>
                                     <object class="sizeritem" expanded="1">
@@ -3805,578 +3859,7 @@
                                             <property name="minimum_size"></property>
                                             <property name="name">bLowerSizer3D</property>
                                             <property name="orient">wxHORIZONTAL</property>
-                                            <property name="permission">none</property>
-                                            <object class="sizeritem" expanded="0">
-                                                <property name="border">5</property>
-                                                <property name="flag">wxEXPAND</property>
-                                                <property name="proportion">1</property>
-                                                <object class="wxStaticBoxSizer" expanded="0">
-                                                    <property name="id">wxID_ANY</property>
-                                                    <property name="label">3D Scale and Position</property>
-                                                    <property name="minimum_size"></property>
-                                                    <property name="name">m_Sizer3DValues</property>
-                                                    <property name="orient">wxVERTICAL</property>
-                                                    <property name="permission">protected</property>
-                                                    <event name="OnUpdateUI"></event>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="0">
-                                                            <property name="minimum_size"></property>
-                                                            <property name="name">m_bSizerShapeScale</property>
-                                                            <property name="orient">wxVERTICAL</property>
-                                                            <property name="permission">protected</property>
-                                                            <object class="sizeritem" expanded="0">
-                                                                <property name="border">5</property>
-                                                                <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                                                <property name="proportion">0</property>
-                                                                <object class="wxStaticText" expanded="0">
-                                                                    <property name="BottomDockable">1</property>
-                                                                    <property name="LeftDockable">1</property>
-                                                                    <property name="RightDockable">1</property>
-                                                                    <property name="TopDockable">1</property>
-                                                                    <property name="aui_layer"></property>
-                                                                    <property name="aui_name"></property>
-                                                                    <property name="aui_position"></property>
-                                                                    <property name="aui_row"></property>
-                                                                    <property name="best_size"></property>
-                                                                    <property name="bg"></property>
-                                                                    <property name="caption"></property>
-                                                                    <property name="caption_visible">1</property>
-                                                                    <property name="center_pane">0</property>
-                                                                    <property name="close_button">1</property>
-                                                                    <property name="context_help"></property>
-                                                                    <property name="context_menu">1</property>
-                                                                    <property name="default_pane">0</property>
-                                                                    <property name="dock">Dock</property>
-                                                                    <property name="dock_fixed">0</property>
-                                                                    <property name="docking">Left</property>
-                                                                    <property name="enabled">1</property>
-                                                                    <property name="fg"></property>
-                                                                    <property name="floatable">1</property>
-                                                                    <property name="font"></property>
-                                                                    <property name="gripper">0</property>
-                                                                    <property name="hidden">0</property>
-                                                                    <property name="id">wxID_ANY</property>
-                                                                    <property name="label">Shape Scale:</property>
-                                                                    <property name="max_size"></property>
-                                                                    <property name="maximize_button">0</property>
-                                                                    <property name="maximum_size"></property>
-                                                                    <property name="min_size"></property>
-                                                                    <property name="minimize_button">0</property>
-                                                                    <property name="minimum_size"></property>
-                                                                    <property name="moveable">1</property>
-                                                                    <property name="name">m_staticTextShapeScale</property>
-                                                                    <property name="pane_border">1</property>
-                                                                    <property name="pane_position"></property>
-                                                                    <property name="pane_size"></property>
-                                                                    <property name="permission">protected</property>
-                                                                    <property name="pin_button">1</property>
-                                                                    <property name="pos"></property>
-                                                                    <property name="resize">Resizable</property>
-                                                                    <property name="show">1</property>
-                                                                    <property name="size"></property>
-                                                                    <property name="style"></property>
-                                                                    <property name="subclass"></property>
-                                                                    <property name="toolbar_pane">0</property>
-                                                                    <property name="tooltip"></property>
-                                                                    <property name="window_extra_style"></property>
-                                                                    <property name="window_name"></property>
-                                                                    <property name="window_style"></property>
-                                                                    <property name="wrap">-1</property>
-                                                                    <event name="OnChar"></event>
-                                                                    <event name="OnEnterWindow"></event>
-                                                                    <event name="OnEraseBackground"></event>
-                                                                    <event name="OnKeyDown"></event>
-                                                                    <event name="OnKeyUp"></event>
-                                                                    <event name="OnKillFocus"></event>
-                                                                    <event name="OnLeaveWindow"></event>
-                                                                    <event name="OnLeftDClick"></event>
-                                                                    <event name="OnLeftDown"></event>
-                                                                    <event name="OnLeftUp"></event>
-                                                                    <event name="OnMiddleDClick"></event>
-                                                                    <event name="OnMiddleDown"></event>
-                                                                    <event name="OnMiddleUp"></event>
-                                                                    <event name="OnMotion"></event>
-                                                                    <event name="OnMouseEvents"></event>
-                                                                    <event name="OnMouseWheel"></event>
-                                                                    <event name="OnPaint"></event>
-                                                                    <event name="OnRightDClick"></event>
-                                                                    <event name="OnRightDown"></event>
-                                                                    <event name="OnRightUp"></event>
-                                                                    <event name="OnSetFocus"></event>
-                                                                    <event name="OnSize"></event>
-                                                                    <event name="OnUpdateUI"></event>
-                                                                </object>
-                                                            </object>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="0">
-                                                            <property name="minimum_size"></property>
-                                                            <property name="name">m_bSizerShapeOffset</property>
-                                                            <property name="orient">wxVERTICAL</property>
-                                                            <property name="permission">protected</property>
-                                                            <object class="sizeritem" expanded="0">
-                                                                <property name="border">5</property>
-                                                                <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                                                <property name="proportion">0</property>
-                                                                <object class="wxStaticText" expanded="0">
-                                                                    <property name="BottomDockable">1</property>
-                                                                    <property name="LeftDockable">1</property>
-                                                                    <property name="RightDockable">1</property>
-                                                                    <property name="TopDockable">1</property>
-                                                                    <property name="aui_layer"></property>
-                                                                    <property name="aui_name"></property>
-                                                                    <property name="aui_position"></property>
-                                                                    <property name="aui_row"></property>
-                                                                    <property name="best_size"></property>
-                                                                    <property name="bg"></property>
-                                                                    <property name="caption"></property>
-                                                                    <property name="caption_visible">1</property>
-                                                                    <property name="center_pane">0</property>
-                                                                    <property name="close_button">1</property>
-                                                                    <property name="context_help"></property>
-                                                                    <property name="context_menu">1</property>
-                                                                    <property name="default_pane">0</property>
-                                                                    <property name="dock">Dock</property>
-                                                                    <property name="dock_fixed">0</property>
-                                                                    <property name="docking">Left</property>
-                                                                    <property name="enabled">1</property>
-                                                                    <property name="fg"></property>
-                                                                    <property name="floatable">1</property>
-                                                                    <property name="font"></property>
-                                                                    <property name="gripper">0</property>
-                                                                    <property name="hidden">0</property>
-                                                                    <property name="id">wxID_ANY</property>
-                                                                    <property name="label">Shape Offset (inch):</property>
-                                                                    <property name="max_size"></property>
-                                                                    <property name="maximize_button">0</property>
-                                                                    <property name="maximum_size"></property>
-                                                                    <property name="min_size"></property>
-                                                                    <property name="minimize_button">0</property>
-                                                                    <property name="minimum_size"></property>
-                                                                    <property name="moveable">1</property>
-                                                                    <property name="name">m_staticTextShapeOffset</property>
-                                                                    <property name="pane_border">1</property>
-                                                                    <property name="pane_position"></property>
-                                                                    <property name="pane_size"></property>
-                                                                    <property name="permission">protected</property>
-                                                                    <property name="pin_button">1</property>
-                                                                    <property name="pos"></property>
-                                                                    <property name="resize">Resizable</property>
-                                                                    <property name="show">1</property>
-                                                                    <property name="size"></property>
-                                                                    <property name="style"></property>
-                                                                    <property name="subclass"></property>
-                                                                    <property name="toolbar_pane">0</property>
-                                                                    <property name="tooltip"></property>
-                                                                    <property name="window_extra_style"></property>
-                                                                    <property name="window_name"></property>
-                                                                    <property name="window_style"></property>
-                                                                    <property name="wrap">-1</property>
-                                                                    <event name="OnChar"></event>
-                                                                    <event name="OnEnterWindow"></event>
-                                                                    <event name="OnEraseBackground"></event>
-                                                                    <event name="OnKeyDown"></event>
-                                                                    <event name="OnKeyUp"></event>
-                                                                    <event name="OnKillFocus"></event>
-                                                                    <event name="OnLeaveWindow"></event>
-                                                                    <event name="OnLeftDClick"></event>
-                                                                    <event name="OnLeftDown"></event>
-                                                                    <event name="OnLeftUp"></event>
-                                                                    <event name="OnMiddleDClick"></event>
-                                                                    <event name="OnMiddleDown"></event>
-                                                                    <event name="OnMiddleUp"></event>
-                                                                    <event name="OnMotion"></event>
-                                                                    <event name="OnMouseEvents"></event>
-                                                                    <event name="OnMouseWheel"></event>
-                                                                    <event name="OnPaint"></event>
-                                                                    <event name="OnRightDClick"></event>
-                                                                    <event name="OnRightDown"></event>
-                                                                    <event name="OnRightUp"></event>
-                                                                    <event name="OnSetFocus"></event>
-                                                                    <event name="OnSize"></event>
-                                                                    <event name="OnUpdateUI"></event>
-                                                                </object>
-                                                            </object>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxBoxSizer" expanded="0">
-                                                            <property name="minimum_size"></property>
-                                                            <property name="name">m_bSizerShapeRotation</property>
-                                                            <property name="orient">wxVERTICAL</property>
-                                                            <property name="permission">protected</property>
-                                                            <object class="sizeritem" expanded="0">
-                                                                <property name="border">5</property>
-                                                                <property name="flag">wxTOP|wxRIGHT|wxLEFT</property>
-                                                                <property name="proportion">0</property>
-                                                                <object class="wxStaticText" expanded="0">
-                                                                    <property name="BottomDockable">1</property>
-                                                                    <property name="LeftDockable">1</property>
-                                                                    <property name="RightDockable">1</property>
-                                                                    <property name="TopDockable">1</property>
-                                                                    <property name="aui_layer"></property>
-                                                                    <property name="aui_name"></property>
-                                                                    <property name="aui_position"></property>
-                                                                    <property name="aui_row"></property>
-                                                                    <property name="best_size"></property>
-                                                                    <property name="bg"></property>
-                                                                    <property name="caption"></property>
-                                                                    <property name="caption_visible">1</property>
-                                                                    <property name="center_pane">0</property>
-                                                                    <property name="close_button">1</property>
-                                                                    <property name="context_help"></property>
-                                                                    <property name="context_menu">1</property>
-                                                                    <property name="default_pane">0</property>
-                                                                    <property name="dock">Dock</property>
-                                                                    <property name="dock_fixed">0</property>
-                                                                    <property name="docking">Left</property>
-                                                                    <property name="enabled">1</property>
-                                                                    <property name="fg"></property>
-                                                                    <property name="floatable">1</property>
-                                                                    <property name="font"></property>
-                                                                    <property name="gripper">0</property>
-                                                                    <property name="hidden">0</property>
-                                                                    <property name="id">wxID_ANY</property>
-                                                                    <property name="label">Shape Rotation (degrees):</property>
-                                                                    <property name="max_size"></property>
-                                                                    <property name="maximize_button">0</property>
-                                                                    <property name="maximum_size"></property>
-                                                                    <property name="min_size"></property>
-                                                                    <property name="minimize_button">0</property>
-                                                                    <property name="minimum_size"></property>
-                                                                    <property name="moveable">1</property>
-                                                                    <property name="name">m_staticTextShapeRotation</property>
-                                                                    <property name="pane_border">1</property>
-                                                                    <property name="pane_position"></property>
-                                                                    <property name="pane_size"></property>
-                                                                    <property name="permission">protected</property>
-                                                                    <property name="pin_button">1</property>
-                                                                    <property name="pos"></property>
-                                                                    <property name="resize">Resizable</property>
-                                                                    <property name="show">1</property>
-                                                                    <property name="size"></property>
-                                                                    <property name="style"></property>
-                                                                    <property name="subclass"></property>
-                                                                    <property name="toolbar_pane">0</property>
-                                                                    <property name="tooltip"></property>
-                                                                    <property name="window_extra_style"></property>
-                                                                    <property name="window_name"></property>
-                                                                    <property name="window_style"></property>
-                                                                    <property name="wrap">-1</property>
-                                                                    <event name="OnChar"></event>
-                                                                    <event name="OnEnterWindow"></event>
-                                                                    <event name="OnEraseBackground"></event>
-                                                                    <event name="OnKeyDown"></event>
-                                                                    <event name="OnKeyUp"></event>
-                                                                    <event name="OnKillFocus"></event>
-                                                                    <event name="OnLeaveWindow"></event>
-                                                                    <event name="OnLeftDClick"></event>
-                                                                    <event name="OnLeftDown"></event>
-                                                                    <event name="OnLeftUp"></event>
-                                                                    <event name="OnMiddleDClick"></event>
-                                                                    <event name="OnMiddleDown"></event>
-                                                                    <event name="OnMiddleUp"></event>
-                                                                    <event name="OnMotion"></event>
-                                                                    <event name="OnMouseEvents"></event>
-                                                                    <event name="OnMouseWheel"></event>
-                                                                    <event name="OnPaint"></event>
-                                                                    <event name="OnRightDClick"></event>
-                                                                    <event name="OnRightDown"></event>
-                                                                    <event name="OnRightUp"></event>
-                                                                    <event name="OnSetFocus"></event>
-                                                                    <event name="OnSize"></event>
-                                                                    <event name="OnUpdateUI"></event>
-                                                                </object>
-                                                            </object>
-                                                        </object>
-                                                    </object>
-                                                </object>
-                                            </object>
-                                            <object class="sizeritem" expanded="0">
-                                                <property name="border">5</property>
-                                                <property name="flag">wxALIGN_CENTER_VERTICAL</property>
-                                                <property name="proportion">0</property>
-                                                <object class="wxBoxSizer" expanded="0">
-                                                    <property name="minimum_size"></property>
-                                                    <property name="name">bSizer3DButtons</property>
-                                                    <property name="orient">wxVERTICAL</property>
-                                                    <property name="permission">none</property>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND|wxTOP|wxRIGHT|wxLEFT</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxButton" expanded="0">
-                                                            <property name="BottomDockable">1</property>
-                                                            <property name="LeftDockable">1</property>
-                                                            <property name="RightDockable">1</property>
-                                                            <property name="TopDockable">1</property>
-                                                            <property name="aui_layer"></property>
-                                                            <property name="aui_name"></property>
-                                                            <property name="aui_position"></property>
-                                                            <property name="aui_row"></property>
-                                                            <property name="best_size"></property>
-                                                            <property name="bg"></property>
-                                                            <property name="caption"></property>
-                                                            <property name="caption_visible">1</property>
-                                                            <property name="center_pane">0</property>
-                                                            <property name="close_button">1</property>
-                                                            <property name="context_help"></property>
-                                                            <property name="context_menu">1</property>
-                                                            <property name="default">0</property>
-                                                            <property name="default_pane">0</property>
-                                                            <property name="dock">Dock</property>
-                                                            <property name="dock_fixed">0</property>
-                                                            <property name="docking">Left</property>
-                                                            <property name="enabled">1</property>
-                                                            <property name="fg"></property>
-                                                            <property name="floatable">1</property>
-                                                            <property name="font"></property>
-                                                            <property name="gripper">0</property>
-                                                            <property name="hidden">0</property>
-                                                            <property name="id">ID_BROWSE_3D_LIB</property>
-                                                            <property name="label">Add 3D Shape</property>
-                                                            <property name="max_size"></property>
-                                                            <property name="maximize_button">0</property>
-                                                            <property name="maximum_size"></property>
-                                                            <property name="min_size"></property>
-                                                            <property name="minimize_button">0</property>
-                                                            <property name="minimum_size"></property>
-                                                            <property name="moveable">1</property>
-                                                            <property name="name">m_buttonBrowse</property>
-                                                            <property name="pane_border">1</property>
-                                                            <property name="pane_position"></property>
-                                                            <property name="pane_size"></property>
-                                                            <property name="permission">protected</property>
-                                                            <property name="pin_button">1</property>
-                                                            <property name="pos"></property>
-                                                            <property name="resize">Resizable</property>
-                                                            <property name="show">1</property>
-                                                            <property name="size"></property>
-                                                            <property name="style"></property>
-                                                            <property name="subclass"></property>
-                                                            <property name="toolbar_pane">0</property>
-                                                            <property name="tooltip"></property>
-                                                            <property name="validator_data_type"></property>
-                                                            <property name="validator_style">wxFILTER_NONE</property>
-                                                            <property name="validator_type">wxDefaultValidator</property>
-                                                            <property name="validator_variable"></property>
-                                                            <property name="window_extra_style"></property>
-                                                            <property name="window_name"></property>
-                                                            <property name="window_style"></property>
-                                                            <event name="OnButtonClick">Add3DShape</event>
-                                                            <event name="OnChar"></event>
-                                                            <event name="OnEnterWindow"></event>
-                                                            <event name="OnEraseBackground"></event>
-                                                            <event name="OnKeyDown"></event>
-                                                            <event name="OnKeyUp"></event>
-                                                            <event name="OnKillFocus"></event>
-                                                            <event name="OnLeaveWindow"></event>
-                                                            <event name="OnLeftDClick"></event>
-                                                            <event name="OnLeftDown"></event>
-                                                            <event name="OnLeftUp"></event>
-                                                            <event name="OnMiddleDClick"></event>
-                                                            <event name="OnMiddleDown"></event>
-                                                            <event name="OnMiddleUp"></event>
-                                                            <event name="OnMotion"></event>
-                                                            <event name="OnMouseEvents"></event>
-                                                            <event name="OnMouseWheel"></event>
-                                                            <event name="OnPaint"></event>
-                                                            <event name="OnRightDClick"></event>
-                                                            <event name="OnRightDown"></event>
-                                                            <event name="OnRightUp"></event>
-                                                            <event name="OnSetFocus"></event>
-                                                            <event name="OnSize"></event>
-                                                            <event name="OnUpdateUI"></event>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="0">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxEXPAND|wxTOP|wxRIGHT|wxLEFT</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxButton" expanded="0">
-                                                            <property name="BottomDockable">1</property>
-                                                            <property name="LeftDockable">1</property>
-                                                            <property name="RightDockable">1</property>
-                                                            <property name="TopDockable">1</property>
-                                                            <property name="aui_layer"></property>
-                                                            <property name="aui_name"></property>
-                                                            <property name="aui_position"></property>
-                                                            <property name="aui_row"></property>
-                                                            <property name="best_size"></property>
-                                                            <property name="bg"></property>
-                                                            <property name="caption"></property>
-                                                            <property name="caption_visible">1</property>
-                                                            <property name="center_pane">0</property>
-                                                            <property name="close_button">1</property>
-                                                            <property name="context_help"></property>
-                                                            <property name="context_menu">1</property>
-                                                            <property name="default">0</property>
-                                                            <property name="default_pane">0</property>
-                                                            <property name="dock">Dock</property>
-                                                            <property name="dock_fixed">0</property>
-                                                            <property name="docking">Left</property>
-                                                            <property name="enabled">1</property>
-                                                            <property name="fg"></property>
-                                                            <property name="floatable">1</property>
-                                                            <property name="font"></property>
-                                                            <property name="gripper">0</property>
-                                                            <property name="hidden">0</property>
-                                                            <property name="id">ID_REMOVE_3D_SHAPE</property>
-                                                            <property name="label">Remove 3D Shape</property>
-                                                            <property name="max_size"></property>
-                                                            <property name="maximize_button">0</property>
-                                                            <property name="maximum_size"></property>
-                                                            <property name="min_size"></property>
-                                                            <property name="minimize_button">0</property>
-                                                            <property name="minimum_size"></property>
-                                                            <property name="moveable">1</property>
-                                                            <property name="name">m_buttonRemove</property>
-                                                            <property name="pane_border">1</property>
-                                                            <property name="pane_position"></property>
-                                                            <property name="pane_size"></property>
-                                                            <property name="permission">protected</property>
-                                                            <property name="pin_button">1</property>
-                                                            <property name="pos"></property>
-                                                            <property name="resize">Resizable</property>
-                                                            <property name="show">1</property>
-                                                            <property name="size"></property>
-                                                            <property name="style"></property>
-                                                            <property name="subclass"></property>
-                                                            <property name="toolbar_pane">0</property>
-                                                            <property name="tooltip"></property>
-                                                            <property name="validator_data_type"></property>
-                                                            <property name="validator_style">wxFILTER_NONE</property>
-                                                            <property name="validator_type">wxDefaultValidator</property>
-                                                            <property name="validator_variable"></property>
-                                                            <property name="window_extra_style"></property>
-                                                            <property name="window_name"></property>
-                                                            <property name="window_style"></property>
-                                                            <event name="OnButtonClick">Remove3DShape</event>
-                                                            <event name="OnChar"></event>
-                                                            <event name="OnEnterWindow"></event>
-                                                            <event name="OnEraseBackground"></event>
-                                                            <event name="OnKeyDown"></event>
-                                                            <event name="OnKeyUp"></event>
-                                                            <event name="OnKillFocus"></event>
-                                                            <event name="OnLeaveWindow"></event>
-                                                            <event name="OnLeftDClick"></event>
-                                                            <event name="OnLeftDown"></event>
-                                                            <event name="OnLeftUp"></event>
-                                                            <event name="OnMiddleDClick"></event>
-                                                            <event name="OnMiddleDown"></event>
-                                                            <event name="OnMiddleUp"></event>
-                                                            <event name="OnMotion"></event>
-                                                            <event name="OnMouseEvents"></event>
-                                                            <event name="OnMouseWheel"></event>
-                                                            <event name="OnPaint"></event>
-                                                            <event name="OnRightDClick"></event>
-                                                            <event name="OnRightDown"></event>
-                                                            <event name="OnRightUp"></event>
-                                                            <event name="OnSetFocus"></event>
-                                                            <event name="OnSize"></event>
-                                                            <event name="OnUpdateUI"></event>
-                                                        </object>
-                                                    </object>
-                                                    <object class="sizeritem" expanded="1">
-                                                        <property name="border">5</property>
-                                                        <property name="flag">wxALL|wxEXPAND</property>
-                                                        <property name="proportion">0</property>
-                                                        <object class="wxButton" expanded="1">
-                                                            <property name="BottomDockable">1</property>
-                                                            <property name="LeftDockable">1</property>
-                                                            <property name="RightDockable">1</property>
-                                                            <property name="TopDockable">1</property>
-                                                            <property name="aui_layer"></property>
-                                                            <property name="aui_name"></property>
-                                                            <property name="aui_position"></property>
-                                                            <property name="aui_row"></property>
-                                                            <property name="best_size"></property>
-                                                            <property name="bg"></property>
-                                                            <property name="caption"></property>
-                                                            <property name="caption_visible">1</property>
-                                                            <property name="center_pane">0</property>
-                                                            <property name="close_button">1</property>
-                                                            <property name="context_help"></property>
-                                                            <property name="context_menu">1</property>
-                                                            <property name="default">0</property>
-                                                            <property name="default_pane">0</property>
-                                                            <property name="dock">Dock</property>
-                                                            <property name="dock_fixed">0</property>
-                                                            <property name="docking">Left</property>
-                                                            <property name="enabled">1</property>
-                                                            <property name="fg"></property>
-                                                            <property name="floatable">1</property>
-                                                            <property name="font"></property>
-                                                            <property name="gripper">0</property>
-                                                            <property name="hidden">0</property>
-                                                            <property name="id">wxID_ANY</property>
-                                                            <property name="label">Edit Filename</property>
-                                                            <property name="max_size"></property>
-                                                            <property name="maximize_button">0</property>
-                                                            <property name="maximum_size"></property>
-                                                            <property name="min_size"></property>
-                                                            <property name="minimize_button">0</property>
-                                                            <property name="minimum_size"></property>
-                                                            <property name="moveable">1</property>
-                                                            <property name="name">m_buttonEdit</property>
-                                                            <property name="pane_border">1</property>
-                                                            <property name="pane_position"></property>
-                                                            <property name="pane_size"></property>
-                                                            <property name="permission">protected</property>
-                                                            <property name="pin_button">1</property>
-                                                            <property name="pos"></property>
-                                                            <property name="resize">Resizable</property>
-                                                            <property name="show">1</property>
-                                                            <property name="size"></property>
-                                                            <property name="style"></property>
-                                                            <property name="subclass"></property>
-                                                            <property name="toolbar_pane">0</property>
-                                                            <property name="tooltip"></property>
-                                                            <property name="validator_data_type"></property>
-                                                            <property name="validator_style">wxFILTER_NONE</property>
-                                                            <property name="validator_type">wxDefaultValidator</property>
-                                                            <property name="validator_variable"></property>
-                                                            <property name="window_extra_style"></property>
-                                                            <property name="window_name"></property>
-                                                            <property name="window_style"></property>
-                                                            <event name="OnButtonClick">Edit3DShapeFilename</event>
-                                                            <event name="OnChar"></event>
-                                                            <event name="OnEnterWindow"></event>
-                                                            <event name="OnEraseBackground"></event>
-                                                            <event name="OnKeyDown"></event>
-                                                            <event name="OnKeyUp"></event>
-                                                            <event name="OnKillFocus"></event>
-                                                            <event name="OnLeaveWindow"></event>
-                                                            <event name="OnLeftDClick"></event>
-                                                            <event name="OnLeftDown"></event>
-                                                            <event name="OnLeftUp"></event>
-                                                            <event name="OnMiddleDClick"></event>
-                                                            <event name="OnMiddleDown"></event>
-                                                            <event name="OnMiddleUp"></event>
-                                                            <event name="OnMotion"></event>
-                                                            <event name="OnMouseEvents"></event>
-                                                            <event name="OnMouseWheel"></event>
-                                                            <event name="OnPaint"></event>
-                                                            <event name="OnRightDClick"></event>
-                                                            <event name="OnRightDown"></event>
-                                                            <event name="OnRightUp"></event>
-                                                            <event name="OnSetFocus"></event>
-                                                            <event name="OnSize"></event>
-                                                            <event name="OnUpdateUI"></event>
-                                                        </object>
-                                                    </object>
-                                                </object>
-                                            </object>
+                                            <property name="permission">protected</property>
                                         </object>
                                     </object>
                                 </object>
diff --git a/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.h b/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.h
index 180f059a61..a3ee4b325a 100644
--- a/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.h
+++ b/pcbnew/dialogs/dialog_edit_module_for_Modedit_base.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
-// C++ code generated with wxFormBuilder (version Mar  9 2015)
+// C++ code generated with wxFormBuilder (version Oct  5 2015)
 // http://www.wxformbuilder.org/
 //
 // PLEASE DO "NOT" EDIT THIS FILE!
@@ -88,20 +88,11 @@ class DIALOG_MODULE_MODULE_EDITOR_BASE : public DIALOG_SHIM
 		wxTextCtrl* m_SolderPasteMarginRatioCtrl;
 		wxStaticText* m_SolderPasteRatioMarginUnits;
 		wxPanel* m_Panel3D;
-		wxStaticText* m_staticText3Dname;
 		wxListBox* m_3D_ShapeNameListBox;
-		wxStaticText* m_staticTextDefault3DPath;
-		wxTextCtrl* m_textCtrl3DDefaultPath;
-		wxStaticBoxSizer* m_Sizer3DValues;
-		wxBoxSizer* m_bSizerShapeScale;
-		wxStaticText* m_staticTextShapeScale;
-		wxBoxSizer* m_bSizerShapeOffset;
-		wxStaticText* m_staticTextShapeOffset;
-		wxBoxSizer* m_bSizerShapeRotation;
-		wxStaticText* m_staticTextShapeRotation;
 		wxButton* m_buttonBrowse;
 		wxButton* m_buttonRemove;
 		wxButton* m_buttonEdit;
+		wxBoxSizer* bLowerSizer3D;
 		wxStdDialogButtonSizer* m_sdbSizerStdButtons;
 		wxButton* m_sdbSizerStdButtonsOK;
 		wxButton* m_sdbSizerStdButtonsCancel;
@@ -110,9 +101,9 @@ class DIALOG_MODULE_MODULE_EDITOR_BASE : public DIALOG_SHIM
 		virtual void OnEditReference( wxCommandEvent& event ) { event.Skip(); }
 		virtual void OnEditValue( wxCommandEvent& event ) { event.Skip(); }
 		virtual void On3DShapeNameSelected( wxCommandEvent& event ) { event.Skip(); }
+		virtual void Edit3DShapeFilename( wxCommandEvent& event ) { event.Skip(); }
 		virtual void Add3DShape( wxCommandEvent& event ) { event.Skip(); }
 		virtual void Remove3DShape( wxCommandEvent& event ) { event.Skip(); }
-		virtual void Edit3DShapeFilename( wxCommandEvent& event ) { event.Skip(); }
 		virtual void OnCancelClick( wxCommandEvent& event ) { event.Skip(); }
 		virtual void OnOkClick( wxCommandEvent& event ) { event.Skip(); }
 		
diff --git a/plugins/3d/CMakeLists.txt b/plugins/3d/CMakeLists.txt
new file mode 100644
index 0000000000..b2274e9ce6
--- /dev/null
+++ b/plugins/3d/CMakeLists.txt
@@ -0,0 +1,31 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_library( s3d_plugin_dummy MODULE
+    s3d_plugin_dummy.cpp
+    )
+
+target_link_libraries( s3d_plugin_dummy ${wxWidgets_LIBRARIES} )
+
+add_library( s3d_plugin_tetra MODULE
+        s3d_plugin_tetra.cpp
+        )
+
+target_link_libraries( s3d_plugin_tetra s3d_sg ${wxWidgets_LIBRARIES} )
+
+if( APPLE )
+    install( TARGETS
+            s3d_plugin_dummy
+            s3d_plugin_tetra
+            DESTINATION /Applications/kicad.app/SharedSupport/plugins/3d
+            COMPONENT binary
+    )
+else()
+    install( TARGETS
+        s3d_plugin_dummy
+        s3d_plugin_tetra
+        DESTINATION lib/kicad/plugins/3d
+        COMPONENT binary
+    )
+endif()
diff --git a/plugins/3d/s3d_plugin_dummy.cpp b/plugins/3d/s3d_plugin_dummy.cpp
new file mode 100644
index 0000000000..bbaffaae32
--- /dev/null
+++ b/plugins/3d/s3d_plugin_dummy.cpp
@@ -0,0 +1,136 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/*
+ * NOTES:
+ *
+ * 1. Notice that the plugin class is instantiated as a static; this
+ * ensures that it created an destroyed.
+ */
+
+#include <iostream>
+#include <s3d_plugin_dummy.h>
+
+
+S3D_PLUGIN_DUMMY::S3D_PLUGIN_DUMMY()
+{
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "wrl" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "x3d" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "idf" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "iges" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "igs" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "stp" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "step" ) );
+
+#ifdef _WIN32
+    // assume a case-insensitive file system
+    m_filters.push_back( wxT( "VRML 1.0/2.0 (*.wrl)|*.wrl" ) );
+    m_filters.push_back( wxT( "X3D (*.x3d)|*.x3d" ) );
+    m_filters.push_back( wxT( "IDF 2.0/3.0 (*.idf)|*.idf" ) );
+    m_filters.push_back( wxT( "IGESv5.3 (*.igs;*.iges)|*.igs;*.iges" ) );
+    m_filters.push_back( wxT( "STEP (*.stp;*.step)|*.stp;*.step" ) );
+#else
+    // assume the filesystem is case sensitive
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "WRL" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "X3D" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "IDF" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "IGES" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "IGS" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "STP" ) );
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "STEP" ) );
+
+    m_filters.push_back( wxT( "VRML 1.0/2.0 (*.wrl;*.WRL)|*.wrl;*.WRL" ) );
+    m_filters.push_back( wxT( "X3D (*.x3d;*.X3D)|*.x3d;*.X3D" ) );
+    m_filters.push_back( wxT( "IDF 2.0/3.0 (*.idf;*.IDF)|*.idf;*.IDF" ) );
+    m_filters.push_back( wxT( "IGESv5.3 (*.igs;*.iges;*.IGS;*.IGES)|*.igs;*.iges;*.IGS;*.IGES" ) );
+    m_filters.push_back( wxT( "STEP (*.stp;*.step;*.STP;*.STEP)|*.stp;*.step;*.STP;*.STEP" ) );
+#endif
+
+
+    return;
+}
+
+
+S3D_PLUGIN_DUMMY::~S3D_PLUGIN_DUMMY()
+{
+    return;
+}
+
+
+int S3D_PLUGIN_DUMMY::GetNExtensions( void ) const
+{
+    return (int) m_extensions.size();
+}
+
+
+const wxString S3D_PLUGIN_DUMMY::GetModelExtension( int aIndex ) const
+{
+    if( aIndex < 0 || aIndex >= (int) m_extensions.size() )
+        return wxString( "" );
+
+    return m_extensions[aIndex];
+}
+
+
+int S3D_PLUGIN_DUMMY::GetNFilters( void ) const
+{
+    return (int)m_filters.size();
+}
+
+
+const wxString S3D_PLUGIN_DUMMY::GetFileFilter( int aIndex ) const
+{
+    if( aIndex < 0 || aIndex >= (int)m_filters.size() )
+        return wxEmptyString;
+
+    return m_filters[aIndex];
+}
+
+
+bool S3D_PLUGIN_DUMMY::CanRender( void ) const
+{
+    // this dummy plugin does not support rendering of any models
+    return false;
+}
+
+
+SCENEGRAPH* S3D_PLUGIN_DUMMY::Load( const wxString& aFileName )
+{
+    // this dummy plugin does not support rendering of any models
+    return NULL;
+}
+
+
+static S3D_PLUGIN_DUMMY dummy;
+
+#ifndef _WIN32
+    extern "C" __attribute__((__visibility__("default"))) S3D_PLUGIN* Get3DPlugin( void )
+    {
+        return &dummy;
+    }
+#else
+extern "C" __declspec( dllexport ) S3D_PLUGIN* Get3DPlugin( void )
+    {
+        return &dummy;
+    }
+#endif
diff --git a/plugins/3d/s3d_plugin_dummy.h b/plugins/3d/s3d_plugin_dummy.h
new file mode 100644
index 0000000000..6484eb0506
--- /dev/null
+++ b/plugins/3d/s3d_plugin_dummy.h
@@ -0,0 +1,58 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_plugin_dummy.h
+ * is a sample dummy plugin which doesn't do much other than serve as
+ * an example of how a plugin must be built.
+ */
+
+
+#ifndef PLUGIN_3D_DUMMY_H
+#define PLUGIN_3D_DUMMY_H
+
+#include <vector>
+#include <plugins/3d/3d_plugin.h>
+
+class SCENEGRAPH;
+
+class S3D_PLUGIN_DUMMY : public S3D_PLUGIN
+{
+private:
+    std::vector< wxString > m_extensions;   // supported extensions
+    std::vector< wxString > m_filters;       // file filters
+
+public:
+    S3D_PLUGIN_DUMMY();
+    virtual ~S3D_PLUGIN_DUMMY();
+
+    virtual int GetNExtensions( void ) const;
+    virtual const wxString GetModelExtension( int aIndex ) const;
+    virtual int GetNFilters( void ) const;
+    virtual const wxString GetFileFilter( int aIndex ) const;
+
+    bool CanRender( void ) const;
+    SCENEGRAPH* Load( const wxString& aFileName );
+};
+
+#endif  // PLUGIN_3D_DUMMY_H
diff --git a/plugins/3d/s3d_plugin_tetra.cpp b/plugins/3d/s3d_plugin_tetra.cpp
new file mode 100644
index 0000000000..005534038e
--- /dev/null
+++ b/plugins/3d/s3d_plugin_tetra.cpp
@@ -0,0 +1,259 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/*
+ * NOTES:
+ *
+ * 1. Notice that the plugin class is instantiated as a static; this
+ * ensures that it is created an destroyed.
+ */
+
+#include <iostream>
+#include <cmath>
+#include <s3d_plugin_tetra.h>
+#include <3d_cache/sg/ifsg_all.h>
+
+
+S3D_PLUGIN_TETRA::S3D_PLUGIN_TETRA()
+{
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "wrl" ) );
+
+#ifdef _WIN32
+    // assume a case-insensitive file system
+    m_filters.push_back( wxT( "VRML 1.0/2.0 (*.wrl)|*.wrl" ) );
+#else
+    // assume the filesystem is case sensitive
+    m_extensions.push_back( wxString::FromUTF8Unchecked( "WRL" ) );
+
+    m_filters.push_back( wxT( "VRML 1.0/2.0 (*.wrl;*.WRL)|*.wrl;*.WRL" ) );
+#endif
+
+
+    return;
+}
+
+
+S3D_PLUGIN_TETRA::~S3D_PLUGIN_TETRA()
+{
+    return;
+}
+
+
+int S3D_PLUGIN_TETRA::GetNExtensions( void ) const
+{
+    return (int) m_extensions.size();
+}
+
+
+const wxString S3D_PLUGIN_TETRA::GetModelExtension( int aIndex ) const
+{
+    if( aIndex < 0 || aIndex >= (int) m_extensions.size() )
+        return wxString( "" );
+
+    return m_extensions[aIndex];
+}
+
+
+int S3D_PLUGIN_TETRA::GetNFilters( void ) const
+{
+    return (int)m_filters.size();
+}
+
+
+const wxString S3D_PLUGIN_TETRA::GetFileFilter( int aIndex ) const
+{
+    if( aIndex < 0 || aIndex >= (int)m_filters.size() )
+        return wxEmptyString;
+
+    return m_filters[aIndex];
+}
+
+
+bool S3D_PLUGIN_TETRA::CanRender( void ) const
+{
+    return true;
+}
+
+
+SCENEGRAPH* S3D_PLUGIN_TETRA::Load( const wxString& aFileName )
+{
+    // For this demonstration we create a tetrahedron and
+    // paint its faces Magenta Red Green Blue. Steps:
+    // * Create a top level transform tx0 which represent the VRML file
+    // * Create a child transform tx1, parent tx0, to define the tetrahedron
+    //    + Create 'shape' to define one facet
+    //    ++ Create a 'face' to hold vertices and indices
+    //    +++ Create 'cp' which is the coordinate list
+    //    +++ Create 'np' which is the per-vertex normals list
+    //    +++ Create 'coordIndex' which is the (triangular) vertex index list
+    //        for facet1 of the tetrahedron
+    //    ++ Create a 'material' to define the appearance of 'shape'
+    //    **
+    //    + shape->NewNode() to define next facet
+    //    ++ face->NewNode() for a new facet
+    //    +++ Add Ref to 'cp' for coordinate list
+    //    +++ Add Ref to 'np' for normals list
+    //    +++ coordIndex->NewNode() for vertex index list of new facet
+    //    ++ material->NewNode() for material of new facet
+    //    + repeat twice from ** to produce last 2 facets
+    // * Create a child transform tx2, parent tx0, for a referenced tetrahedron
+    //    + Set a translation and rotation so that this is distinct from tx1
+    //    + Add Reference to tx1
+    // ALL DONE: we now have:
+    // tx0
+    //  - contains tx1 which contains all elements of a tetrahedron
+    //  - contains tx0 which contains a reference to tx1 and offsets it so
+    //    that it renders in a different position
+
+    // create the top level transform; this will hold all other
+    // scenegraph objects; a transform may hold other transforms and
+    // shapes
+    IFSG_TRANSFORM* tx0 = new IFSG_TRANSFORM( true );
+
+    // create the transform which will house the shapes
+    IFSG_TRANSFORM* tx1 = new IFSG_TRANSFORM( tx0->GetRawPtr() );
+
+    // add a shape which we will use to define a tetrahedron; shapes
+    // hold facesets and appearances
+    IFSG_SHAPE* shape = new IFSG_SHAPE( *tx1 );
+
+    // add a faceset; these contain coordinate lists, coordinate indices,
+    // vertex lists, vertex indices, and may also contain color lists and
+    // their indices.
+
+    IFSG_FACESET* face = new IFSG_FACESET( *shape );
+
+    // define the vertices of the tetrahedron
+    double SQ2 = sqrt( 0.5 );
+    SGPOINT vert[4];
+    vert[0] = SGPOINT( 1.0, 0.0, -SQ2 );
+    vert[1] = SGPOINT( -1.0, 0.0, -SQ2 );
+    vert[2] = SGPOINT( 0.0, 1.0, SQ2 );
+    vert[3] = SGPOINT( 0.0, -1.0, SQ2 );
+    IFSG_COORDS* cp = new IFSG_COORDS( *face );
+    cp->SetCoordsList( 4, vert );
+    // coordinate indices - note: enforce triangles;
+    // in real plugins where it is not necessarily possible
+    // to determine which side a triangle is visible from,
+    // 2 point orders must be specified for each triangle
+    IFSG_COORDINDEX* coordIdx = new IFSG_COORDINDEX( *face );
+    int cidx[12] = { 0, 3, 1, 0, 2, 3, 1, 3, 2, 0, 1, 2 };
+    coordIdx->SetIndices( 3, cidx );
+
+    // the vertex normals in this case are the normalized
+    // vertex points
+    SGVECTOR norm[4];
+    norm[0] = SGVECTOR( -1.0, 0.0, SQ2 );
+    norm[1] = SGVECTOR( 1.0, 0.0, SQ2 );
+    norm[2] = SGVECTOR( 0.0, -1.0, -SQ2 );
+    norm[3] = SGVECTOR( 0.0, 1.0, -SQ2 );
+    IFSG_NORMALS* np = new IFSG_NORMALS( *face );
+    np->SetNormalList( 4, norm );
+
+    // create an appearance; appearances are owned by shapes
+    // magenta
+    IFSG_APPEARANCE* material = new IFSG_APPEARANCE( *shape);
+    material->SetSpecular( 1.0, 0.0, 1.0 );
+    material->SetDiffuse( 0.9, 0.0, 0.9 );
+    material->SetAmbient( 0.9 );
+    material->SetShininess( 0.3 );
+
+    // Shape2
+    shape->NewNode( *tx1 );
+    face->NewNode( *shape );
+    face->AddRefNode( *cp );
+    face->AddRefNode( *np );
+    coordIdx->NewNode( *face );
+    coordIdx->SetIndices( 3, &cidx[3] );
+    // red
+    material->NewNode( *shape );
+    material->SetSpecular( 1.0, 0.0, 0.0 );
+    material->SetDiffuse( 0.9, 0.0, 0.0 );
+    material->SetAmbient( 0.9 );
+    material->SetShininess( 0.3 );
+
+    // Shape3
+    shape->NewNode( *tx1 );
+    face->NewNode( *shape );
+    face->AddRefNode( *cp );
+    face->AddRefNode( *np );
+    coordIdx->NewNode( *face );
+    coordIdx->SetIndices( 3, &cidx[6] );
+    // green
+    material->NewNode( *shape );
+    material->SetSpecular( 0.0, 1.0, 0.0 );
+    material->SetDiffuse( 0.0, 0.9, 0.0 );
+    material->SetAmbient( 0.9 );
+    material->SetShininess( 0.3 );
+
+    // Shape4
+    shape->NewNode( *tx1 );
+    face->NewNode( *shape );
+    face->AddRefNode( *cp );
+    face->AddRefNode( *np );
+    coordIdx->NewNode( *face );
+    coordIdx->SetIndices( 3, &cidx[9] );
+    // blue
+    material->NewNode( *shape );
+    material->SetSpecular( 0.0, 0.0, 1.0 );
+    material->SetDiffuse( 0.0, 0.0, 0.9 );
+    material->SetAmbient( 0.9 );
+    material->SetShininess( 0.3 );
+
+
+    // create a copy of the entire tetrahedron shifted Z+2 and rotated 2/3PI
+    IFSG_TRANSFORM* tx2 = new IFSG_TRANSFORM( tx0->GetRawPtr() );
+    tx2->AddRefNode( *tx1 );
+    tx2->SetTranslation( SGPOINT( 0, 0, 2 ) );
+    tx2->SetRotation( SGVECTOR( 0, 0, 1 ), M_PI*2.0/3.0 );
+
+    SGNODE* data = tx0->GetRawPtr();
+
+    // delete the wrappers
+    delete shape;
+    delete face;
+    delete coordIdx;
+    delete material;
+    delete cp;
+    delete np;
+    delete tx0;
+    delete tx1;
+    delete tx2;
+
+    return (SCENEGRAPH*)data;
+}
+
+
+static S3D_PLUGIN_TETRA plugin_3d_tetra;
+
+#ifndef _WIN32
+extern "C" __attribute__((__visibility__("default"))) S3D_PLUGIN* Get3DPlugin( void )
+{
+    return &plugin_3d_tetra;
+}
+#else
+extern "C" __declspec( dllexport ) S3D_PLUGIN* Get3DPlugin( void )
+    {
+        return &plugin_3d_tetra;
+    }
+#endif
diff --git a/plugins/3d/s3d_plugin_tetra.h b/plugins/3d/s3d_plugin_tetra.h
new file mode 100644
index 0000000000..19b10c4310
--- /dev/null
+++ b/plugins/3d/s3d_plugin_tetra.h
@@ -0,0 +1,60 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_plugin_tetra.h
+ * is a sample plugin which demonstrates the basic use of the SG*
+ * classes for the intermediate representation of objects. The plugin
+ * accepts any *.wrl filename but does not actually load any files,
+ * instead the Load() routine only creates a magenta tetrahedron.
+ */
+
+
+#ifndef PLUGIN_3D_TETRA_H
+#define PLUGIN_3D_TETRA_H
+
+#include <vector>
+#include <plugins/3d/3d_plugin.h>
+
+class SCENEGRAPH;
+
+class S3D_PLUGIN_TETRA : public S3D_PLUGIN
+{
+private:
+    std::vector< wxString > m_extensions;   // supported extensions
+    std::vector< wxString > m_filters;       // file filters
+
+public:
+    S3D_PLUGIN_TETRA();
+    virtual ~S3D_PLUGIN_TETRA();
+
+    virtual int GetNExtensions( void ) const;
+    virtual const wxString GetModelExtension( int aIndex ) const;
+    virtual int GetNFilters( void ) const;
+    virtual const wxString GetFileFilter( int aIndex ) const;
+
+    bool CanRender( void ) const;
+    SCENEGRAPH* Load( const wxString& aFileName );
+};
+
+#endif  // PLUGIN_3D_TETRA_H
diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
new file mode 100644
index 0000000000..1c299b9c31
--- /dev/null
+++ b/plugins/CMakeLists.txt
@@ -0,0 +1,7 @@
+include_directories(
+        ${GLM_INCLUDE_DIR}
+        ${CMAKE_SOURCE_DIR}/include
+        ${CMAKE_SOURCE_DIR}/3d-viewer
+)
+
+add_subdirectory( 3d )