LocalPlayer::accelerateHorizontal: cleanups

[oweals/minetest.git] / src / clientmap.cpp

diff --git a/src/clientmap.cpp b/src/clientmap.cpp
index 5e88cab45556643db96126272779ef876e6a7156..c443773b66461beaf7391066193001e97c295e1f 100644 (file)
--- a/src/clientmap.cpp
+++ b/src/clientmap.cpp
@@ -31,16 +31,16 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "camera.h"               // CameraModes
 #include "util/basic_macros.h"
 #include <algorithm>
+#include "client/renderingengine.h"
 
 ClientMap::ClientMap(
                Client *client,
                MapDrawControl &control,
-               scene::ISceneNode* parent,
-               scene::ISceneManager* mgr,
                s32 id
 ):
        Map(dout_client, client),
-       scene::ISceneNode(parent, mgr, id),
+       scene::ISceneNode(RenderingEngine::get_scene_manager()->getRootSceneNode(),
+               RenderingEngine::get_scene_manager(), id),
        m_client(client),
        m_control(control),
        m_camera_position(0,0,0),
@@ -283,49 +283,45 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
 
 struct MeshBufList
 {
-       /*!
-        * Specifies in which layer the list is.
-        * All lists which are in a lower layer are rendered before this list.
-        */
-       u8 layer;
        video::SMaterial m;
        std::vector<scene::IMeshBuffer*> bufs;
 };
 
 struct MeshBufListList
 {
-       std::vector<MeshBufList> lists;
+       /*!
+        * Stores the mesh buffers of the world.
+        * The array index is the material's layer.
+        * The vector part groups vertices by material.
+        */
+       std::vector<MeshBufList> lists[MAX_TILE_LAYERS];
 
        void clear()
        {
-               lists.clear();
+               for (int l = 0; l < MAX_TILE_LAYERS; l++)
+                       lists[l].clear();
        }
 
        void add(scene::IMeshBuffer *buf, u8 layer)
        {
+               // Append to the correct layer
+               std::vector<MeshBufList> &list = lists[layer];
                const video::SMaterial &m = buf->getMaterial();
-               for(std::vector<MeshBufList>::iterator i = lists.begin();
-                               i != lists.end(); ++i){
-                       MeshBufList &l = *i;
-
+               for (MeshBufList &l : list) {
                        // comparing a full material is quite expensive so we don't do it if
                        // not even first texture is equal
                        if (l.m.TextureLayer[0].Texture != m.TextureLayer[0].Texture)
                                continue;
 
-                       if(l.layer != layer)
-                               continue;
-
                        if (l.m == m) {
                                l.bufs.push_back(buf);
                                return;
                        }
                }
                MeshBufList l;
-               l.layer = layer;
                l.m = m;
                l.bufs.push_back(buf);
-               lists.push_back(l);
+               list.push_back(l);
        }
 };
 
@@ -353,7 +349,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
                Measuring time is very useful for long delays when the
                machine is swapping a lot.
        */
-       int time1 = time(0);
+       std::time_t time1 = time(0);
 
        /*
                Get animation parameters
@@ -469,35 +465,32 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
                }
        }
 
-       std::vector<MeshBufList> &lists = drawbufs.lists;
-
-       int timecheck_counter = 0;
-       for (std::vector<MeshBufList>::iterator i = lists.begin();
-                       i != lists.end(); ++i) {
-               timecheck_counter++;
-               if (timecheck_counter > 50) {
-                       timecheck_counter = 0;
-                       int time2 = time(0);
-                       if (time2 > time1 + 4) {
-                               infostream << "ClientMap::renderMap(): "
-                                       "Rendering takes ages, returning."
-                                       << std::endl;
-                               return;
+       // Render all layers in order
+       for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
+               std::vector<MeshBufList> &lists = drawbufs.lists[layer];
+
+               int timecheck_counter = 0;
+               for (MeshBufList &list : lists) {
+                       timecheck_counter++;
+                       if (timecheck_counter > 50) {
+                               timecheck_counter = 0;
+                               std::time_t time2 = time(0);
+                               if (time2 > time1 + 4) {
+                                       infostream << "ClientMap::renderMap(): "
+                                               "Rendering takes ages, returning."
+                                               << std::endl;
+                                       return;
+                               }
                        }
-               }
 
-               MeshBufList &list = *i;
+                       driver->setMaterial(list.m);
 
-               driver->setMaterial(list.m);
-
-               for (std::vector<scene::IMeshBuffer*>::iterator j = list.bufs.begin();
-                               j != list.bufs.end(); ++j) {
-                       scene::IMeshBuffer *buf = *j;
-                       driver->drawMeshBuffer(buf);
-                       vertex_count += buf->getVertexCount();
-                       meshbuffer_count++;
+                       for (scene::IMeshBuffer *buf : list.bufs) {
+                               driver->drawMeshBuffer(buf);
+                               vertex_count += buf->getVertexCount();
+                               meshbuffer_count++;
+                       }
                }
-
        }
        } // ScopeProfiler
 
@@ -603,11 +596,12 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
        };
        if(z_directions[0].X < -99){
                for(u32 i=0; i<sizeof(z_directions)/sizeof(*z_directions); i++){
+                       // Assumes FOV of 72 and 16/9 aspect ratio
                        z_directions[i] = v3f(
-                               0.01 * myrand_range(-100, 100),
+                               0.02 * myrand_range(-100, 100),
                                1.0,
                                0.01 * myrand_range(-100, 100)
-                       );
+                       ).normalize();
                        z_offsets[i] = 0.01 * myrand_range(0,100);
                }
        }
@@ -620,7 +614,6 @@ int ClientMap::getBackgroundBrightness(float max_d, u32 daylight_factor,
        std::vector<int> values;
        for(u32 i=0; i<sizeof(z_directions)/sizeof(*z_directions); i++){
                v3f z_dir = z_directions[i];
-               z_dir.normalize();
                core::CMatrix4<f32> a;
                a.buildRotateFromTo(v3f(0,1,0), z_dir);
                v3f dir = m_camera_direction;