Merge branch 'main' of https://github.com/Xertis/VoxelEngine-Cpp

.github/workflows/windows.yml

@@ -0,0 +1,48 @@
+name: Windows Build
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build-windows:
+
+    strategy:
+      matrix:
+        include:
+          - os: windows-latest
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'true'
+
+      - name: Set up vcpkg
+        run: |
+          git clone https://github.com/microsoft/vcpkg.git
+          cd vcpkg
+          .\bootstrap-vcpkg.bat
+          .\vcpkg integrate install
+          cd ..
+      - name: Configure and build project with CMake and vcpkg
+        run: |
+          mkdir build
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_WINDOWS_VCPKG=ON ..
+          Remove-Item -Path CMakeFiles -Recurse -Force
+          cmake -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_WINDOWS_VCPKG=ON ..
+          cmake --build . --config Release
+      - name: Package for Windows
+        run: |
+          mkdir packaged
+          cp -r build/* packaged/
+        working-directory: ${{ github.workspace }}
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: Windows-Build
+          path: 'packaged/Release/*'

src/engine.cpp

@@ -58,7 +58,7 @@ inline void create_channel(Engine* engine, std::string name, NumberSetting& sett
     }
     engine->keepAlive(setting.observe([=](auto value) {
         audio::get_channel(name)->setVolume(value*value);
-    }));
+    }, true));
 }
 
 Engine::Engine(EngineSettings& settings, SettingsHandler& settingsHandler, EnginePaths* paths) 

src/graphics/core/Batch2D.cpp

@@ -13,19 +13,18 @@ Batch2D::Batch2D(size_t capacity) : capacity(capacity), color(1.0f){
         {2}, {2}, {4}, {0}
     };
 
-    buffer = new float[capacity * B2D_VERTEX_SIZE];
+    buffer = std::make_unique<float[]>(capacity * B2D_VERTEX_SIZE);
-    mesh = std::make_unique<Mesh>(buffer, 0, attrs);
+    mesh = std::make_unique<Mesh>(buffer.get(), 0, attrs);
     index = 0;
 
     ubyte pixels[] = {
         0xFF, 0xFF, 0xFF, 0xFF
     };
     blank = std::make_unique<Texture>(pixels, 1, 1, ImageFormat::rgba8888);
-    _texture = nullptr;
+    currentTexture = nullptr;
 }
 
 Batch2D::~Batch2D(){
-    delete[] buffer;
 }
 
 void Batch2D::setPrimitive(DrawPrimitive primitive) {
@@ -37,7 +36,7 @@ void Batch2D::setPrimitive(DrawPrimitive primitive) {
 }
 
 void Batch2D::begin(){
-    _texture = nullptr;
+    currentTexture = nullptr;
     blank->bind();
     color = glm::vec4(1.0f);
     primitive = DrawPrimitive::triangle;
@@ -73,14 +72,16 @@ void Batch2D::vertex(
 }
 
 void Batch2D::texture(Texture* new_texture){
-    if (_texture == new_texture)
+    if (currentTexture == new_texture) {
         return;
+    }
     flush();
-    _texture = new_texture;
+    currentTexture = new_texture;
-    if (new_texture == nullptr)
+    if (new_texture == nullptr) {
         blank->bind();
-    else
+    } else {
         new_texture->bind();
+    }
 }
 
 void Batch2D::untexture() {
@@ -327,7 +328,7 @@ void Batch2D::sprite(float x, float y, float w, float h, int atlasRes, int index
 void Batch2D::flush() {
     if (index == 0)
         return;
-    mesh->reload(buffer, index / B2D_VERTEX_SIZE);
+    mesh->reload(buffer.get(), index / B2D_VERTEX_SIZE);
     mesh->draw(gl::to_glenum(primitive));
     index = 0;
 }

src/graphics/core/Batch2D.hpp

@@ -12,13 +12,13 @@ class Texture;
 struct UVRegion;
 
 class Batch2D {
-    float* buffer;
+    std::unique_ptr<float[]> buffer;
     size_t capacity;
     std::unique_ptr<Mesh> mesh;
     std::unique_ptr<Texture> blank;
     size_t index;
     glm::vec4 color;
-    Texture* _texture;
+    Texture* currentTexture;
     DrawPrimitive primitive = DrawPrimitive::triangle;
 
     void setPrimitive(DrawPrimitive primitive);

src/graphics/core/Batch3D.cpp

@@ -14,28 +14,29 @@ Batch3D::Batch3D(size_t capacity)
         {3}, {2}, {4}, {0}
     };
 
-    buffer = new float[capacity * B3D_VERTEX_SIZE];
+    buffer = std::make_unique<float[]>(capacity * B3D_VERTEX_SIZE);
-    mesh = std::make_unique<Mesh>(buffer, 0, attrs);
+    mesh = std::make_unique<Mesh>(buffer.get(), 0, attrs);
     index = 0;
 
     ubyte pixels[] = {
         255, 255, 255, 255,
     };
     blank = std::make_unique<Texture>(pixels, 1, 1, ImageFormat::rgba8888);
-    _texture = nullptr;
+    currentTexture = nullptr;
 }
 
 Batch3D::~Batch3D(){
-    delete[] buffer;
 }
 
 void Batch3D::begin(){
-    _texture = nullptr;
+    currentTexture = nullptr;
     blank->bind();
 }
 
-void Batch3D::vertex(float x, float y, float z, float u, float v,
+void Batch3D::vertex(
-                     float r, float g, float b, float a) {
+    float x, float y, float z, float u, float v,
+    float r, float g, float b, float a
+) {
     buffer[index++] = x;
     buffer[index++] = y;
     buffer[index++] = z;
@@ -46,8 +47,10 @@ void Batch3D::vertex(float x, float y, float z, float u, float v,
     buffer[index++] = b;
     buffer[index++] = a;
 }
-void Batch3D::vertex(glm::vec3 coord, float u, float v,
+void Batch3D::vertex(
-                     float r, float g, float b, float a) {
+    glm::vec3 coord, float u, float v,
+    float r, float g, float b, float a
+) {
     buffer[index++] = coord.x;
     buffer[index++] = coord.y;
     buffer[index++] = coord.z;
@@ -58,9 +61,11 @@ void Batch3D::vertex(glm::vec3 coord, float u, float v,
     buffer[index++] = b;
     buffer[index++] = a;
 }
-void Batch3D::vertex(glm::vec3 point,
+void Batch3D::vertex(
-                     glm::vec2 uvpoint,
+    glm::vec3 point,
-                     float r, float g, float b, float a) {
+    glm::vec2 uvpoint,
+    float r, float g, float b, float a
+) {
     buffer[index++] = point.x;
     buffer[index++] = point.y;
     buffer[index++] = point.z;
@@ -99,10 +104,10 @@ void Batch3D::face(
 }
 
 void Batch3D::texture(Texture* new_texture){
-    if (_texture == new_texture)
+    if (currentTexture == new_texture)
         return;
     flush();
-    _texture = new_texture;
+    currentTexture = new_texture;
     if (new_texture == nullptr)
         blank->bind();
     else
@@ -166,7 +171,9 @@ inline glm::vec4 do_tint(float value) {
     return glm::vec4(value, value, value, 1.0f);
 }
 
-void Batch3D::xSprite(float w, float h, const UVRegion& uv, const glm::vec4 tint, bool shading) {
+void Batch3D::xSprite(
+    float w, float h, const UVRegion& uv, const glm::vec4 tint, bool shading
+) {
     face(
         glm::vec3(-w * 0.25f, 0.0f, -w * 0.25f), 
         w, h, 
@@ -244,13 +251,13 @@ void Batch3D::point(glm::vec3 coord, glm::vec4 tint) {
 }
 
 void Batch3D::flush() {
-    mesh->reload(buffer, index / B3D_VERTEX_SIZE);
+    mesh->reload(buffer.get(), index / B3D_VERTEX_SIZE);
     mesh->draw();
     index = 0;
 }
 
 void Batch3D::flushPoints() {
-    mesh->reload(buffer, index / B3D_VERTEX_SIZE);
+    mesh->reload(buffer.get(), index / B3D_VERTEX_SIZE);
     mesh->draw(GL_POINTS);
     index = 0;
 }

src/graphics/core/Batch3D.hpp

@@ -12,28 +12,35 @@ class Mesh;
 class Texture;
 
 class Batch3D {
-    float* buffer;
+    std::unique_ptr<float[]> buffer;
     size_t capacity;
     std::unique_ptr<Mesh> mesh;
     std::unique_ptr<Texture> blank;
     size_t index;
     
-    Texture* _texture;
+    Texture* currentTexture;
 
-    void vertex(float x, float y, float z,
+    void vertex(
-                float u, float v,
+        float x, float y, float z,
-                float r, float g, float b, float a);
+        float u, float v,
-    void vertex(glm::vec3 coord,
+        float r, float g, float b, float a
-            float u, float v,
+    );
-            float r, float g, float b, float a);
+    void vertex(
-    void vertex(glm::vec3 point, glm::vec2 uvpoint,
+        glm::vec3 coord,
-                float r, float g, float b, float a);
+        float u, float v,
-
+        float r, float g, float b, float a
-    void face(const glm::vec3& coord, float w, float h,
+    );
+    void vertex(
+        glm::vec3 point, glm::vec2 uvpoint,
+        float r, float g, float b, float a
+    );
+    void face(
+        const glm::vec3& coord, float w, float h,
         const glm::vec3& axisX,
         const glm::vec3& axisY,
         const UVRegion& region,
-        const glm::vec4& tint);
+        const glm::vec4& tint
+    );
 
 public:
     Batch3D(size_t capacity);

src/graphics/ui/GUI.cpp

@@ -68,30 +68,25 @@ void GUI::updateTooltip(float delta) {
     if (hover == nullptr || !hover->isInside(Events::cursor)) {
         return resetTooltip();
     }
-    float mouseDelta = glm::length(Events::delta);
+    if (tooltipTimer + delta >= hover->getTooltipDelay()) {
-    if (mouseDelta < 1.0f || tooltipTimer >= hover->getTooltipDelay()) {
+        auto label = std::dynamic_pointer_cast<gui::Label>(get("tooltip.label"));
-        if (tooltipTimer + delta >= hover->getTooltipDelay()) {
+        const auto& text = hover->getTooltip();
-            auto label = std::dynamic_pointer_cast<gui::Label>(get("tooltip.label"));
+        if (text.empty() && tooltip->isVisible()) {
-            const auto& text = hover->getTooltip();
+            return resetTooltip();
-            if (text.empty() && tooltip->isVisible()) {
+        }
-                return resetTooltip();
+        if (label && !text.empty()) {
-            }
+            tooltip->setVisible(true);
-            if (label && !text.empty()) {
+            label->setText(langs::get(text));
-                tooltip->setVisible(true);
+            auto size = label->getSize()+glm::vec2(4.0f);
-                label->setText(langs::get(text));
+            auto pos = Events::cursor+glm::vec2(10.0f);
-                auto size = label->getSize()+glm::vec2(4.0f);
+            auto rootSize = container->getSize();
-                auto pos = Events::cursor+glm::vec2(10.0f);
+            pos.x = glm::min(pos.x, rootSize.x-size.x);
-                auto rootSize = container->getSize();
+            pos.y = glm::min(pos.y, rootSize.y-size.y);
-                pos.x = glm::min(pos.x, rootSize.x-size.x);
+            tooltip->setSize(size);
-                pos.y = glm::min(pos.y, rootSize.y-size.y);
+            tooltip->setPos(pos);
-                tooltip->setSize(size);
-                tooltip->setPos(pos);
-            }
         }
-        tooltipTimer += delta;
-    } else {
-        resetTooltip();
     }
+    tooltipTimer += delta;
 }
 
 /// @brief Mouse related input and logic handling