[General] Wall

Author: MetsukiMio

include/openminecraft-shell/data/om_model_precompiler.hpp

@@ -27,47 +27,14 @@ enum OMModelCullSide
     East,
     None,
 };
-static auto fromSide(std::string s) -> OMModelCullSide
-{
-    using namespace binary::hash;
-    switch (hash_compile_time(s.c_str()))
-    {
-    case "down"_hash:
-        return Down;
-    case "up"_hash:
-        return Up;
-    case "south"_hash:
-        return South;
-    case "north"_hash:
-        return North;
-    case "east"_hash:
-        return East;
-    case "west"_hash:
-        return West;
-    default:
-        return None;
-    }
-}
+
 enum OMModelAxis : uint8_t
 {
     X = 0,
     Y = 1,
     Z = 2
 };
-static auto fromAxis(std::string s) -> OMModelAxis
-{
-    using namespace binary::hash;
-    switch (hash_compile_time(s.c_str()))
-    {
-    default:
-    case "x"_hash:
-        return X;
-    case "y"_hash:
-        return Y;
-    case "z"_hash:
-        return Z;
-    }
-}
+
 struct OMModelFace
 {
     OMModelCullSide cull;

include/openminecraft-shell/data/om_textureatlas.hpp

@@ -10,8 +10,6 @@
 #include "openminecraft/specs/png/om_png.hpp"
 #include "openminecraft/vfs/om_vfs_base.hpp"
 #include <array>
-#include <iostream>
-#include <tuple>
 #include <unordered_map>
 #include <utility>
 using namespace openminecraft;
@@ -21,7 +19,7 @@ class OMTextureAtlas
 {
   public:
     OMTextureAtlas(std::string root, renderer::OMRenderer *renderer)
-        : renderer(renderer), root(std::move(root)), logger("OMTextureAtlas", this)
+        : root(std::move(root)), renderer(renderer), logger("OMTextureAtlas", this)
     {
     }
     ~OMTextureAtlas()

include/openminecraft/io/json/om_io_ast_json.hpp

@@ -83,6 +83,7 @@ class OMJsonNodeObject : public OMJsonNode
     OMJsonNodeObject(std::unordered_map<std::string, std::shared_ptr<OMJsonNode>> v) : data(std::move(v))
     {
     }
+    virtual ~OMJsonNodeObject() = default;
 
     auto type() -> OMJsonNodeType override
     {
@@ -196,7 +197,7 @@ class OMJsonNodeArray : public OMJsonNode
 class OMJsonNodeNumber : public OMJsonNode
 {
   public:
-    OMJsonNodeNumber(int64_t v) : ivalue(v), dvalue(static_cast<double>(v))
+    OMJsonNodeNumber(int64_t v) : dvalue(static_cast<double>(v)), ivalue(v)
     {
     }
 

include/openminecraft/io/json/om_io_tokeniter_json.hpp

@@ -12,7 +12,7 @@ class OMJsonTokenIter : public OMTokenIter<OMJsonToken>
     OMJsonTokenIter(std::shared_ptr<std::istream> istr) : OMTokenIter(istr)
     {
     }
-    ~OMJsonTokenIter() = default;
+    virtual ~OMJsonTokenIter() = default;
 
     auto next() -> std::shared_ptr<OMJsonToken> override;
     auto end() -> bool override;

include/openminecraft/renderer/common/demiurge/element/om_demiurge_element_textsdf_channel.hpp

@@ -16,7 +16,7 @@ class OMDemiurgeTextSdfChannel : public OMDemiurgeQuadChannel<OMDemiurgeElementT
         : OMDemiurgeQuadChannel(renderer, f), fontSet(set)
     {
     }
-    ~OMDemiurgeTextSdfChannel() = default;
+    virtual ~OMDemiurgeTextSdfChannel() = default;
 
     void init(OMRendererBuffer *uniform, OMRendererRenderTarget *target) override;
     void destroy() override

include/openminecraft/renderer/common/demiurge/om_demiurge_geometry.hpp

@@ -25,40 +25,14 @@ enum OMDemiurgeDirection
     Column,
     ColumnReverse
 };
-static auto toYGDirection(OMDemiurgeDirection d) -> YGFlexDirection
-{
-    switch (d)
-    {
-    case Row:
-    default:
-        return YGFlexDirectionRow;
-    case RowReverse:
-        return YGFlexDirectionRowReverse;
-    case Column:
-        return YGFlexDirectionColumn;
-    case ColumnReverse:
-        return YGFlexDirectionColumnReverse;
-    }
-}
+
 enum OMDemiurgeWrap
 {
     Wrap,
     WrapReverse,
     NoWrap
 };
-static auto toYGWrap(OMDemiurgeWrap w) -> YGWrap
-{
-    switch (w)
-    {
-    case Wrap:
-        return YGWrapWrap;
-    case WrapReverse:
-        return YGWrapWrapReverse;
-    default:
-    case NoWrap:
-        return YGWrapNoWrap;
-    }
-}
+
 enum OMDemiurgeAlign
 {
     Auto,
@@ -71,53 +45,7 @@ enum OMDemiurgeAlign
     SpaceAround,
     SpaceEvenly
 };
-static auto toYGJustify(OMDemiurgeAlign a) -> YGJustify
-{
-    switch (a)
-    {
-    default:
-    case FlexStart:
-        return YGJustifyFlexStart;
-    case Auto:
-    case Stretch:
-    case Baseline:
-    case Center:
-        return YGJustifyCenter;
-    case FlexEnd:
-        return YGJustifyFlexEnd;
-    case SpaceAround:
-        return YGJustifySpaceAround;
-    case SpaceBetween:
-        return YGJustifySpaceBetween;
-    case SpaceEvenly:
-        return YGJustifySpaceEvenly;
-    }
-}
-static auto toYGAlign(OMDemiurgeAlign a) -> YGAlign
-{
-    switch (a)
-    {
-    default:
-    case Auto:
-        return YGAlignAuto;
-    case FlexStart:
-        return YGAlignFlexStart;
-    case Center:
-        return YGAlignCenter;
-    case FlexEnd:
-        return YGAlignFlexEnd;
-    case Stretch:
-        return YGAlignStretch;
-    case Baseline:
-        return YGAlignBaseline;
-    case SpaceBetween:
-        return YGAlignSpaceBetween;
-    case SpaceAround:
-        return YGAlignSpaceAround;
-    case SpaceEvenly:
-        return YGAlignSpaceEvenly;
-    }
-}
+
 struct OMDemiurgeSize
 {
     enum Unit

include/openminecraft/renderer/common/demiurge/om_demiurge_node.hpp

@@ -5,7 +5,6 @@
 #include "openminecraft/renderer/common/demiurge/om_demiurge_styles.hpp"
 #include "yoga/YGNode.h"
 #include "yoga/YGNodeLayout.h"
-#include "yoga/YGNodeStyle.h"
 #include <algorithm>
 #include <any>
 #include <initializer_list>
@@ -18,30 +17,6 @@
 namespace openminecraft::renderer::common::demiurge
 {
 class OMDemiurgeRendererHandler;
-static void setSizeToYoga(YGNodeRef node, OMDemiurgeSize size, bool isWidth)
-{
-    switch (size.unit)
-    {
-    case OMDemiurgeSize::Pixel:
-        if (isWidth)
-            YGNodeStyleSetWidth(node, size.value);
-        else
-            YGNodeStyleSetHeight(node, size.value);
-        break;
-    case OMDemiurgeSize::Percent:
-        if (isWidth)
-            YGNodeStyleSetWidthPercent(node, size.value * 100.0f);
-        else
-            YGNodeStyleSetHeightPercent(node, size.value * 100.0f);
-        break;
-    case OMDemiurgeSize::Fit:
-        if (isWidth)
-            YGNodeStyleSetWidthAuto(node);
-        else
-            YGNodeStyleSetHeightAuto(node);
-        break;
-    }
-}
 
 class OMDemiurgeNode : public std::enable_shared_from_this<OMDemiurgeNode>
 {

include/openminecraft/renderer/common/om_renderer_shader.hpp

@@ -38,11 +38,11 @@ class OMShader : public OMRendererObject
     OMShader() = default;
     OMShader(OMShaderFileType type, std::vector<uint8_t> data, std::string filename, std::string entrypoint,
              OMShaderType typebase)
-        : type(type), data(std::move(data)), entrypoint(std::move(entrypoint)), filename(std::move(filename)),
+        : data(std::move(data)), type(type), filename(std::move(filename)), entrypoint(std::move(entrypoint)),
           typebase(typebase)
     {
     }
-    ~OMShader() = default;
+    virtual ~OMShader() = default;
 
     const std::vector<uint8_t> data;
     OMShaderFileType type;

include/openminecraft/renderer/common/shader/om_renderer_shadercompiler_shaderc.hpp

@@ -15,7 +15,7 @@ class OMRendererShaderCompilerBackendShaderc : public OMRendererShaderCompilerBa
     {
         compiler = std::make_shared<shaderc::Compiler>();
     }
-    ~OMRendererShaderCompilerBackendShaderc() = default;
+    virtual ~OMRendererShaderCompilerBackendShaderc() = default;
 
     auto compile(std::shared_ptr<OMShader> shader) -> std::shared_ptr<OMShader> override;
 

include/openminecraft/renderer/common/wrap/om_renderer_segbuf.hpp

@@ -3,7 +3,6 @@
 
 #include "openminecraft/renderer/common/om_renderer_buffer.hpp"
 #include "openminecraft/renderer/om_renderer_layer.hpp"
-#include <iostream>
 #include <vector>
 #include <algorithm>
 
@@ -36,7 +35,7 @@ struct OMRendererSegBufBlock
 class OMRendererSegBuf
 {
   public:
-    OMRendererSegBuf(OMRenderer *renderer, uint32_t initialSize) : renderer(renderer), totalSize(initialSize)
+    OMRendererSegBuf(OMRenderer *renderer, uint32_t initialSize) : totalSize(initialSize), renderer(renderer)
     {
         buffer = renderer->allocateBuffer(InstanceData, totalSize);
         freeBlocks = {{0, totalSize}};