PolitikerNEU jpg and png support! ( currently linux only ? )

Some little changes where I forgot to integrate the playername
Mousescroll is not longer super fast

mk/linux/Jamfile

@@ -26,7 +26,7 @@ for i in $(LIB_DIRS) {
 }
 
 Library glestlib : $(LIB_SOURCES) ;
-ExternalLibs glestlib : SDL GL GLU XERCES VORBIS VORBISFILE OGG OPENAL LUA ;
+ExternalLibs glestlib : SDL GL GLU XERCES VORBIS VORBISFILE OGG OPENAL LUA JPEG PNG ;
 IncludeDir glestlib : $(LIB_INCLUDE_DIRS) ;
 
 #### Game ####
@@ -55,7 +55,7 @@ for i in $(GLEST_DIRS) {
 
 Application glest.bin : $(GLEST_SOURCES) ;
 LinkWith glest.bin : glestlib ;
-ExternalLibs glest.bin : SDL GL GLU XERCES VORBIS VORBISFILE OGG OPENAL LUA ;
+ExternalLibs glest.bin : SDL GL GLU XERCES VORBIS VORBISFILE OGG OPENAL LUA JPEG PNG ;
 IncludeDir glest.bin : ../shared_lib/include/$(LIB_INCLUDE_DIRS) $(GLEST_DIRS) ;
 
 #### Editor ####

mk/linux/configure.ac

@@ -103,6 +103,25 @@ NP_FINDLIB([OPENAL], [OpenAL], [OpenAL],
 		[AC_MSG_ERROR([Please intall OpenAL])],
 		[], [])
 
+NP_FINDLIB([JPEG], [LibJPEG], [LibJPEG],
+		NP_LANG_PROGRAM([
+		#include <stdio.h>
+		#include <sys/types.h>
+		#include <jpeglib.h>],
+			[jpeg_create_decompress(0);]),
+		[], [-ljpeg],
+		[],
+		[AC_MSG_ERROR([Please intall libjpeg])],
+		[], [])
+
+NP_FINDLIB([PNG], [LibPng], [LibPNG],
+		NP_LANG_PROGRAM([#include <png.h>],
+			[png_sig_cmp(0, 0, 8);]),
+		[], [-lpng],
+		[],
+		[AC_MSG_ERROR([Please intall libpng])],
+		[], [])
+
 CHECK_LUA([], [AC_MSG_ERROR([Please install lua 5.1])])
 
 AX_CHECK_GL

source/glest_game/game/game.cpp

@@ -1,7 +1,7 @@
 // ==============================================================
 //	This file is part of Glest (www.glest.org)
 //
-//	Copyright (C) 2001-2008 Marti<74>o Figueroa
+//	Copyright (C) 2001-2008 Marti<74>o Figueroa
 //
 //	You can redistribute this code and/or modify it under
 //	the terms of the GNU General Public License as published
@@ -478,7 +478,8 @@ void Game::mouseMove(int x, int y, const MouseState *ms){
 void Game::eventMouseWheel(int x, int y, int zDelta) {
     SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 	//gameCamera.transitionXYZ(0.0f, -(float)zDelta / 30.0f, 0.0f);
-	gameCamera.zoom((float)zDelta / 30.0f);
+	gameCamera.zoom((float)zDelta / 60.0f);
+	//gameCamera.setMoveY(1);
 }
 
 void Game::keyDown(char key){

source/glest_game/menu/menu_state_join_game.cpp

@@ -1,7 +1,7 @@
 // ==============================================================
 //	This file is part of Glest (www.glest.org)
 //
-//	Copyright (C) 2001-2005 Marti<74>o Figueroa
+//	Copyright (C) 2001-2005 Marti<74>o Figueroa
 //
 //	You can redistribute this code and/or modify it under
 //	the terms of the GNU General Public License as published
@@ -139,7 +139,7 @@ void MenuStateJoinGame::mouseClick(int x, int y, MouseButton mouseButton)
 		{
 		    if(clientInterface->isConnected() == true)
 		    {
-                string sQuitText = clientInterface->getHostName() + " has chosen to leave the game!";
+                string sQuitText = Config::getInstance().getString("NetPlayerName",Socket::getHostName().c_str()) + " has chosen to leave the game!";
                 clientInterface->sendTextMessage(sQuitText,-1);
 		    }
 		    clientInterface->close();

source/glest_game/network/client_interface.cpp

@@ -55,7 +55,7 @@ ClientInterface::~ClientInterface()
 
     if(clientSocket != NULL && clientSocket->isConnected() == true)
     {
-        string sQuitText = getHostName() + " has chosen to leave the game!";
+        string sQuitText = Config::getInstance().getString("NetPlayerName",Socket::getHostName().c_str()) + " has chosen to leave the game!";
         sendTextMessage(sQuitText,-1);
     }
 
@@ -85,7 +85,7 @@ void ClientInterface::reset()
 {
     if(getSocket() != NULL)
     {
-        string sQuitText = getHostName() + " has chosen to leave the game!";
+        string sQuitText = Config::getInstance().getString("NetPlayerName",Socket::getHostName().c_str()) + " has chosen to leave the game!";
         sendTextMessage(sQuitText,-1);
         close();
     }
@@ -554,7 +554,7 @@ void ClientInterface::quitGame(bool userManuallyQuit)
 
     if(clientSocket != NULL && userManuallyQuit == true)
     {
-        string sQuitText = getHostName() + " has chosen to leave the game!";
+        string sQuitText = Config::getInstance().getString("NetPlayerName",Socket::getHostName().c_str()) + " has chosen to leave the game!";
         sendTextMessage(sQuitText,-1);
         close();
     }

source/glest_game/network/server_interface.cpp

@@ -357,7 +357,7 @@ void ServerInterface::quitGame(bool userManuallyQuit)
 {
     if(userManuallyQuit == true)
     {
-        string sQuitText = getHostName() + " has chosen to leave the game!";
+        string sQuitText = Config::getInstance().getString("NetPlayerName",Socket::getHostName().c_str()) + " has chosen to leave the game!";
         NetworkMessageText networkMessageText(sQuitText,getHostName(),-1);
         broadcastMessage(&networkMessageText, -1);
     }

source/shared_lib/include/graphics/BMPReader.h

@@ -0,0 +1,34 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef BMPREADER_H
+#define BMPREADER_H
+
+// =====================================
+//      class BMPReader
+// =====================================
+
+#include "FileReader.h"
+#include "pixmap.h"
+
+namespace Shared{ namespace Graphics{
+
+class BMPReader: FileReader<Pixmap2D> {
+public:
+	BMPReader();
+
+	Pixmap2D* read(ifstream& in, const string& path, Pixmap2D* ret) const;
+};
+
+
+}} //end namespace
+
+#endif

source/shared_lib/include/graphics/FileReader.h

@@ -0,0 +1,274 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef FILE_READER_H
+#define FILE_READER_H
+
+#include "platform_util.h"
+
+#include <map>
+#include <string>
+#include <vector>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+
+using std::map;
+using std::string;
+using std::vector;
+using std::ifstream;
+using std::ios;
+using std::runtime_error;
+
+using Shared::Platform::extractExtension;
+
+namespace Shared{
+
+// =====================================================
+//	class FileReader
+// =====================================================
+
+template <class T>
+class FileReader {
+protected:
+	string const * extensions;
+
+	/**Creates a filereader being able to possibly load files
+	 * from the specified extension
+	 **/
+	FileReader(string const * extensions);
+
+public:
+	/*Return the - existing and initialized - fileReadersMap
+	 */
+	static map<string, vector<FileReader<T> const * >* >& getFileReadersMap() {
+		static map<string, vector<FileReader<T> const * >* > fileReaderByExtension;
+		return fileReaderByExtension;
+	}
+	static vector<FileReader<T> const * > fileReaders;
+
+
+public:
+
+	/**Tries to read a file
+	 * This method tries to read the file with the specified filepath.
+	 * If it fails, either <code>null</code> is returned or an exception
+         * is thrown*/
+	static T* readPath(const string& filepath);
+
+	/**Tries to read a file from an object
+	 * This method tries to read the file with the specified filepath.
+	 * If it fails, either <code>null</code> is returned or an exception
+         * is thrown*/
+	static T* readPath(const string& filepath, T* object);
+
+	/**Gives a quick estimation of whether the specified file
+         * can be read or not depending on the filename*/
+	virtual bool canRead(const string& filepath) const;
+
+	/**Gives a better estimation of whether the specified file
+	 * can be read or not depending on the file content*/
+	virtual bool canRead(ifstream& file) const;
+
+	/**Reads a file
+	 * This method tries to read the file with the specified filepath
+	 * If it fails, either <code>null</code> is returned or an exception
+	 * is thrown
+         */
+	virtual T* read(const string& filepath) const;
+
+	/**Reads a file to an object
+	 * This method tries to read the file with the specified filepath
+	 * If it fails, either <code>null</code> is returned or an exception
+	 * is thrown
+         */
+	virtual T* read(const string& filepath, T* object) const;
+
+	/**Reads a file
+	 * This method tries to read the specified file
+	 * If it failes, either <code>null</code> is returned or an exception
+	 * Default implementation generates an object using T()
+	 * is thrown
+	 */
+	virtual T* read(ifstream& file, const string& path) const {
+		T* obj = new T();
+		T* ret = read(file,path,obj);
+		if (obj != ret) {
+			delete obj;
+		}
+		return ret;
+	}
+
+
+	/**Reads a file onto the specified object
+	 * This method tries to read the specified file
+	 * If it failes, either <code>null</code> is returned or an exception
+	 * is thrown
+	 */
+	virtual T* read(ifstream& file, const string& path, T* former) const = 0;
+
+	virtual ~FileReader() {
+		/*for (typename vector<FileReader<T> const * >::const_iterator i = fileReaders.begin(); i != fileReaders.end(); ++i) {
+			delete const_cast<FileReader<T>* >(*i); //Segfault
+		}*/
+	}; //Well ... these objects aren't supposed to be destroyed
+};
+
+template <typename T>
+static inline T* readFromFileReaders(vector<FileReader<T> const *>* readers, const string& filepath) {
+	for (typename vector<FileReader<T> const *>::const_iterator i = readers->begin(); i != readers->end(); ++i) {
+		try {
+			FileReader<T> const * reader = *i;		
+			T* ret = reader->read(filepath); //It is guaranteed that at least the filepath matches ...
+			if (ret != NULL) {
+				return ret;
+			}
+		} catch (...) { //TODO: Specific exceptions
+		}
+	}
+	return NULL;
+}
+
+template <typename T>
+static inline T* readFromFileReaders(vector<FileReader<T> const *>* readers, const string& filepath, T* object) {
+	for (typename vector<FileReader<T> const *>::const_iterator i = readers->begin(); i != readers->end(); ++i) {
+		try {
+			FileReader<T> const * reader = *i;
+			T* ret = reader->read(filepath, object); //It is guaranteed that at least the filepath matches ...
+			if (ret != NULL) {
+				return ret;
+			}
+		} catch (...) { //TODO: Specific exceptions
+		}
+	}
+	std::cerr << "Could not parse filepath: " << filepath << std::endl;
+	return NULL;
+}
+
+/**Tries to read a file
+ * This method tries to read the file with the specified filepath.
+ * If it fails, either <code>null</code> is returned or an exception
+ * is thrown*/
+template <typename T>
+T* FileReader<T>::readPath(const string& filepath) {
+	const string& extension = extractExtension(filepath);
+	vector<FileReader<T> const * >* possibleReaders = (getFileReadersMap())[extension];
+	if (possibleReaders != NULL) {
+		//Search in these possible readers
+		T* ret = readFromFileReaders(possibleReaders, filepath);
+		if (ret != NULL) {
+			return ret;
+		}
+	}
+	T* ret = readFromFileReaders(&fileReaders, filepath); //Try all other
+	return ret;
+}
+
+/**Tries to read a file
+ * This method tries to read the file with the specified filepath.
+ * If it fails, either <code>null</code> is returned or an exception
+ * is thrown*/
+template <typename T>
+T* FileReader<T>::readPath(const string& filepath, T* object) {
+	const string& extension = extractExtension(filepath);
+	vector<FileReader<T> const * >* possibleReaders = (getFileReadersMap())[extension];
+	if (possibleReaders != NULL) {
+		//Search in these possible readers
+		T* ret = readFromFileReaders(possibleReaders, filepath, object);
+		if (ret != NULL) {
+			return ret;
+		}
+	}
+	T* ret = readFromFileReaders(&fileReaders, filepath, object); //Try all other
+	return ret;
+}
+
+
+template<typename T>
+vector<FileReader<T> const * > FileReader<T>::fileReaders;
+
+template <typename T>
+FileReader<T>::FileReader(string const * extensions): extensions(extensions) {
+	fileReaders.push_back(this);
+	string const * nextExtension = extensions;
+	while (((*nextExtension) != "")) {
+		vector<FileReader<T> const* >* curPossibleReaders = (getFileReadersMap())[*nextExtension];
+		if (curPossibleReaders == NULL) {
+			(getFileReadersMap())[*nextExtension] = (curPossibleReaders = new vector<FileReader<T> const *>());
+		}
+		curPossibleReaders->push_back(this);
+		++nextExtension;
+	}
+}
+
+
+
+/**Gives a quick estimation of whether the specified file
+ * can be read or not depending on the filename*/
+template <typename T>
+bool FileReader<T>::canRead(const string& filepath) const {
+	const string& realExtension = extractExtension(filepath);
+	const string* haveExtension = extensions;
+	while (*haveExtension != "") {
+		if (realExtension == *haveExtension) {
+			return true;
+		}
+		++haveExtension;
+	}
+	return false;
+}
+
+/**Gives a better estimation of whether the specified file
+ * can be read or not depending on the file content*/
+template <typename T>
+bool FileReader<T>::canRead(ifstream& file) const {
+	try {
+		T* wouldRead = read(file,"unknown file");
+		bool ret = (wouldRead != NULL);
+		delete wouldRead;
+		return ret;
+	} catch (...) {
+		return false;
+	}
+}
+
+/**Reads a file
+ * This method tries to read the file with the specified filepath
+ * If it fails, either <code>null</code> is returned or an exception
+ * is thrown
+ */
+template <typename T>
+T* FileReader<T>::read(const string& filepath) const {
+	ifstream file(filepath.c_str(), ios::in | ios::binary);
+	if (!file.is_open()) { //An error occured; TODO: Which one - throw an exception, print error message?
+		throw runtime_error("Could not open file " + filepath);
+	}
+	return read(file,filepath);
+}
+
+/**Reads a file
+ * This method tries to read the file with the specified filepath
+ * If it fails, either <code>null</code> is returned or an exception
+ * is thrown
+ */
+template <typename T>
+T* FileReader<T>::read(const string& filepath, T* object) const {
+	ifstream file(filepath.c_str(), ios::in | ios::binary);
+	if (!file.is_open()) { //An error occured; TODO: Which one - throw an exception, print error message?
+		throw runtime_error("Could not open file " + filepath);
+	}
+	read(file,filepath,object);
+}
+
+
+} //end namespace
+
+#endif

source/shared_lib/include/graphics/ImageReaders.h

@@ -0,0 +1,39 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef IMAGE_READERS_H
+#define IMAGE_READERS_H
+
+#include "FileReader.h"
+#include "BMPReader.h"
+#include "JPGReader.h"
+#include "PNGReader.h"
+#include "TGAReader.h"
+
+//Initialize some objects
+namespace Shared{ namespace Graphics{
+
+// =====================================================
+//	namespace ImageRegisterer
+// =====================================================
+
+namespace ImageRegisterer {
+
+	//This function registers all image-readers, but only once (any further call is unnecessary)
+	bool registerImageReaders();
+
+	//Since you can't call void methods here, I have used a method doing nothing except initializing the image Readers
+	static bool readersRegistered = registerImageReaders(); //should always return true, this should guarantee that the readers are registered <--> ImageReaders is included anywhere
+}
+
+}} //end namespace
+
+#endif

source/shared_lib/include/graphics/JPGReader.h

@@ -0,0 +1,34 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef JPGREADER_H
+#define JPGREADER_H
+
+// =====================================
+//      class JPGReader
+// =====================================
+
+#include "FileReader.h"
+#include "pixmap.h"
+
+namespace Shared{ namespace Graphics{
+
+class JPGReader: FileReader<Pixmap2D> {
+public:
+	JPGReader();
+
+	Pixmap2D* read(ifstream& in, const string& path, Pixmap2D* ret) const;
+};
+
+
+}} //end namespace
+
+#endif

source/shared_lib/include/graphics/PNGReader.h

@@ -0,0 +1,34 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef PNGREADER_H
+#define PNGREADER_H
+
+// =====================================
+//      class PNGReader
+// =====================================
+
+#include "FileReader.h"
+#include "pixmap.h"
+
+namespace Shared{ namespace Graphics{
+
+class PNGReader: FileReader<Pixmap2D> {
+public:
+	PNGReader();
+
+	Pixmap2D* read(ifstream& in, const string& path, Pixmap2D* ret) const;
+};
+
+
+}} //end namespace
+
+#endif

source/shared_lib/include/graphics/TGAReader.h

@@ -0,0 +1,34 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef TGAREADER_H
+#define TGAREADER_H
+
+// =====================================
+//      class TGAReader
+// =====================================
+
+#include "FileReader.h"
+#include "pixmap.h"
+
+namespace Shared{ namespace Graphics{
+
+class TGAReader: FileReader<Pixmap2D> {
+public:
+	TGAReader();
+
+	Pixmap2D* read(ifstream& in, const string& path, Pixmap2D* ret) const;
+};
+
+
+}} //end namespace
+
+#endif

source/shared_lib/include/graphics/pixmap.h

@@ -0,0 +1,269 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2008 Marti<74>o Figueroa
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#ifndef _SHARED_GRAPHICS_PIXMAP_H_
+#define _SHARED_GRAPHICS_PIXMAP_H_
+
+#include <string>
+
+#include "vec.h"
+#include "types.h"
+
+using std::string;
+using Shared::Platform::int8;
+using Shared::Platform::uint8;
+using Shared::Platform::int16;
+using Shared::Platform::uint16;
+using Shared::Platform::int32;
+using Shared::Platform::uint32;
+using Shared::Platform::float32;
+
+namespace Shared{ namespace Graphics{
+
+// =====================================================
+//	class PixmapIo
+// =====================================================
+
+class PixmapIo{
+protected:
+	int w;
+	int h;
+	int components;
+
+public:
+	virtual ~PixmapIo(){}
+
+	int getW() const			{return w;}
+	int getH() const			{return h;}
+	int getComponents() const	{return components;}
+
+	virtual void openRead(const string &path)= 0;
+	virtual void read(uint8 *pixels)= 0;
+	virtual void read(uint8 *pixels, int components)= 0;
+
+	virtual void openWrite(const string &path, int w, int h, int components)= 0;
+	virtual void write(uint8 *pixels)= 0;
+};
+
+// =====================================================
+//	class PixmapIoTga
+// =====================================================
+
+class PixmapIoTga: public PixmapIo{
+private:
+	FILE *file;
+
+public:
+	PixmapIoTga();
+	virtual ~PixmapIoTga();
+
+	virtual void openRead(const string &path);
+	virtual void read(uint8 *pixels);
+	virtual void read(uint8 *pixels, int components);
+
+	virtual void openWrite(const string &path, int w, int h, int components);
+	virtual void write(uint8 *pixels);
+};
+
+// =====================================================
+//	class PixmapIoBmp
+// =====================================================
+
+class PixmapIoBmp: public PixmapIo{
+private:
+	FILE *file;
+
+public:
+	PixmapIoBmp();
+	virtual ~PixmapIoBmp();
+	
+	virtual void openRead(const string &path);
+	virtual void read(uint8 *pixels);
+	virtual void read(uint8 *pixels, int components);
+
+	virtual void openWrite(const string &path, int w, int h, int components);
+	virtual void write(uint8 *pixels);
+};
+
+// =====================================================
+//	class Pixmap1D
+// =====================================================
+
+class Pixmap1D{
+protected:
+	int w;
+	int components;
+	uint8 *pixels;
+
+public:
+	//constructor & destructor
+	Pixmap1D();
+	Pixmap1D(int components);
+	Pixmap1D(int w, int components);
+	void init(int components);
+	void init(int w, int components);
+	~Pixmap1D();
+	
+	//load & save
+	void load(const string &path);
+	void loadTga(const string &path);
+	void loadBmp(const string &path);
+
+	//get 
+	int getW() const			{return w;}
+	int getComponents() const	{return components;}
+	uint8 *getPixels() const	{return pixels;}
+};
+
+// =====================================================
+//	class Pixmap2D
+// =====================================================
+
+class Pixmap2D{
+protected:
+	int h;
+	int w;
+	int components;
+	uint8 *pixels;
+
+public:
+	//constructor & destructor
+	Pixmap2D();
+	Pixmap2D(int components);
+	Pixmap2D(int w, int h, int components);
+	void init(int components);
+	void init(int w, int h, int components);
+	~Pixmap2D();
+	
+	//load & save
+	static Pixmap2D* loadPath(const string& path);
+	void load(const string &path);
+	/*void loadTga(const string &path);
+	void loadBmp(const string &path);*/
+	void save(const string &path);
+	void saveBmp(const string &path);
+	void saveTga(const string &path);
+
+
+	//get 
+	int getW() const			{return w;}
+	int getH() const			{return h;}
+	int getComponents() const	{return components;}
+	uint8 *getPixels() const	{return pixels;}
+		
+	//get data
+	void getPixel(int x, int y, uint8 *value) const;
+	void getPixel(int x, int y, float32 *value) const;
+	void getComponent(int x, int y, int component, uint8 &value) const;
+	void getComponent(int x, int y, int component, float32 &value) const;
+
+	//vector get
+	Vec4f getPixel4f(int x, int y) const;
+	Vec3f getPixel3f(int x, int y) const;
+	float getPixelf(int x, int y) const;
+	float getComponentf(int x, int y, int component) const;
+
+	//set data
+	void setPixel(int x, int y, const uint8 *value);
+	void setPixel(int x, int y, const float32 *value);
+	void setComponent(int x, int y, int component, uint8 value);
+	void setComponent(int x, int y, int component, float32 value);
+
+	//vector set
+	void setPixel(int x, int y, const Vec3f &p);
+	void setPixel(int x, int y, const Vec4f &p);
+	void setPixel(int x, int y, float p);
+	
+	//mass set
+	void setPixels(const uint8 *value);
+	void setPixels(const float32 *value);
+	void setComponents(int component, uint8 value);
+	void setComponents(int component, float32 value);
+
+	//operations
+	void splat(const Pixmap2D *leftUp, const Pixmap2D *rightUp, const Pixmap2D *leftDown, const Pixmap2D *rightDown); 
+	void lerp(float t, const Pixmap2D *pixmap1, const Pixmap2D *pixmap2);
+	void copy(const Pixmap2D *sourcePixmap);
+	void subCopy(int x, int y, const Pixmap2D *sourcePixmap);
+
+private:
+	bool doDimensionsAgree(const Pixmap2D *pixmap);
+};
+
+// =====================================================
+//	class Pixmap3D
+// =====================================================
+
+class Pixmap3D{
+protected:
+	int h;
+	int w;
+	int d;
+	int components;
+	uint8 *pixels;
+
+public:
+	//constructor & destructor
+	Pixmap3D();
+	Pixmap3D(int w, int h, int d, int components);
+	Pixmap3D(int d, int components);
+	void init(int w, int h, int d, int components);
+	void init(int d, int components);
+	~Pixmap3D();
+	
+	//load & save
+	void loadSlice(const string &path, int slice);
+	void loadSliceBmp(const string &path, int slice);
+	void loadSliceTga(const string &path, int slice);
+	
+	//get 
+	int getW() const			{return w;}
+	int getH() const			{return h;}
+	int getD() const			{return d;}
+	int getComponents() const	{return components;}
+	uint8 *getPixels() const	{return pixels;}
+};
+
+// =====================================================
+//	class PixmapCube
+// =====================================================
+
+class PixmapCube{
+public:
+	enum Face{
+		fPositiveX,
+		fNegativeX,
+		fPositiveY,
+		fNegativeY,
+		fPositiveZ,
+		fNegativeZ
+	};
+
+protected:
+	Pixmap2D faces[6];
+
+public:
+	//init
+	void init(int w, int h, int components);
+
+	//load & save
+	void loadFace(const string &path, int face);
+	/*void loadFaceBmp(const string &path, int face);
+	void loadFaceTga(const string &path, int face);*/
+	
+	//get 
+	Pixmap2D *getFace(int face)				{return &faces[face];}
+	const Pixmap2D *getFace(int face) const	{return &faces[face];}
+};
+
+}}//end namespace
+
+#endif

source/shared_lib/include/platform/sdl/platform_util.h

@@ -96,6 +96,7 @@ int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string
 vector<std::pair<string,int32> > getFolderTreeContentsCheckSumListRecursively(const string &path, const string &filterFileExt, vector<std::pair<string,int32> > *recursiveMap);
 void createDirectoryPaths(string  Path);
 string extractDirectoryPathFromFile(string filename);
+string extractExtension(const string& filename);
 
 void getFullscreenVideoInfo(int &colorBits,int &screenWidth,int &screenHeight);
 bool changeVideoMode(int resH, int resW, int colorBits, int refreshFrequency);

source/shared_lib/include/platform/win32/platform_util.h

@@ -105,6 +105,7 @@ int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string
 vector<std::pair<string,int32> > getFolderTreeContentsCheckSumListRecursively(const string &path, const string &filterFileExt, vector<std::pair<string,int32> > *recursiveMap);
 void createDirectoryPaths(string  Path);
 string extractDirectoryPathFromFile(string filename);
+string extractExtension(const string& filename);
 
 void getFullscreenVideoInfo(int &colorBits,int &screenWidth,int &screenHeight);
 bool changeVideoMode(int resH, int resW, int colorBits, int refreshFrequency);

source/shared_lib/sources/graphics/BMPReader.cpp

@@ -0,0 +1,114 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#include "BMPReader.h"
+#include "types.h"
+#include "pixmap.h"
+#include <stdexcept>
+
+using std::runtime_error;
+
+namespace Shared{ namespace Graphics{
+
+/**Copied from pixmap.cpp*/
+// =====================================================
+//	Structs used for BMP-reading
+// =====================================================
+#pragma pack(push, 1)
+
+struct BitmapFileHeader{
+	uint8 type1;
+	uint8 type2;
+	uint32 size;
+	uint16 reserved1;
+	uint16 reserved2;
+	uint32 offsetBits;
+};
+
+struct BitmapInfoHeader{
+	uint32 size;
+	int32 width;
+	int32 height;
+	uint16 planes;
+	uint16 bitCount;
+	uint32 compression;
+	uint32 sizeImage;
+	int32 xPelsPerMeter;
+	int32 yPelsPerMeter;
+	uint32 clrUsed;
+	uint32 clrImportant;
+};
+
+#pragma pack(pop)
+
+/**Returns a string containing the extensions we want, intitialisation is guaranteed*/
+static inline const string* getExtensionsBmp() {
+	static const string extensions[] = {"bmp", ""};
+	return extensions;
+}
+
+// =====================================================
+//	class BMPReader
+// =====================================================
+
+BMPReader::BMPReader(): FileReader<Pixmap2D>(getExtensionsBmp()) {}
+
+/**Reads a Pixmap2D-object
+  *This function reads a Pixmap2D-object from the given ifstream utilising the already existing Pixmap2D* ret.
+  *Path is used for printing error messages
+  *@return <code>NULL</code> if the Pixmap2D could not be read, else the pixmap*/
+Pixmap2D* BMPReader::read(ifstream& in, const string& path, Pixmap2D* ret) const {
+	//read file header
+	BitmapFileHeader fileHeader;
+	in.read((char*)&fileHeader, sizeof(BitmapFileHeader));
+	if(fileHeader.type1!='B' || fileHeader.type2!='M'){
+		throw runtime_error(path +" is not a bitmap");
+	}
+		//read info header
+	BitmapInfoHeader infoHeader;
+	in.read((char*)&infoHeader, sizeof(BitmapInfoHeader));
+	if(infoHeader.bitCount!=24){
+		throw runtime_error(path+" is not a 24 bit bitmap");
+	}
+	int h= infoHeader.height;
+	int w= infoHeader.width;
+	int components= (ret->getComponents() == -1)?3:ret->getComponents();
+	ret->init(w,h,components);
+	uint8* pixels = ret->getPixels();
+	for(int i=0; i<h*w*components; i+=components){
+		uint8 r, g, b;
+		in.read((char*)&b, 1);
+		in.read((char*)&g, 1);
+		in.read((char*)&r, 1);
+		if (!in.good()) {
+			return NULL;
+		}
+		switch(components){
+		case 1:
+			pixels[i]= (r+g+b)/3;
+			break;
+		case 3:
+			pixels[i]= r;
+			pixels[i+1]= g;
+			pixels[i+2]= b;
+			break;
+		case 4:
+			pixels[i]= r;
+			pixels[i+1]= g;
+			pixels[i+2]= b;
+			pixels[i+3]= 255;
+			break;
+		}
+	}
+	return ret;
+}
+
+}} //end namespace

source/shared_lib/sources/graphics/FileReader.cpp

@@ -0,0 +1,6 @@
+#include "FileReader.h"
+
+namespace Shared {
+
+
+}

source/shared_lib/sources/graphics/ImageReaders.cpp

@@ -0,0 +1,29 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#include "ImageReaders.h"
+
+namespace Shared{ namespace Graphics{
+
+// =====================================================
+//	namespace ImageRegisterer
+// =====================================================
+
+/**Create & register all known Readers*/
+bool ImageRegisterer::registerImageReaders() {
+	static BMPReader imageReaderBmp;
+	static JPGReader imageReaderJpg;
+	static PNGReader imageReaderPng;
+	static TGAReader imageReaderTga;
+	return true;
+}
+
+}} //end namespace

source/shared_lib/sources/graphics/JPGReader.cpp

@@ -0,0 +1,185 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#include "JPGReader.h"
+#include "FileReader.h"
+
+#include "types.h"
+#include "pixmap.h"
+#include <stdexcept>
+#include <jpeglib.h>
+#include <setjmp.h>
+
+using std::runtime_error;
+using std::ios;
+
+/**Used things from CImageLoaderJPG.cpp from Irrlicht*/
+
+namespace Shared{ namespace Graphics{
+
+// =====================================================
+//	Methods used for JPG-Decompression
+// =====================================================
+
+
+//Methods used by jpeglib
+static void init_source(j_decompress_ptr cinfo) {
+	//It already is initialized
+}
+static boolean fill_input_buffer (j_decompress_ptr cinfo) {
+	//it is already filled
+	return true;
+}
+static void skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
+	if (num_bytes > 0) {
+		jpeg_source_mgr* This = cinfo->src;
+		This->bytes_in_buffer-= num_bytes;
+		This->next_input_byte+= num_bytes;
+	}
+}
+static void term_source (j_decompress_ptr cinfo) {
+}
+
+// =====================================================
+//	class JPGReader
+// =====================================================
+
+/**Return an array containing the used extensions,
+  * initialized*/
+static inline const string* getExtensions() {
+	static const string extensions[] = {"jpg", "jpeg", ""};
+	return extensions;
+}
+
+JPGReader::JPGReader(): FileReader<Pixmap2D>(getExtensions()) {}
+
+Pixmap2D* JPGReader::read(ifstream& is, const string& path, Pixmap2D* ret) const {
+	//Read file
+	is.seekg(0, ios::end);
+	size_t length = is.tellg();
+	is.seekg(0, ios::beg);
+	uint8 * buffer = new uint8[length];
+	is.read((char*)buffer, length);
+
+	struct jpeg_decompress_struct cinfo;
+	struct jpeg_error_mgr jerr;
+	
+	JSAMPROW row_pointer[1];
+	row_pointer[0] = NULL;
+	cinfo.err = jpeg_std_error( &jerr ); //Standard error handler
+	jpeg_create_decompress( &cinfo ); //Create decompressing structure
+	struct jpeg_source_mgr source;	
+
+	jmp_buf error_buffer; //Used for saving/restoring context
+	// Set up data pointer
+	source.bytes_in_buffer = length;
+	source.next_input_byte = (JOCTET*)buffer;
+	cinfo.src = &source;
+
+	if (setjmp(error_buffer)) { //Longjump was called --> an exception was thrown
+		delete[] buffer;
+		jpeg_destroy_decompress(&cinfo);
+		if (row_pointer[0] != NULL) {
+			delete[] row_pointer[0];
+		}
+		return NULL;
+	}
+
+	source.init_source = init_source;
+	source.fill_input_buffer = fill_input_buffer;
+	source.resync_to_restart = jpeg_resync_to_restart;
+	source.skip_input_data = skip_input_data;
+	source.term_source = term_source;
+
+	/* reading the image header which contains image information */
+	if (jpeg_read_header( &cinfo, TRUE ) != JPEG_HEADER_OK) {
+		delete[] buffer;
+		jpeg_destroy_decompress(&cinfo);
+		return NULL;
+	}
+
+
+	/*std::cout << "JPEG FILE Information: " << std::endl;
+	std::cout << "Image width and height: " << cinfo.image_width <<" pixels and " << cinfo.image_height <<" pixels." << std::endl;
+	std::cout << "Color components per fixel: " << cinfo.num_components << std::endl;
+	std::cout << "Color space: " << cinfo.jpeg_color_space << std::endl;*/
+	const int picComponents = (ret->getComponents() == -1)?cinfo.num_components:ret->getComponents();
+	ret->init(cinfo.image_width, cinfo.image_height, picComponents);
+	uint8* pixels = ret->getPixels();
+	//TODO: Irrlicht has some special CMYK-handling - maybe needed too?
+	/* Start decompression jpeg here */
+	jpeg_start_decompress( &cinfo );
+
+	/* now actually read the jpeg into the raw buffer */
+	row_pointer[0] = new unsigned char[cinfo.output_width*cinfo.num_components];
+	size_t location = 0; //Current pixel
+	/* read one scan line at a time */
+	/* Again you need to invert the lines unfortunately*/
+	while( cinfo.output_scanline < cinfo.image_height )
+	{
+		jpeg_read_scanlines( &cinfo, row_pointer, 1 );
+		location = (cinfo.image_height - cinfo.output_scanline)*cinfo.image_width*cinfo.num_components;
+		if (picComponents == cinfo.num_components) {
+			memcpy(pixels+location,row_pointer[0],cinfo.image_width*cinfo.num_components);
+		} else {
+			int r,g,b,a,l;
+			for (int xPic = 0, xFile = 0; xPic < cinfo.image_width*picComponents; xPic+= picComponents, xFile+= cinfo.num_components) {
+				switch(cinfo.num_components) {
+					case 3:
+						r = row_pointer[0][xFile];
+						g = row_pointer[0][xFile+1];
+						b = row_pointer[0][xFile+2];
+						l = (r+g+b+2)/3;
+						a = 255;
+						break;
+					case 4:
+						r = row_pointer[0][xFile];
+						g = row_pointer[0][xFile+1];
+						b = row_pointer[0][xFile+2];
+						l = (r+g+b+2)/3;
+						a = row_pointer[0][xFile+3];	
+						break;
+					default:
+						//TODO: Error
+					case 1:
+						r = g = b = l = row_pointer[0][xFile];
+						a = 255;
+						break;
+				}
+				switch (picComponents) {
+					case 1:
+						pixels[location+xPic] = l;
+						break;
+					case 4:
+						pixels[location+xPic+3] = a; //Next case
+					case 3:
+						pixels[location+xPic] = r;
+						pixels[location+xPic+1] = g;
+						pixels[location+xPic+2] = b;
+						break;
+					default:
+						//just so at least something works
+						for (int i = 0; i < picComponents; ++i) {
+							pixels[location+xPic+i] = l;
+						}
+						//TODO: Error
+				}
+			}
+		}
+	}
+	/* wrap up decompression, destroy objects, free pointers and close open files */
+	jpeg_finish_decompress( &cinfo );
+	jpeg_destroy_decompress( &cinfo );
+	delete[] row_pointer[0];
+	return ret;
+}
+
+}} //end namespace

source/shared_lib/sources/graphics/PNGReader.cpp

@@ -0,0 +1,170 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#include "PNGReader.h"
+
+#include "types.h"
+#include "pixmap.h"
+#include <stdexcept>
+#include <png.h>
+#include <setjmp.h>
+
+using std::runtime_error;
+using std::ios;
+
+/**Used things from CImageLoaderJPG.cpp from Irrlicht*/
+
+namespace Shared{ namespace Graphics{
+
+// =====================================================
+//	Callbacks for PNG-decompression
+// =====================================================
+
+static void user_read_data(png_structp read_ptr, png_bytep data, png_size_t length) {
+	ifstream& is = *((ifstream*)png_get_io_ptr(read_ptr));
+	is.read((char*)data,length);
+	if (!is.good()) {
+		png_error(read_ptr,"Could not read from png-file");
+	}
+}
+
+static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length) {
+}
+
+static void user_flush_data(png_structp png_ptr) {}
+
+/**Get Extension array, initialised*/
+static inline const string* getExtensionsPng() {
+	static const string extensions[] = {"png", ""};
+	return extensions;
+}
+
+// =====================================================
+//	class PNGReader
+// =====================================================
+
+PNGReader::PNGReader(): FileReader<Pixmap2D>(getExtensionsPng()) {}
+
+Pixmap2D* PNGReader::read(ifstream& is, const string& path, Pixmap2D* ret) const {
+	//Read file
+	is.seekg(0, ios::end);
+	size_t length = is.tellg();
+	is.seekg(0, ios::beg);
+	uint8 * buffer = new uint8[8];
+	is.read((char*)buffer, 8);
+
+	if (png_sig_cmp(buffer, 0, 8) != 0) {
+		return NULL; //This is not a PNG file - could be used for fast checking whether file is supported or not
+	}
+
+	png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	if (!png_ptr) {
+		return NULL;
+	}
+	png_infop info_ptr = png_create_info_struct(png_ptr);
+	if (!info_ptr) {
+		return NULL;
+	}
+	if (setjmp(png_jmpbuf(png_ptr))) {
+		return NULL; //Error during init_io
+	}
+	png_set_read_fn(png_ptr, &is, user_read_data); 
+	png_set_sig_bytes(png_ptr, 8);
+	png_read_info(png_ptr, info_ptr);
+	
+	int width = info_ptr->width;
+	int height = info_ptr->height;
+	int color_type = info_ptr->color_type;
+	int bit_depth = info_ptr->bit_depth;
+
+	//We want RGB, 24 bit
+	if (color_type == PNG_COLOR_TYPE_PALETTE || (color_type == PNG_COLOR_TYPE_GRAY && info_ptr->bit_depth < 8) || (info_ptr->valid & PNG_INFO_tRNS)) {
+		png_set_expand(png_ptr);
+	}
+
+	if (color_type == PNG_COLOR_TYPE_GRAY) {
+		png_set_gray_to_rgb(png_ptr);
+	}
+
+	int number_of_passes = png_set_interlace_handling(png_ptr);
+	png_read_update_info(png_ptr, info_ptr);
+	png_bytep* row_pointers = new png_bytep[height];
+
+	if (setjmp(png_jmpbuf(png_ptr))) {
+		delete[] row_pointers;
+		return NULL; //error during read_image
+	}
+	for (int y = 0; y < height; ++y) {
+		row_pointers[y] = new png_byte[info_ptr->rowbytes];
+	}
+	png_read_image(png_ptr, row_pointers);
+	int fileComponents = info_ptr->rowbytes/info_ptr->width;
+	int picComponents = (ret->getComponents()==-1)?fileComponents:ret->getComponents();
+	//Copy image
+	ret->init(width,height,picComponents);
+	uint8* pixels = ret->getPixels();
+	const int rowbytes = info_ptr->rowbytes;
+	int location = 0;
+	for (int y = height-1; y >= 0; --y) { //you have to somehow invert the lines
+		if (picComponents == fileComponents) {
+			memcpy(pixels+location,row_pointers[y],rowbytes);
+		} else {
+			int r,g,b,a,l;
+			for (int xPic = 0, xFile = 0; xFile < rowbytes; xPic+= picComponents, xFile+= fileComponents) {
+				switch(fileComponents) {
+					case 3:
+						r = row_pointers[y][xFile];
+						g = row_pointers[y][xFile+1];
+						b = row_pointers[y][xFile+2];
+						l = (r+g+b+2)/3;
+						a = 255;
+						break;
+					case 4:
+						r = row_pointers[y][xFile];
+						g = row_pointers[y][xFile+1];
+						b = row_pointers[y][xFile+2];
+						l = (r+g+b+2)/3;
+						a = row_pointers[y][xFile+3];	
+						break;
+					default:
+						//TODO: Error
+					case 1:
+						r = g = b = l = row_pointers[y][xFile];
+						a = 255;
+						break;
+				}
+				switch (picComponents) {
+					case 1:
+						pixels[location+xPic] = l;
+						break;
+					case 4:
+						pixels[location+xPic+3] = a; //Next case
+					case 3:
+						pixels[location+xPic] = r;
+						pixels[location+xPic+1] = g;
+						pixels[location+xPic+2] = b;
+						break;
+					default:
+						//just so at least something works
+						for (int i = 0; i < picComponents; ++i) {
+							pixels[location+xPic+i] = l;
+						}
+						//TODO: Error
+				}
+			}
+		}
+		location+=picComponents*width;
+	}
+	delete[] row_pointers;
+	return ret;
+}
+
+}} //end namespace

source/shared_lib/sources/graphics/TGAReader.cpp

@@ -0,0 +1,136 @@
+// ==============================================================
+//	This file is part of Glest Shared Library (www.glest.org)
+//
+//	Copyright (C) 2001-2010 Martiño Figueroa and others
+//
+//	You can redistribute this code and/or modify it under 
+//	the terms of the GNU General Public License as published 
+//	by the Free Software Foundation; either version 2 of the 
+//	License, or (at your option) any later version
+// ==============================================================
+
+#include "TGAReader.h"
+#include "types.h"
+#include "pixmap.h"
+#include <stdexcept>
+#include <iostream>
+
+using std::runtime_error;
+
+namespace Shared{ namespace Graphics{
+
+#pragma pack(push, 1)
+
+/**Copied from pixmap.cpp*/
+// =====================================================
+//	Information for reading the targa-file
+// =====================================================
+struct TargaFileHeader{
+	int8 idLength;
+	int8 colourMapType;
+	int8 dataTypeCode;
+	int16 colourMapOrigin;
+	int16 colourMapLength;
+	int8 colourMapDepth;
+	int16 xOrigin;
+	int16 yOrigin;
+	int16 width;
+	int16 height;
+	int8 bitsPerPixel;
+	int8 imageDescriptor;
+};
+
+#pragma pack(pop)
+
+static const int tgaUncompressedRgb= 2;
+static const int tgaUncompressedBw= 3;
+
+// =====================================================
+//	class TGAReader
+// =====================================================
+
+/**Get Extension array, initialised*/
+static inline const string* getExtensionStrings() {
+	static string * extensions = new string[2];
+	extensions[0] = "tga";
+	extensions[1] = "";
+	return extensions;
+}
+
+TGAReader::TGAReader(): FileReader<Pixmap2D>(getExtensionStrings()) {}
+
+Pixmap2D* TGAReader::read(ifstream& in, const string& path, Pixmap2D* ret) const {
+	//read header
+	TargaFileHeader fileHeader;
+	in.read((char*)&fileHeader, sizeof(TargaFileHeader));
+	if (!in.good()) {
+		throw runtime_error(path + " could not be read");
+	}
+
+	//check that we can load this tga file
+	if(fileHeader.idLength!=0){
+		throw runtime_error(path + ": id field is not 0");
+	}
+
+	if(fileHeader.dataTypeCode!=tgaUncompressedRgb && fileHeader.dataTypeCode!=tgaUncompressedBw){
+		throw runtime_error(path + ": only uncompressed BW and RGB targa images are supported");
+	}	
+
+	//check bits per pixel
+	if(fileHeader.bitsPerPixel!=8 && fileHeader.bitsPerPixel!=24 && fileHeader.bitsPerPixel!=32){
+		throw runtime_error(path + ": only 8, 24 and 32 bit targa images are supported");
+	}
+
+	const int h = fileHeader.height;
+ 	const int w = fileHeader.width;
+	const int fileComponents= fileHeader.bitsPerPixel/8;
+	const int picComponents = (ret->getComponents()==-1)?fileComponents:ret->getComponents();
+	ret->init(w,h,picComponents);
+	uint8* pixels = ret->getPixels();
+	//read file
+	for(int i=0; i<h*w*picComponents; i+=picComponents){
+		uint8 r, g, b, a, l;
+
+		if(fileComponents==1){
+			in.read((char*)&l,1);
+			r= l;
+			g= l;
+			b= l;
+			a= 255;
+		}
+		else{
+			in.read((char*)&b, 1);
+			in.read((char*)&g, 1);
+			in.read((char*)&r, 1);
+			if(fileComponents==4){
+				in.read((char*)&a, 1);
+			} else {
+				a= 255;
+			}
+			l= (r+g+b)/3;
+		}
+		if (!in.good()) {
+			return NULL;
+		}
+
+		switch(picComponents){
+		case 1:
+			pixels[i]= l;
+			break;
+		case 3:
+			pixels[i]= r;
+			pixels[i+1]= g;
+			pixels[i+2]= b;
+			break;
+		case 4:
+			pixels[i]= r;
+			pixels[i+1]= g;
+			pixels[i+2]= b;
+			pixels[i+3]= a;
+		break;
+		}
+	}
+	return ret;
+	}
+
+}} //end namespace

source/shared_lib/sources/graphics/pixmap.cpp

@@ -19,6 +19,12 @@
 #include "math_util.h"
 #include "random.h"
 #include "leak_dumper.h"
+#include "FileReader.h"
+
+//Readers
+#include "ImageReaders.h"
+
+
 
 using namespace Shared::Util;
 using namespace std;
@@ -460,59 +466,14 @@ Pixmap2D::~Pixmap2D(){
 	delete [] pixels;
 }
 
+Pixmap2D* Pixmap2D::loadPath(const string& path) {
+	return FileReader<Pixmap2D>::readPath(path);
+}
+
 void Pixmap2D::load(const string &path){
-	string extension= path.substr(path.find_last_of('.')+1);
+	FileReader<Pixmap2D>::readPath(path,this);
-	if(extension=="bmp"){
-		loadBmp(path);
-	}
-	else if(extension=="tga"){
-		loadTga(path);
-	}
-	else{
-		throw runtime_error("Unknown pixmap extension: "+extension);
-	}
 }
 
-void Pixmap2D::loadBmp(const string &path){
-
-	PixmapIoBmp plb;
-	plb.openRead(path);
-
-	//init
-	w= plb.getW();
-	h= plb.getH();
-	if(components==-1){
-		components= 3;
-	}
-	if(pixels==NULL){
-		pixels= new uint8[w*h*components];
-	}
-
-	//data
-	plb.read(pixels, components);
-}
-
-void Pixmap2D::loadTga(const string &path){
-
-	PixmapIoTga plt;
-	plt.openRead(path);
-	w= plt.getW();
-	h= plt.getH();
-
-	//header
-	int fileComponents= plt.getComponents();
-
-	//init
-	if(components==-1){
-		components= fileComponents;
-	}
-	if(pixels==NULL){
-		pixels= new uint8[w*h*components];
-	}
-
-	//read data
-	plt.read(pixels, components);
-}
 
 void Pixmap2D::save(const string &path){
 	string extension= path.substr(path.find_last_of('.')+1);
@@ -865,12 +826,5 @@ void PixmapCube::loadFace(const string &path, int face){
 	faces[face].load(path);
 }
 
-void PixmapCube::loadFaceBmp(const string &path, int face){
-	faces[face].loadBmp(path);
-}
-
-void PixmapCube::loadFaceTga(const string &path, int face){
-	faces[face].loadTga(path);
-}
 
 }}//end namespace

source/shared_lib/sources/platform/sdl/platform_util.cpp

@@ -414,6 +414,15 @@ string extractDirectoryPathFromFile(string filename)
     return filename.substr( 0, filename.rfind("/")+1 );
 }
 
+string extractExtension(const string& filepath) {
+	size_t lastPoint = filepath.find_last_of('.');
+	size_t lastDirectory = filepath.find_last_of('/');
+	if (lastPoint == string::npos || (lastDirectory != string::npos && lastDirectory > lastPoint)) {
+		return "";
+	}
+	return filepath.substr(lastPoint+1);
+} 
+
 void createDirectoryPaths(string Path)
 {
  char DirName[256]="";

source/shared_lib/sources/platform/win32/platform_util.cpp

@@ -449,6 +449,17 @@ string extractDirectoryPathFromFile(string filename)
     return filename.substr( 0, filename.rfind("/")+1 );
 }
 
+string extractExtension(const string& filepath) {
+	size_t lastPoint = filepath.find_last_of('.');
+	size_t lastDirectory_Win = filepath.find_last_of('\\');
+	size_t lastDirectory_Lin = filepath.find_last_of('/');
+	size_t lastDirectory = (lastDirectory_Win<lastDirectory_Lin)?lastDirectory_Lin:lastDirectory_Win;
+	if (lastPoint == string::npos || (lastDirectory != string::npos && lastDirectory > lastPoint)) {
+		return "";
+	}
+	return filepath.substr(lastPoint+1);
+} 
+
 void createDirectoryPaths(string Path)
 {
  char DirName[256]="";