[vfs, #3] All file reading code goes through the VFS now, new mod downloader & mod selector in place. Also a bunch of other stuff. (...)

- HTTP networking support, mods can be downloaded via the builtin downloader.
  All network activity runs in a seperate thread, which is started
  as soon as any network activity is requested.
- The master server is hard-coded to fg.wzff.de/aqmods/ if not specified otherwise;
  this setting can be overridden in the config file.
- The mod selector screen is now a grid-view for much better navigation;
  also works with joystick.
- VFS code is functionally similar to the old molebox-packed release
  for win32. The game could also have its data shipped in a Zip file
  or any other kind of archive.
- It is still possible to build without VFS support, but then the mod
  downloader and soft-patching will not be available.

The full commit history can be found here:
https://github.com/fgenesis/Aquaria_clean/compare/master...vfs

The most important commit messages follow:
[...]
    This replaces all std::ifstream with InStream, and fopen(), ... with vfopen(), ...
    Some code is #ifdef'd for better performance and less memory-copying.
    VFILE is defined to whatever type of file is in use:
    - FILE if BBGE_BUILD_VFS is not defined
    - tttvfs::VFSFile if it is.

    Other changes:
    - [un]packFile() is now unused and obsolete. That code has not been adjusted to use VFILE.
    - glpng can now load from a memory buffer.
    - TinyXML uses the VFS for reading operations now.
    - The rather clunky binary stream loading of glfont2 got replaced with ByteBuffer,
      which gets its data in one block (necessary to use the VFS without implementing
      a somewhat STL-compliant std::ifstream replacement.)
-------------
Implement loading mods from zip files.
-------------
Implement soft-patching game data files. (Replacing textures/audio/... on the fly)
-------------
Misc bits:
- Extended GUI focus handling a bit
- Fixed weirdness in texture loading... not sure but this seems more correct to me.
  Actually, considering that the texture will have its native size after restarting the game,
  the lines removed with this commit seem pretty useless.

ExternalLibs/FileAPI.cpp

@@ -0,0 +1,125 @@
+#ifdef BBGE_BUILD_VFS
+
+#include "FileAPI.h"
+#include "ttvfs_zip/VFSZipArchiveLoader.h"
+#include <stdio.h>
+
+
+ttvfs::VFSHelper vfs;
+
+
+VFILE *vfopen(const char *fn, const char *mode)
+{
+	if (strchr(mode, 'w'))
+	{
+		fprintf(stderr, "FileAPI.h: File writing via VFS not yet supported!");
+		return NULL;
+	}
+
+	VFILE *vf = vfs.GetFile(fn);
+	if (!vf || !vf->open(mode))
+		return NULL;
+	++(vf->ref); // keep the file alive until closed.
+	return vf;
+}
+
+size_t vfread(void *ptr, size_t size, size_t count, VFILE *vf)
+{
+	return vf->read(ptr, size * count) / size;
+}
+
+int vfclose(VFILE *vf)
+{
+	bool closed = vf->close();
+	vf->ref--;
+	return closed ? 0 : EOF;
+}
+
+size_t vfwrite(const void *ptr, size_t size, size_t count, VFILE *vf)
+{
+	return vf->write(ptr, size * count) / size;
+}
+
+// return 0 on success, -1 on error
+int vfseek(VFILE *vf, long int offset, int origin)
+{
+	bool ok = false;
+	switch(origin)
+	{
+	case SEEK_SET: ok = vf->seek(offset); break;
+	case SEEK_CUR: ok = vf->seekRel(offset); break;
+	case SEEK_END: ok = vf->seek((long int)(vf->size() - offset)); break;
+	}
+	return ok ? 0 : -1;
+}
+
+char *vfgets(char *str, int num, VFILE *vf)
+{
+	char *s = str;
+	if (vf->iseof())
+		return NULL;
+	char *ptr = (char*)vf->getBuf() + vf->getpos();
+	unsigned int remain = int(vf->size() - vf->getpos());
+	if (remain < (unsigned int)num)
+		num = remain;
+	else
+		--num; // be sure to keep space for the final null char
+	int i = 0;
+	char c;
+	for( ; i < num && *ptr; ++i)
+	{
+		c = (*s++ = *ptr++);
+		if(c == '\n' || c == '\r')
+		{
+			++i;
+			c = *ptr++; // because windows linebreaks suck.
+			if(c == '\n' || c == '\r')
+				++i;
+			break;
+		}
+	}
+
+	vf->seekRel(i);
+	*s++ = 0;
+	return str;
+}
+
+void vfclear(VFILE *vf)
+{
+	vf->dropBuf(true);
+}
+
+long int vftell(VFILE *vf)
+{
+	return (long int)vf->getpos();
+}
+
+
+InStream::InStream(const std::string& fn)
+: std::istringstream()
+{
+    open(fn.c_str());
+}
+
+InStream::InStream(const char *fn)
+: std::istringstream()
+{
+    open(fn);
+}
+
+bool InStream::open(const char *fn)
+{
+    ttvfs::VFSFile *vf = vfs.GetFile(fn);
+    if(vf)
+    {
+        vf->open("r");
+        str((char*)vf->getBuf()); // stringstream will always make a copy
+        vf->close();
+        vf->dropBuf(true);
+        return true;
+    }
+    setstate(std::ios_base::failbit);
+    return false;
+}
+
+#endif

ExternalLibs/FileAPI.h

@@ -0,0 +1,55 @@
+#ifndef FILE_API_H
+#define FILE_API_H
+
+// TODO: need VFS output functions?
+
+#ifdef BBGE_BUILD_VFS
+
+#include "ttvfs/VFS.h"
+#include <sstream>
+
+extern ttvfs::VFSHelper vfs;
+typedef ttvfs::VFSFile VFILE;
+
+
+VFILE *vfopen(const char *fn, const char *mode);
+size_t vfread(void *ptr, size_t size, size_t count, VFILE *vf);
+int vfclose(VFILE *vf);
+size_t vfwrite(const void *ptr, size_t size, size_t count, VFILE *vf);
+int vfseek(VFILE *vf, long int offset, int origin);
+char *vfgets(char *str, int num, VFILE *vf);
+void vfclear(VFILE *vf);
+long int vftell(VFILE *vf);
+
+// This class is a minimal adapter to support STL-like read-only file streams for VFS files, using std::istringstream.
+class InStream : public std::istringstream
+{
+public:
+    InStream(const char *fn);
+    InStream(const std::string& fn);
+    bool open(const char *fn);
+    inline bool is_open() { return good(); }
+    inline void close() {}
+private:
+    void _init(const char *fn);
+};
+
+#else // BBGE_BUILD_VFS
+
+#include <stdio.h>
+#include <fstream>
+typedef std::ifstream InStream;
+typedef FILE VFILE;
+#define vfopen        fopen
+#define vfread        fread
+#define vfclose       fclose
+#define vfwrite       fwrite
+#define vfseek        fseek
+#define vfgets        fgets
+#define vftell        ftell
+#define vfclear
+
+#endif // BBGE_BUILD_VFS
+
+
+#endif // FILE_API_H

ExternalLibs/tinyxml.cpp

@@ -22,6 +22,8 @@ must not be misrepresented as being the original software.
 distribution.
 */
 
+// see tinyxml.h for changes
+
 #include <ctype.h>
 
 #ifdef TIXML_USE_STL
@@ -923,12 +925,12 @@ bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
 	value = filename;
 
 	// reading in binary mode so that tinyxml can normalize the EOL
-	FILE* file = TiXmlFOpen( value.c_str (), "rb" );	
+	VFILE* file = vfopen( value.c_str (), "rb" );
 
 	if ( file )
 	{
 		bool result = LoadFile( file, encoding );
-		fclose( file );
+		vfclose( file );
 		return result;
 	}
 	else
@@ -938,7 +940,7 @@ bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
 	}
 }
 
-bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
+bool TiXmlDocument::LoadFile( VFILE* file, TiXmlEncoding encoding )
 {
 	if ( !file ) 
 	{
@@ -952,9 +954,13 @@ bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
 
 	// Get the file size, so we can pre-allocate the string. HUGE speed impact.
 	long length = 0;
+#ifdef BBGE_BUILD_VFS
+	length = file->size();
+#else
 	fseek( file, 0, SEEK_END );
 	length = ftell( file );
 	fseek( file, 0, SEEK_SET );
+#endif
 
 	// Strange case, but good to handle up front.
 	if ( length <= 0 )
@@ -984,14 +990,24 @@ bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
 	}
 	*/
 
+#ifdef BBGE_BUILD_VFS
+	char *buf = (char*)file->getBuf();
+	file->dropBuf(false);
+	if (!buf)
+	{
+		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
+		return false;
+	}
+#else
 	char* buf = new char[ length+1 ];
 	buf[0] = 0;
 
-	if ( fread( buf, length, 1, file ) != 1 ) {
+	if ( vfread( buf, length, 1, file ) != 1 ) {
 		delete [] buf;
 		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
 		return false;
 	}
+#endif
 
 	return LoadMem(buf, length, encoding);
 }

ExternalLibs/tinyxml.h

@@ -24,6 +24,7 @@ distribution.
 
 // EDIT:
 // - added LoadMem() function
+// - added VFS stuff
 
 
 #ifndef TINYXML_INCLUDED
@@ -35,11 +36,13 @@ distribution.
 #pragma warning( disable : 4786 )
 #endif
 
+#include "FileAPI.h"
+
 #include <ctype.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include <stdio.h>
 
 // Help out windows:
 #if defined( _DEBUG ) && !defined( DEBUG )
@@ -1420,7 +1423,7 @@ public:
 		will be interpreted as an XML file. TinyXML doesn't stream in XML from the current
 		file location. Streaming may be added in the future.
 	*/
-	bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
+	bool LoadFile( VFILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
 	/// Save a file using the given FILE*. Returns true if successful.
 	bool SaveFile( FILE* ) const;