51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
#ifndef UTILITY_HEADER
#define UTILITY_HEADER
#include <jmutex.h>
#include <jmutexautolock.h>
-#ifdef _WIN32
- #include <windows.h>
- #define sleep_ms(x) Sleep(x)
-#else
- #include <unistd.h>
- #define sleep_ms(x) usleep(x*1000)
-#endif
-
#include "common_irrlicht.h"
#include "debug.h"
#include "strfnd.h"
#include "exceptions.h"
+#include "porting.h"
extern const v3s16 g_26dirs[26];
TimeTaker
*/
+class IrrlichtWrapper;
+
class TimeTaker
{
public:
- TimeTaker(const char *name, IrrlichtDevice *dev, u32 *result=NULL)
- {
- m_name = name;
- m_dev = dev;
- m_result = result;
- m_running = true;
- if(dev == NULL)
- {
- m_time1 = 0;
- return;
- }
- m_time1 = m_dev->getTimer()->getRealTime();
- }
+ TimeTaker(const char *name, u32 *result=NULL);
+
~TimeTaker()
{
stop();
}
- u32 stop(bool quiet=false)
- {
- if(m_running)
- {
- if(m_dev == NULL)
- {
- /*if(quiet == false)
- std::cout<<"Couldn't measure time for "<<m_name
- <<": dev==NULL"<<std::endl;*/
- return 0;
- }
- u32 time2 = m_dev->getTimer()->getRealTime();
- u32 dtime = time2 - m_time1;
- if(m_result != NULL)
- {
- (*m_result) += dtime;
- }
- else
- {
- if(quiet == false)
- std::cout<<m_name<<" took "<<dtime<<"ms"<<std::endl;
- }
- m_running = false;
- return dtime;
- }
- return 0;
- }
+
+ u32 stop(bool quiet=false);
+
private:
const char *m_name;
- IrrlichtDevice *m_dev;
u32 m_time1;
bool m_running;
u32 *m_result;
);
}
+inline s16 rangelim(s16 i, s16 min, s16 max)
+{
+ if(i < min)
+ return min;
+ if(i > max)
+ return max;
+ return i;
+}
+
+inline s16 rangelim(s16 i, s16 max)
+{
+ if(i < 0)
+ return 0;
+ if(i > max)
+ return max;
+ return i;
+}
+
+inline v3s16 arealim(v3s16 p, s16 d)
+{
+ if(p.X < 0)
+ p.X = 0;
+ if(p.Y < 0)
+ p.Y = 0;
+ if(p.Z < 0)
+ p.Z = 0;
+ if(p.X > d-1)
+ p.X = d-1;
+ if(p.Y > d-1)
+ p.Y = d-1;
+ if(p.Z > d-1)
+ p.Z = d-1;
+ return p;
+}
+
inline std::wstring narrow_to_wide(const std::string& mbs)
{
size_t wcl = mbs.size();
return f;
}
-inline std::string lowercase(std::string s)
+inline std::string lowercase(const std::string &s)
{
+ std::string s2;
for(size_t i=0; i<s.size(); i++)
{
- if(s[i] >= 'A' && s[i] <= 'Z')
- s[i] -= 'A' - 'a';
+ char c = s[i];
+ if(c >= 'A' && c <= 'Z')
+ c -= 'A' - 'a';
+ s2 += c;
}
- return s;
+ return s2;
}
-inline bool is_yes(std::string s)
+inline bool is_yes(const std::string &s)
{
- s = lowercase(trim(s));
- if(s == "y" || s == "yes" || s == "true")
+ std::string s2 = lowercase(trim(s));
+ if(s2 == "y" || s2 == "yes" || s2 == "true")
return true;
return false;
}
-inline s32 stoi(std::string s, s32 min, s32 max)
+inline s32 stoi(const std::string &s, s32 min, s32 max)
{
s32 i = atoi(s.c_str());
if(i < min)
return atoi(s.c_str());
}
+inline std::string itos(s32 i)
+{
+ std::ostringstream o;
+ o<<i;
+ return o.str();
+}
+
+inline std::string ftos(float f)
+{
+ std::ostringstream o;
+ o<<f;
+ return o.str();
+}
+
+/*
+ A base class for simple background thread implementation
+*/
+
+class SimpleThread : public JThread
+{
+ bool run;
+ JMutex run_mutex;
+
+public:
+
+ SimpleThread():
+ JThread(),
+ run(true)
+ {
+ run_mutex.Init();
+ }
+
+ virtual ~SimpleThread()
+ {}
+
+ virtual void * Thread() = 0;
+
+ bool getRun()
+ {
+ JMutexAutoLock lock(run_mutex);
+ return run;
+ }
+ void setRun(bool a_run)
+ {
+ JMutexAutoLock lock(run_mutex);
+ run = a_run;
+ }
+
+ void stop()
+ {
+ setRun(false);
+ while(IsRunning())
+ sleep_ms(100);
+ }
+};
+
/*
Config stuff
*/
// Asks if empty
bool getBoolAsk(std::string name, std::string question, bool def)
{
- std::string s = get(name);
- if(s != "")
- return is_yes(s);
+ // If it is in settings
+ if(m_settings.find(name))
+ return getBool(name);
+ std::string s;
char templine[10];
std::cout<<question<<" [y/N]: ";
std::cin.getline(templine, 10);
u16 getU16Ask(std::string name, std::string question, u16 def)
{
- std::string s = get(name);
- if(s != "")
- return stoi(s, 0, 65535);
+ // If it is in settings
+ if(m_settings.find(name))
+ return getU16(name);
+ std::string s;
char templine[10];
std::cout<<question<<" ["<<def<<"]: ";
std::cin.getline(templine, 10);
return stoi(get(name));
}
+ void clear()
+ {
+ m_settings.clear();
+ m_defaults.clear();
+ }
+
+ Settings & operator+=(Settings &other)
+ {
+ if(&other == this)
+ return *this;
+
+ for(core::map<std::string, std::string>::Iterator
+ i = other.m_settings.getIterator();
+ i.atEnd() == false; i++)
+ {
+ m_settings.insert(i.getNode()->getKey(),
+ i.getNode()->getValue());
+ }
+
+ for(core::map<std::string, std::string>::Iterator
+ i = other.m_defaults.getIterator();
+ i.atEnd() == false; i++)
+ {
+ m_defaults.insert(i.getNode()->getKey(),
+ i.getNode()->getValue());
+ }
+
+ }
+
+ Settings & operator=(Settings &other)
+ {
+ if(&other == this)
+ return *this;
+
+ clear();
+ (*this) += other;
+
+ return *this;
+ }
+
private:
core::map<std::string, std::string> m_settings;
core::map<std::string, std::string> m_defaults;
};
/*
- A thread-safe texture cache.
+ FIFO queue
+*/
+template<typename T>
+class Queue
+{
+public:
+ void push_back(T t)
+ {
+ m_list.push_back(t);
+ }
+
+ T pop_front()
+ {
+ if(m_list.size() == 0)
+ throw ItemNotFoundException("MutexedQueue: queue is empty");
- This is used so that irrlicht doesn't get called from many threads
+ typename core::list<T>::Iterator begin = m_list.begin();
+ T t = *begin;
+ m_list.erase(begin);
+ return t;
+ }
+
+ u32 size()
+ {
+ return m_list.size();
+ }
+
+protected:
+ core::list<T> m_list;
+};
+
+/*
+ Thread-safe FIFO queue
*/
-class TextureCache
+template<typename T>
+class MutexedQueue
{
public:
- TextureCache()
+ MutexedQueue()
{
m_mutex.Init();
- assert(m_mutex.IsInitialized());
}
-
- void set(std::string name, video::ITexture *texture)
+ u32 size()
+ {
+ return m_list.size();
+ }
+ void push_back(T t)
{
JMutexAutoLock lock(m_mutex);
+ m_list.push_back(t);
+ }
+ T pop_front(u32 wait_time_max_ms=0)
+ {
+ u32 wait_time_ms = 0;
+
+ for(;;)
+ {
+ {
+ JMutexAutoLock lock(m_mutex);
+
+ if(m_list.size() > 0)
+ {
+ typename core::list<T>::Iterator begin = m_list.begin();
+ T t = *begin;
+ m_list.erase(begin);
+ return t;
+ }
+
+ if(wait_time_ms >= wait_time_max_ms)
+ throw ItemNotFoundException("MutexedQueue: queue is empty");
+ }
+
+ // Wait a while before trying again
+ sleep_ms(10);
+ wait_time_ms += 10;
+ }
+ }
- m_textures[name] = texture;
+ JMutex & getMutex()
+ {
+ return m_mutex;
+ }
+
+ core::list<T> & getList()
+ {
+ return m_list;
+ }
+
+protected:
+ JMutex m_mutex;
+ core::list<T> m_list;
+};
+
+template<typename Caller, typename Data>
+class CallerInfo
+{
+public:
+ Caller caller;
+ Data data;
+};
+
+template<typename Key, typename T, typename Caller, typename CallerData>
+class GetResult
+{
+public:
+ Key key;
+ T item;
+ core::list<CallerInfo<Caller, CallerData> > callers;
+};
+
+template<typename Key, typename T, typename Caller, typename CallerData>
+class ResultQueue: public MutexedQueue< GetResult<Key, T, Caller, CallerData> >
+{
+};
+
+template<typename Key, typename T, typename Caller, typename CallerData>
+class GetRequest
+{
+public:
+ GetRequest()
+ {
+ dest = NULL;
+ }
+ GetRequest(ResultQueue<Key,T, Caller, CallerData> *a_dest)
+ {
+ dest = a_dest;
+ }
+ GetRequest(ResultQueue<Key,T, Caller, CallerData> *a_dest,
+ Key a_key)
+ {
+ dest = a_dest;
+ key = a_key;
+ }
+ ~GetRequest()
+ {
}
- video::ITexture* get(std::string name)
+ Key key;
+ ResultQueue<Key, T, Caller, CallerData> *dest;
+ core::list<CallerInfo<Caller, CallerData> > callers;
+};
+
+/*
+ Quickhands for typical request-result queues.
+ Used for distributing work between threads.
+*/
+
+template<typename Key, typename T, typename Caller, typename CallerData>
+class RequestQueue
+{
+public:
+ u32 size()
{
- JMutexAutoLock lock(m_mutex);
+ return m_queue.size();
+ }
+
+ void add(Key key, Caller caller, CallerData callerdata,
+ ResultQueue<Key, T, Caller, CallerData> *dest)
+ {
+ JMutexAutoLock lock(m_queue.getMutex());
+
+ /*
+ If the caller is already on the list, only update CallerData
+ */
+ for(typename core::list< GetRequest<Key, T, Caller, CallerData> >::Iterator
+ i = m_queue.getList().begin();
+ i != m_queue.getList().end(); i++)
+ {
+ GetRequest<Key, T, Caller, CallerData> &request = *i;
- core::map<std::string, video::ITexture*>::Node *n;
- n = m_textures.find(name);
+ if(request.key == key)
+ {
+ for(typename core::list< CallerInfo<Caller, CallerData> >::Iterator
+ i = request.callers.begin();
+ i != request.callers.end(); i++)
+ {
+ CallerInfo<Caller, CallerData> &ca = *i;
+ if(ca.caller == caller)
+ {
+ ca.data = callerdata;
+ return;
+ }
+ }
+ CallerInfo<Caller, CallerData> ca;
+ ca.caller = caller;
+ ca.data = callerdata;
+ request.callers.push_back(ca);
+ return;
+ }
+ }
- if(n != NULL)
- return n->getValue();
+ /*
+ Else add a new request to the queue
+ */
+
+ GetRequest<Key, T, Caller, CallerData> request;
+ request.key = key;
+ CallerInfo<Caller, CallerData> ca;
+ ca.caller = caller;
+ ca.data = callerdata;
+ request.callers.push_back(ca);
+ request.dest = dest;
+
+ m_queue.getList().push_back(request);
+ }
- return NULL;
+ GetRequest<Key, T, Caller, CallerData> pop(bool wait_if_empty=false)
+ {
+ return m_queue.pop_front(wait_if_empty);
}
private:
- core::map<std::string, video::ITexture*> m_textures;
- JMutex m_mutex;
+ MutexedQueue< GetRequest<Key, T, Caller, CallerData> > m_queue;
};
-class SimpleThread : public JThread
+/*
+ Pseudo-random (VC++ rand() sucks)
+*/
+int myrand(void);
+void mysrand(unsigned seed);
+#define MYRAND_MAX 32767
+
+/*
+ Some kind of a thing that stores attributes related to
+ coordinate points
+*/
+
+struct Attribute
{
- bool run;
- JMutex run_mutex;
+ Attribute()
+ {
+ }
-public:
+ Attribute(const std::string &value):
+ m_value(value)
+ {
+ }
- SimpleThread():
- JThread(),
- run(true)
+ Attribute(float value)
{
- run_mutex.Init();
+ m_value = ftos(value);
}
- virtual ~SimpleThread()
- {}
+ void set(const std::string &value)
+ {
+ m_value = value;
+ }
+
+ std::string get()
+ {
+ return m_value;
+ }
+
+ bool getBool()
+ {
+ return is_yes(get());
+ }
+
+ float getFloat()
+ {
+ float f;
+ std::istringstream vis(get());
+ vis>>f;
+ return f;
+ }
- virtual void * Thread() = 0;
+ u16 getU16()
+ {
+ return stoi(get(), 0, 65535);
+ }
- bool getRun()
+ s16 getS16()
{
- JMutexAutoLock lock(run_mutex);
- return run;
+ return stoi(get(), -32768, 32767);
}
- void setRun(bool a_run)
+
+ s32 getS32()
{
- JMutexAutoLock lock(run_mutex);
- run = a_run;
+ return stoi(get());
}
- void stop()
+ std::string m_value;
+};
+
+class PointAttributeList
+{
+ struct PointWithAttr
{
- setRun(false);
- while(IsRunning())
- sleep_ms(100);
+ v3s16 p;
+ Attribute attr;
+ };
+
+public:
+ ~PointAttributeList()
+ {
+ /*for(core::list<PointWithAttr>::Iterator
+ i = m_points.begin();
+ i != m_points.end(); i++)
+ {
+ PointWithAttr &pwa = *i;
+ //delete pwa.attr;
+ }*/
}
+
+ Attribute getNearAttr(v3s16 p)
+ {
+ core::list<PointWithAttr>::Iterator
+ nearest_i = m_points.end();
+ s16 nearest_d = 32767;
+ for(core::list<PointWithAttr>::Iterator
+ i = m_points.begin();
+ i != m_points.end(); i++)
+ {
+ PointWithAttr &pwa = *i;
+ s16 d = pwa.p.getDistanceFrom(p);
+ if(d < nearest_d)
+ {
+ nearest_i = i;
+ nearest_d = d;
+ }
+ }
+
+ if(nearest_i == m_points.end())
+ Attribute();
+
+ return nearest_i->attr;
+ }
+
+ Attribute getNearAttr(v2s16 p)
+ {
+ return getNearAttr(v3s16(p.X, 0, p.Y));
+ }
+
+ bool empty()
+ {
+ return (m_points.size() == 0);
+ }
+
+ /*
+ Take all points in range, or at least the nearest point,
+ and interpolate the values as floats
+ */
+ float getInterpolatedFloat(v3s16 p);
+
+ float getInterpolatedFloat(v2s16 p)
+ {
+ return getInterpolatedFloat(v3s16(p.X, 0, p.Y));
+ }
+
+ //float getInterpolatedFloat(v3s16 p, s32 range);
+ /*float getInterpolatedFloat(v2s16 p, s32 range)
+ {
+ return getInterpolatedFloat(v3s16(p.X, 0, p.Y), range);
+ }*/
+
+ void addPoint(v3s16 p, const Attribute &attr)
+ {
+ PointWithAttr pattr;
+ pattr.p = p;
+ pattr.attr = attr;
+ m_points.push_back(pattr);
+ }
+
+ void addPoint(v2s16 p, const Attribute &attr)
+ {
+ addPoint(v3s16(p.X, 0, p.Y), attr);
+ }
+
+private:
+ core::list<PointWithAttr> m_points;
};
+/*
+ Basically just a wrapper to core::map<PointAttributeList*>
+*/
+
+class PointAttributeDatabase
+{
+public:
+ ~PointAttributeDatabase()
+ {
+ for(core::map<std::string, PointAttributeList*>::Iterator
+ i = m_lists.getIterator();
+ i.atEnd() == false; i++)
+ {
+ delete i.getNode()->getValue();
+ }
+ }
+
+ PointAttributeList *getList(const std::string &name)
+ {
+ PointAttributeList *list = NULL;
+
+ core::map<std::string, PointAttributeList*>::Node *n;
+ n = m_lists.find(name);
+
+ if(n == NULL)
+ {
+ list = new PointAttributeList();
+ m_lists.insert(name, list);
+ }
+ else
+ {
+ list = n->getValue();
+ }
+
+ return list;
+ }
+private:
+ core::map<std::string, PointAttributeList*> m_lists;
+};
+
+/*
+ Miscellaneous functions
+*/
+
+bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir, f32 range);
+
+
#endif
projects / minetest.git / blobdiff