add scale and mode to sprite_renderer

headers/enduro2d/high/components/sprite_renderer.hpp

@@ -16,6 +16,10 @@ namespace e2d
 {
     class sprite_renderer final {
     public:
+        ENUM_HPP_CLASS_DECL(modes, u8,
+            (simple)
+            (sliced))
+
         ENUM_HPP_CLASS_DECL(blendings, u8,
             (normal)
             (additive)
@@ -28,6 +32,12 @@ namespace e2d
         sprite_renderer& tint(const color32& value) noexcept;
         [[nodiscard]] const color32& tint() const noexcept;
 
+        sprite_renderer& scale(const v2f& value) noexcept;
+        [[nodiscard]] const v2f& scale() const noexcept;
+
+        sprite_renderer& mode(modes value) noexcept;
+        [[nodiscard]] modes mode() const noexcept;
+
         sprite_renderer& blending(blendings value) noexcept;
         [[nodiscard]] blendings blending() const noexcept;
 
@@ -42,6 +52,8 @@ namespace e2d
         [[nodiscard]] material_asset::ptr find_material(str_hash name) const noexcept;
     private:
         color32 tint_ = color32::white();
+        v2f scale_ = v2f::unit();
+        modes mode_ = modes::simple;
         blendings blending_ = blendings::normal;
         bool filtering_ = true;
         sprite_asset::ptr sprite_;
@@ -49,6 +61,7 @@ namespace e2d
     };
 }
 
+ENUM_HPP_REGISTER_TRAITS(e2d::sprite_renderer::modes)
 ENUM_HPP_REGISTER_TRAITS(e2d::sprite_renderer::blendings)
 
 namespace e2d
@@ -94,11 +107,24 @@ namespace e2d
         return tint_;
     }
 
-    inline sprite_renderer& sprite_renderer::filtering(bool value) noexcept {
+    inline sprite_renderer& sprite_renderer::scale(const v2f& value) noexcept {
-        filtering_ = value;
+        scale_ = value;
         return *this;
     }
 
+    inline const v2f& sprite_renderer::scale() const noexcept {
+        return scale_;
+    }
+
+    inline sprite_renderer& sprite_renderer::mode(modes value) noexcept {
+        mode_ = value;
+        return *this;
+    }
+
+    inline sprite_renderer::modes sprite_renderer::mode() const noexcept {
+        return mode_;
+    }
+
     inline sprite_renderer& sprite_renderer::blending(blendings value) noexcept {
         blending_ = value;
         return *this;
@@ -108,6 +134,11 @@ namespace e2d
         return blending_;
     }
 
+    inline sprite_renderer& sprite_renderer::filtering(bool value) noexcept {
+        filtering_ = value;
+        return *this;
+    }
+
     inline bool sprite_renderer::filtering() const noexcept {
         return filtering_;
     }

samples/bin/library/scripts/emmy/components/sprite_renderer.lua

@@ -3,6 +3,12 @@ local sprite_renderer = {
     ---@type color32
     tint = color32.white(),
 
+    ---@type v2f
+    scale = v2f.unit(),
+
+    ---@type sprite_renderer_modes
+    mode = sprite_renderer.modes.simple,
+
     ---@type sprite_renderer_blendings
     blending = sprite_renderer.blendings.normal,
 
@@ -13,6 +19,12 @@ local sprite_renderer = {
     sprite = nil
 }
 
+---@class sprite_renderer_modes
+sprite_renderer.modes = {
+    simple = "simple",
+    sliced = "sliced"
+}
+
 ---@class sprite_renderer_blendings
 sprite_renderer.blendings = {
     normal = "normal",

sources/enduro2d/high/bindings/high_binds/components/sprite_renderer_binds.cpp

@@ -23,6 +23,22 @@ namespace e2d::bindings::high
                     c->tint(v);
                 }),
 
+            "scale", sol::property(
+                [](const gcomponent<sprite_renderer>& c) -> v2f {
+                    return c->scale();
+                },
+                [](gcomponent<sprite_renderer>& c, const v2f& v){
+                    c->scale(v);
+                }),
+
+            "mode", sol::property(
+                [](const gcomponent<sprite_renderer>& c) -> sprite_renderer::modes {
+                    return c->mode();
+                },
+                [](gcomponent<sprite_renderer>& c, sprite_renderer::modes v){
+                    c->mode(v);
+                }),
+
             "blending", sol::property(
                 [](const gcomponent<sprite_renderer>& c) -> sprite_renderer::blendings {
                     return c->blending();
@@ -48,6 +64,14 @@ namespace e2d::bindings::high
                 })
         );
 
