save presets using serializer

src/serializer.h

@@ -10,7 +10,7 @@ template<typename T> BinaryStreamWriter& operator<<(BinaryStreamWriter& w, const
     return w;
 }
 
-template<typename T> BinaryStreamReader& operator>>(BinaryStreamReader& r, const T& obj)
+template<typename T> BinaryStreamReader& operator>>(BinaryStreamReader& r, T& obj)
 {
     obj.read(r);
     return r;
@@ -94,6 +94,27 @@ public:
             w.wdbl(value);
         }
     };
+    struct Float : public Type
+    {
+        using native_type = float;
+        float value;
+        Float() = default;
+        Float(float value) : value(value) { }
+        virtual std::string type_key() const override { return "flt "; }
+        virtual std::string str(int indent, const std::string& prefix) const override
+        {
+            return std::string(indent, '-') + prefix + fmt::format("float: {}", value);
+        }
+        virtual bool read(BinaryStreamReader& r) override
+        {
+            value = r.rflt();
+            return true;
+        }
+        virtual void write(BinaryStreamWriter& w) const override
+        {
+            w.wflt(value);
+        }
+    };
     struct UnitFloat : public Type
     {
         using native_type = double;
@@ -146,6 +167,102 @@ public:
             w.wwstring(value);
         }
     };
+    struct CString : public Type
+    {
+        using native_type = std::string;
+        std::string value;
+        CString() = default;
+        CString(const std::string& s) : value(s) { }
+        virtual std::string type_key() const override { return "cstr"; }
+        virtual std::string str(int indent, const std::string& prefix) const override
+        {
+            return std::string(indent, '-') + prefix + fmt::format("cstring: {}", value);
+        }
+        virtual bool read(BinaryStreamReader& r) override
+        {
+            value = r.rstring();
+            return true;
+        }
+        virtual void write(BinaryStreamWriter& w) const override
+        {
+            w.wstring(value);
+        }
+    };
+    struct Vec2 : public Type
+    {
+        using native_type = glm::vec2;
+        glm::vec2 value;
+        Vec2() = default;
+        Vec2(glm::vec2 v) : value(v) { }
+        virtual std::string type_key() const override { return "vec2"; }
+        virtual std::string str(int indent, const std::string& prefix) const override
+        {
+            return std::string(indent, '-') + prefix + fmt::format("vec2: {} {}", value.x, value.y);
+        }
+        virtual bool read(BinaryStreamReader& r) override
+        {
+            value.x = r.rflt();
+            value.y = r.rflt();
+            return true;
+        }
+        virtual void write(BinaryStreamWriter& w) const override
+        {
+            w.wflt(value.x);
+            w.wflt(value.y);
+        }
+    };
+    struct Vec3 : public Type
+    {
+        using native_type = glm::vec3;
+        glm::vec3 value;
+        Vec3() = default;
+        Vec3(glm::vec3 v) : value(v) { }
+        virtual std::string type_key() const override { return "vec3"; }
+        virtual std::string str(int indent, const std::string& prefix) const override
+        {
+            return std::string(indent, '-') + prefix + fmt::format("vec3: {} {} {}", value.x, value.y, value.z);
+        }
+        virtual bool read(BinaryStreamReader& r) override
+        {
+            value.x = r.rflt();
+            value.y = r.rflt();
+            value.z = r.rflt();
+            return true;
+        }
+        virtual void write(BinaryStreamWriter& w) const override
+        {
+            w.wflt(value.x);
+            w.wflt(value.y);
+            w.wflt(value.z);
+        }
+    };
+    struct Vec4 : public Type
+    {
+        using native_type = glm::vec4;
+        glm::vec4 value;
+        Vec4() = default;
+        Vec4(glm::vec4 v) : value(v) { }
+        virtual std::string type_key() const override { return "vec4"; }
+        virtual std::string str(int indent, const std::string& prefix) const override
+        {
+            return std::string(indent, '-') + prefix + fmt::format("vec4: {} {} {} {}", value.x, value.y, value.z, value.w);
+        }
+        virtual bool read(BinaryStreamReader& r) override
+        {
+            value.x = r.rflt();
+            value.y = r.rflt();
+            value.z = r.rflt();
+            value.w = r.rflt();
+            return true;
+        }
+        virtual void write(BinaryStreamWriter& w) const override
+        {
+            w.wflt(value.x);
+            w.wflt(value.y);
+            w.wflt(value.z);
+            w.wflt(value.w);
+        }
+    };
     struct Enum : public Type
     {
         std::string type;
@@ -299,7 +416,7 @@ public:
             for (auto& p : props)
             {
                 w.wkey_or_string(p.first);
-                w.wstring(p.second->type_key());
+                w.wstring_raw(p.second->type_key());
                 p.second->write(w);
             }
         }