Merge branch 'dev' into generated-pcm-stream

doc/en/scripting/builtins/libplayer.md

@@ -142,3 +142,21 @@ player.get_entity(playerid: int) -> int
 ```
 
 Returns unique identifier of the player entity
+
+```lua
+player.get_all_in_radius(center: vec3, radius: number) -> table<int>
+```
+
+Returns an array of player IDs within a sphere with center `center` and radius `radius`.
+
+```lua
+player.get_all() -> table<int>
+```
+
+Returns an array of all active player IDs.
+
+```lua
+player.get_nearest(position: vec3) -> int
+```
+
+Returns the ID of the player closest to the specified position, or nil if there are no players.

doc/ru/scripting/builtins/libplayer.md

@@ -142,3 +142,21 @@ player.get_entity(playerid: int) -> int
 ```
 
 Возвращает уникальный идентификатор сущности игрока
+
+```lua
+player.get_all_in_radius(center: vec3, radius: number) -> table<int>
+```
+
+Возвращает массив id игроков в пределах сферы с центром `center` и радиусом `radius`.
+
+```lua
+player.get_all() -> table<int>
+```
+
+Возвращает массив id всех активных игроков.
+
+```lua
+player.get_nearest(position: vec3) -> int
+```
+
+Возвращает id ближайшего к указанной позиции игрока, либо nil если игроков нет.

doc/ru/vcm.md

@@ -42,6 +42,8 @@
 
 - `from` - точка начала примитива. Пример: `from (0,0,0)`
 - `to` - противоположная от начала точка. Пример: `to (1,1,1)`
+- `origin` - точка, относительно которой будет применено вращение. По-умолчанию: центр примитива. Пример: `origin (0.5,0.5,0.5)`
+- `rotate` - вращение вокруг осей (x,y,z) в градусах, или кватернион (x,y,z,w). Пример: `rotate (45,0,0)` или `rotate (0.3826834, 0, 0, 0.9238795)`
 - `texture` - отображаемая текстура для всех сторон по-умолчанию.
 - `shading` определяет возможность затенения на примитиве. Пример: `shading off`
 - `delete` удаляет стороны по именам (top, bottom, east, west, north, south)

src/coders/vcm.cpp

@@ -1,6 +1,8 @@
 #include "vcm.hpp"
 
-#include <iostream>
+#include <algorithm>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/matrix_transform.hpp>
 
 #include "xml.hpp"
 #include "util/stringutil.hpp"
@@ -73,6 +75,29 @@ static void perform_box(const xmlelement& root, model::Model& model) {
     auto from = root.attr("from").asVec3();
     auto to = root.attr("to").asVec3();
 
+    glm::vec3 origin = (from + to) * 0.5f;
+    if (root.has("origin")) {
+        origin = root.attr("origin").asVec3();
+    }
+
+    glm::mat4 tsf(1.0f);
+    from -= origin;
+    to -= origin;
+    tsf = glm::translate(tsf, origin);
+
+    if (root.has("rotate")) {
+        auto text = root.attr("rotate").getText();
+        if (std::count(text.begin(), text.end(), ',') == 3) {
+            auto quat = root.attr("rotate").asVec4();
+            tsf *= glm::mat4_cast(glm::quat(quat.w, quat.x, quat.y, quat.z));
+        } else {
+            auto rot = root.attr("rotate").asVec3();
+            tsf = glm::rotate(tsf, glm::radians(rot.x), glm::vec3(1, 0, 0));
+            tsf = glm::rotate(tsf, glm::radians(rot.y), glm::vec3(0, 1, 0));
+            tsf = glm::rotate(tsf, glm::radians(rot.z), glm::vec3(0, 0, 1));
+        }
+    }
+
     UVRegion regions[6] {};
     regions[0].scale(to.x - from.x, to.y - from.y);
     regions[1].scale(from.x - to.x, to.y - from.y);
@@ -142,7 +167,7 @@ static void perform_box(const xmlelement& root, model::Model& model) {
         bool enabled[6] {};
         enabled[i] = true;
         auto& mesh = model.addMesh(texfaces[i], shading);
-        mesh.addBox(center, halfsize, regions, enabled);
+        mesh.addBox(center, halfsize, regions, enabled, tsf);
     }
 }
 

