615 changes: 348 additions & 267 deletions src/minimap.cpp
View file
Open in desktop

Large diffs are not rendered by default.

142 changes: 63 additions & 79 deletions src/minimap.h
View file
Open in desktop
Original file line number Original file line Diff line number Diff line change
Expand Up @@ -20,14 +20,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#ifndef MINIMAP_HEADER #ifndef MINIMAP_HEADER
#define MINIMAP_HEADER #define MINIMAP_HEADER


#include <map>
#include <string>
#include <vector>
#include "irrlichttypes_extrabloated.h" #include "irrlichttypes_extrabloated.h"
#include "client.h" #include "client.h"
#include "voxel.h" #include "voxel.h"
#include "jthread/jmutex.h" #include "jthread/jmutex.h"
#include "jthread/jsemaphore.h" #include "jthread/jsemaphore.h"
#include <map>
#include <string> #define MINIMAP_MAX_SX 512
#include <vector> #define MINIMAP_MAX_SY 512


enum MinimapMode { enum MinimapMode {
MINIMAP_MODE_OFF, MINIMAP_MODE_OFF,
Expand All @@ -36,31 +39,37 @@ enum MinimapMode {
MINIMAP_MODE_SURFACEx4, MINIMAP_MODE_SURFACEx4,
MINIMAP_MODE_RADARx1, MINIMAP_MODE_RADARx1,
MINIMAP_MODE_RADARx2, MINIMAP_MODE_RADARx2,
MINIMAP_MODE_RADARx4 MINIMAP_MODE_RADARx4,
MINIMAP_MODE_COUNT,
}; };


struct MinimapPixel struct MinimapModeDef {
{ bool is_radar;
u16 scan_height;
u16 map_size;
};

struct MinimapPixel {
u16 id; u16 id;
u16 height; u16 height;
u16 air_count; u16 air_count;
u16 light; u16 light;
}; };


struct MinimapMapblock struct MinimapMapblock {
{ void getMinimapNodes(VoxelManipulator *vmanip, v3s16 pos);

MinimapPixel data[MAP_BLOCKSIZE * MAP_BLOCKSIZE]; MinimapPixel data[MAP_BLOCKSIZE * MAP_BLOCKSIZE];
}; };


struct MinimapData struct MinimapData {
{ bool is_radar;
bool radar;
MinimapMode mode; MinimapMode mode;
v3s16 pos; v3s16 pos;
v3s16 old_pos; v3s16 old_pos;
u16 scan_height; u16 scan_height;
u16 map_size; u16 map_size;
MinimapPixel minimap_scan[512 * 512]; MinimapPixel minimap_scan[MINIMAP_MAX_SX * MINIMAP_MAX_SY];
bool map_invalidated; bool map_invalidated;
bool minimap_shape_round; bool minimap_shape_round;
video::IImage *minimap_image; video::IImage *minimap_image;
Expand All @@ -74,104 +83,79 @@ struct MinimapData
video::ITexture *player_marker; video::ITexture *player_marker;
}; };


struct QueuedMinimapUpdate struct QueuedMinimapUpdate {
{
v3s16 pos; v3s16 pos;
MinimapMapblock *data; MinimapMapblock *data;

QueuedMinimapUpdate();
~QueuedMinimapUpdate();
}; };


/* class MinimapUpdateThread : public UpdateThread {
A thread-safe queue of minimap mapblocks update tasks
*/

class MinimapUpdateQueue
{
public: public:
MinimapUpdateQueue(); virtual ~MinimapUpdateThread();

~MinimapUpdateQueue();


bool addBlock(v3s16 pos, MinimapMapblock *data); void getMap(v3s16 pos, s16 size, s16 height, bool radar);
MinimapPixel *getMinimapPixel(v3s16 pos, s16 height, s16 *pixel_height);
s16 getAirCount(v3s16 pos, s16 height);
video::SColor getColorFromId(u16 id);


QueuedMinimapUpdate *pop(); void enqueueBlock(v3s16 pos, MinimapMapblock *data);


u32 size() bool pushBlockUpdate(v3s16 pos, MinimapMapblock *data);
{ bool popBlockUpdate(QueuedMinimapUpdate *update);
JMutexAutoLock lock(m_mutex);
return m_queue.size();
}

private:
std::list<QueuedMinimapUpdate*> m_queue;
JMutex m_mutex;
};


class MinimapUpdateThread : public UpdateThread MinimapData *data;
{
private:
MinimapUpdateQueue m_queue;
std::map<v3s16, MinimapMapblock *> m_blocks_cache;


protected: protected:
const char *getName() const char *getName()
{ return "MinimapUpdateThread"; }
virtual void doUpdate();

public:
MinimapUpdateThread(IrrlichtDevice *device, Client *client)
{ {
this->device = device; return "MinimapUpdateThread";
this->client = client;
this->driver = device->getVideoDriver();
this->tsrc = client->getTextureSource();
} }
~MinimapUpdateThread();
void getMap (v3s16 pos, s16 size, s16 height, bool radar);
MinimapPixel *getMinimapPixel (v3s16 pos, s16 height, s16 &pixel_height);
s16 getAirCount (v3s16 pos, s16 height);
video::SColor getColorFromId(u16 id);


void enqueue_Block(v3s16 pos, MinimapMapblock *data); virtual void doUpdate();
IrrlichtDevice *device;
Client *client;
video::IVideoDriver *driver;
ITextureSource *tsrc;
MinimapData *data;
};


class Mapper
{
private: private:
MinimapUpdateThread *m_minimap_update_thread; JMutex m_queue_mutex;
video::ITexture *minimap_texture; std::deque<QueuedMinimapUpdate> m_update_queue;
scene::SMeshBuffer *m_meshbuffer; std::map<v3s16, MinimapMapblock *> m_blocks_cache;
bool m_enable_shaders; };
u16 m_surface_mode_scan_height;
JMutex m_mutex;


class Mapper {
public: public:
Mapper(IrrlichtDevice *device, Client *client); Mapper(IrrlichtDevice *device, Client *client);
~Mapper(); ~Mapper();


void addBlock(v3s16 pos, MinimapMapblock *data); void addBlock(v3s16 pos, MinimapMapblock *data);
void setPos(v3s16 pos);
video::ITexture* getMinimapTexture();
v3f getYawVec(); v3f getYawVec();
MinimapMode getMinimapMode(); MinimapMode getMinimapMode();

void setPos(v3s16 pos);
void setAngle(f32 angle);
void setMinimapMode(MinimapMode mode); void setMinimapMode(MinimapMode mode);
void toggleMinimapShape(); void toggleMinimapShape();


video::ITexture *getMinimapTexture();

void blitMinimapPixelsToImageRadar(video::IImage *map_image);
void blitMinimapPixelsToImageSurface(video::IImage *map_image,
video::IImage *heightmap_image);

scene::SMeshBuffer *getMinimapMeshBuffer(); scene::SMeshBuffer *getMinimapMeshBuffer();
void drawMinimap(); void drawMinimap();
IrrlichtDevice *device;
Client *client;
video::IVideoDriver *driver; video::IVideoDriver *driver;
LocalPlayer *player;
ITextureSource *tsrc;
IShaderSource *shdrsrc;
MinimapData *data; MinimapData *data;

private:
ITextureSource *m_tsrc;
IShaderSource *m_shdrsrc;
INodeDefManager *m_ndef;
MinimapUpdateThread *m_minimap_update_thread;
scene::SMeshBuffer *m_meshbuffer;
bool m_enable_shaders;
u16 m_surface_mode_scan_height;
f32 m_angle;
JMutex m_mutex;
}; };


#endif #endif