+    #define SPRITE_RENDERER_MODES_PAIR(x) {#x, sprite_renderer::modes::x},
+        l["sprite_renderer"].get_or_create<sol::table>()
+        .new_enum<sprite_renderer::modes>("modes", {
+            SPRITE_RENDERER_MODES_PAIR(simple)
+            SPRITE_RENDERER_MODES_PAIR(sliced)
+        });
+    #undef SPRITE_RENDERER_MODES_PAIR
+
     #define SPRITE_RENDERER_BLENDINGS_PAIR(x) {#x, sprite_renderer::blendings::x},
         l["sprite_renderer"].get_or_create<sol::table>()
         .new_enum<sprite_renderer::blendings>("blendings", {

sources/enduro2d/high/components/sprite_renderer.cpp

@@ -14,6 +14,8 @@ namespace e2d
         "additionalProperties" : false,
         "properties" : {
             "tint" : { "$ref": "#/common_definitions/color" },
+            "scale" : { "$ref": "#/common_definitions/v2" },
+            "mode" : { "$ref": "#/definitions/modes" },
             "blending" : { "$ref": "#/definitions/blendings" },
             "filtering" : { "type" : "boolean" },
             "atlas" : { "$ref": "#/common_definitions/address" },
@@ -21,6 +23,13 @@ namespace e2d
             "materials" : { "$ref": "#/definitions/materials" }
         },
         "definitions" : {
+            "modes" : {
+                "type" : "string",
+                "enum" : [
+                    "simple",
+                    "sliced"
+                ]
+            },
             "blendings" : {
                 "type" : "string",
                 "enum" : [
@@ -57,6 +66,24 @@ namespace e2d
             component.tint(tint);
         }
 
+        if ( ctx.root.HasMember("scale") ) {
+            v2f scale = component.scale();
+            if ( !json_utils::try_parse_value(ctx.root["scale"], scale) ) {
+                the<debug>().error("SPRITE_RENDERER: Incorrect formatting of 'scale' property");
+                return false;
+            }
+            component.scale(scale);
+        }
+
+        if ( ctx.root.HasMember("mode") ) {
+            sprite_renderer::modes mode = component.mode();
+            if ( !json_utils::try_parse_value(ctx.root["mode"], mode) ) {
+                the<debug>().error("SPRITE_RENDERER: Incorrect formatting of 'mode' property");
+                return false;
+            }
+            component.mode(mode);
+        }
+
         if ( ctx.root.HasMember("blending") ) {
             sprite_renderer::blendings blending = component.blending();
             if ( !json_utils::try_parse_value(ctx.root["blending"], blending) ) {
@@ -181,6 +208,18 @@ namespace e2d
             c->tint(color32(tint));
         }
 
+        if ( v2f scale = c->scale();
+            ImGui::DragFloat2("scale", scale.data(), 0.01f) )
+        {
+            c->scale(scale);
+        }
+
+        if ( sprite_renderer::modes mode = c->mode();
+            imgui_utils::show_enum_combo_box("mode", &mode) )
+        {
+            c->mode(mode);
+        }
+
         if ( sprite_renderer::blendings blending = c->blending();
             imgui_utils::show_enum_combo_box("blending", &blending) )
         {