src/graphics/commons/Model.cpp

@@ -8,21 +8,6 @@ inline constexpr glm::vec3 X(1, 0, 0);
 inline constexpr glm::vec3 Y(0, 1, 0);
 inline constexpr glm::vec3 Z(0, 0, 1);
 
-void Mesh::addPlane(
-    const glm::vec3& pos,
-    const glm::vec3& right,
-    const glm::vec3& up,
-    const glm::vec3& norm
-) {
-    vertices.push_back({pos-right-up, {0,0}, norm});
-    vertices.push_back({pos+right-up, {1,0}, norm});
-    vertices.push_back({pos+right+up, {1,1}, norm});
-
-    vertices.push_back({pos-right-up, {0,0}, norm});
-    vertices.push_back({pos+right+up, {1,1}, norm});
-    vertices.push_back({pos-right+up, {0,1}, norm});
-}
-
 void Mesh::addPlane(
     const glm::vec3& pos,
     const glm::vec3& right,
@@ -39,6 +24,23 @@ void Mesh::addPlane(
     vertices.push_back({pos-right+up, {uv.u1, uv.v2}, norm});
 }
 
+void Mesh::addPlane(
+    const glm::vec3& pos,
+    const glm::vec3& right,
+    const glm::vec3& up,
+    const glm::vec3& norm,
+    const UVRegion& region,
+    const glm::mat4& transform
+) {
+    addPlane(
+        glm::vec3(transform * glm::vec4(pos, 1.0f)),
+        glm::vec3(transform * glm::vec4(right, 0.0f)),
+        glm::vec3(transform * glm::vec4(up, 0.0f)),
+        glm::normalize(glm::vec3(transform * glm::vec4(norm, 0.0f))),
+        region
+    );
+}
+
 void Mesh::addRect(
     const glm::vec3& pos,
     const glm::vec3& right,
@@ -56,14 +58,15 @@ void Mesh::addRect(
 }
 
 void Mesh::addBox(const glm::vec3& pos, const glm::vec3& size) {
-    addPlane(pos+Z*size, X*size, Y*size, Z);
-    addPlane(pos-Z*size, -X*size, Y*size, -Z);
+    UVRegion fullRegion (0, 0, 1, 1);
+    addPlane(pos+Z*size, X*size, Y*size, Z, fullRegion);
+    addPlane(pos-Z*size, -X*size, Y*size, -Z, fullRegion);
 
-    addPlane(pos+Y*size, X*size, -Z*size, Y);
-    addPlane(pos-Y*size, X*size, Z*size, -Y);
+    addPlane(pos+Y*size, X*size, -Z*size, Y, fullRegion);
+    addPlane(pos-Y*size, X*size, Z*size, -Y, fullRegion);
 
-    addPlane(pos+X*size, -Z*size, Y*size, X);
-    addPlane(pos-X*size, Z*size, Y*size, -X);
+    addPlane(pos+X*size, -Z*size, Y*size, X, fullRegion);
+    addPlane(pos-X*size, Z*size, Y*size, -X, fullRegion);
 }
 
 void Mesh::addBox(
@@ -71,19 +74,29 @@ void Mesh::addBox(
     const glm::vec3& size,
     const UVRegion (&uvs)[6],
     const bool enabledSides[6]
+) {
+    addBox(pos, size, uvs, enabledSides, glm::mat4(1.0f));
+}
+
+void Mesh::addBox(
+    const glm::vec3& pos,
+    const glm::vec3& size,
+    const UVRegion (&uvs)[6],
+    const bool enabledSides[6],
+    const glm::mat4& transform
 ) {
     if (enabledSides[0]) // north
-        addPlane(pos+Z*size, X*size, Y*size, Z, uvs[0]);
+        addPlane(pos+Z*size, X*size, Y*size, Z, uvs[0], transform);
     if (enabledSides[1]) // south
-        addPlane(pos-Z*size, -X*size, Y*size, -Z, uvs[1]);
+        addPlane(pos-Z*size, -X*size, Y*size, -Z, uvs[1], transform);
     if (enabledSides[2]) // top
-        addPlane(pos+Y*size, X*size, -Z*size, Y, uvs[2] * glm::vec2(-1));
+        addPlane(pos+Y*size, X*size, -Z*size, Y, uvs[2] * glm::vec2(-1), transform);
     if (enabledSides[3]) // bottom
-        addPlane(pos-Y*size, X*size, Z*size, -Y, uvs[3] * glm::vec2(-1, 1));
+        addPlane(pos-Y*size, X*size, Z*size, -Y, uvs[3] * glm::vec2(-1, 1), transform);
     if (enabledSides[4]) // west
-        addPlane(pos+X*size, -Z*size, Y*size, X, uvs[4]);
+        addPlane(pos+X*size, -Z*size, Y*size, X, uvs[4], transform);
     if (enabledSides[5]) // east
-        addPlane(pos-X*size, Z*size, Y*size, -X, uvs[5] * glm::vec2(-1, 1));
+        addPlane(pos-X*size, Z*size, Y*size, -X, uvs[5] * glm::vec2(-1, 1), transform);
 }
 
 void Mesh::scale(const glm::vec3& size) {

src/graphics/commons/Model.hpp

@@ -22,14 +22,16 @@ namespace model {
             const glm::vec3& pos,
             const glm::vec3& right,
             const glm::vec3& up,
-            const glm::vec3& norm
+            const glm::vec3& norm,
+            const UVRegion& region
         );
         void addPlane(
             const glm::vec3& pos,
             const glm::vec3& right,
             const glm::vec3& up,
             const glm::vec3& norm,
-            const UVRegion& region
+            const UVRegion& region,
+            const glm::mat4& transform
         );
         void addRect(
             const glm::vec3& pos,
@@ -45,6 +47,13 @@ namespace model {
             const UVRegion (&texfaces)[6],
             const bool enabledSides[6]
         );
+        void addBox(
+            const glm::vec3& pos,
+            const glm::vec3& size,
+            const UVRegion (&texfaces)[6],
+            const bool enabledSides[6],
+            const glm::mat4& transform
+        );
         void scale(const glm::vec3& size);
     };
 

src/graphics/core/Shadows.cpp

@@ -1,8 +1,11 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/norm.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
 #include "Shadows.hpp"
 
 #include <GL/glew.h>
-#define GLM_ENABLE_EXPERIMENTAL
-#include <glm/gtx/norm.hpp>
 
 #include "assets/Assets.hpp"
 #include "graphics/core/DrawContext.hpp"

src/graphics/render/Emitter.cpp

@@ -1,6 +1,8 @@
 #include "Emitter.hpp"
 
 #include <glm/gtc/random.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/matrix_transform.hpp>
 #define GLM_ENABLE_EXPERIMENTAL
 #include <glm/gtx/norm.hpp>
 

src/logic/scripting/lua/libs/libplayer.cpp

@@ -322,6 +322,38 @@ static int l_set_suspended(lua::State* L) {
     return 0;
 }
 
+static int l_get_all_in_radius(lua::State* L) {
+    auto center = lua::tovec3(L, 1);
+    auto radius = static_cast<float>(lua::tonumber(L, 2));
+
+    auto players = level->players->getAllInRadius(center, radius);
+    lua::createtable(L, players.size(), 0);
+    for (size_t i = 0; i < players.size(); i++) {
+        lua::pushinteger(L, players[i]->getId());
+        lua::rawseti(L, i + 1);
+    }
+    return 1;
+}
+
+static int l_get_all(lua::State* L) {
+    auto players = level->players->getAll();
+    lua::createtable(L, players.size(), 0);
+    for (size_t i = 0; i < players.size(); i++) {
+        lua::pushinteger(L, players[i]->getId());
+        lua::rawseti(L, i + 1);
+    }
+    return 1;
+}
+
+static int l_get_nearest(lua::State* L) {
+    auto position = lua::tovec3(L, 1);
+    if (auto player = level->players->getNearest(position)) {
+        lua::pushinteger(L, player->getId());
+        return 1;
+    }
+    return 0;
+}
+
 const luaL_Reg playerlib[] = {
     {"get_pos", lua::wrap<l_get_pos>},
     {"set_pos", lua::wrap<l_set_pos>},
@@ -358,5 +390,8 @@ const luaL_Reg playerlib[] = {
     {"set_name", lua::wrap<l_set_name>},
     {"create", lua::wrap<l_create>},
     {"delete", lua::wrap<l_delete>},
+    {"get_all_in_radius", lua::wrap<l_get_all_in_radius>},
+    {"get_all", lua::wrap<l_get_all>},
+    {"get_nearest", lua::wrap<l_get_nearest>},
     {nullptr, nullptr}
 };

src/objects/Players.cpp

@@ -1,5 +1,8 @@
 #include "Players.hpp"
 
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/norm.hpp>
+
 #include "Player.hpp"
 #include "items/Inventories.hpp"
 #include "world/Level.hpp"
@@ -20,6 +23,48 @@ Player* Players::get(int64_t id) const {
     return found->second.get();
 }
 
+std::vector<Player*> Players::getAllInRadius(
+    const glm::vec3& center, float radius
+) const {
+    std::vector<Player*> foundPlayers;
+
+    for (const auto& pair : players) {
+        auto player = pair.second.get();
+        auto relativePos = player->getPosition() - center;
+        if (!player->isSuspended() && glm::length2(relativePos) <= radius) {
+            foundPlayers.emplace_back(player);
+        }
+    }
+    return foundPlayers;
+}
+
+std::vector<Player*> Players::getAll() const {
+    std::vector<Player*> allPlayers;
+    allPlayers.reserve(players.size());
+    for (const auto& pair : players) {
+        allPlayers.emplace_back(pair.second.get());
+    }
+    return allPlayers;
+}
+
+Player* Players::getNearest(const glm::vec3& position) const {
+    Player* nearest = nullptr;
+    float nearestDist2 = std::numeric_limits<float>::max();
+    for (const auto& pair : players) {
+        auto player = pair.second.get();
+        if (player->isSuspended()) {
+            continue;
+        }
+        auto relativePos = player->getPosition() - position;
+        auto dist2 = glm::length2(relativePos);
+        if (dist2 < nearestDist2) {
+            nearestDist2 = dist2;
+            nearest = player;
+        }
+    }
+    return nearest;
+}
+
 Player* Players::create(int64_t id) {
     int64_t& nextPlayerID = level.getWorld()->getInfo().nextPlayerId;
     if (id == NONE) {

src/objects/Players.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <memory>
+#include <vector>
 #include <unordered_map>
+#include <glm/vec3.hpp>
 
 #include "typedefs.hpp"
 #include "interfaces/Serializable.hpp"
@@ -34,6 +36,10 @@ public:
 
     void remove(int64_t id);
 
+    std::vector<Player*> getAllInRadius(const glm::vec3& center, float radius) const;
+    std::vector<Player*> getAll() const;
+    Player* getNearest(const glm::vec3& position) const;
+
     dv::value serialize() const override;
 
     void deserialize(const dv::value& src) override;

src/objects/Transform.cpp

@@ -2,6 +2,8 @@
 
 #include "data/dv_util.hpp"
 
+#include <glm/gtc/matrix_transform.hpp>
+
 void Transform::refresh() {
     combined = glm::mat4(1.0f);
     combined = glm::translate(combined, pos);