Index: code/branches/buildsystem2/src/orxonox/CMakeLists.txt
===================================================================
--- code/branches/buildsystem2/src/orxonox/CMakeLists.txt	(revision 2568)
+++ code/branches/buildsystem2/src/orxonox/CMakeLists.txt	(revision 2569)
@@ -40,4 +40,5 @@
   #${CEGUI_SCRIPT_LIBRARIES}
   ceguilua_orxonox
+  ogreceguirenderer_orxonox
   tinyxml_orxonox
   tolualib_orxonox
Index: code/branches/buildsystem2/src/orxonox/gui/CMakeLists.txt
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/CMakeLists.txt	(revision 2568)
+++ code/branches/buildsystem2/src/orxonox/gui/CMakeLists.txt	(revision 2569)
@@ -1,6 +1,3 @@
 ADD_SOURCE_FILES(
   GUIManager.cc
-  OgreCEGUIRenderer.cpp
-  OgreCEGUIResourceProvider.cpp
-  OgreCEGUITexture.cpp
 )
Index: code/branches/buildsystem2/src/orxonox/gui/GUIManager.cc
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/GUIManager.cc	(revision 2568)
+++ code/branches/buildsystem2/src/orxonox/gui/GUIManager.cc	(revision 2569)
@@ -40,4 +40,6 @@
 #include <CEGUI.h>
 #include <CEGUILua.h>
+#include <OgreCEGUIRenderer.h>
+
 #include "util/Exception.h"
 #include "core/input/InputManager.h"
@@ -47,5 +49,4 @@
 #include "core/ToluaBindCore.h"
 #include "ToluaBindOrxonox.h"
