added partial VFS support - enough to read static data from any source

ExternalLibs/ttvfs/VFSAtomic.cpp

@@ -0,0 +1,103 @@
+// VFSAtomic.cpp - atomic operations and thread locking
+// For conditions of distribution and use, see copyright notice in VFS.h
+
+/** --- Atomic operations and thread safety ---
+  * You may want to add your own implementation if thread safety is needed.
+  * If not, just leave everything like it is.
+
+  * If you are on windows, Interlocked[In/De]crement is faster than
+    explicit mutex locking for integer operations.
+
+  * TODO: The actual locking that is done in the tree when VFS_THREADSAFE is defined
+    is rather crude for the time beeing; a somewhat more efficient ReadWriteLock
+    implementation would be nice to have, someday.
+
+  * If you can, leave VFS_THREADSAFE undefined and do the locking externally,
+    it will probably have much better performance than if each and every operation
+    does a lock and unlock call.
+    (For a rather I/O based library this should not really make a difference, anyway.
+    But don't say you haven't been warned :) )
+*/
+
+#include "VFSInternal.h"
+#include "VFSAtomic.h"
+
+// for Interlocked[In/De]crement, if required
+#if defined(_WIN32) && defined(VFS_THREADSAFE)
+#    define WIN32_LEAN_AND_MEAN
+#    include <windows.h>
+#endif
+
+VFS_NAMESPACE_START
+
+#ifdef VFS_THREADSAFE
+static Mutex mtx;
+#endif
+
+int Atomic_Incr(volatile int &i)
+{
+#ifdef VFS_THREADSAFE
+#   ifdef _WIN32
+        volatile LONG* dp = (volatile LONG*) &i;
+        return InterlockedIncrement( dp );
+#   else
+        Guard g(mtx);
+#   endif
+#endif
+    return ++i;
+}
+
+int Atomic_Decr(volatile int &i)
+{
+#ifdef VFS_THREADSAFE
+#   ifdef _WIN32
+        volatile LONG* dp = (volatile LONG*) &i;
+        return InterlockedDecrement( dp );
+#   else
+        Guard g(mtx);
+#   endif
+#endif
+    return --i;
+}
+
+/* Implement your Mutex class here.
+   Important: The mutex must be re-entrant/recursive,
+   means it must be possible to lock it from the same thread multiple times.
+*/
+Mutex::Mutex()
+{
+    // implement your own if needed. Remove the trap below when you are done.
+    // This is to prevent people from defining VFS_THREADSAFE and expecting everything to work just like that :)
+#ifdef VFS_THREADSAFE
+#error VFSAtomic: Hey, you forgot to implement the mutex class, cant guarantee thread safety! Either undef VFS_THREADSAFE or read the docs and get your hands dirty.
+#endif
+}
+
+Mutex::~Mutex()
+{
+    // implement your own if needed
+}
+
+void Mutex::Lock(void)
+{
+    // implement your own if needed
+}
+
+void Mutex::Unlock(void)
+{
+    // implement your own if needed
+}
+
+Guard::Guard(Mutex& m)
+: _m(m)
+{
+    _m.Lock();
+}
+
+Guard::~Guard()
+{
+    _m.Unlock();
+}
+
+
+VFS_NAMESPACE_END