All textures are are now searched first from the directory specified by the texture_p...

[dragonfireclient.git] / src / utility.h

diff --git a/src/utility.h b/src/utility.h
index 2b143f0bac4aa03fdb6cb276f6b575bef96dd402..cc8891a0797c1345d0325460c8a4821c373528c9 100644 (file)
--- a/src/utility.h
+++ b/src/utility.h
@@ -24,6 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <fstream>
 #include <string>
 #include <sstream>
+#include <vector>
 #include <jthread.h>
 #include <jmutex.h>
 #include <jmutexautolock.h>
@@ -95,8 +96,6 @@ inline u8 readU8(u8 *data)
        return (data[0]<<0);
 }
 
-// Signed variants of the above
-
 inline void writeS32(u8 *data, s32 i){
        writeU32(data, (u32)i);
 }
@@ -104,6 +103,13 @@ inline s32 readS32(u8 *data){
        return (s32)readU32(data);
 }
 
+inline void writeF1000(u8 *data, f32 i){
+       writeS32(data, i*1000);
+}
+inline f32 readF1000(u8 *data){
+       return (f32)readS32(data)/1000.;
+}
+
 inline void writeS16(u8 *data, s16 i){
        writeU16(data, (u16)i);
 }
@@ -117,7 +123,6 @@ inline void writeV3S32(u8 *data, v3s32 p)
        writeS32(&data[4], p.Y);
        writeS32(&data[8], p.Z);
 }
-
 inline v3s32 readV3S32(u8 *data)
 {
        v3s32 p;
@@ -127,6 +132,21 @@ inline v3s32 readV3S32(u8 *data)
        return p;
 }
 
+inline void writeV3F1000(u8 *data, v3f p)
+{
+       writeF1000(&data[0], p.X);
+       writeF1000(&data[4], p.Y);
+       writeF1000(&data[8], p.Z);
+}
+inline v3f readV3F1000(u8 *data)
+{
+       v3f p;
+       p.X = (float)readF1000(&data[0]);
+       p.Y = (float)readF1000(&data[4]);
+       p.Z = (float)readF1000(&data[8]);
+       return p;
+}
+
 inline void writeV2S16(u8 *data, v2s16 p)
 {
        writeS16(&data[0], p.X);
@@ -171,6 +191,62 @@ inline v3s16 readV3S16(u8 *data)
        return p;
 }
 
+/*
+       The above stuff directly interfaced to iostream
+*/
+
+inline void writeU8(std::ostream &os, u8 p)
+{
+       char buf[1];
+       writeU8((u8*)buf, p);
+       os.write(buf, 1);
+}
+inline u8 readU8(std::istream &is)
+{
+       char buf[1];
+       is.read(buf, 1);
+       return readU8((u8*)buf);
+}
+
+inline void writeU16(std::ostream &os, u16 p)
+{
+       char buf[2];
+       writeU16((u8*)buf, p);
+       os.write(buf, 2);
+}
+inline u16 readU16(std::istream &is)
+{
+       char buf[2];
+       is.read(buf, 2);
+       return readU16((u8*)buf);
+}
+
+inline void writeF1000(std::ostream &os, f32 p)
+{
+       char buf[2];
+       writeF1000((u8*)buf, p);
+       os.write(buf, 2);
+}
+inline f32 readF1000(std::istream &is)
+{
+       char buf[2];
+       is.read(buf, 2);
+       return readF1000((u8*)buf);
+}
+
+inline void writeV3F1000(std::ostream &os, v3f p)
+{
+       char buf[12];
+       writeV3F1000((u8*)buf, p);
+       os.write(buf, 12);
+}
+inline v3f readV3F1000(std::istream &is)
+{
+       char buf[12];
+       is.read(buf, 12);
+       return readV3F1000((u8*)buf);
+}
+
 /*
        None of these are used at the moment
 */
@@ -421,8 +497,6 @@ class MutexedVariable
        TimeTaker
 */
 
-class IrrlichtWrapper;
-
 class TimeTaker
 {
 public:
@@ -658,6 +732,19 @@ inline std::string wide_to_narrow(const std::wstring& wcs)
        return *mbs;
 }
 
