Merge lp:~unity-team/nux/nux.gpudevice-cleanup into lp:nux

[Jay Taoko]

* Removing instances of NString.
* Fixed integer to pointer convertion in GpuDevice::DrawIndexedPrimitive.
* Fixed bug in Them.cpp: Check that a pointer is NULL before calling UnReference.
* Use proper member variables naming.
* GpuDevice: Changed code for detection of OpenGL minor and minor version.

* Removing instances of NString.
* Fixed integer to pointer convertion in GpuDevice::DrawIndexedPrimitive.
* Fixed bug in Them.cpp: Check that a pointer is NULL before calling UnReference.
* Use proper member variables naming.
* GpuDevice: Changed code for detection of OpenGL minor and minor version.

[Michi Henning (michihenning)]

Looks OK.

review: Approve

[Michi Henning (michihenning)]

This also fixes Bug #1052765

[Eleni Maria Stea (hikiko)]

It seems OK!

review: Approve

[Nicolas d'Offay (nicolas-doffay)]

Looks good to land from here.

review: Approve

=== modified file 'Nux/Theme.cpp'
--- Nux/Theme.cpp	2012-09-26 12:23:04 +0000
+++ Nux/Theme.cpp	2012-09-30 17:24:22 +0000
@@ -151,7 +151,10 @@
     std::list<PainterImage*>::iterator it;
     for (it = painter_image_list_.begin(); it != painter_image_list_.end(); it++)
     {
-      (*it)->texture->UnReference();
+      if ((*it)->texture)
+      {
+        (*it)->texture->UnReference();
+      }
       delete(*it);
     }
     painter_image_list_.clear();
@@ -204,8 +207,8 @@
       {
         BaseTexture* device_texture;
 
-        NString texture_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(*value_cursor);
-        device_texture = theme->Load2DTextureFile(texture_filename.GetTCharPtr());
+        std::string texture_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(*value_cursor);
+        device_texture = theme->Load2DTextureFile(texture_filename.c_str());
 
         pimage->texture = device_texture;
       }
@@ -228,8 +231,8 @@
 
   void UXTheme::LoadPainterImages()
   {
-    NString file_search = "Painter.xml";
-    NString painter_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(file_search.GetTCharPtr());
+    std::string file_search = "Painter.xml";
+    std::string painter_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(file_search.c_str());
 
     if (painter_filename == "")
     {
@@ -253,10 +256,10 @@
       this,
       NULL);
 
-    NString str;
-    LoadFileToString(str, painter_filename.GetTCharPtr());
+    std::string str;
+    LoadFileToString(str, painter_filename.c_str());
 
-    if (g_markup_parse_context_parse(context, str.GetTCharPtr(), str.Length(), NULL) == FALSE)
+    if (g_markup_parse_context_parse(context, str.c_str(), str.length(), NULL) == FALSE)
     {
       nuxCriticalMsg("[GraphicsEngine::LoadPainterImages] Failed to parse data.");
       return;
@@ -264,7 +267,7 @@
 
 #else
 
-    TiXmlDocument doc(painter_filename.GetTCharPtr());
+    TiXmlDocument doc(painter_filename.c_str());
     doc.LoadFile();
 
     TiXmlHandle docHandle( &doc );
@@ -273,12 +276,12 @@
 
     for (image = data->FirstChildElement(TCHARToUTF8("Image")); image; image = image->NextSiblingElement(TCHARToUTF8("Image")))
     {
-      PainterImage *pimage = new PainterImage;
+      PainterImage* pimage = new PainterImage;
       Memset(pimage, 0, sizeof(PainterImage));
 
-      NString style = image->Attribute(TCHARToUTF8("style"));
+      std::string style = image->Attribute(TCHARToUTF8("style"));
 
-      pimage->style = GetStyleImageRef(style.GetTCharPtr());
+      pimage->style = GetStyleImageRef(style.c_str());
 
       // If the attributes border_left, border_right, border_top, border_bottom are not present, assume they are equal to 0;
       pimage->border_left = pimage->border_right = pimage->border_top = pimage->border_bottom = 0;
@@ -309,16 +312,16 @@
 
       if (1)
       {
-        NString filename = image->Attribute(TCHARToUTF8("Name"));
-        NString texture_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(filename.GetTCharPtr());
+        std::string filename = image->Attribute(TCHARToUTF8("Name"));
+        std::string texture_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(filename.c_str());
         pimage->texture = 0;
         pimage->filename = texture_filename;
       }
       else
       {
-        NString filename = image->Attribute(TCHARToUTF8("Name"));
-        NString texture_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(filename.GetTCharPtr());
-        pimage->texture = Load2DTextureFile(texture_filename.GetTCharPtr());
+        std::string filename = image->Attribute(TCHARToUTF8("Name"));
+        std::string texture_filename = NUX_FIND_RESOURCE_LOCATION_NOFAIL(filename.c_str());
+        pimage->texture = Load2DTextureFile(texture_filename.c_str());
       }
 
       painter_image_list_.push_back(pimage);
 
=== modified file 'NuxCore/FileIO.cpp'
--- NuxCore/FileIO.cpp	2011-10-21 22:06:35 +0000
+++ NuxCore/FileIO.cpp	2012-09-30 17:24:22 +0000
@@ -229,10 +229,10 @@
   }
 
   /*!
-      Load a text file to an NString. The file maybe ANSI or Unicode.
+      Load a text file to an std::string. The file maybe ANSI or Unicode.
       The resulting string is TCHAR.
   */
-  bool LoadFileToString ( NString &Result, const TCHAR *Filename, NFileManager &FileManager )
+  bool LoadFileToString(std::string &Result, const TCHAR *Filename, NFileManager &FileManager)
   {
     NSerializer *Reader = FileManager.CreateFileReader (Filename);
 
@@ -318,9 +318,9 @@
   /*!
       Save string to File. Attempt to write it as ASCII if possible. If not write as UTF16-BE.
   */
-  bool SaveStringToFile ( const NString &String, const TCHAR *Filename, NFileManager &FileManager )
+  bool SaveStringToFile(const std::string &String, const TCHAR *Filename, NFileManager &FileManager)
   {
-    if ( !String.Length() )
+    if ( !String.length() )
       return 0;
 
     NSerializer *Ar = FileManager.CreateFileWriter ( Filename );
@@ -347,20 +347,20 @@
 
     if ( SaveAsUnicode || (sizeof (TCHAR) == 1) )
     {
-      unsigned int s = (unsigned int) String.Length() * sizeof (TCHAR);
-      Ar->Serialize ( NUX_CONST_CAST (TCHAR *, String.GetTCharPtr() ), (unsigned int) s);
+      unsigned int s = (unsigned int) String.length() * sizeof (TCHAR);
+      Ar->Serialize(NUX_CONST_CAST(TCHAR *, String.c_str()), (unsigned int) s);
     }
     else
     {
-      unsigned int s = (unsigned int) String.Length();
+      unsigned int s = (unsigned int) String.length();
       std::vector<ANSICHAR> AnsiBuffer ( (unsigned int) s);
 
       // Cast all character down from UTF16 to ANSI
-      for (unsigned int i = 0; i < (unsigned int) String.Length(); i++ )
+      for (unsigned int i = 0; i < (unsigned int) String.length(); i++)
         AnsiBuffer[i] = ConvertTCHARToAnsiChar ( (unsigned int) String[i]);
 
       // serialize
-      s = (unsigned int) String.Length();
+      s = (unsigned int) String.length();
       Ar->Serialize ( NUX_CONST_CAST (ANSICHAR *, &AnsiBuffer[0]), s);
     }
 
 
=== modified file 'NuxCore/FileIO.h'
--- NuxCore/FileIO.h	2011-04-06 21:54:09 +0000
+++ NuxCore/FileIO.h	2012-09-30 17:24:22 +0000
@@ -29,9 +29,9 @@
   bool LoadFileToArray ( std::vector<BYTE>& Result, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
   bool LoadTextFileToAnsiArray ( std::vector<ANSICHAR>& Result, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
   bool LoadTextFileToUnicodeArray ( std::vector<UNICHAR>& Result, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
-  bool LoadFileToString ( NString &Result, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
-  bool SaveArrayToFile ( const std::vector<BYTE>& Array, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
-  bool SaveStringToFile ( const NString &String, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
+  bool LoadFileToString(std::string &Result, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
+  bool SaveArrayToFile(const std::vector<BYTE>& Array, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
+  bool SaveStringToFile(const std::string &String, const TCHAR *Filename, NFileManager &FileManager = GFileManager );
 
 }
 
 
=== modified file 'NuxGraphics/FontRenderer.cpp'
--- NuxGraphics/FontRenderer.cpp	2012-08-27 09:09:21 +0000
+++ NuxGraphics/FontRenderer.cpp	2012-09-30 17:24:22 +0000
@@ -179,7 +179,7 @@
     if (NumCharacter == 0)
       NumChar = str_len;
     else
-      NumChar = std::min(str_len, NumCharacter);
+      NumChar = std::min<int>(str_len, NumCharacter);
 
     strBBox.width = Font->GetStringWidth(str, NumChar);
     strBBox.height = Font->GetLineHeight();
@@ -323,7 +323,7 @@
     nuxAssertMsg(StartCharacter >= 0, "[FontRenderer::RenderText] Incorrect value for StartCharacter.");
     nuxAssertMsg(StartCharacter <= StrLength, "[FontRenderer::RenderText] Incorrect value for StartCharacter.");
 
-    int NumCharToDraw = std::min(StrLength - StartCharacter, NumCharacters);
+    int NumCharToDraw = std::min<int>(StrLength - StartCharacter, NumCharacters);
 
     if (NumCharToDraw <= 0)
       return 0;
 
=== modified file 'NuxGraphics/GLError.cpp'
--- NuxGraphics/GLError.cpp	2012-09-17 09:55:43 +0000
+++ NuxGraphics/GLError.cpp	2012-09-30 17:24:22 +0000
@@ -83,8 +83,10 @@
       if (logger.IsWarningEnabled() && !error_msg.empty())
       {
         std::string stacktrace;
+#if defined(NUX_OS_LINUX)
         if (debug_glerror_stack())
           stacktrace = "\n" + logging::Backtrace();
+#endif
         logging::LogStream(logging::Warning, logger.module(), file, line).stream()
 #ifndef NUX_OPENGLES_20
           << "[CheckGLError] OpenGL Error " << glErr << " (" << gluErrorString(glErr) << ")"
 
=== modified file 'NuxGraphics/GLRenderStates.cpp'
--- NuxGraphics/GLRenderStates.cpp	2012-02-21 06:57:05 +0000
+++ NuxGraphics/GLRenderStates.cpp	2012-09-30 17:24:22 +0000
@@ -113,8 +113,8 @@
 
   GpuRenderStates::GpuRenderStates(GpuBrand board, GpuInfo* info)
   {
-    _gpu_brand = board;
-    _gpu_info = info;
+    gpu_brand_ = board;
+    gpu_info_ = info;
     Memcpy(&render_state_changes_, &s_StateLUT.default_render_state, sizeof(render_state_changes_));
   }
 
 
=== modified file 'NuxGraphics/GLRenderStates.h'
--- NuxGraphics/GLRenderStates.h	2012-02-21 06:18:24 +0000
+++ NuxGraphics/GLRenderStates.h	2012-09-30 17:24:22 +0000
@@ -264,8 +264,8 @@
 
   private:
 
-    GpuBrand _gpu_brand;
-    GpuInfo *_gpu_info;
+    GpuBrand gpu_brand_;
+    GpuInfo* gpu_info_;
 
     inline void HW__EnableAlphaTest(unsigned int b);
 
@@ -963,11 +963,11 @@
       (BlendOpAlpha_ == GL_MAX),
       "Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState");
 
-    if (_gpu_info->SupportOpenGL20())
+    if (gpu_info_->SupportOpenGL20())
     {
       CHECKGL(glBlendEquationSeparate(BlendOpRGB_, BlendOpAlpha_));
     }
-    else if (_gpu_info->Support_EXT_Blend_Equation_Separate())
+    else if (gpu_info_->Support_EXT_Blend_Equation_Separate())
     {
       CHECKGL(glBlendEquationSeparateEXT(BlendOpRGB_, BlendOpAlpha_));
     }
@@ -1138,7 +1138,7 @@
   {
     if (b)
     {
-      if (_gpu_brand == GPU_BRAND_AMD)
+      if (gpu_brand_ == GPU_BRAND_AMD)
       {
         CHECKGL(glEnable(GL_STENCIL_TEST));
       }
@@ -1149,7 +1149,7 @@
     }
     else
     {
-      if (_gpu_brand == GPU_BRAND_AMD)
+      if (gpu_brand_ == GPU_BRAND_AMD)
       {
         CHECKGL(glDisable(GL_STENCIL_TEST));
       }
@@ -1215,7 +1215,7 @@
       (Func_ == GL_ALWAYS),
       "Error(HW__SetBackFaceStencilFunc): Invalid Stencil Function RenderState");
 
-    if (_gpu_brand == GPU_BRAND_AMD)
+    if (gpu_brand_ == GPU_BRAND_AMD)
     {
       CHECKGL(glStencilFuncSeparateATI(Func_/*Front function*/, Func_/*Back function*/, Ref_, Mask_)); // incorrect
     }
@@ -1268,7 +1268,7 @@
       (ZPassOp_ == GL_INVERT),
       "Error(HW__SetFrontFaceStencilOp): Invalid ZPassOp RenderState");
 
-    if (_gpu_brand == GPU_BRAND_AMD)
+    if (gpu_brand_ == GPU_BRAND_AMD)
     {
       CHECKGL(glStencilOpSeparateATI(GL_FRONT, FailOp_, ZFailOp_, ZPassOp_));
     }
@@ -1321,7 +1321,7 @@
       (ZPassOp_ == GL_INVERT),
       "Error(HW__SetBackFaceStencilOp): Invalid ZPassOp RenderState");
 
-    if (_gpu_brand == GPU_BRAND_AMD)
+    if (gpu_brand_ == GPU_BRAND_AMD)
     {
       CHECKGL(glStencilOpSeparateATI(GL_BACK, FailOp_, ZFailOp_, ZPassOp_));
     }
 
=== modified file 'NuxGraphics/GLShaderParameter.h'
--- NuxGraphics/GLShaderParameter.h	2011-10-19 20:32:38 +0000
+++ NuxGraphics/GLShaderParameter.h	2012-09-30 17:24:22 +0000
@@ -50,8 +50,8 @@
   {
   public:
     int                      m_Index;                  // Register m_Index / Attribute m_Index
-    eShaderParameterType        m_ShaderParameterType;
-    NString                     m_Name;
+    eShaderParameterType       m_ShaderParameterType;
+    std::string                m_Name;
     bool                       m_bIsOptional;
     bool                       m_bIsStatic;
     bool                       bStaticSet;
 
=== modified file 'NuxGraphics/GpuDevice.cpp'
--- NuxGraphics/GpuDevice.cpp	2012-09-19 04:53:45 +0000
+++ NuxGraphics/GpuDevice.cpp	2012-09-30 17:24:22 +0000
@@ -32,6 +32,8 @@
 #include "GLTemplatePrimitiveBuffer.h"
 #include "GraphicsEngine.h"
 
+#include <algorithm>
+
 namespace nux
 {
 #if (NUX_ENABLE_CG_SHADERS)
@@ -299,11 +301,14 @@
     bool opengl_es_20)
 #endif
 #endif
+    : opengl_major_(0)
+    , opengl_minor_(0)
+    , use_pixel_buffer_object_(false)
+    , pixel_store_alignment_(4)
+    , gpu_render_states_(NULL)
+    , gpu_info_(NULL)
   {
-    _PixelStoreAlignment  = 4;
-    _UsePixelBufferObject = false;
-    _gpu_info             = NULL;
-    _gpu_brand            = GPU_VENDOR_UNKNOWN;
+    gpu_brand_            = GPU_VENDOR_UNKNOWN;
 
 #ifndef NUX_OPENGLES_20    
     // OpenGL extension initialization
@@ -328,35 +333,70 @@
 #endif
 
 #ifndef NUX_OPENGLES_20
-    _glsl_version_string = ANSI_TO_TCHAR(NUX_REINTERPRET_CAST(const char *, glGetString(GL_VERSION)));
+    _openGL_version_string = ANSI_TO_TCHAR(NUX_REINTERPRET_CAST(const char *, glGetString(GL_VERSION)));
     CHECKGL_MSG(glGetString(GL_VERSION));
 
-    NString opengl_major;
-    NString opengl_minor;
-    char split = '.';
-    _glsl_version_string.SplitAtFirstOccurenceOf(split, opengl_major, opengl_minor);
-
-    _opengl_major = (char)opengl_major.GetTCharPtr()[0] - '0';
-    _opengl_minor = (char)opengl_minor.GetTCharPtr()[0] - '0';
-
-    if (_opengl_major >= 3)
-    {
-      CHECKGL(glGetIntegerv(GL_MAJOR_VERSION, &_opengl_major));
-      CHECKGL(glGetIntegerv(GL_MINOR_VERSION, &_opengl_minor));
+    // We need OpenGL minor and major version. Before OpenGL 3.0, the version number was reported as a string of format
+    // "major.minor". That string has to be parsed to extract the major and minor version numbers. This is not really safe as
+    // we have no guaranty that the version string is has we think it is. Some drivers report a version string like "xx.xx.xx".
+    
+    // Begin string parsing to extract the major and minor version numbers.
+    std::string opengl_major;
+    std::string opengl_minor;
+    std::string split = ".";
+
+    size_t pos = 0;
+    pos = _openGL_version_string.find(split, pos);
+
+    if (pos != tstring::npos)
+    {
+      size_t split_string_size = split.length();
+      opengl_major = _openGL_version_string.substr(0, pos);
+      opengl_minor = _openGL_version_string.substr(pos + split_string_size, _openGL_version_string.length() - (pos + split_string_size) );
+    }
+
+    int major_length = opengl_major.length();
+    opengl_major_ = 0;
+    int digit_position = 1;
+    while (major_length && (opengl_major.c_str()[major_length-1] >= '0') && (opengl_major.c_str()[major_length-1] <= '9'))
+    {
+      opengl_major_ += (opengl_major.c_str()[major_length-1] - '0') * digit_position;
+
+      digit_position *= 10;
+      --major_length;
+    }
+
+    int minor_length = opengl_minor.length();
+    opengl_minor_ = 0;
+    digit_position = 0;
+    while (minor_length && (opengl_minor.c_str()[digit_position] >= '0') && (opengl_minor.c_str()[digit_position] <= '9'))
+    {
+      opengl_minor_ += opengl_minor_ * 10 + (opengl_minor.c_str()[digit_position] - '0');
+
+      ++digit_position;
+      --minor_length;
+    }
+
+    // End string parsing
+
+    if (opengl_major_ >= 3)
+    {
+      CHECKGL(glGetIntegerv(GL_MAJOR_VERSION, &opengl_major_));
+      CHECKGL(glGetIntegerv(GL_MINOR_VERSION, &opengl_minor_));
     }
 #else
-    _opengl_major = 2;
-    _opengl_minor = 0;
+    opengl_major_ = 2;
+    opengl_minor_ = 0;
 #endif
 
 #if defined(NUX_OS_WINDOWS)
     bool opengl_es_context_created = false;
-    if (((_opengl_major >= 3) && (req_opengl_major >= 3)) || (_opengl_major >= 3) || opengl_es_20)
+    if (((opengl_major_ >= 3) && (req_opengl_major >= 3)) || (opengl_major_ >= 3) || opengl_es_20)
 #elif defined(NUX_OS_LINUX)
     //bool opengl_es_context_created = false;
     if (has_glx_13_support &&
-    (((_opengl_major >= 3) && (req_opengl_major >= 3)) ||
-    ((_opengl_major >= 3) && opengl_es_20)))
+    (((opengl_major_ >= 3) && (req_opengl_major >= 3)) ||
+    ((opengl_major_ >= 3) && opengl_es_20)))
 #endif
     {
       // Create a new Opengl Rendering Context
@@ -367,22 +407,22 @@
         if ((OpenGLVersionTable[index].major == req_opengl_major) &&
           (OpenGLVersionTable[index].minor == req_opengl_minor))
         {
-          if (_opengl_major == 1)
+          if (opengl_major_ == 1)
           {
             if ((req_opengl_major == 1) && (req_opengl_minor >= 0) && (req_opengl_minor <= 5))
               requested_profile_is_supported = true;
           }
-          else if (_opengl_major == 2)
+          else if (opengl_major_ == 2)
           {
             if ((req_opengl_major == 2) && (req_opengl_minor >= 0) && (req_opengl_minor <= 1))
               requested_profile_is_supported = true;
           }
-          else if (_opengl_major == 3)
+          else if (opengl_major_ == 3)
           {
             if ((req_opengl_major == 3) && (req_opengl_minor >= 0) && (req_opengl_minor <= 3))
               requested_profile_is_supported = true;
           }
-          else if (_opengl_major == 4)
+          else if (opengl_major_ == 4)
           {
             if ((req_opengl_major == 4) && (req_opengl_minor >= 0) && (req_opengl_minor <= 1))
               requested_profile_is_supported = true;
@@ -528,43 +568,32 @@
     _openGL_version_string = ANSI_TO_TCHAR(NUX_REINTERPRET_CAST(const char *, glGetString(GL_VERSION)));
     CHECKGL_MSG(glGetString(GL_VERSION));
 
-    nuxDebugMsg("Gpu Vendor: %s", _board_vendor_string.GetTCharPtr());
-    nuxDebugMsg("Gpu Renderer: %s", _board_renderer_string.GetTCharPtr());
-    nuxDebugMsg("Gpu OpenGL Version: %s", _openGL_version_string.GetTCharPtr());
-    nuxDebugMsg("Gpu OpenGL Major Version: %d", _opengl_major);
-    nuxDebugMsg("Gpu OpenGL Minor Version: %d", _opengl_minor);
-    nuxDebugMsg("Gpu GLSL Version: %s", _glsl_version_string.GetTCharPtr());
-
-    NString TempStr = (const char *) TCharToUpperCase(_board_vendor_string.GetTCharPtr());
-
-    if (TempStr.FindFirstOccurence("NVIDIA") != tstring::npos)
-    {
-      _gpu_brand = GPU_BRAND_NVIDIA;
-    }
-    else if (TempStr.FindFirstOccurence("ATI") != tstring::npos)
-    {
-      _gpu_brand = GPU_BRAND_AMD;
-    }
-    else if (TempStr.FindFirstOccurence("TUNGSTEN") != tstring::npos)
-    {
-      _gpu_brand = GPU_BRAND_INTEL;
-    }
-
-    if (0)
-    {
-      if (GetGPUBrand() == GPU_BRAND_AMD)
-        _UsePixelBufferObject = false;
-      else
-        _UsePixelBufferObject = true;
-    }
-    else
-    {
-      _UsePixelBufferObject = false;
-    }
-
-    _gpu_info = new GpuInfo();
-    _gpu_info->Setup();
-    _gpu_render_states = new GpuRenderStates(_gpu_brand, _gpu_info);
+    nuxDebugMsg("Gpu Vendor: %s", _board_vendor_string.c_str());
+    nuxDebugMsg("Gpu Renderer: %s", _board_renderer_string.c_str());
+    nuxDebugMsg("Gpu OpenGL Version: %s", _openGL_version_string.c_str());
+    nuxDebugMsg("Gpu OpenGL Major Version: %d", opengl_major_);
+    nuxDebugMsg("Gpu OpenGL Minor Version: %d", opengl_minor_);
+
+    std::transform(_board_vendor_string.begin(), _board_vendor_string.end(), _board_vendor_string.begin(), ::toupper); 
+
+    if (_board_vendor_string.find("NVIDIA", 0) != tstring::npos)
+    {
+      gpu_brand_ = GPU_BRAND_NVIDIA;
+    }
+    else if (_board_vendor_string.find("ATI", 0) != tstring::npos)
+    {
+      gpu_brand_ = GPU_BRAND_AMD;
+    }
+    else if (_board_vendor_string.find("TUNGSTEN", 0) != tstring::npos)
+    {
+      gpu_brand_ = GPU_BRAND_INTEL;
+    }
+
+   use_pixel_buffer_object_ = false;
+
+    gpu_info_ = new GpuInfo();
+    gpu_info_->Setup();
+    gpu_render_states_ = new GpuRenderStates(gpu_brand_, gpu_info_);
 
 #if defined(NUX_OS_WINDOWS)
     OGL_EXT_SWAP_CONTROL                = WGLEW_EXT_swap_control ? true : false;
@@ -579,8 +608,8 @@
     // http://www.opengl.org/resources/features/KilgardTechniques/oglpitfall/
     // We use a pack /unpack alignment to 1 so we don't have any padding at the end of row.
 
-    CHECKGL(glPixelStorei(GL_UNPACK_ALIGNMENT, _PixelStoreAlignment));
-    CHECKGL(glPixelStorei(GL_PACK_ALIGNMENT, _PixelStoreAlignment));
+    CHECKGL(glPixelStorei(GL_UNPACK_ALIGNMENT, pixel_store_alignment_));
+    CHECKGL(glPixelStorei(GL_PACK_ALIGNMENT, pixel_store_alignment_));
 
 //     _DeviceWidth = DeviceWidth;
 //     _DeviceHeight = DeviceHeight;
@@ -619,8 +648,8 @@
 
   GpuDevice::~GpuDevice()
   {
-    NUX_SAFE_DELETE(_gpu_info);
-    NUX_SAFE_DELETE(_gpu_render_states);
+    NUX_SAFE_DELETE(gpu_info_);
+    NUX_SAFE_DELETE(gpu_render_states_);
 
     _FrameBufferObject.Release();
     active_framebuffer_object_.Release();
@@ -656,37 +685,47 @@
 
   int GpuDevice::GetOpenGLMajorVersion() const
   {
-    return _opengl_major;
+    return opengl_major_;
   }
 
   int GpuDevice::GetOpenGLMinorVersion() const
   {
-    return _opengl_minor;
+    return opengl_minor_;
+  }
+
+  unsigned int GpuDevice::GetPixelStoreAlignment() const
+  {
+    return pixel_store_alignment_;
+  }
+
+  bool GpuDevice::UsePixelBufferObjects() const
+  {
+    return use_pixel_buffer_object_;
   }
 
   GpuBrand GpuDevice::GetGPUBrand() const
   {
-    return _gpu_brand;
+    return gpu_brand_;
   }
 
   GpuRenderStates &GpuDevice::GetRenderStates()
   {
-    return *_gpu_render_states;
+    return *gpu_render_states_;
   }
 
-  GpuInfo &GpuDevice::GetGpuInfo()
+  const GpuInfo& GpuDevice::GetGpuInfo() const
   {
-    return *_gpu_info;
+    return *gpu_info_;
   }
 
   void GpuDevice::ResetRenderStates()
   {
-    _gpu_render_states->ResetStateChangeToDefault();
+    gpu_render_states_->ResetStateChangeToDefault();
   }
 
   void GpuDevice::VerifyRenderStates()
   {
-    _gpu_render_states->CheckStateChange();
+    gpu_render_states_->CheckStateChange();
   }
 
   void GpuDevice::InvalidateTextureUnit(int TextureUnitIndex)
 
=== modified file 'NuxGraphics/GpuDevice.h'
--- NuxGraphics/GpuDevice.h	2012-09-17 09:55:43 +0000
+++ NuxGraphics/GpuDevice.h	2012-09-30 17:24:22 +0000
@@ -362,11 +362,6 @@
     //! Setup a NULL texture
     void InvalidateTextureUnit(int TextureUnitIndex);
 
-    unsigned int GetPixelStoreAlignment()
-    {
-      return _PixelStoreAlignment;
-    }
-
     int AllocateUnpackPixelBufferIndex(int *index);
     int FreeUnpackPixelBufferIndex(const int index);
     int BindUnpackPixelBufferIndex(const int index);
@@ -389,6 +384,8 @@
     //! Restore the backbuffer as the render target.
     void DeactivateFrameBuffer(); 
 
+    unsigned int GetPixelStoreAlignment() const;
+
   public:
     void SetCurrentFrameBufferObject(ObjectPtr<IOpenGLFrameBufferObject> fbo);
     ObjectPtr<IOpenGLFrameBufferObject> GetCurrentFrameBufferObject();
@@ -409,10 +406,6 @@
       bool   IsReserved;
     };
 
-    unsigned int _PixelStoreAlignment;
-
-    std::vector<PixelBufferObject> _PixelBufferArray;
-
   public:
 
 #if (NUX_ENABLE_CG_SHADERS)
@@ -423,16 +416,13 @@
     CGcontext m_Cgcontext;
 #endif
 
-    inline bool UsePixelBufferObjects() const
-    {
-      return _UsePixelBufferObject;
-    }
+    bool UsePixelBufferObjects() const;
 
     GpuBrand GetGPUBrand() const;
 
-    GpuRenderStates &GetRenderStates();
+    GpuRenderStates& GetRenderStates();
 
-    GpuInfo &GetGpuInfo();
+    const GpuInfo& GetGpuInfo() const;
 
     void ResetRenderStates();
 
@@ -460,34 +450,34 @@
 
     bool SUPPORT_GL_ARB_TEXTURE_NON_POWER_OF_TWO() const
     {
-      return _gpu_info->Support_ARB_Texture_Non_Power_Of_Two();
+      return gpu_info_->Support_ARB_Texture_Non_Power_Of_Two();
     }
 
     bool SUPPORT_GL_EXT_TEXTURE_RECTANGLE()    const
     {
-      return _gpu_info->Support_EXT_Texture_Rectangle();
+      return gpu_info_->Support_EXT_Texture_Rectangle();
     }
 
     bool SUPPORT_GL_ARB_TEXTURE_RECTANGLE()    const
     {
-      return _gpu_info->Support_ARB_Texture_Rectangle();
+      return gpu_info_->Support_ARB_Texture_Rectangle();
     }
     
   private:
 
     // 
-    int _opengl_major;  //!< OpenGL major version.
-    int _opengl_minor;  //!< OpenGL minor version.
-    int _glsl_version_major;  //!< GLSL major version.
-    int _glsl_version_minor;  //!< GLSL major version.
-
-    NString _board_vendor_string;     //!< GPU vendor sting.
-    NString _board_renderer_string;   //!< GPU renderer sting.
-    NString _openGL_version_string;   //!< OpenGL version string.
-    NString _glsl_version_string;     //!< GLSL version string.
-    GpuBrand _gpu_brand;              //!< GPU brand.
-
-    bool _UsePixelBufferObject;
+    int opengl_major_;  //!< OpenGL major version.
+    int opengl_minor_;  //!< OpenGL minor version.
+
+    std::string _board_vendor_string;     //!< GPU vendor sting.
+    std::string _board_renderer_string;   //!< GPU renderer sting.
+    std::string _openGL_version_string;   //!< OpenGL version string.
+    GpuBrand gpu_brand_;                  //!< GPU brand.
+
+    bool use_pixel_buffer_object_;
+    unsigned int pixel_store_alignment_;
+    std::vector<PixelBufferObject> _PixelBufferArray;
+
 
     bool OGL_EXT_SWAP_CONTROL;
     bool GL_ARB_VERTEX_PROGRAM;
@@ -504,8 +494,8 @@
     bool GL_ARB_TEXTURE_RECTANGLE; //!< Promoted from GL_EXT_TEXTURE_RECTANGLE to ARB.
     bool GL_NV_TEXTURE_RECTANGLE;
 
-    GpuRenderStates *_gpu_render_states;
-    GpuInfo *_gpu_info;
+    GpuRenderStates* gpu_render_states_;
+    GpuInfo* gpu_info_;
 
   public:
     
 
=== modified file 'NuxGraphics/GpuDeviceVertex.cpp'
--- NuxGraphics/GpuDeviceVertex.cpp	2012-09-19 04:53:45 +0000
+++ NuxGraphics/GpuDeviceVertex.cpp	2012-09-30 17:24:22 +0000
@@ -160,7 +160,7 @@
         vtxelement.Type,
         GL_FALSE,
         vtxelement.stride_,
-        (void*)vtxelement.Offset)); // TODO: Bug. It doesn't make sense to convert a 4-byte int into an 8-byte pointer.
+        (void*)&vtxelement.Offset));
 
       VertexDeclaration->_valid_vertex_input[shader_attribute_location] = 1;
       ++decl;
 
=== modified file 'NuxGraphics/GraphicsEngine.cpp'
--- NuxGraphics/GraphicsEngine.cpp	2012-09-17 09:55:43 +0000
+++ NuxGraphics/GraphicsEngine.cpp	2012-09-30 17:24:22 +0000
@@ -230,7 +230,7 @@
       }
 #endif
 
-      GpuInfo& gpu_info = _graphics_display.GetGpuDevice()->GetGpuInfo();
+      const GpuInfo& gpu_info = _graphics_display.GetGpuDevice()->GetGpuInfo();
 
       if ((gpu_info.Support_ARB_Vertex_Program() && gpu_info.Support_ARB_Fragment_Program())
           || (gpu_info.Support_ARB_Vertex_Shader() && gpu_info.Support_ARB_Fragment_Shader()))
 
=== modified file 'NuxGraphics/GraphicsEngine.h'
--- NuxGraphics/GraphicsEngine.h	2012-09-19 04:53:45 +0000
+++ NuxGraphics/GraphicsEngine.h	2012-09-30 17:24:22 +0000
@@ -662,15 +662,15 @@
 
     GpuRenderStates& GetRenderStates()
     {
-      return *_graphics_display.m_DeviceFactory->_gpu_render_states;
+      return *_graphics_display.m_DeviceFactory->gpu_render_states_;
     }
     void ResetRenderStates()
     {
-      _graphics_display.m_DeviceFactory->_gpu_render_states->ResetStateChangeToDefault();
+      _graphics_display.m_DeviceFactory->gpu_render_states_->ResetStateChangeToDefault();
     }
     void VerifyRenderStates()
     {
-      _graphics_display.m_DeviceFactory->_gpu_render_states->CheckStateChange();
+      _graphics_display.m_DeviceFactory->gpu_render_states_->CheckStateChange();
     }
 
     ObjectPtr<FontTexture> GetFont();
 
=== modified file 'NuxGraphics/IOpenGLAsmShader.cpp'
--- NuxGraphics/IOpenGLAsmShader.cpp	2012-08-02 16:29:19 +0000
+++ NuxGraphics/IOpenGLAsmShader.cpp	2012-09-30 17:24:22 +0000
@@ -39,7 +39,7 @@
   NUX_IMPLEMENT_OBJECT_TYPE(IOpenGLAsmPixelShader);
   NUX_IMPLEMENT_OBJECT_TYPE(IOpenGLAsmShaderProgram);
 
-  bool ExtractShaderString3(const NString &ShaderToken, const NString &ShaderSource, NString &RetSource, NString ShaderPreprocessorDefines);
+  bool ExtractShaderString3(const std::string& ShaderToken, const std::string& ShaderSource, std::string& RetSource, std::string ShaderPreprocessorDefines);
 
   IOpenGLAsmShader::IOpenGLAsmShader(std::string const& shader_name, GLint shader_type, OpenGLResourceType ResourceType)
     : IOpenGLResource(ResourceType)
@@ -113,7 +113,7 @@
   {
   }
 
-  IOpenGLAsmShaderProgram::IOpenGLAsmShaderProgram(NString ShaderProgramName)
+  IOpenGLAsmShaderProgram::IOpenGLAsmShaderProgram(std::string ShaderProgramName)
     :   IOpenGLResource(RT_GLSL_SHADERPROGRAM)
     ,   _ShaderProgramName(ShaderProgramName)
   {
@@ -131,19 +131,19 @@
   {
     nuxAssertMsg(ShaderFileName, "[IOpenGLAsmShaderProgram::LoadIShaderFile] Invalid shader file name.");
     NUX_RETURN_IF_NULL(ShaderFileName);
-    NString SourceCode;
+    std::string SourceCode;
     LoadFileToString(SourceCode, ShaderFileName);
     LoadIShader(&SourceCode[0]);
   }
 
-  void IOpenGLAsmShaderProgram::LoadIShader(const char *ShaderCode)
+  void IOpenGLAsmShaderProgram::LoadIShader(const char* ShaderCode)
   {
     nuxAssertMsg(ShaderCode, "[IOpenGLAsmShaderProgram::LoadIShader] Invalid shader code.");
     NUX_RETURN_IF_NULL(ShaderCode);
-    NString VertexShaderSource;
-    ExtractShaderString3("[Vertex Shader]", ShaderCode, VertexShaderSource, NString(""));
-    NString PixelShaderSource;
-    ExtractShaderString3("[Fragment Shader]", ShaderCode, PixelShaderSource, NString(""));
+    std::string VertexShaderSource;
+    ExtractShaderString3("[Vertex Shader]", ShaderCode, VertexShaderSource, std::string(""));
+    std::string PixelShaderSource;
+    ExtractShaderString3("[Fragment Shader]", ShaderCode, PixelShaderSource, std::string(""));
 
     m_AsmVertexProgram->SetShaderCode(&VertexShaderSource[0]);
     m_AsmFragmentProgram->SetShaderCode(&PixelShaderSource[0]);
@@ -152,7 +152,7 @@
     m_AsmFragmentProgram->Compile();
   }
 
-  void IOpenGLAsmShaderProgram::LoadVertexShader(const char *glslshader)
+  void IOpenGLAsmShaderProgram::LoadVertexShader(const char* glslshader)
   {
     nuxAssertMsg(glslshader, "[IOpenGLAsmShaderProgram::LoadVertexShader] Invalid shader code.");
     NUX_RETURN_IF_NULL(glslshader);
 
=== modified file 'NuxGraphics/IOpenGLAsmShader.h'
--- NuxGraphics/IOpenGLAsmShader.h	2012-08-02 16:29:19 +0000
+++ NuxGraphics/IOpenGLAsmShader.h	2012-09-30 17:24:22 +0000
@@ -121,9 +121,9 @@
     void SetFragmentLocalParameter4fvARB    (unsigned int index, const float *params);
 
   private:
-    IOpenGLAsmShaderProgram(NString ShaderProgramName = NString("AsmShaderProgram"));
+    IOpenGLAsmShaderProgram(std::string ShaderProgramName = std::string("AsmShaderProgram"));
     std::vector<ObjectPtr<IOpenGLAsmShader> > ShaderObjectList;
-    NString _ShaderProgramName;
+    std::string _ShaderProgramName;
 
     ObjectPtr<IOpenGLAsmVertexShader> m_AsmVertexProgram;
     ObjectPtr<IOpenGLAsmPixelShader> m_AsmFragmentProgram;
 
=== modified file 'NuxGraphics/IOpenGLCgShader.h'
--- NuxGraphics/IOpenGLCgShader.h	2011-10-19 20:32:38 +0000
+++ NuxGraphics/IOpenGLCgShader.h	2012-09-30 17:24:22 +0000
@@ -33,7 +33,7 @@
     NUX_DECLARE_OBJECT_TYPE(ICgShader, IOpenGLResource);
 
   public:
-    ICgShader(NString ShaderName, OpenGLResourceType ResourceType);
+    ICgShader(std::string ShaderName, OpenGLResourceType ResourceType);
     virtual ~ICgShader();
 
     virtual void CreateProgram(const ANSICHAR *ShaderCode, const ANSICHAR *EntryPoint) = 0;
@@ -45,9 +45,9 @@
     virtual bool IsValid() = 0;
     CGparameter GetNamedParameter(const char *parameter);
 
-    NString _ShaderName;
-    NString _ShaderCode;
-    NString _EntryPoint;
+    std::string _ShaderName;
+    std::string _ShaderCode;
+    std::string _EntryPoint;
     CGprogram _CgProgram;
   };
 
@@ -62,7 +62,7 @@
     virtual bool Compile();
     virtual bool IsValid();
   private:
-    ICgVertexShader(NString ShaderName = NString("VertexProgram"));
+    ICgVertexShader(std::string ShaderName = std::string("VertexProgram"));
     int _ready;
     friend class GpuDevice;
   };
@@ -78,7 +78,7 @@
     virtual bool Compile();
     virtual bool IsValid();
   private:
-    ICgPixelShader(NString ShaderName = NString("PixelProgram"));
+    ICgPixelShader(std::string ShaderName = std::string("PixelProgram"));
     int _ready;
     friend class GpuDevice;
   };
 
=== modified file 'NuxGraphics/IOpenGLGLSLShader.cpp'
--- NuxGraphics/IOpenGLGLSLShader.cpp	2012-02-23 16:30:14 +0000
+++ NuxGraphics/IOpenGLGLSLShader.cpp	2012-09-30 17:24:22 +0000
@@ -43,7 +43,7 @@
   NUX_IMPLEMENT_OBJECT_TYPE(IOpenGLShaderProgram);
 
 
-  bool ExtractShaderString3(const NString &ShaderToken, const NString &ShaderSource, NString &RetSource, NString ShaderPreprocessorDefines)
+  bool ExtractShaderString3(const std::string &ShaderToken, const std::string &ShaderSource, std::string &RetSource, std::string ShaderPreprocessorDefines)
   {
     size_t lineStart = 0;
     size_t lineCount = 1;
@@ -57,7 +57,7 @@
     {
       size_t i;
 
-      for (i = 0; i < ShaderSource.Length(); i++)
+      for (i = 0; i < ShaderSource.length(); i++)
       {
         //Check if the starting character '[' (open bracket) is found at the beginning of the line
         // i counts the characters in the file. lineStart is equal to i at the beginning of the line.
@@ -66,10 +66,10 @@
           if (!startTokenFound)
           {
             //Test for the start token
-            if (ShaderSource.FindFirstOccurence(ShaderToken) == i)
+            if (ShaderSource.find(ShaderToken, 0) == i)
             {
               // Found the shader token
-              shaderStringStart = i + ShaderToken.Length();
+              shaderStringStart = i + ShaderToken.length();
               startTokenFound = true;
 
               //Set what line the shader was found on
@@ -104,11 +104,11 @@
       }
 
       //Assign the return string
-      RetSource = ShaderSource.GetSubString(shaderStringStart, i - shaderStringStart);
+      RetSource = ShaderSource.substr(shaderStringStart, i - shaderStringStart);
 
       //Add the line directive to the shader source. See the documentation for GLSL #line directive.
       // GLSL spec: The #version directive must occur in a shader before anything else, except for comments and white space.
-      size_t Pos = RetSource.FindFirstOccurence("#version");
+      size_t Pos = RetSource.find("#version", 0);
 
       while (RetSource[Pos] != '\n')
       {
@@ -124,17 +124,21 @@
       size_t EndOfLinePosition = 0;
       size_t LinePosition = 0;
 
-      while ((EndOfLinePosition = RetSource.FindNextOccurence('\n', EndOfLinePosition)) < Pos - 1)
+      while ((EndOfLinePosition = RetSource.find('\n', EndOfLinePosition)) < Pos - 1)
       {
         ++EndOfLinePosition;
         ++LinePosition;
       }
 
-      RetSource.Insert(Pos, NString::Printf("#line %u\n", LinePosition + shaderStartLine));
+      std::ostringstream o_str_stream;
+      o_str_stream << "#line " << LinePosition + shaderStartLine << "\n";
+      std::string line_num_str = o_str_stream.str();
+
+      RetSource.insert(Pos, line_num_str);
 
       // Insert the preprocessor definitions before the #line directive
-      if (ShaderPreprocessorDefines.Length())
-        RetSource.Insert(Pos, ShaderPreprocessorDefines + NString('\n'));
+      if (ShaderPreprocessorDefines.length())
+        RetSource.insert(Pos, ShaderPreprocessorDefines + std::string("\n"));
 
       return true;
     }
@@ -146,26 +150,26 @@
     }
   }
 
-  static void InsertPreProcessorDefinitions(const NString &ShaderSource, NString &RetSource, NString &ShaderPreprocessorDefines)
+  static void InsertPreProcessorDefinitions(const std::string &ShaderSource, std::string &RetSource, std::string &ShaderPreprocessorDefines)
   {
     RetSource = ShaderSource;
 
-    if (ShaderPreprocessorDefines.Length() == 0)
+    if (ShaderPreprocessorDefines.length() == 0)
       return;
 
     // GLSL spec: The #version directive must occur in a shader before anything else, except for comments and white space.
-    size_t Pos = RetSource.FindFirstOccurence("#version");
+    size_t Pos = RetSource.find("#version", 0);
 
     if (Pos != tstring::npos)
     {
-      Pos = RetSource.FindNextOccurence('\n', Pos);
+      Pos = RetSource.find('\n', Pos);
 
       if (Pos == tstring::npos)
       {
         // this is most likely an incorrect shader
-        Pos = RetSource.Size();
-        RetSource.Insert(Pos, NString('\n'));
-        Pos = RetSource.Size();
+        Pos = RetSource.size();
+        RetSource.insert(Pos, std::string("\n"));
+        Pos = RetSource.size();
       }
       else
       {
@@ -178,11 +182,11 @@
       Pos = 0;
     }
 
-    if (ShaderPreprocessorDefines.Length())
-      RetSource.Insert(Pos, ShaderPreprocessorDefines + NString('\n'));
+    if (ShaderPreprocessorDefines.length())
+      RetSource.insert(Pos, ShaderPreprocessorDefines + std::string("\n"));
   }
 
-  IOpenGLShader::IOpenGLShader(NString ShaderName, OpenGLResourceType ResourceType)
+  IOpenGLShader::IOpenGLShader(std::string ShaderName, OpenGLResourceType ResourceType)
     :   IOpenGLResource(ResourceType)
     ,   _ShaderName(ShaderName)
   {
@@ -194,7 +198,7 @@
 
   }
 
-  IOpenGLVertexShader::IOpenGLVertexShader(NString ShaderName)
+  IOpenGLVertexShader::IOpenGLVertexShader(std::string ShaderName)
     :   IOpenGLShader(ShaderName, RT_GLSL_VERTEXSHADER)
     ,   m_CompiledAndReady(false)
   {
@@ -213,8 +217,8 @@
   {
     nuxAssertMsg(ShaderCode, "[IOpenGLVertexShader::SetShaderCode] Invalid shader code.");
     NUX_RETURN_IF_NULL(ShaderCode);
-    NString ProcessedShaderSource;
-    NString Defines(VtxShaderPreprocessorDefines);
+    std::string ProcessedShaderSource;
+    std::string Defines(VtxShaderPreprocessorDefines);
     InsertPreProcessorDefinitions(ShaderCode, ProcessedShaderSource, Defines);
 
     m_CompiledAndReady = false;
@@ -223,7 +227,7 @@
 
   bool IOpenGLVertexShader::Compile()
   {
-    size_t CodeSize = _ShaderCode.Size();
+    size_t CodeSize = _ShaderCode.size();
 
     if (CodeSize == 0)
     {
@@ -232,7 +236,7 @@
 
     char *ShaderSource = new char[CodeSize+1];
     Memset(ShaderSource, 0, CodeSize + 1);
-    Memcpy(ShaderSource, _ShaderCode.GetTCharPtr(), CodeSize);
+    Memcpy(ShaderSource, _ShaderCode.c_str(), CodeSize);
 
     CHECKGL(glShaderSource(_OpenGLID, 1, (const GLcharARB **) &ShaderSource, NULL));
     delete [] ShaderSource;
@@ -272,7 +276,7 @@
     return(m_CompiledAndReady ? true : false);
   }
 
-  IOpenGLPixelShader::IOpenGLPixelShader(NString ShaderName)
+  IOpenGLPixelShader::IOpenGLPixelShader(std::string ShaderName)
     :   IOpenGLShader(ShaderName, RT_GLSL_PIXELSHADER)
     ,   m_CompiledAndReady(false)
 
@@ -292,8 +296,8 @@
   {
     nuxAssertMsg(ShaderCode, "[IOpenGLPixelShader::SetShaderCode] Invalid shader code.");
     NUX_RETURN_IF_NULL(ShaderCode);
-    NString ProcessedShaderSource;
-    NString Defines(FrgShaderPreprocessorDefines);
+    std::string ProcessedShaderSource;
+    std::string Defines(FrgShaderPreprocessorDefines);
     InsertPreProcessorDefinitions(ShaderCode, ProcessedShaderSource, Defines);
 
     m_CompiledAndReady = false;
@@ -303,7 +307,7 @@
   bool IOpenGLPixelShader::Compile()
   {
 
-    GLint CodeSize = (GLint) _ShaderCode.Size();
+    GLint CodeSize = (GLint) _ShaderCode.size();
 
     if (CodeSize == 0)
     {
@@ -312,7 +316,7 @@
 
     char *ShaderSource = new char[CodeSize+1];
     Memset(ShaderSource, 0, CodeSize + 1);
-    Memcpy(ShaderSource, _ShaderCode.m_string.c_str(), CodeSize);
+    Memcpy(ShaderSource, _ShaderCode.c_str(), CodeSize);
     CHECKGL(glShaderSource(_OpenGLID, 1, (const GLcharARB **) &ShaderSource, &CodeSize));
     delete [] ShaderSource;
 
@@ -354,7 +358,7 @@
   }
 
 #if 0
-  IOpenGLGeometryShader::IOpenGLGeometryShader(NString ShaderName)
+  IOpenGLGeometryShader::IOpenGLGeometryShader(std::string ShaderName)
     :   IOpenGLShader(ShaderName, RT_GLSL_GEOMETRYSHADER)
     ,   m_CompiledAndReady(false)
 
@@ -374,8 +378,8 @@
   {
     nuxAssertMsg(ShaderCode, "[IOpenGLGeometryShader::SetShaderCode] Invalid shader code.");
     NUX_RETURN_IF_NULL(ShaderCode);
-    NString ProcessedShaderSource;
-    NString Defines(GeometryShaderPreprocessorDefines);
+    std::string ProcessedShaderSource;
+    std::string Defines(GeometryShaderPreprocessorDefines);
     InsertPreProcessorDefinitions(ShaderCode, ProcessedShaderSource, Defines);
 
     m_CompiledAndReady = false;
@@ -449,7 +453,7 @@
   }
 #endif
 
-  IOpenGLShaderProgram::IOpenGLShaderProgram(NString ShaderProgramName)
+  IOpenGLShaderProgram::IOpenGLShaderProgram(std::string ShaderProgramName)
     :   IOpenGLResource(RT_GLSL_SHADERPROGRAM)
     ,   _FirstParameter(0)
     ,   m_CompiledAndReady(false)
@@ -476,7 +480,7 @@
   {
     nuxAssertMsg(ShaderFileName, "[IOpenGLShaderProgram::LoadIShaderFile] Invalid shader file name.");
     NUX_RETURN_IF_NULL(ShaderFileName);
-    NString SourceCode;
+    std::string SourceCode;
     LoadFileToString(SourceCode, ShaderFileName);
     LoadIShader(&SourceCode[0], VtxShaderPreprocessorDefines, FrgShaderPreprocessorDefines);
   }
@@ -485,10 +489,10 @@
   {
     nuxAssertMsg(ShaderCode, "[IOpenGLShaderProgram::LoadIShader] Invalid shader code.");
     NUX_RETURN_IF_NULL(ShaderCode);
-    NString VertexShaderSource;
-    ExtractShaderString3("[Vertex Shader]", ShaderCode, VertexShaderSource, NString(VtxShaderPreprocessorDefines));
-    NString PixelShaderSource;
-    ExtractShaderString3("[Fragment Shader]", ShaderCode, PixelShaderSource, NString(FrgShaderPreprocessorDefines));
+    std::string VertexShaderSource;
+    ExtractShaderString3("[Vertex Shader]", ShaderCode, VertexShaderSource, std::string(VtxShaderPreprocessorDefines));
+    std::string PixelShaderSource;
+    ExtractShaderString3("[Fragment Shader]", ShaderCode, PixelShaderSource, std::string(FrgShaderPreprocessorDefines));
 
     ObjectPtr<IOpenGLVertexShader> vs = GetGraphicsDisplay()->GetGpuDevice()->CreateVertexShader(); //new IOpenGLVertexShader;
     ObjectPtr<IOpenGLPixelShader> ps = GetGraphicsDisplay()->GetGpuDevice()->CreatePixelShader(); //new IOpenGLPixelShader;
@@ -510,8 +514,8 @@
     NUX_RETURN_IF_NULL(glslshader);
     ObjectPtr<IOpenGLVertexShader> vs = GetGraphicsDisplay()->GetGpuDevice()->CreateVertexShader(); //new IOpenGLVertexShader;
 
-    NString ProcessedShaderSource;
-    NString Defines(VtxShaderPreprocessorDefines);
+    std::string ProcessedShaderSource;
+    std::string Defines(VtxShaderPreprocessorDefines);
     InsertPreProcessorDefinitions(glslshader, ProcessedShaderSource, Defines);
 
     vs->SetShaderCode(glslshader);
@@ -525,8 +529,8 @@
     NUX_RETURN_IF_NULL(glslshader);
     ObjectPtr<IOpenGLPixelShader> ps = GetGraphicsDisplay()->GetGpuDevice()->CreatePixelShader(); //new IOpenGLPixelShader;
 
-    NString ProcessedShaderSource;
-    NString Defines(FrgShaderPreprocessorDefines);
+    std::string ProcessedShaderSource;
+    std::string Defines(FrgShaderPreprocessorDefines);
     InsertPreProcessorDefinitions(glslshader, ProcessedShaderSource, Defines);
 
     ps->SetShaderCode(glslshader);
@@ -607,7 +611,7 @@
       {
         if (ShaderObjectList[i]->Compile() == false)
         {
-          nuxDebugMsg("[IOpenGLShaderProgram::Link] Attached shader %s does not compile with program: %s.", ShaderObjectList[i]->_ShaderName.GetTCharPtr(), _ShaderProgramName.GetTCharPtr());
+          nuxDebugMsg("[IOpenGLShaderProgram::Link] Attached shader %s does not compile with program: %s.", ShaderObjectList[i]->_ShaderName.c_str(), _ShaderProgramName.c_str());
         }
       }
 
@@ -793,13 +797,13 @@
 
     while (m_CompiledAndReady && parameter)
     {
-      int location = glGetUniformLocationARB(_OpenGLID, TCHAR_TO_ANSI(parameter->m_Name.GetTCharPtr()));
-      CHECKGL_MSG( glGetUniformLocationARB(_OpenGLID, TCHAR_TO_ANSI(parameter->m_Name.GetTCharPtr())));
+      int location = glGetUniformLocationARB(_OpenGLID, TCHAR_TO_ANSI(parameter->m_Name.c_str()));
+      CHECKGL_MSG( glGetUniformLocationARB(_OpenGLID, TCHAR_TO_ANSI(parameter->m_Name.c_str())));
 
       //nuxDebugMsg("[IOpenGLShaderProgram::CheckUniformLocation] Location index: %d", location);
       if (location == -1 && (!parameter->m_bIsOptional))
       {
-        nuxDebugMsg("[IOpenGLShaderProgram::CheckUniformLocation] Couldn't find shader program parameter %s \n", parameter->m_Name.GetTCharPtr());
+        nuxDebugMsg("[IOpenGLShaderProgram::CheckUniformLocation] Couldn't find shader program parameter %s \n", parameter->m_Name.c_str());
         nuxAssert(0);
       }
 
 
=== modified file 'NuxGraphics/IOpenGLGLSLShader.h'
--- NuxGraphics/IOpenGLGLSLShader.h	2011-10-19 20:32:38 +0000
+++ NuxGraphics/IOpenGLGLSLShader.h	2012-09-30 17:24:22 +0000
@@ -28,19 +28,19 @@
 
   class IOpenGLResource;
 
-  bool ExtractShaderString3(const NString &ShaderToken, const NString &ShaderSource, NString &RetSource, NString ShaderPreprocessorDefines = NString(""));
+  bool ExtractShaderString3(const std::string &ShaderToken, const std::string &ShaderSource, std::string &RetSource, std::string ShaderPreprocessorDefines = std::string(""));
 
   class IOpenGLShader:  public IOpenGLResource
   {
     NUX_DECLARE_OBJECT_TYPE(IOpenGLShader, IOpenGLResource);
-    IOpenGLShader(NString ShaderName, OpenGLResourceType ResourceType);
+    IOpenGLShader(std::string ShaderName, OpenGLResourceType ResourceType);
     virtual ~IOpenGLShader();
   public:
     virtual void SetShaderCode(const ANSICHAR *ShaderCode, const char *ShaderPreprocessorDefines = "") = 0;
     virtual bool Compile() = 0;
     virtual bool IsValid() = 0;
-    NString _ShaderName;
-    NString _ShaderCode;
+    std::string _ShaderName;
+    std::string _ShaderCode;
   };
 
   class IOpenGLVertexShader:  public IOpenGLShader
@@ -52,7 +52,7 @@
     virtual bool Compile();
     virtual bool IsValid();
   private:
-    IOpenGLVertexShader(NString ShaderName = NString("Vertex Shader"));
+    IOpenGLVertexShader(std::string ShaderName = std::string("Vertex Shader"));
     int m_CompiledAndReady;
     friend class GpuDevice;
   };
@@ -66,7 +66,7 @@
     virtual bool Compile();
     virtual bool IsValid();
   private:
-    IOpenGLPixelShader(NString ShaderName = NString("Fragment Shader"));
+    IOpenGLPixelShader(std::string ShaderName = std::string("Fragment Shader"));
     int m_CompiledAndReady;
     friend class GpuDevice;
   };
@@ -86,7 +86,7 @@
     void SetMaxVertexOutput(int max_vertex_output);
 
   private:
-    IOpenGLGeometryShader(NString ShaderName = NString("Geometry Shader"));
+    IOpenGLGeometryShader(std::string ShaderName = std::string("Geometry Shader"));
     int m_CompiledAndReady;
     friend class GpuDevice;
   };
@@ -207,11 +207,11 @@
     int GetAttributeLocation(const char *AttributeName);
 
   private:
-    IOpenGLShaderProgram(NString ShaderProgramName = NString("ShaderProgram"));
+    IOpenGLShaderProgram(std::string ShaderProgramName = std::string("ShaderProgram"));
     ShaderAttributeDefinition m_ProgramAttributeDefinition[16/*NUM_VERTEX_SHADER_INPUT_ATTRIBUTE*/];
     std::vector<ObjectPtr<IOpenGLShader> > ShaderObjectList;
     bool m_CompiledAndReady;
-    NString _ShaderProgramName;
+    std::string _ShaderProgramName;
     friend class GpuDevice;
   };