-#include "OgreCEGUIRenderer.h"
 
 extern "C" {
Index: code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIRenderer.cpp
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIRenderer.cpp	(revision 2568)
+++ 	(revision )
@@ -1,803 +1,0 @@
-/************************************************************************
-    filename: 	OgreCEGUIRenderer.cpp
-    created:	11/5/2004
-    author:		Paul D Turner
-    
-    purpose:	Implementation of Renderer class for Ogre engine
-*************************************************************************/
-/*************************************************************************
-    Crazy Eddie's GUI System (http://www.cegui.org.uk)
-    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*************************************************************************/
-
-#include "OrxonoxStableHeaders.h"
-#include <CEGUIImagesetManager.h>
-#include <CEGUIImageset.h>
-#include <CEGUIImage.h>
-#include <CEGUIExceptions.h>
-#include <CEGUISystem.h>
-
-#include "OgreCEGUIRenderer.h"
-#include "OgreCEGUITexture.h"
-#include "OgreCEGUIResourceProvider.h"
-
-#include <OgreRenderSystem.h>
-#include <OgreRoot.h>
-#include <OgreHardwareBufferManager.h>
-#include <OgreRenderWindow.h>
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-/*************************************************************************
-    Constants definitions
-*************************************************************************/
-const size_t	OgreCEGUIRenderer::VERTEX_PER_QUAD			= 6;
-const size_t	OgreCEGUIRenderer::VERTEX_PER_TRIANGLE		= 3;
-const size_t	OgreCEGUIRenderer::VERTEXBUFFER_INITIAL_CAPACITY	= 256;
-const size_t    OgreCEGUIRenderer::UNDERUSED_FRAME_THRESHOLD = 50000; // halfs buffer every 8 minutes on 100fps
-
-/*************************************************************************
-    Utility function to create a render operation and vertex buffer to render quads
-*************************************************************************/
-static void createQuadRenderOp(Ogre::RenderOperation &d_render_op, 
-    Ogre::HardwareVertexBufferSharedPtr &d_buffer, size_t nquads)
-{
-    using namespace Ogre;
-    // Create and initialise the Ogre specific parts required for use in rendering later.
-    d_render_op.vertexData = new VertexData;
-    d_render_op.vertexData->vertexStart = 0;
-
-    // setup vertex declaration for the vertex format we use
-    VertexDeclaration* vd = d_render_op.vertexData->vertexDeclaration;
-    size_t vd_offset = 0;
-    vd->addElement(0, vd_offset, VET_FLOAT3, VES_POSITION);
-    vd_offset += VertexElement::getTypeSize(VET_FLOAT3);
-    vd->addElement(0, vd_offset, VET_COLOUR, VES_DIFFUSE);
-    vd_offset += VertexElement::getTypeSize(VET_COLOUR);
-    vd->addElement(0, vd_offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);
-
-    // create hardware vertex buffer
-    d_buffer = HardwareBufferManager::getSingleton().createVertexBuffer(vd->getVertexSize(0), nquads,  
-        HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, false);
-
-    // bind vertex buffer
-    d_render_op.vertexData->vertexBufferBinding->setBinding(0, d_buffer);
-
-    // complete render operation basic initialisation
-    d_render_op.operationType = RenderOperation::OT_TRIANGLE_LIST;
-    d_render_op.useIndexes = false;
-}
-
-static void destroyQuadRenderOp(Ogre::RenderOperation &d_render_op, 
-    Ogre::HardwareVertexBufferSharedPtr &d_buffer)
-{
-    delete d_render_op.vertexData;
-    d_render_op.vertexData = 0;
-    d_buffer.setNull();
-}
-
-/*************************************************************************
-    Constructor
-*************************************************************************/
-OgreCEGUIRenderer::OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads)
-{
-    constructor_impl(window, queue_id, post_queue, max_quads);
-}
-
-
-/*************************************************************************
-    Constructor (specifying scene manager)
-*************************************************************************/
-OgreCEGUIRenderer::OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads, Ogre::SceneManager* scene_manager)
-{
-    constructor_impl(window, queue_id, post_queue, max_quads);
-
-    // hook into ogre rendering system
-    setTargetSceneManager(scene_manager);
-}
-
-
-/*************************************************************************
-    Destructor
-*************************************************************************/
-OgreCEGUIRenderer::~OgreCEGUIRenderer(void)
-{
-    setTargetSceneManager(NULL);
-
-    if (d_ourlistener)
-    {
-        delete d_ourlistener;
-    }
-
-    // cleanup vertex data we allocated in constructor
-    destroyQuadRenderOp(d_render_op, d_buffer);
-    destroyQuadRenderOp(d_direct_render_op, d_direct_buffer);
-
-    destroyAllTextures();
-}
-
-
-/*************************************************************************
-    add's a quad to the list to be rendered
-*************************************************************************/
-void OgreCEGUIRenderer::addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
-{
-    // if not queueing, render directly (as in, right now!). This is used for the mouse cursor.
-    if (!d_queueing)
-    {
-        renderQuadDirect(dest_rect, z, tex, texture_rect, colours, quad_split_mode);
-    }
-    else
-    {
-        d_sorted = false;
-        QuadInfo quad;
-        
-        // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset
-        quad.position.d_left	= dest_rect.d_left;
-        quad.position.d_right	= dest_rect.d_right;
-        quad.position.d_top		= d_display_area.getHeight() - dest_rect.d_top;
-        quad.position.d_bottom	= d_display_area.getHeight() - dest_rect.d_bottom;
-        quad.position.offset(d_texelOffset);
-
-        // convert quad co-ordinates for a -1 to 1 co-ordinate system.
-        quad.position.d_left	/= (d_display_area.getWidth() * 0.5f);
-        quad.position.d_right	/= (d_display_area.getWidth() * 0.5f);
-        quad.position.d_top		/= (d_display_area.getHeight() * 0.5f);
-        quad.position.d_bottom	/= (d_display_area.getHeight() * 0.5f);
-        quad.position.offset(Point(-1.0f, -1.0f));
-
-        quad.z				= -1 + z;
-        quad.texture		= ((OgreCEGUITexture*)tex)->getOgreTexture();
-        quad.texPosition	= texture_rect;
-
-        // covert colours for ogre, note that top / bottom are switched.
-        quad.topLeftCol		= colourToOgre(colours.d_bottom_left);
-        quad.topRightCol	= colourToOgre(colours.d_bottom_right);
-        quad.bottomLeftCol	= colourToOgre(colours.d_top_left);
-        quad.bottomRightCol	= colourToOgre(colours.d_top_right);
-        
-        // set quad split mode
-        quad.splitMode = quad_split_mode;
-
-        d_quadlist.insert(quad);
-    }
-}
-
-
-
-/*************************************************************************
-perform final rendering for all queued renderable quads.
-*************************************************************************/
-void OgreCEGUIRenderer::doRender(void)
-{
-    // Render if overlays enabled and the quad list is not empty
-
-    // ORXONOX CHANGE: Even render when OverlaysEnabled is deactivated
-    // The reason is that we don't want the HUD to be shown in the viewport of the
-    // GUI (uses its own viewport to be able render on top of all viewports).
-    // But since we don't use overlays in the GUI, it doesn't matter.
-    // ORXONOX REVERT: Changes are not in place anymore, but might be in the future!
-    if (d_render_sys->_getViewport()->getOverlaysEnabled() && !d_quadlist.empty())
-    //if (!d_quadlist.empty())
-    {
-        /// Quad list needs to be sorted and thus the vertex buffer rebuilt. If not, we can
-        /// reuse the vertex buffer resulting in a nice speed gain.
-        if(!d_sorted)
-        {
-            sortQuads();
-            /// Resize vertex buffer if it is too small
-            size_t size = d_buffer->getNumVertices();
-            size_t requestedSize = d_quadlist.size()*VERTEX_PER_QUAD;
-            if(size < requestedSize)
-            {
-                /// Double buffer size until smaller than requested size
-                while(size < requestedSize)
-                    size = size * 2;
-                /// Reallocate the buffer
-                destroyQuadRenderOp(d_render_op, d_buffer);
-                createQuadRenderOp(d_render_op, d_buffer, size);
-            }
-            else if(requestedSize < size/2 && d_underused_framecount >= UNDERUSED_FRAME_THRESHOLD)
-            {
-                /// Resize vertex buffer if it has been to big for too long
-                size = size / 2;
-                destroyQuadRenderOp(d_render_op, d_buffer);
-                createQuadRenderOp(d_render_op, d_buffer, size);
-                /// Reset underused framecount so it takes another UNDERUSED_FRAME_THRESHOLD to half again
-                d_underused_framecount = 0;
-            }
-            /// Fill the buffer
-            QuadVertex*	buffmem;
-            buffmem = (QuadVertex*)d_buffer->lock(Ogre::HardwareVertexBuffer::HBL_DISCARD);
-            // iterate over each quad in the list
-            for (QuadList::iterator i = d_quadlist.begin(); i != d_quadlist.end(); ++i)
-            {
-                const QuadInfo& quad = (*i);
-                // setup Vertex 1...
-                buffmem->x = quad.position.d_left;
-                buffmem->y = quad.position.d_bottom;
-                buffmem->z = quad.z;
-                buffmem->diffuse = quad.topLeftCol;
-                buffmem->tu1 = quad.texPosition.d_left;
-                buffmem->tv1 = quad.texPosition.d_bottom;
-                ++buffmem;
-    
-                // setup Vertex 2...
-                
-                // top-left to bottom-right diagonal
-                if (quad.splitMode == TopLeftToBottomRight)
-                {
-                    buffmem->x = quad.position.d_right;
-                    buffmem->y = quad.position.d_bottom;
-                    buffmem->z = quad.z;
-                    buffmem->diffuse = quad.topRightCol;
-                    buffmem->tu1 = quad.texPosition.d_right;
-                    buffmem->tv1 = quad.texPosition.d_bottom;
-                }
-                // bottom-left to top-right diagonal
-                else
-                {
-                    buffmem->x = quad.position.d_right;
-                    buffmem->y = quad.position.d_top;
-                    buffmem->z = quad.z;
-                    buffmem->diffuse = quad.bottomRightCol;
-                    buffmem->tu1 = quad.texPosition.d_right;
-                    buffmem->tv1 = quad.texPosition.d_top;
-                }
-                ++buffmem;
-    
-                // setup Vertex 3...
-                buffmem->x = quad.position.d_left;
-                buffmem->y = quad.position.d_top;
-                buffmem->z = quad.z;
-                buffmem->diffuse = quad.bottomLeftCol;
-                buffmem->tu1 = quad.texPosition.d_left;
-                buffmem->tv1 = quad.texPosition.d_top;
-                ++buffmem;
-    
-                // setup Vertex 4...
-                buffmem->x = quad.position.d_right;
-                buffmem->y = quad.position.d_bottom;
-                buffmem->z = quad.z;
-                buffmem->diffuse = quad.topRightCol;
-                buffmem->tu1 = quad.texPosition.d_right;
-                buffmem->tv1 = quad.texPosition.d_bottom;
-                ++buffmem;
-    
-                // setup Vertex 5...
-                buffmem->x = quad.position.d_right;
-                buffmem->y = quad.position.d_top;
-                buffmem->z = quad.z;
-                buffmem->diffuse = quad.bottomRightCol;
-                buffmem->tu1 = quad.texPosition.d_right;
-                buffmem->tv1 = quad.texPosition.d_top;
-                ++buffmem;
-    
-                // setup Vertex 6...
-                
-                // top-left to bottom-right diagonal
-                if (quad.splitMode == TopLeftToBottomRight)
-                {
-                    buffmem->x = quad.position.d_left;
-                    buffmem->y = quad.position.d_top;
-                    buffmem->z = quad.z;
-                    buffmem->diffuse = quad.bottomLeftCol;
-                    buffmem->tu1 = quad.texPosition.d_left;
-                    buffmem->tv1 = quad.texPosition.d_top;
-                }
-                // bottom-left to top-right diagonal
-                else
-                {
-                    buffmem->x = quad.position.d_left;
-                    buffmem->y = quad.position.d_bottom;
-                    buffmem->z = quad.z;
-                    buffmem->diffuse = quad.topLeftCol;
-                    buffmem->tu1 = quad.texPosition.d_left;
-                    buffmem->tv1 = quad.texPosition.d_bottom;
-                }
-                ++buffmem;
-            }
-    
-            // ensure we leave the buffer in the unlocked state
-            d_buffer->unlock();
-        }
-        
-        /// Render the buffer
-        d_bufferPos = 0;
-        bool first = true;
-
-        // Iterate over each quad in the list and render it
-        QuadList::iterator i = d_quadlist.begin();
-        while(i != d_quadlist.end())
-        {
-            
-            d_currTexture = i->texture;
-            d_render_op.vertexData->vertexStart = d_bufferPos;
-            for (; i != d_quadlist.end(); ++i)
-            {
-                const QuadInfo& quad = (*i);
-                if (d_currTexture != quad.texture)
-                {
-                    /// If it has a different texture, render this quad in next operation
-                    /// also need to reset render states
-                    first = true;
-                    break;
-                }
-                d_bufferPos += VERTEX_PER_QUAD;
-            }
-            d_render_op.vertexData->vertexCount = d_bufferPos - d_render_op.vertexData->vertexStart;
-            /// Set texture, and do the render
-            d_render_sys->_setTexture(0, true, d_currTexture);
-            if (first)
-            {
-                initRenderStates();
-                first = false;
-            }
-            d_render_sys->_render(d_render_op);
-        }
-
-    }
-    /// Count frames to check if utilization of vertex buffer was below half the capacity for 500,000 frames
-    if(d_bufferPos < d_buffer->getNumVertices()/2)
-       d_underused_framecount++;
-    else
-       d_underused_framecount = 0;
-}
-
-
-/*************************************************************************
-    clear the queue
-*************************************************************************/
-void OgreCEGUIRenderer::clearRenderList(void)
-{
-    d_sorted = true;
-    d_quadlist.clear();
-}
-
-
-/*************************************************************************
-    create an empty texture
-*************************************************************************/
-Texture* OgreCEGUIRenderer::createTexture(void)
-{
-    OgreCEGUITexture* tex = new OgreCEGUITexture(this);
-    d_texturelist.push_back(tex);
-    return tex;
-}
-
-
-/*************************************************************************
-    create a texture and load it with the specified file.
-*************************************************************************/
-Texture* OgreCEGUIRenderer::createTexture(const String& filename, const String& resourceGroup)
-{
-    OgreCEGUITexture* tex = (OgreCEGUITexture*)createTexture();
-    tex->loadFromFile(filename, resourceGroup);
-
-    return tex;
-}
-
-
-/*************************************************************************
-    create a texture and set it to the specified size
-*************************************************************************/
-Texture* OgreCEGUIRenderer::createTexture(float size)
-{
-    OgreCEGUITexture* tex = (OgreCEGUITexture*)createTexture();
-    tex->setOgreTextureSize((uint)size);
-
-    return tex;
-}
-
-
-/*************************************************************************
-    destroy the given texture
-*************************************************************************/
-void OgreCEGUIRenderer::destroyTexture(Texture* texture)
-{
-    if (texture != NULL)
-    {
-        OgreCEGUITexture* tex = (OgreCEGUITexture*)texture;
-
-        d_texturelist.remove(tex);
-        delete tex;
-    }
-}
-
-
-/*************************************************************************
-    destroy all textures still active
-*************************************************************************/
-void OgreCEGUIRenderer::destroyAllTextures(void)
-{
-    while (!d_texturelist.empty())
-    {
-        destroyTexture(*(d_texturelist.begin()));
-    }
-}
-
-
-/*************************************************************************
-    setup states etc	
-*************************************************************************/
-void OgreCEGUIRenderer::initRenderStates(void)
-{
-    using namespace Ogre;
-
-    // set-up matrices
-    d_render_sys->_setWorldMatrix(Matrix4::IDENTITY);
-    d_render_sys->_setViewMatrix(Matrix4::IDENTITY);
-    d_render_sys->_setProjectionMatrix(Matrix4::IDENTITY);
-
-    // initialise render settings
-    d_render_sys->setLightingEnabled(false);
-    d_render_sys->_setDepthBufferParams(false, false);
-    d_render_sys->_setDepthBias(0, 0);
-    d_render_sys->_setCullingMode(CULL_NONE);
-    d_render_sys->_setFog(FOG_NONE);
-    d_render_sys->_setColourBufferWriteEnabled(true, true, true, true);
-    d_render_sys->unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
-    d_render_sys->unbindGpuProgram(GPT_VERTEX_PROGRAM);
-    d_render_sys->setShadingType(SO_GOURAUD);
-    d_render_sys->_setPolygonMode(PM_SOLID);
-
-    // initialise texture settings
-    d_render_sys->_setTextureCoordCalculation(0, TEXCALC_NONE);
-    d_render_sys->_setTextureCoordSet(0, 0);
-    d_render_sys->_setTextureUnitFiltering(0, FO_LINEAR, FO_LINEAR, FO_POINT);
-    d_render_sys->_setTextureAddressingMode(0, d_uvwAddressMode);
-    d_render_sys->_setTextureMatrix(0, Matrix4::IDENTITY);
-    d_render_sys->_setAlphaRejectSettings(CMPF_ALWAYS_PASS, 0);
-    d_render_sys->_setTextureBlendMode(0, d_colourBlendMode);
-    d_render_sys->_setTextureBlendMode(0, d_alphaBlendMode);
-    d_render_sys->_disableTextureUnitsFrom(1);
-
-    // enable alpha blending
-    d_render_sys->_setSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
-}
-
-
- 
-/*************************************************************************
-    sort quads list according to texture	
-*************************************************************************/
-void OgreCEGUIRenderer::sortQuads(void)
-{
-    if (!d_sorted)
-    {
-        d_sorted = true;
-    }
-
-}
-
-/*************************************************************************
-render a quad directly to the display
-*************************************************************************/
-void OgreCEGUIRenderer::renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
-{
-    // ORXONOX CHANGE: Even render when OverlaysEnabled is deactivated
-    // The reason is that we don't want the HUD to be shown in the viewport of the
-    // GUI (uses its own viewport to be able render on top of all viewports).
-    // But since we don't use overlays in the GUI, it doesn't matter.
-    // ORXONOX REVERT: Changes are not in place anymore, but might be in the future!
-    if (d_render_sys->_getViewport()->getOverlaysEnabled())
-    //if (true)
-    {
-        z = -1 + z;
-
-        Rect final_rect;
-
-        // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset
-        final_rect.d_left	= dest_rect.d_left;
-        final_rect.d_right	= dest_rect.d_right;
-        final_rect.d_top	= d_display_area.getHeight() - dest_rect.d_top;
-        final_rect.d_bottom	= d_display_area.getHeight() - dest_rect.d_bottom;
-        final_rect.offset(d_texelOffset);
-
-        // convert quad co-ordinates for a -1 to 1 co-ordinate system.
-        final_rect.d_left	/= (d_display_area.getWidth() * 0.5f);
-        final_rect.d_right	/= (d_display_area.getWidth() * 0.5f);
-        final_rect.d_top	/= (d_display_area.getHeight() * 0.5f);
-        final_rect.d_bottom	/= (d_display_area.getHeight() * 0.5f);
-        final_rect.offset(Point(-1.0f, -1.0f));
-
-        // convert colours for ogre, note that top / bottom are switched.
-        uint32 topLeftCol	= colourToOgre(colours.d_bottom_left);
-        uint32 topRightCol	= colourToOgre(colours.d_bottom_right);
-        uint32 bottomLeftCol	= colourToOgre(colours.d_top_left);
-        uint32 bottomRightCol= colourToOgre(colours.d_top_right);
-
-        QuadVertex*	buffmem = (QuadVertex*)d_direct_buffer->lock(Ogre::HardwareVertexBuffer::HBL_DISCARD);
-
-        // setup Vertex 1...
-        buffmem->x	= final_rect.d_left;
-        buffmem->y	= final_rect. d_bottom;
-        buffmem->z	= z;
-        buffmem->diffuse = topLeftCol;
-        buffmem->tu1	= texture_rect.d_left;
-        buffmem->tv1	= texture_rect.d_bottom;
-        ++buffmem;
-
-        // setup Vertex 2...
-        
-        // top-left to bottom-right diagonal
-        if (quad_split_mode == TopLeftToBottomRight)
-        {
-            buffmem->x	= final_rect.d_right;
-            buffmem->y = final_rect.d_bottom;
-            buffmem->z	= z;
-            buffmem->diffuse = topRightCol;
-            buffmem->tu1	= texture_rect.d_right;
-            buffmem->tv1	= texture_rect.d_bottom;
-            ++buffmem;
-        }
-        // bottom-left to top-right diagonal
-        else
-        {
-            buffmem->x	= final_rect.d_right;
-            buffmem->y = final_rect.d_top;
-            buffmem->z	= z;
-            buffmem->diffuse = bottomRightCol;
-            buffmem->tu1	= texture_rect.d_right;
-            buffmem->tv1	= texture_rect.d_top;
-            ++buffmem;
-        }
-
-        // setup Vertex 3...
-        buffmem->x	= final_rect.d_left;
-        buffmem->y	= final_rect.d_top;
-        buffmem->z	= z;
-        buffmem->diffuse = bottomLeftCol;
-        buffmem->tu1	= texture_rect.d_left;
-        buffmem->tv1	= texture_rect.d_top;
-        ++buffmem;
-
-        // setup Vertex 4...
-        buffmem->x	= final_rect.d_right;
-        buffmem->y	= final_rect.d_bottom;
-        buffmem->z	= z;
-        buffmem->diffuse = topRightCol;
-        buffmem->tu1	= texture_rect.d_right;
-        buffmem->tv1	= texture_rect.d_bottom;
-        ++buffmem;
-
-        // setup Vertex 5...
-        buffmem->x	= final_rect.d_right;
-        buffmem->y	= final_rect.d_top;
-        buffmem->z	= z;
-        buffmem->diffuse = bottomRightCol;
-        buffmem->tu1	= texture_rect.d_right;
-        buffmem->tv1	= texture_rect.d_top;
-        ++buffmem;
-
-        // setup Vertex 6...
-        
-        // top-left to bottom-right diagonal
-        if (quad_split_mode == TopLeftToBottomRight)
-        {
-            buffmem->x	= final_rect.d_left;
-            buffmem->y = final_rect.d_top;
-            buffmem->z	= z;
-            buffmem->diffuse = bottomLeftCol;
-            buffmem->tu1	= texture_rect.d_left;
-            buffmem->tv1	= texture_rect.d_top;
-        }
-        // bottom-left to top-right diagonal
-        else
-        {
-            buffmem->x	= final_rect.d_left;
-            buffmem->y = final_rect.d_bottom;
-            buffmem->z	= z;
-            buffmem->diffuse = topLeftCol;
-            buffmem->tu1	= texture_rect.d_left;
-            buffmem->tv1	= texture_rect.d_bottom;
-        }
-
-        d_direct_buffer->unlock();
-
-        //
-        // perform rendering...
-        //
-        d_render_sys->_setTexture(0, true, ((OgreCEGUITexture*)tex)->getOgreTexture()->getName());
-        initRenderStates();
-        d_direct_render_op.vertexData->vertexCount = VERTEX_PER_QUAD;
-        d_render_sys->_render(d_direct_render_op);
-    }
-
-}
-
-/*************************************************************************
-    convert ARGB colour value to whatever the Ogre render system is
-    expecting.	
-*************************************************************************/
-uint32 OgreCEGUIRenderer::colourToOgre(const colour& col) const
-{
-    Ogre::ColourValue cv(col.getRed(), col.getGreen(), col.getBlue(), col.getAlpha());
-
-    uint32 final;
-    d_render_sys->convertColourValue(cv, &final);
-
-    return final;
-}
-
-
-/*************************************************************************
-    Set the scene manager to be used for rendering the GUI.	
-*************************************************************************/
-void OgreCEGUIRenderer::setTargetSceneManager(Ogre::SceneManager* scene_manager)
-{
-    // unhook from current scene manager.
-    if (d_sceneMngr != NULL)
-    {
-        d_sceneMngr->removeRenderQueueListener(d_ourlistener);
-        d_sceneMngr = NULL;
-    }
-
-    // hook new scene manager if that is not NULL
-    if (scene_manager != NULL)
-    {
-        d_sceneMngr = scene_manager;
-        d_sceneMngr->addRenderQueueListener(d_ourlistener);
-    }
-
-}
-
-
-/*************************************************************************
-    Set the target render queue for GUI rendering.	
-*************************************************************************/
-void OgreCEGUIRenderer::setTargetRenderQueue(Ogre::uint8 queue_id, bool post_queue)
-{
-    d_queue_id		= queue_id;
-    d_post_queue	= post_queue;
-
-    if (d_ourlistener != NULL)
-    {
-        d_ourlistener->setTargetRenderQueue(queue_id);
-        d_ourlistener->setPostRenderQueue(post_queue);
-    }
-
-}
-
-
-/*************************************************************************
-    perform main work of the constructor
-*************************************************************************/
-void OgreCEGUIRenderer::constructor_impl(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads)
-{
-    using namespace Ogre;
-
-    // initialise the renderer fields
-    d_queueing		= true;
-    d_queue_id		= queue_id;
-    d_currTexture.isNull();
-    d_post_queue	= post_queue;
-    d_sceneMngr		= NULL;
-    d_bufferPos		= 0;
-    d_sorted		= true;
-    d_ogre_root		= Root::getSingletonPtr();
-    d_render_sys	= d_ogre_root->getRenderSystem();
-    // set ID string
-    d_identifierString = "CEGUI::OgreRenderer - Official Ogre based renderer module for CEGUI";
-
-    // Create and initialise the Ogre specific parts required for use in rendering later.
-    // Main GUI
-    createQuadRenderOp(d_render_op, d_buffer, VERTEXBUFFER_INITIAL_CAPACITY);
-    d_underused_framecount = 0;
-
-    // Mouse cursor
-    createQuadRenderOp(d_direct_render_op, d_direct_buffer, VERTEX_PER_QUAD);
-
-    // Discover display settings and setup d_display_area
-    d_display_area.d_left	= 0;
-    d_display_area.d_top	= 0;
-    d_display_area.d_right	= window->getWidth();
-    d_display_area.d_bottom	= window->getHeight();
-
-    // initialise required texel offset
-    d_texelOffset = Point((float)d_render_sys->getHorizontalTexelOffset(), -(float)d_render_sys->getVerticalTexelOffset());
-
-    // create listener which will handler the rendering side of things for us.
-    d_ourlistener = new CEGUIRQListener(this, queue_id, post_queue);
-
-    // Initialise blending modes to be used.
-    d_colourBlendMode.blendType	= Ogre::LBT_COLOUR;
-    d_colourBlendMode.source1	= Ogre::LBS_TEXTURE;
-    d_colourBlendMode.source2	= Ogre::LBS_DIFFUSE;
-    d_colourBlendMode.operation	= Ogre::LBX_MODULATE;
-
-    d_alphaBlendMode.blendType	= Ogre::LBT_ALPHA;
-    d_alphaBlendMode.source1	= Ogre::LBS_TEXTURE;
-    d_alphaBlendMode.source2	= Ogre::LBS_DIFFUSE;
-    d_alphaBlendMode.operation	= Ogre::LBX_MODULATE;
-
-    d_uvwAddressMode.u = Ogre::TextureUnitState::TAM_CLAMP;
-    d_uvwAddressMode.v = Ogre::TextureUnitState::TAM_CLAMP;
-    d_uvwAddressMode.w = Ogre::TextureUnitState::TAM_CLAMP;
-}
-
-
-/*************************************************************************
-    Create a texture from an existing Ogre::TexturePtr object	
-*************************************************************************/
-Texture* OgreCEGUIRenderer::createTexture(Ogre::TexturePtr& texture)
-{
-    OgreCEGUITexture* t = (OgreCEGUITexture*)createTexture();
-
-    if (!texture.isNull())
-    {
-        t->setOgreTexture(texture);
-    }
-
-    return t;
-
-}
-
-/*************************************************************************
-    Create a resource provider object
-*************************************************************************/
-ResourceProvider* OgreCEGUIRenderer::createResourceProvider(void)
-{
-    d_resourceProvider = new OgreCEGUIResourceProvider();
-    return d_resourceProvider;
-}
-
-/*************************************************************************
-Set the size of the display in pixels.	
-*************************************************************************/
-void OgreCEGUIRenderer::setDisplaySize(const Size& sz)
-{
-    if (d_display_area.getSize() != sz)
-    {
-        d_display_area.setSize(sz);
-
-        EventArgs args;
-        fireEvent(EventDisplaySizeChanged, args, EventNamespace);
-    }
-
-}
-
-/*************************************************************************
-    Callback from Ogre invoked before other stuff in our target queue
-    is rendered
-*************************************************************************/
-void CEGUIRQListener::renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, 
-                                         bool& skipThisQueue)
-{
-    if ((!d_post_queue) && (d_queue_id == id))
-    {
-        CEGUI::System::getSingleton().renderGUI();
-    }
-
-}
-
-
-/*************************************************************************
-Callback from Ogre invoked after other stuff in our target queue
-is rendered
-*************************************************************************/
-void CEGUIRQListener::renderQueueEnded(Ogre::uint8 id, const Ogre::String& invocation, bool& repeatThisQueue)
-{
-    if ((d_post_queue) && (d_queue_id == id))
-    {
-        CEGUI::System::getSingleton().renderGUI();
-    }
-
-}
-
-} // End of  CEGUI namespace section
Index: code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIRenderer.h
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIRenderer.h	(revision 2568)
+++ 	(revision )
@@ -1,465 +1,0 @@
-/************************************************************************
-    filename: 	OgreCEGUIRenderer.h
-    created:	11/5/2004
-    author:		Paul D Turner
-
-    purpose:	Interface for main Ogre GUI renderer class
-*************************************************************************/
-/*************************************************************************
-    Crazy Eddie's GUI System (http://www.cegui.org.uk)
-    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*************************************************************************/
-/*************************************************************************
-    This file contains code that is specific to Ogre (http://www.ogre3d.org)
-*************************************************************************/
-#ifndef _OgreCEGUIRenderer_H__
-#define _OgreCEGUIRenderer_H__
-
-#include <CEGUIBase.h>
-#include <CEGUIRenderer.h>
-#include <CEGUITexture.h>
-
-#include <OgreRenderQueueListener.h>
-#include <OgreSceneManagerEnumerator.h>
-#include <OgreTextureUnitState.h>
-
-/** CHANGES MADE BY ORXONOX TO FIT DLL IMPORT/EXPORT **/
-#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32) && !(defined(ORXONOX_STATIC_BUILD) || defined(ORXONOX_NO_EXPORTS))
-#   ifdef ORXONOX_SHARED_BUILD
-#       define OGRE_GUIRENDERER_API __declspec(dllexport)
-#   else
-#       if defined(__MINGW32__)
-#           define OGRE_GUIRENDERER_API
-#       else
-#           define OGRE_GUIRENDERER_API __declspec(dllimport)
-#       endif
-#   endif
-#elif defined ( OGRE_GCC_VISIBILITY )
-#    define OGRE_GUIRENDERER_API  __attribute__ ((visibility("default")))
-#else
-#    define OGRE_GUIRENDERER_API
-#endif
-
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-/*************************************************************************
-    Forward refs
-*************************************************************************/
-class OgreCEGUITexture;
-class OgreCEGUIRenderer;
-
-
-/*!
-\brief
-    RenderQueueListener based class used to hook into the ogre rendering system
-*/
-class _OgrePrivate CEGUIRQListener : public Ogre::RenderQueueListener
-{
-public:
-    CEGUIRQListener(OgreCEGUIRenderer* renderer, Ogre::uint8 queue_id, bool post_queue)
-    {
-        d_renderer		= renderer;
-        d_queue_id		= queue_id;
-        d_post_queue	= post_queue;
-    }
-
-    virtual ~CEGUIRQListener() {}
-
-    virtual void	renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, bool& skipThisQueue);
-    virtual void	renderQueueEnded(Ogre::uint8 id, const Ogre::String& invocation, bool& repeatThisQueue);
-
-    // methods for adjusting target queue settings
-    void	setTargetRenderQueue(Ogre::uint8 queue_id)		{d_queue_id = queue_id;}
-    void	setPostRenderQueue(bool post_queue)		{d_post_queue = post_queue;}
-
-private:
-    /*************************************************************************
-        Implementation Data
-    *************************************************************************/
-    OgreCEGUIRenderer*				d_renderer;		//!< CEGUI renderer object for Ogre.
-    Ogre::uint8	d_queue_id;		//!< ID of the queue that we are hooked into
-    bool						d_post_queue;	//!< true if we render after everything else in our queue.
-};
-
-
-/*!
-\brief
-    Renderer class to interface with Ogre engine.
-*/
-class OGRE_GUIRENDERER_API OgreCEGUIRenderer : public Renderer
-{
-public:
-    /*!
-    \brief
-        Constructor for renderer class that uses Ogre for rendering. Note that if
-        you use this option you must call setTargetSceneManager before rendering.
-
-    \param window
-        Pointer to an Ogre::RenderWindow object.
-
-    \param queue_id
-        Ogre::uint8 value that specifies where the GUI should appear in the ogre rendering output.
-
-    \param post_queue
-        set to true to have GUI rendered after render queue \a queue_id, or false to have the GUI rendered before render queue
-        \a queue_id.
-
-    \param max_quads
-        Obsolete.  Set to 0.
-
-    */
-    OgreCEGUIRenderer(Ogre::RenderWindow* window,
-        Ogre::uint8 queue_id = Ogre::RENDER_QUEUE_OVERLAY,
-        bool post_queue = false, uint max_quads = 0);
-
-
-    /*!
-    \brief
-        Constructor for renderer class that uses Ogre for rendering.
-
-    \param window
-        Pointer to an Ogre::RenderWindow object.
-
-    \param queue_id
-        Ogre::uint8 value that specifies where the GUI should appear in the ogre rendering output.
-
-    \param post_queue
-        set to true to have GUI rendered after render queue \a queue_id, or false to have the GUI rendered before render queue
-        \a queue_id.
-
-    \param max_quads
-        Obsolete.  Set to 0.
-
-    \param scene_manager
-        Pointer to an Ogre::SceneManager object that is to be used for GUI rendering.
-    */
-    OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads, Ogre::SceneManager* scene_manager);
-
-
-    /*!
-    \brief
-        Destructor for Ogre renderer.
-    */
-    virtual ~OgreCEGUIRenderer(void);
-
-
-
-    // add's a quad to the list to be rendered
-    virtual	void	addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);
-
-    // perform final rendering for all queued renderable quads.
-    virtual	void	doRender(void);
-
-    // clear the queue
-    virtual	void	clearRenderList(void);
-
-
-    /*!
-    \brief
-        Enable or disable the queueing of quads from this point on.
-
-        This only affects queueing.  If queueing is turned off, any calls to addQuad will cause the quad to be rendered directly.  Note that
-        disabling queueing will not cause currently queued quads to be rendered, nor is the queue cleared - at any time the queue can still
-        be drawn by calling doRender, and the list can be cleared by calling clearRenderList.  Re-enabling the queue causes subsequent quads
-        to be added as if queueing had never been disabled.
-
-    \param setting
-        true to enable queueing, or false to disable queueing (see notes above).
-
-    \return
-        Nothing
-    */
-    virtual void	setQueueingEnabled(bool setting)		{d_queueing = setting;}
-
-
-    // create an empty texture
-    virtual	Texture*	createTexture(void);
-
-    // create a texture and load it with the specified file.
-    virtual	Texture*	createTexture(const String& filename, const String& resourceGroup = "General");
-
-    // create a texture and set it to the specified size
-    virtual	Texture*	createTexture(float size);
-
-    // create an OGRE resource provider.
-    virtual ResourceProvider* createResourceProvider(void);
-
-    // destroy the given texture
-    virtual	void		destroyTexture(Texture* texture);
-
-    // destroy all textures still active
-    virtual void		destroyAllTextures(void);
-
-
-    /*!
-    \brief
-        Return whether queueing is enabled.
-
-    \return
-        true if queueing is enabled, false if queueing is disabled.
-    */
-    virtual bool	isQueueingEnabled(void) const	{return d_queueing;}
-
-
-    /*!
-    \brief
-    Return the current width of the display in pixels
-
-    \return
-    float value equal to the current width of the display in pixels.
-    */
-    virtual float	getWidth(void) const		{return d_display_area.getWidth();}
-
-
-    /*!
-    \brief
-    Return the current height of the display in pixels
-
-    \return
-    float value equal to the current height of the display in pixels.
-    */
-    virtual float	getHeight(void) const		{return d_display_area.getHeight();}
-
-
-    /*!
-    \brief
-    Return the size of the display in pixels
-
-    \return
-    Size object describing the dimensions of the current display.
-    */
-    virtual Size	getSize(void) const			{return d_display_area.getSize();}
-
-
-    /*!
-    \brief
-    Return a Rect describing the screen
-
-    \return
-    A Rect object that describes the screen area.  Typically, the top-left values are always 0, and the size of the area described is
-    equal to the screen resolution.
-    */
-    virtual Rect	getRect(void) const			{return d_display_area;}
-
-
-    /*!
-    \brief
-        Return the maximum texture size available
-
-    \return
-        Size of the maximum supported texture in pixels (textures are always assumed to be square)
-    */
-    virtual	uint	getMaxTextureSize(void) const		{return 2048;}		// TODO: Change to proper value
-
-
-    /*!
-    \brief
-        Return the horizontal display resolution dpi
-
-    \return
-        horizontal resolution of the display in dpi.
-    */
-    virtual	uint	getHorzScreenDPI(void) const	{return 96;}
-
-
-    /*!
-    \brief
-        Return the vertical display resolution dpi
-
-    \return
-        vertical resolution of the display in dpi.
-    */
-    virtual	uint	getVertScreenDPI(void) const	{return 96;}
-
-
-    /*!
-    \brief
-        Set the scene manager to be used for rendering the GUI.
-
-        The GUI system will be unhooked from the current scene manager and attached to what ever
-        is specified here.
-
-    \param scene_manager
-        Pointer to an Ogre::SceneManager object that is the new target Ogre::SceneManager to be
-        used for GUI rendering.
-
-    \return
-        Nothing.
-    */
-    void	setTargetSceneManager(Ogre::SceneManager* scene_manager);
-
-
-    /*!
-    \brief
-        Set the target render queue for GUI rendering.
-
-    \param queue_id
-        Ogre::uint8 value specifying the render queue that the GUI system should attach to.
-
-    \param post_queue
-        - true to specify that the GUI should render after everything else in render queue \a queue_id.
-        - false to specify the GUI should render before everything else in render queue \a queue_id.
-
-    \return
-        Nothing.
-    */
-    void	setTargetRenderQueue(Ogre::uint8 queue_id, bool post_queue);
-
-
-    /*!
-    \brief
-        Create a texture from an existing Ogre::TexturePtr object.
-
-    \note
-        If you want to use an Ogre::RenderTexture (for putting rendered output onto Gui elements or other
-        advanced techniques), you can get the Ogre::TexturePtr to be used by calling Ogre::TextureManager::getByName()
-        passing the name returned from Ogre::RenderTexture::getName() (and casting the result as necessary).
-
-    \param texture
-        pointer to an Ogre::TexturePtr object to be used as the basis for the new CEGUI::Texture
-
-    \return
-        Pointer to the newly created CEGUI::TexturePtr object.
-    */
-    Texture*	createTexture(Ogre::TexturePtr& texture);
-
-
-    /*!
-    \brief
-    Set the size of the display in pixels.
-
-    You do not have to call this method under normal operation as the system
-    will automatically extract the size from the current view port.
-
-    \note
-    This method will cause the EventDisplaySizeChanged event to fire if the
-    display size has changed.
-
-    \param sz
-    Size object describing the size of the display.
-
-    \return
-    Nothing.
-    */
-    void	setDisplaySize(const Size& sz);
-
-
-private:
-    /************************************************************************
-        Implementation Constants
-    ************************************************************************/
-    static const size_t    VERTEX_PER_QUAD;						 //!< number of vertices per quad
-    static const size_t    VERTEX_PER_TRIANGLE;					 //!< number of vertices for a triangle
-    static const size_t    VERTEXBUFFER_INITIAL_CAPACITY;		 //!< initial capacity of the allocated vertex buffer
-    static const size_t    UNDERUSED_FRAME_THRESHOLD;            //!< number of frames to wait before shrinking buffer
-
-    /*************************************************************************
-        Implementation Structs & classes
-    *************************************************************************/
-    /*!
-    \brief
-        structure used for all vertices.
-    */
-    struct QuadVertex {
-        float x, y, z;			//!< The position for the vertex.
-        Ogre::RGBA diffuse;		//!< colour of the vertex
-        float tu1, tv1;			//!< texture coordinates
-    };
-
-    /*!
-    \brief
-        structure holding details about a quad to be drawn
-    */
-    struct QuadInfo
-    {
-        Ogre::TexturePtr		texture;
-        Rect				position;
-        float				z;
-        Rect				texPosition;
-        uint32		        topLeftCol;
-        uint32		        topRightCol;
-        uint32		        bottomLeftCol;
-        uint32		        bottomRightCol;
-
-        QuadSplitMode		splitMode;
-
-        bool operator<(const QuadInfo& other) const
-        {
-            // this is intentionally reversed.
-            return z > other.z;
-        }
-    };
-
-
-    /*************************************************************************
-        Implementation Methods
-    *************************************************************************/
-    // setup states etc
-    void	initRenderStates(void);
-
-    // sort quads list according to texture
-    void	sortQuads(void);
-
-    // render a quad directly to the display
-    void	renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);
-
-    // convert colour value to whatever the Ogre render system is expecting.
-    uint32    colourToOgre(const colour& col) const;
-
-    // perform main work of the constructor.  This does everything except the final hook into the render system.
-    void	constructor_impl(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads);
-
-
-    /*************************************************************************
-        Implementation Data
-    *************************************************************************/
-    Rect				d_display_area;
-
-    typedef std::multiset<QuadInfo>		QuadList;
-    QuadList d_quadlist;
-    bool	 d_queueing;		//!< setting for queueing control.
-
-    // Ogre specific bits.
-    Ogre::Root*					d_ogre_root;		//!< pointer to the Ogre root object that we attach to
-    Ogre::RenderSystem*			d_render_sys;		//!< Pointer to the render system for Ogre.
-    Ogre::uint8	d_queue_id;			//!< ID of the queue that we are hooked into
-    Ogre::TexturePtr			d_currTexture;		//!< currently set texture;
-    Ogre::RenderOperation		d_render_op;		//!< Ogre render operation we use to do our stuff.
-    Ogre::HardwareVertexBufferSharedPtr	d_buffer;	//!< vertex buffer to queue sprite rendering
-    size_t d_underused_framecount;                  //!< Number of frames elapsed since buffer utilization was above half the capacity
-    Ogre::RenderOperation		d_direct_render_op;		//!< Renderop for cursor
-    Ogre::HardwareVertexBufferSharedPtr	d_direct_buffer;	//!< Renderop for cursor
-    Ogre::SceneManager*			d_sceneMngr;		//!< The scene manager we are hooked into.
-    Ogre::LayerBlendModeEx		d_colourBlendMode;	//!< Controls colour blending mode used.
-    Ogre::LayerBlendModeEx		d_alphaBlendMode;	//!< Controls alpha blending mode used.
-    Ogre::TextureUnitState::UVWAddressingMode d_uvwAddressMode;
-
-    CEGUIRQListener*			d_ourlistener;
-    bool						d_post_queue;		//!< true if we render after everything else in our queue.
-    size_t						d_bufferPos;		//!< index into buffer where next vertex should be put.
-    bool						d_sorted;			//!< true when data in quad list is sorted.
-    Point						d_texelOffset;		//!< Offset required for proper texel mapping.
-
-    std::list<OgreCEGUITexture*> d_texturelist;		//!< List used to track textures.
-};
-
-} // End of  CEGUI namespace section
-
-
-#endif	// end of guard _OgreCEGUIRenderer_H__
Index: code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIResourceProvider.cpp
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIResourceProvider.cpp	(revision 2568)
+++ 	(revision )
@@ -1,98 +1,0 @@
-/************************************************************************
-    filename: 	OgreCEGUIResourceProvider.cpp
-    created:	8/7/2004
-    author:		James '_mental_' O'Sullivan
-
-    purpose:	Implements the Resource Provider common functionality
-*************************************************************************/
-/*************************************************************************
-    Crazy Eddie's GUI System (http://www.cegui.org.uk)
-    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*************************************************************************/
-#include "OrxonoxStableHeaders.h"
-#include "OgreCEGUIResourceProvider.h"
-
-#include <CEGUIExceptions.h>
-#include <OgreArchiveManager.h>
-
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-    OgreCEGUIResourceProvider::OgreCEGUIResourceProvider() : ResourceProvider()
-    {
-        // set deafult resource group for Ogre
-        d_defaultResourceGroup = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str();
-    }
-
-//    void OgreResourceProvider::loadInputSourceContainer(const String& filename, InputSourceContainer& output)
-//   {
-//        Ogre::DataStreamPtr input = Ogre::ResourceGroupManager::getSingleton().openResource(filename.c_str());
-//
-//		if (input.isNull())
-//		{
-//			throw InvalidRequestException((utf8*)
-//				"Scheme::Scheme - Filename supplied for Scheme loading must be valid");
-//		}
-//
-//       XERCES_CPP_NAMESPACE_USE
-//        size_t buffsz = input->size();
-//        unsigned char* mem = reinterpret_cast<unsigned char*>(XMLPlatformUtils::fgArrayMemoryManager->allocate(buffsz));
-//        memcpy(mem, input.getPointer()->getAsString().c_str(), buffsz);
-//        InputSource* mInputSource = new MemBufInputSource(mem, buffsz, filename.c_str(), true);
-//        input.setNull();
-//
-//       output.setData(mInputSource);
-//    }
-
-    void OgreCEGUIResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output,  const String& resourceGroup)
-    {
-        String orpGroup;
-        if (resourceGroup.empty())
-            orpGroup = d_defaultResourceGroup.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : d_defaultResourceGroup;
-        else
-            orpGroup = resourceGroup;
-
-        Ogre::DataStreamPtr input =
-            Ogre::ResourceGroupManager::getSingleton().openResource(filename.c_str(), orpGroup.c_str());
-
-        if (input.isNull())
-        {
-            throw InvalidRequestException((utf8*)
-                "OgreCEGUIResourceProvider::loadRawDataContainer - Unable to open resource file '" + filename + (utf8*)"' in resource group '" + orpGroup + (utf8*)"'.");
-        }
-
-        Ogre::String buf = input->getAsString();
-        const size_t memBuffSize = buf.length();
-
-        unsigned char* mem = new unsigned char[memBuffSize];
-        memcpy(mem, buf.c_str(), memBuffSize);
-
-        output.setData(mem);
-        output.setSize(memBuffSize);
-    }
-
-    void OgreCEGUIResourceProvider::unloadRawDataContainer(RawDataContainer& data)
-    {
-        if (data.getDataPtr())
-        {
-            delete[] data.getDataPtr();
-            data.setData(0);
-            data.setSize(0);
-        }
-    }
-} // End of  CEGUI namespace section
Index: code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIResourceProvider.h
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/OgreCEGUIResourceProvider.h	(revision 2568)
+++ 	(revision )
@@ -1,52 +1,0 @@
-/************************************************************************
-    filename: 	CEGUIOgreResourceProvider.h
-    created:	8/7/2004
-    author:		James '_mental_' O'Sullivan
-    
-    purpose:	Defines abstract base class for CEGUIData objects
-*************************************************************************/
-/*************************************************************************
-    Crazy Eddie's GUI System (http://www.cegui.org.uk)
-    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*************************************************************************/
-#ifndef _OgreCEGUIResourceProvider_H__
-#define _OgreCEGUIResourceProvider_H__
-
-#include <CEGUIResourceProvider.h>
-#include "OgreCEGUIRenderer.h"
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-class _OgrePrivate OgreCEGUIResourceProvider : public ResourceProvider
-{
-public:
-    /*************************************************************************
-        Construction and Destruction
-    *************************************************************************/
-    OgreCEGUIResourceProvider();
-
-    ~OgreCEGUIResourceProvider(void) {}
-
-//    void loadInputSourceContainer(const String& filename, InputSourceContainer& output);
-    void loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup);
-    void unloadRawDataContainer(RawDataContainer& output);
-};
-
-} // End of  CEGUI namespace section
-
-#endif	// end of guard _OgreCEGUIResourceProvider_H__
Index: code/branches/buildsystem2/src/orxonox/gui/OgreCEGUITexture.cpp
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/OgreCEGUITexture.cpp	(revision 2568)
+++ 	(revision )
@@ -1,269 +1,0 @@
-/************************************************************************
-    filename: 	OgreCEGUITexture.cpp
-    created:	11/5/2004
-    author:		Paul D Turner
-    
-    purpose:	Implementation of Texture using Ogre engine
-*************************************************************************/
-/*************************************************************************
-    Crazy Eddie's GUI System (http://www.cegui.org.uk)
-    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*************************************************************************/
-
-#include "OrxonoxStableHeaders.h"
-#include <CEGUISystem.h>
-#include <CEGUIExceptions.h>
-#include "OgreCEGUITexture.h"
-#include "OgreCEGUIRenderer.h"
-
-#include <OgreTextureManager.h>
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-/*************************************************************************
-    Static data definition / initialisation
-*************************************************************************/
-uint32 OgreCEGUITexture::d_texturenumber		= 0;
-
-
-/*************************************************************************
-    Constructor
-*************************************************************************/
-OgreCEGUITexture::OgreCEGUITexture(Renderer* owner) :
-    Texture(owner)
-{
-    d_ogre_texture.setNull();
-    d_isLinked = false;
-}
-
-
-/*************************************************************************
-    Destructor
-*************************************************************************/
-OgreCEGUITexture::~OgreCEGUITexture(void)
-{
-    freeOgreTexture();
-}
-
-
-/*************************************************************************
-    Loads the specified image file into the texture.  The texture is
-    resized as required to hold the image.	
-*************************************************************************/
-void OgreCEGUITexture::loadFromFile(const String& filename, const String& resourceGroup)
-{
-    using namespace Ogre;
-
-    // unload old ogre texture
-    freeOgreTexture();
-
-    // create / load a new ogre texture from the specified image
-    try
-    {
-        TextureManager& textureManager = TextureManager::getSingleton();
-
-        // see if texture already exists
-        Ogre::TexturePtr ogreTexture = (Ogre::TexturePtr)textureManager.getByName(filename.c_str());
-
-        if (!ogreTexture.isNull())
-        {
-            // texture already exists, so create a 'linked' texture (ensures texture is not destroyed twice)
-            d_ogre_texture = ogreTexture;
-            d_isLinked = true;
-        }
-        // texture does not already exist, so load it in
-        else
-        {
-            String orpGroup;
-            if (resourceGroup.empty())
-            {
-                const String& defGrp = CEGUI::System::getSingleton().getResourceProvider()->getDefaultResourceGroup();
-                orpGroup = defGrp.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : defGrp;
-            }
-            else
-            {
-                orpGroup = resourceGroup;
-            }
-
-            d_ogre_texture = TextureManager::getSingleton().load(filename.c_str(), orpGroup.c_str(), TEX_TYPE_2D, 0, 1.0f);
-            d_isLinked = false;
-        }
-
-    }
-    catch(Ogre::Exception e)
-    {
-        throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'. Additional Information:\n" + e.getFullDescription().c_str());
-    }
-
-    // if we got a pointer cache some details
-    if (!d_ogre_texture.isNull())
-    {
-        d_width		= d_ogre_texture->getWidth();
-        d_height	= d_ogre_texture->getHeight();
-    }
-    // no texture from image so throw.
-    else
-    {
-        throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'.  Ogre returned a NULL pointer.");
-    }
-
-}
-
-
-/*************************************************************************
-    Loads (copies) an image in memory into the texture.  The texture is
-    resized as required to hold the image.	
-*************************************************************************/
-
-void _byteSwap(unsigned char* b, int n)
-{
-    register int i = 0;
-    register int j = n-1;
-    while (i<j)
-    {
-        std::swap(b[i], b[j]);
-        i++, j--;
-    }
-}
-#define byteSwap(x) _byteSwap((unsigned char*) &x,sizeof(x))
-
-void OgreCEGUITexture::loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight, PixelFormat pixelFormat)
-{
-    using namespace Ogre;
-
-    // get rid of old texture
-    freeOgreTexture();
-
-    // wrap input buffer with an Ogre DataChunk
-    uint32 bytesize = ((buffWidth * sizeof(uint32)) * buffHeight);
-
-#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
-    uint32* swappedBuffer = new uint32[bytesize/4];
-    memcpy(swappedBuffer, buffPtr, bytesize);
-
-    for (int i=0; i < bytesize/4; i++)
-        byteSwap(swappedBuffer[i]);
-
-    DataStreamPtr odc(new MemoryDataStream(static_cast<void*>(swappedBuffer), bytesize, false));
-#else
-    DataStreamPtr odc(new MemoryDataStream(const_cast<void*>(buffPtr), bytesize, false));
-#endif
-
-    // get pixel type for the target texture - the elements here might look wrong, but is just
-    // differences in definition (at the core level, between GL and D3D).
-    Ogre::PixelFormat targetFmt =
-        (pixelFormat == PF_RGBA) ? Ogre::PF_A8R8G8B8 : Ogre::PF_R8G8B8;
-
-    // try to create a Ogre::Texture from the input data
-    d_ogre_texture = TextureManager::getSingleton().loadRawData(getUniqueName(), "General", odc, buffWidth, buffHeight, targetFmt , TEX_TYPE_2D, 0, 1.0f);
-
-    // if we got a pointer cache some details
-    if (!d_ogre_texture.isNull())
-    {
-        d_width		= d_ogre_texture->getWidth();
-        d_height	= d_ogre_texture->getHeight();
-    }
-    // no texture from memory so throw.
-    else
-    {
-        throw RendererException((utf8*)"Failed to create Texture object from memory:  Ogre returned a NULL Ogre::Texture pointer.");
-    }
-
-}
-
-
-/*************************************************************************
-    set the size of the internal Ogre texture.  Previous Ogre texture
-    is lost.	
-*************************************************************************/
-void OgreCEGUITexture::setOgreTextureSize(uint size)
-{
-    using namespace Ogre;
-
-    // unload any current Ogre::Texture
-    freeOgreTexture();
-
-    // Try to create an empty texture of the given size
-    d_ogre_texture = TextureManager::getSingleton().createManual(getUniqueName(), "General", TEX_TYPE_2D, size, size, 0, PF_A8R8G8B8, TU_DEFAULT);
-
-    // if we got a pointer cache some details
-    if (!d_ogre_texture.isNull())
-    {
-        d_width		= d_ogre_texture->getWidth();
-        d_height	= d_ogre_texture->getHeight();
-    }
-    // no texture so throw.
-    else
-    {
-        throw RendererException((utf8*)"Failed to create texture of specified size: Ogre::Texture creation failed.");
-    }
-
-}
-
-
-/*************************************************************************
-    safely free Ogre::Texture texture (can be called multiple times with
-    no ill effect)
-*************************************************************************/
-void OgreCEGUITexture::freeOgreTexture(void)
-{
-    if ((!d_ogre_texture.isNull()) && !d_isLinked)
-    {
-        Ogre::TextureManager::getSingleton().remove(d_ogre_texture->getHandle());
-    }
-    d_ogre_texture.setNull();
-}
-
-
-/*************************************************************************
-    return a Ogre::string that contains a unique name.	
-*************************************************************************/
-Ogre::String OgreCEGUITexture::getUniqueName(void)
-{
-    Ogre::String str;
-
-#ifdef CEGUI_USEOLDOGRESTRING
-    str << "_cegui_ogre_" << d_texturenumber;
-#else
-    Ogre::StringUtil::StrStreamType strstream;
-    strstream << "_cegui_ogre_" << d_texturenumber;
-    str = strstream.str();
-#endif
-
-    ++d_texturenumber;
-
-    return str;
-}
-
-
-/*************************************************************************
-    Set the internal Ogre::Texture object.
-*************************************************************************/
-void OgreCEGUITexture::setOgreTexture(Ogre::TexturePtr& texture)
-{
-    freeOgreTexture();
-
-    d_ogre_texture = texture;
-    d_width	 = d_ogre_texture->getWidth();
-    d_height = d_ogre_texture->getHeight();
-    d_isLinked = true;
-}
-
-
-} // End of  CEGUI namespace section
-
Index: code/branches/buildsystem2/src/orxonox/gui/OgreCEGUITexture.h
===================================================================
--- code/branches/buildsystem2/src/orxonox/gui/OgreCEGUITexture.h	(revision 2568)
+++ 	(revision )
@@ -1,179 +1,0 @@
-/************************************************************************
-    filename: 	OgreCEGUITexture.h
-    created:	11/5/2004
-    author:		Paul D Turner
-    
-    purpose:	Interface to Texture implemented via Ogre engine
-*************************************************************************/
-/*************************************************************************
-    Crazy Eddie's GUI System (http://www.cegui.org.uk)
-    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*************************************************************************/
-#ifndef _OgreCEGUITexture_H__
-#define _OgreCEGUITexture_H__
-
-#include <CEGUIBase.h>
-#include <CEGUIRenderer.h>
-#include <CEGUITexture.h>
-#include "OgreCEGUIRenderer.h"
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-/*!
-\brief
-    Texture class that is created by OgreCEGUIRenderer objects
-*/
-class _OgrePrivate OgreCEGUITexture : public Texture
-{
-private:
-    /*************************************************************************
-        Friends (to allow construction and destruction)
-    *************************************************************************/
-    friend	Texture* OgreCEGUIRenderer::createTexture(void);
-    friend	Texture* OgreCEGUIRenderer::createTexture(const String& filename, const String& resourceGroup);
-    friend	Texture* OgreCEGUIRenderer::createTexture(float size);
-    friend	void	 OgreCEGUIRenderer::destroyTexture(Texture* texture);
-
-
-    /*************************************************************************
-        Construction & Destruction (by Renderer object only)
-    *************************************************************************/
-    OgreCEGUITexture(Renderer* owner);
-    virtual ~OgreCEGUITexture(void);
-
-public:
-    /*!
-    \brief
-        Returns the current pixel width of the texture
-
-    \return
-        ushort value that is the current width of the texture in pixels
-    */
-    virtual	ushort	getWidth(void) const		{return d_width;}
-
-
-    /*!
-    \brief
-        Returns the current pixel height of the texture
-
-    \return
-        ushort value that is the current height of the texture in pixels
-    */
-    virtual	ushort	getHeight(void) const		{return d_height;}
-
-
-    /*!
-    \brief
-        Loads the specified image file into the texture.  The texture is resized as required to hold the image.
-
-    \param filename
-        The filename of the image file that is to be loaded into the texture
-
-    \return
-        Nothing.
-    */
-    virtual void	loadFromFile(const String& filename, const String& resourceGroup);
-
-
-    /*!
-    \brief
-        Loads (copies) an image in memory into the texture.  The texture is resized as required to hold the image.
-    
-    \param buffPtr
-        Pointer to the buffer containing the image data
-    
-    \param buffWidth
-        Width of the buffer (in pixels as specified by \a pixelFormat )
-    
-    \param buffHeight
-        Height of the buffer (in pixels as specified by \a pixelFormat )
-    
-    \param pixelFormat
-    PixelFormat value describing the format contained in \a buffPtr
-    
-    \return
-        Nothing.
-    */
-    virtual void	loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight, PixelFormat pixelFormat);
-
-
-    /*!
-    \brief
-        Return a pointer to the internal Ogre::Texture object
-
-    \return
-        Pointer to the Ogre::Texture object currently being used by this Texture object
-    */
-    Ogre::TexturePtr	getOgreTexture(void) const		{return d_ogre_texture;}
-
-
-    /*!
-    \brief
-        set the size of the internal Ogre texture.  Previous Ogre texture is lost.
-
-    \param size
-        pixel size of the new internal texture.  This will be rounded up to a power of 2.
-
-    \return
-        Nothing.
-    */
-    void	setOgreTextureSize(uint size);
-
-
-    /*!
-    \brief
-        Set the internal Ogre::TexturePtr object.
-
-    \param texture
-        Reference to an Ogre::TexturePtr object that is to be used by this Texture object.
-
-    \return
-        Nothing.
-    */
-    void	setOgreTexture(Ogre::TexturePtr& texture);
-
-
-private:
-    /*************************************************************************
-        Implementation Functions
-    *************************************************************************/
-    // safely free Ogre::Texture texture (can be called multiple times with no ill effect)
-    void	freeOgreTexture(void);
-
-    // return a Ogre::string that contains a unique name.
-    Ogre::String	getUniqueName(void);
-
-
-    /*************************************************************************
-        Implementation Data
-    *************************************************************************/
-    static	uint32          d_texturenumber;	//!< Counter used to provide unique texture names.
-
-    Ogre::TexturePtr		d_ogre_texture;		//!< The 'real' texture.
-
-    ushort					d_width;			//!< cached width of the texture
-    ushort					d_height;			//!< cached height of the texture
-
-    bool	d_isLinked;		//!< True if we are linked to a texture we did not actually create.
-};
-
-
-} // End of  CEGUI namespace section
-
-
-#endif	// end of guard _OgreCEGUITexture_H__
