LocalPlayer::accelerateHorizontal: cleanups

[oweals/minetest.git] / src / minimap.h

diff --git a/src/minimap.h b/src/minimap.h
index edb491717e13591ff9e738351270ac8d2610efea..01eafbe595070ba5b3278b57c7dd041ee709a4d3 100644 (file)
--- a/src/minimap.h
+++ b/src/minimap.h
@@ -20,18 +20,19 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #ifndef MINIMAP_HEADER
 #define MINIMAP_HEADER
 
-#include <map>
-#include <string>
-#include <vector>
 #include "irrlichttypes_extrabloated.h"
 #include "client.h"
 #include "voxel.h"
-#include "jthread/jmutex.h"
-#include "jthread/jsemaphore.h"
+#include "threading/semaphore.h"
+#include <map>
+#include <string>
+#include <vector>
+#include "camera.h"
 
 #define MINIMAP_MAX_SX 512
 #define MINIMAP_MAX_SY 512
 
+
 enum MinimapMode {
        MINIMAP_MODE_OFF,
        MINIMAP_MODE_SURFACEx1,
@@ -43,6 +44,11 @@ enum MinimapMode {
        MINIMAP_MODE_COUNT,
 };
 
+enum MinimapShape {
+       MINIMAP_SHAPE_SQUARE,
+       MINIMAP_SHAPE_ROUND,
+};
+
 struct MinimapModeDef {
        bool is_radar;
        u16 scan_height;
@@ -50,14 +56,14 @@ struct MinimapModeDef {
 };
 
 struct MinimapPixel {
-       u16 id;
+       //! The topmost node that the minimap displays.
+       MapNode n;
        u16 height;
        u16 air_count;
-       u16 light;
 };
 
 struct MinimapMapblock {
-       void getMinimapNodes(VoxelManipulator *vmanip, v3s16 pos);
+       void getMinimapNodes(VoxelManipulator *vmanip, const v3s16 &pos);
 
        MinimapPixel data[MAP_BLOCKSIZE * MAP_BLOCKSIZE];
 };
@@ -72,66 +78,60 @@ struct MinimapData {
        MinimapPixel minimap_scan[MINIMAP_MAX_SX * MINIMAP_MAX_SY];
        bool map_invalidated;
        bool minimap_shape_round;
-       video::IImage *minimap_image;
-       video::IImage *heightmap_image;
-       video::IImage *minimap_mask_round;
-       video::IImage *minimap_mask_square;
-       video::ITexture *texture;
-       video::ITexture *heightmap_texture;
-       video::ITexture *minimap_overlay_round;
-       video::ITexture *minimap_overlay_square;
-       video::ITexture *player_marker;
+       video::IImage *minimap_mask_round = nullptr;
+       video::IImage *minimap_mask_square = nullptr;
+       video::ITexture *texture = nullptr;
+       video::ITexture *heightmap_texture = nullptr;
+       video::ITexture *minimap_overlay_round = nullptr;
+       video::ITexture *minimap_overlay_square = nullptr;
+       video::ITexture *player_marker = nullptr;
+       video::ITexture *object_marker_red = nullptr;
 };
 
 struct QueuedMinimapUpdate {
        v3s16 pos;
-       MinimapMapblock *data;
+       MinimapMapblock *data = nullptr;
 };
 
 class MinimapUpdateThread : public UpdateThread {
 public:
+       MinimapUpdateThread() : UpdateThread("Minimap") {}
        virtual ~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 getMap(v3s16 pos, s16 size, s16 height);
        void enqueueBlock(v3s16 pos, MinimapMapblock *data);
-
        bool pushBlockUpdate(v3s16 pos, MinimapMapblock *data);
        bool popBlockUpdate(QueuedMinimapUpdate *update);
 
-       MinimapData *data;
+       MinimapData *data = nullptr;
 
 protected:
-       const char *getName()
-       {
-               return "MinimapUpdateThread";
-       }
-
        virtual void doUpdate();
 
 private:
-       JMutex m_queue_mutex;
+       std::mutex m_queue_mutex;
        std::deque<QueuedMinimapUpdate> m_update_queue;
        std::map<v3s16, MinimapMapblock *> m_blocks_cache;
 };
 
-class Mapper {
+class Minimap {
 public:
-       Mapper(IrrlichtDevice *device, Client *client);
-       ~Mapper();
+       Minimap(Client *client);
+       ~Minimap();
 
        void addBlock(v3s16 pos, MinimapMapblock *data);
 
        v3f getYawVec();
-       MinimapMode getMinimapMode();
 
        void setPos(v3s16 pos);
+       v3s16 getPos() const { return data->pos; }
        void setAngle(f32 angle);
+       f32 getAngle() const { return m_angle; }
        void setMinimapMode(MinimapMode mode);
+       MinimapMode getMinimapMode() const { return data->mode; }
        void toggleMinimapShape();
+       void setMinimapShape(MinimapShape shape);
+       MinimapShape getMinimapShape();
 
 
        video::ITexture *getMinimapTexture();
@@ -141,9 +141,12 @@ public:
                video::IImage *heightmap_image);
 
        scene::SMeshBuffer *getMinimapMeshBuffer();
+
+       void updateActiveMarkers();
        void drawMinimap();
 
        video::IVideoDriver *driver;
+       Client* client;
        MinimapData *data;
 
 private:
@@ -155,7 +158,8 @@ private:
        bool m_enable_shaders;
        u16 m_surface_mode_scan_height;
        f32 m_angle;
-       JMutex m_mutex;
+       std::mutex m_mutex;
+       std::list<v2f> m_active_markers;
 };
 
 #endif