+// Split a string using the given delimiter. Returns a vector containing
+// the component parts.
+inline std::vector<std::wstring> str_split(const std::wstring &str, wchar_t delimiter)
+{
+       std::vector<std::wstring> parts;
+       std::wstringstream sstr(str);
+       std::wstring part;
+       while(std::getline(sstr, part, delimiter))
+               parts.push_back(part);
+       return parts;
+}
+
+
 /*
        See test.cpp for example cases.
        wraps degrees to the range of -360...360
@@ -713,11 +800,20 @@ inline s32 stoi(const std::string &s, s32 min, s32 max)
        return i;
 }
 
+
+// MSVC2010 includes it's own versions of these
+#if !defined(_MSC_VER) || _MSC_VER < 1600
+
 inline s32 stoi(std::string s)
 {
        return atoi(s.c_str());
 }
 
+inline s32 stoi(std::wstring s)
+{
+       return atoi(wide_to_narrow(s).c_str());
+}
+
 inline float stof(std::string s)
 {
        float f;
@@ -726,6 +822,8 @@ inline float stof(std::string s)
        return f;
 }
 
+#endif
+
 inline std::string itos(s32 i)
 {
        std::ostringstream o;
@@ -1256,6 +1354,14 @@ class Settings
                return value;
        }
 
+       void setBool(std::string name, bool value)
+       {
+               if(value)
+                       set(name, "true");
+               else
+                       set(name, "false");
+       }
+
        void setS32(std::string name, s32 value)
        {
                set(name, itos(value));
@@ -1660,12 +1766,12 @@ class UniqueQueue
        core::list<Value> m_list;
 };
 
-#if 0
+#if 1
 template<typename Key, typename Value>
-class MutexedCache
+class MutexedMap
 {
 public:
-       MutexedCache()
+       MutexedMap()
        {
                m_mutex.Init();
                assert(m_mutex.IsInitialized());
@@ -1687,8 +1793,10 @@ class MutexedCache
 
                if(n == NULL)
                        return false;
-
-               *result = n->getValue();
+               
+               if(result != NULL)
+                       *result = n->getValue();
+                       
                return true;
        }
 
@@ -1828,9 +1936,11 @@ inline v3f intToFloat(v3s16 p, f32 d)
 */
 
 // Creates a string with the length as the first two bytes
-inline std::string serializeString(const std::string plain)
+inline std::string serializeString(const std::string &plain)
 {
-       assert(plain.size() <= 65535);
+       //assert(plain.size() <= 65535);
+       if(plain.size() > 65535)
+               throw SerializationError("String too long for serializeString");
        char buf[2];
        writeU16((u8*)&buf[0], plain.size());
        std::string s;
@@ -1870,7 +1980,7 @@ inline std::string deSerializeString(std::istream &is)
 }
 
 // Creates a string with the length as the first four bytes
-inline std::string serializeLongString(const std::string plain)
+inline std::string serializeLongString(const std::string &plain)
 {
        char buf[4];
        writeU32((u8*)&buf[0], plain.size());
@@ -1920,7 +2030,8 @@ inline u32 time_to_daynight_ratio(u32 time_of_day)
        s32 d = daylength;
        s32 t = (((time_of_day)%24000)/(24000/d));
        if(t < nightlength/2 || t >= d - nightlength/2)
-               return 300;
+               //return 300;
+               return 350;
        else if(t >= d/2 - daytimelength/2 && t < d/2 + daytimelength/2)
                return 1000;
        else
@@ -1940,6 +2051,32 @@ inline core::aabbox3d<f32> getNodeBox(v3s16 p, float d)
        );
 }
        
+class IntervalLimiter
+{
+public:
+       IntervalLimiter():
+               m_accumulator(0)
+       {
+       }
+       /*
+               dtime: time from last call to this method
+               wanted_interval: interval wanted
+               return value:
+                       true: action should be skipped
+                       false: action should be done
+       */
+       bool step(float dtime, float wanted_interval)
+       {
+               m_accumulator += dtime;
+               if(m_accumulator < wanted_interval)
+                       return false;
+               m_accumulator -= wanted_interval;
+               return true;
+       }
+protected:
+       float m_accumulator;
+};
+
 
 #endif