save presets using serializer

src/binary_stream.h

@@ -170,5 +170,3 @@ protected:
         m_data.insert(m_data.end(), bytes, bytes + size * sizeof(T));
     }
 };
-
-

src/brush.cpp

@@ -484,3 +484,174 @@ bool Brush::valid()
         return false;
     return true;
 }
+
+bool Brush::read(BinaryStreamReader& r)
+{
+    Serializer::Descriptor d;
+    r >> d;
+    d.value<Serializer::CString>("m_name", m_name);
+    d.value<Serializer::CString>("m_brush_path", m_brush_path);
+    d.value<Serializer::CString>("m_brush_thumb_path", m_brush_thumb_path);
+    d.value<Serializer::CString>("m_dual_path", m_dual_path);
+    d.value<Serializer::CString>("m_dual_thumb_path", m_dual_thumb_path);
+    d.value<Serializer::CString>("m_pattern_path", m_pattern_path);
+    d.value<Serializer::CString>("m_pattern_thumb_path", m_pattern_thumb_path);
+
+    d.value<Serializer::Vec4>("m_tip_color", m_tip_color);
+    d.value<Serializer::Vec2>("m_tip_scale", m_tip_scale);
+    d.value<Serializer::Vec2>("m_dual_scale", m_dual_scale);
+
+    d.value<Serializer::Float>("m_tip_size", m_tip_size);
+    d.value<Serializer::Float>("m_tip_spacing", m_tip_spacing);
+    d.value<Serializer::Float>("m_tip_flow", m_tip_flow);
+    d.value<Serializer::Float>("m_tip_opacity", m_tip_opacity);
+    d.value<Serializer::Float>("m_tip_angle", m_tip_angle);
+    d.value<Serializer::Float>("m_tip_angle_smooth", m_tip_angle_smooth);
+    d.value<Serializer::Float>("m_tip_mix", m_tip_mix);
+    d.value<Serializer::Float>("m_tip_wet", m_tip_wet);
+    d.value<Serializer::Float>("m_tip_noise", m_tip_noise);
+    d.value<Serializer::Float>("m_tip_hue", m_tip_hue);
+    d.value<Serializer::Float>("m_tip_sat", m_tip_sat);
+    d.value<Serializer::Float>("m_tip_val", m_tip_val);
+    d.value<Serializer::Float>("m_jitter_scale", m_jitter_scale);
+    d.value<Serializer::Float>("m_jitter_angle", m_jitter_angle);
+    d.value<Serializer::Float>("m_jitter_scatter", m_jitter_scatter);
+    d.value<Serializer::Float>("m_jitter_flow", m_jitter_flow);
+    d.value<Serializer::Float>("m_jitter_opacity", m_jitter_opacity);
+    d.value<Serializer::Float>("m_jitter_hue", m_jitter_hue);
+    d.value<Serializer::Float>("m_jitter_sat", m_jitter_sat);
+    d.value<Serializer::Float>("m_jitter_val", m_jitter_val);
+    d.value<Serializer::Float>("m_jitter_aspect", m_jitter_aspect);
+    d.value<Serializer::Float>("m_dual_size", m_dual_size);
+    d.value<Serializer::Float>("m_dual_spacing", m_dual_spacing);
+    d.value<Serializer::Float>("m_dual_scatter", m_dual_scatter);
+    d.value<Serializer::Float>("m_tip_aspect", m_tip_aspect);
+    d.value<Serializer::Float>("m_dual_flow", m_dual_flow);
+    d.value<Serializer::Float>("m_dual_opacity", m_dual_opacity);
+    d.value<Serializer::Float>("m_dual_rotate", m_dual_rotate);
+    d.value<Serializer::Float>("m_dual_angle", m_dual_angle);
+    d.value<Serializer::Float>("m_dual_aspect", m_dual_aspect);
+    d.value<Serializer::Float>("m_pattern_scale", m_pattern_scale);
+    d.value<Serializer::Float>("m_pattern_brightness", m_pattern_brightness);
+    d.value<Serializer::Float>("m_pattern_contrast", m_pattern_contrast);
+    d.value<Serializer::Float>("m_pattern_depth", m_pattern_depth);
+
+    d.value<Serializer::Boolean>("m_tip_angle_init", m_tip_angle_init);
+    d.value<Serializer::Boolean>("m_tip_angle_follow", m_tip_angle_follow);
+    d.value<Serializer::Boolean>("m_tip_flow_pressure", m_tip_flow_pressure);
+    d.value<Serializer::Boolean>("m_tip_opacity_pressure", m_tip_opacity_pressure);
+    d.value<Serializer::Boolean>("m_tip_size_pressure", m_tip_size_pressure);
+    d.value<Serializer::Boolean>("m_jitter_scatter_bothaxis", m_jitter_scatter_bothaxis);
+    d.value<Serializer::Boolean>("m_jitter_hsv_eachsample", m_jitter_hsv_eachsample);
+    d.value<Serializer::Boolean>("m_jitter_aspect_bothaxis", m_jitter_aspect_bothaxis);
+    d.value<Serializer::Boolean>("m_tip_invert", m_tip_invert);
+    d.value<Serializer::Boolean>("m_tip_flipx", m_tip_flipx);
+    d.value<Serializer::Boolean>("m_tip_flipy", m_tip_flipy);
+    d.value<Serializer::Boolean>("m_pattern_enabled", m_pattern_enabled);
+    d.value<Serializer::Boolean>("m_dual_enabled", m_dual_enabled);
+    d.value<Serializer::Boolean>("m_dual_randflip", m_dual_randflip);
+    d.value<Serializer::Boolean>("m_dual_scatter_bothaxis", m_dual_scatter_bothaxis);
+    d.value<Serializer::Boolean>("m_dual_invert", m_dual_invert);
+    d.value<Serializer::Boolean>("m_dual_flipx", m_dual_flipx);
+    d.value<Serializer::Boolean>("m_dual_flipy", m_dual_flipy);
+    d.value<Serializer::Boolean>("m_tip_randflipx", m_tip_randflipx);
+    d.value<Serializer::Boolean>("m_tip_randflipy", m_tip_randflipy);
+    d.value<Serializer::Boolean>("m_pattern_eachsample", m_pattern_eachsample);
+    d.value<Serializer::Boolean>("m_pattern_invert", m_pattern_invert);
+    d.value<Serializer::Boolean>("m_pattern_flipx", m_pattern_flipx);
+    d.value<Serializer::Boolean>("m_pattern_flipy", m_pattern_flipy);
+    d.value<Serializer::Boolean>("m_pattern_rand_offset", m_pattern_rand_offset);
+
+    d.value<Serializer::Integer>("m_blend_mode", m_blend_mode);
+    d.value<Serializer::Integer>("m_dual_blend_mode", m_dual_blend_mode);
+    d.value<Serializer::Integer>("m_dual_count", m_dual_count);
+    d.value<Serializer::Integer>("m_pattern_blend_mode", m_pattern_blend_mode);
+
+    return true;
+}
+
+void Brush::write(BinaryStreamWriter& w) const
+{
+    Serializer::Descriptor d;
+    d.class_id = "brush";
+    d.name = L"Brush class";
+    d.props["m_name"] = std::make_shared<Serializer::CString>(m_name);
+    d.props["m_brush_path"] = std::make_shared<Serializer::CString>(m_brush_path);
+    d.props["m_brush_thumb_path"] = std::make_shared<Serializer::CString>(m_brush_thumb_path);
+    d.props["m_dual_path"] = std::make_shared<Serializer::CString>(m_dual_path);
+    d.props["m_dual_thumb_path"] = std::make_shared<Serializer::CString>(m_dual_thumb_path);
+    d.props["m_pattern_path"] = std::make_shared<Serializer::CString>(m_pattern_path);
+    d.props["m_pattern_thumb_path"] = std::make_shared<Serializer::CString>(m_pattern_thumb_path);
+
+    d.props["m_tip_color"] = std::make_shared<Serializer::Vec4>(m_tip_color);
+    d.props["m_tip_scale"] = std::make_shared<Serializer::Vec2>(m_tip_scale);
+    d.props["m_dual_scale"] = std::make_shared<Serializer::Vec2>(m_dual_scale);
+
+    d.props["m_tip_size"] = std::make_shared<Serializer::Float>(m_tip_size);
+    d.props["m_tip_spacing"] = std::make_shared<Serializer::Float>(m_tip_spacing);
+    d.props["m_tip_flow"] = std::make_shared<Serializer::Float>(m_tip_flow);
+    d.props["m_tip_opacity"] = std::make_shared<Serializer::Float>(m_tip_opacity);
+    d.props["m_tip_angle"] = std::make_shared<Serializer::Float>(m_tip_angle);
+    d.props["m_tip_angle_smooth"] = std::make_shared<Serializer::Float>(m_tip_angle_smooth);
+    d.props["m_tip_mix"] = std::make_shared<Serializer::Float>(m_tip_mix);
+    d.props["m_tip_wet"] = std::make_shared<Serializer::Float>(m_tip_wet);
+    d.props["m_tip_noise"] = std::make_shared<Serializer::Float>(m_tip_noise);
+    d.props["m_tip_hue"] = std::make_shared<Serializer::Float>(m_tip_hue);
+    d.props["m_tip_sat"] = std::make_shared<Serializer::Float>(m_tip_sat);
+    d.props["m_tip_val"] = std::make_shared<Serializer::Float>(m_tip_val);
+    d.props["m_jitter_scale"] = std::make_shared<Serializer::Float>(m_jitter_scale);
+    d.props["m_jitter_angle"] = std::make_shared<Serializer::Float>(m_jitter_angle);
+    d.props["m_jitter_scatter"] = std::make_shared<Serializer::Float>(m_jitter_scatter);
+    d.props["m_jitter_flow"] = std::make_shared<Serializer::Float>(m_jitter_flow);
+    d.props["m_jitter_opacity"] = std::make_shared<Serializer::Float>(m_jitter_opacity);
+    d.props["m_jitter_hue"] = std::make_shared<Serializer::Float>(m_jitter_hue);
+    d.props["m_jitter_sat"] = std::make_shared<Serializer::Float>(m_jitter_sat);
+    d.props["m_jitter_val"] = std::make_shared<Serializer::Float>(m_jitter_val);
+    d.props["m_jitter_aspect"] = std::make_shared<Serializer::Float>(m_jitter_aspect);
+    d.props["m_dual_size"] = std::make_shared<Serializer::Float>(m_dual_size);
+    d.props["m_dual_spacing"] = std::make_shared<Serializer::Float>(m_dual_spacing);
+    d.props["m_dual_scatter"] = std::make_shared<Serializer::Float>(m_dual_scatter);
+    d.props["m_tip_aspect"] = std::make_shared<Serializer::Float>(m_tip_aspect);
+    d.props["m_dual_flow"] = std::make_shared<Serializer::Float>(m_dual_flow);
+    d.props["m_dual_opacity"] = std::make_shared<Serializer::Float>(m_dual_opacity);
+    d.props["m_dual_rotate"] = std::make_shared<Serializer::Float>(m_dual_rotate);
+    d.props["m_dual_angle"] = std::make_shared<Serializer::Float>(m_dual_angle);
+    d.props["m_dual_aspect"] = std::make_shared<Serializer::Float>(m_dual_aspect);
+    d.props["m_pattern_scale"] = std::make_shared<Serializer::Float>(m_pattern_scale);
+    d.props["m_pattern_brightness"] = std::make_shared<Serializer::Float>(m_pattern_brightness);
+    d.props["m_pattern_contrast"] = std::make_shared<Serializer::Float>(m_pattern_contrast);
+    d.props["m_pattern_depth"] = std::make_shared<Serializer::Float>(m_pattern_depth);
+    
+    d.props["m_tip_angle_init"] = std::make_shared<Serializer::Boolean>(m_tip_angle_init);
+    d.props["m_tip_angle_follow"] = std::make_shared<Serializer::Boolean>(m_tip_angle_follow);
+    d.props["m_tip_flow_pressure"] = std::make_shared<Serializer::Boolean>(m_tip_flow_pressure);
+    d.props["m_tip_opacity_pressure"] = std::make_shared<Serializer::Boolean>(m_tip_opacity_pressure);
+    d.props["m_tip_size_pressure"] = std::make_shared<Serializer::Boolean>(m_tip_size_pressure);
+    d.props["m_jitter_scatter_bothaxis"] = std::make_shared<Serializer::Boolean>(m_jitter_scatter_bothaxis);
+    d.props["m_jitter_hsv_eachsample"] = std::make_shared<Serializer::Boolean>(m_jitter_hsv_eachsample);
+    d.props["m_jitter_aspect_bothaxis"] = std::make_shared<Serializer::Boolean>(m_jitter_aspect_bothaxis);
+    d.props["m_tip_invert"] = std::make_shared<Serializer::Boolean>(m_tip_invert);
+    d.props["m_tip_flipx"] = std::make_shared<Serializer::Boolean>(m_tip_flipx);
+    d.props["m_tip_flipy"] = std::make_shared<Serializer::Boolean>(m_tip_flipy);
+    d.props["m_pattern_enabled"] = std::make_shared<Serializer::Boolean>(m_pattern_enabled);
+    d.props["m_dual_enabled"] = std::make_shared<Serializer::Boolean>(m_dual_enabled);
+    d.props["m_dual_randflip"] = std::make_shared<Serializer::Boolean>(m_dual_randflip);
+    d.props["m_dual_scatter_bothaxis"] = std::make_shared<Serializer::Boolean>(m_dual_scatter_bothaxis);
+    d.props["m_dual_invert"] = std::make_shared<Serializer::Boolean>(m_dual_invert);
+    d.props["m_dual_flipx"] = std::make_shared<Serializer::Boolean>(m_dual_flipx);
+    d.props["m_dual_flipy"] = std::make_shared<Serializer::Boolean>(m_dual_flipy);
+    d.props["m_tip_randflipx"] = std::make_shared<Serializer::Boolean>(m_tip_randflipx);
+    d.props["m_tip_randflipy"] = std::make_shared<Serializer::Boolean>(m_tip_randflipy);
+    d.props["m_pattern_eachsample"] = std::make_shared<Serializer::Boolean>(m_pattern_eachsample);
+    d.props["m_pattern_invert"] = std::make_shared<Serializer::Boolean>(m_pattern_invert);
+    d.props["m_pattern_flipx"] = std::make_shared<Serializer::Boolean>(m_pattern_flipx);
+    d.props["m_pattern_flipy"] = std::make_shared<Serializer::Boolean>(m_pattern_flipy);
+    d.props["m_pattern_rand_offset"] = std::make_shared<Serializer::Boolean>(m_pattern_rand_offset);
+
+    d.props["m_blend_mode"] = std::make_shared<Serializer::Integer>(m_blend_mode);
+    d.props["m_dual_blend_mode"] = std::make_shared<Serializer::Integer>(m_dual_blend_mode);
+    d.props["m_dual_count"] = std::make_shared<Serializer::Integer>(m_dual_count);
+    d.props["m_pattern_blend_mode"] = std::make_shared<Serializer::Integer>(m_pattern_blend_mode);
+
+    w << d;
+}

src/brush.h

@@ -2,8 +2,9 @@
 #include "rtt.h"
 #include "shader.h"
 #include "texture.h"
+#include "serializer.h"
 
-class Brush
+class Brush : public Serializer::Type
 {
     std::shared_ptr<Image> m_tip_img;
     std::shared_ptr<Image> m_pattern_img;
@@ -101,6 +102,9 @@ public:
     bool preload();
     void unload();
     bool valid();
+
+    virtual bool read(BinaryStreamReader& r) override;
+    virtual void write(BinaryStreamWriter& w) const override;
 };
 
 struct StrokeSample

src/node_panel_brush.cpp

@@ -474,98 +474,17 @@ bool NodePanelBrushPreset::save()
     auto path = App::I.data_path + "/settings/presets.bin";
     if (FILE* fp = fopen(path.c_str(), "wb"))
     {
-        header_t h;
+        BinaryStreamWriter sw;
-        h.count = m_container->m_children.size();
+        sw.init();
-        fwrite(&h, sizeof(h), 1, fp);
+        sw.wu32(m_container->m_children.size());
         for (int ci = 0; ci < m_container->m_children.size(); ci++)
         {
             auto bpi = static_cast<NodeBrushPresetItem*>(m_container->get_child_at(ci));
             auto& b = bpi->m_brush;
-            item_t i;
-            i.m_name_len = b->m_name.size();
-            i.m_brush_path_len = b->m_brush_path.size();
-            i.m_brush_thumb_path_len = b->m_brush_thumb_path.size();
-            i.m_dual_path_len = b->m_dual_path.size();
-            i.m_dual_thumb_path_len = b->m_dual_thumb_path.size();
-            i.m_pattern_path_len = b->m_pattern_path.size();
-            i.m_pattern_thumb_path_len = b->m_pattern_thumb_path.size();
-            i.m_tip_color           = b->m_tip_color;
-            i.m_tip_scale           = b->m_tip_scale;
-            i.m_tip_size            = b->m_tip_size;
-            i.m_tip_spacing         = b->m_tip_spacing;
-            i.m_tip_flow            = b->m_tip_flow;
-            i.m_tip_opacity         = b->m_tip_opacity;
-            i.m_tip_angle           = b->m_tip_angle;
-            i.m_tip_angle_smooth    = b->m_tip_angle_smooth;
-            i.m_tip_mix             = b->m_tip_mix;
-            i.m_tip_wet             = b->m_tip_wet;
-            i.m_tip_noise           = b->m_tip_noise;
-            i.m_tip_hue             = b->m_tip_hue;
-            i.m_tip_sat             = b->m_tip_sat;
-            i.m_tip_val             = b->m_tip_val;
-            i.m_tip_angle_init      = b->m_tip_angle_init;
-            i.m_tip_angle_follow    = b->m_tip_angle_follow;
-            i.m_tip_flow_pressure   = b->m_tip_flow_pressure;
-            i.m_tip_opacity_pressure= b->m_tip_opacity_pressure;
-            i.m_tip_size_pressure   = b->m_tip_size_pressure;
-            i.m_jitter_scale        = b->m_jitter_scale;
-            i.m_jitter_angle        = b->m_jitter_angle;
-            i.m_jitter_scatter      = b->m_jitter_scatter;
-            i.m_jitter_scatter_bothaxis = b->m_jitter_scatter_bothaxis;
-            i.m_jitter_flow         = b->m_jitter_flow;
-            i.m_jitter_opacity      = b->m_jitter_opacity;
-            i.m_jitter_hue          = b->m_jitter_hue;
-            i.m_jitter_sat          = b->m_jitter_sat;
-            i.m_jitter_val          = b->m_jitter_val;
-            i.m_jitter_hsv_eachsample = b->m_jitter_hsv_eachsample;
-            i.m_jitter_aspect       = b->m_jitter_aspect;
-            i.m_jitter_aspect_bothaxis = b->m_jitter_aspect_bothaxis;
-            i.m_blend_mode          = b->m_blend_mode;
 
-            i.m_tip_invert          = b->m_tip_invert;
+            sw << *b;
-            i.m_tip_flipx           = b->m_tip_flipx;
-            i.m_tip_flipy           = b->m_tip_flipy;
-            i.m_pattern_enabled     = b->m_pattern_enabled;
-            i.m_dual_enabled        = b->m_dual_enabled;
-            i.m_dual_blend_mode     = b->m_dual_blend_mode;
-            i.m_dual_randflip       = b->m_dual_randflip;
-            i.m_dual_size           = b->m_dual_size;
-            i.m_dual_spacing        = b->m_dual_spacing;
-            i.m_dual_scatter        = b->m_dual_scatter;
-            i.m_dual_scatter_bothaxis = b->m_dual_scatter_bothaxis;
-            i.m_dual_invert         = b->m_dual_invert;
-            i.m_dual_flipx          = b->m_dual_flipx;
-            i.m_dual_flipy          = b->m_dual_flipy;
-            i.m_tip_randflipx       = b->m_tip_randflipx;
-            i.m_tip_randflipy       = b->m_tip_randflipy;
-            i.m_tip_aspect          = b->m_tip_aspect;
-            i.m_dual_flow           = b->m_dual_flow;
-            i.m_dual_opacity        = b->m_dual_opacity;
-            i.m_dual_rotate         = b->m_dual_rotate;
-            i.m_dual_angle          = b->m_dual_angle;
-            i.m_dual_count          = b->m_dual_count;
-            i.m_dual_aspect         = b->m_dual_aspect;
-            i.m_dual_scale          = b->m_dual_scale;
-
-            i.m_pattern_eachsample  = b->m_pattern_eachsample;
-            i.m_pattern_invert      = b->m_pattern_invert;
-            i.m_pattern_flipx       = b->m_pattern_flipx;
-            i.m_pattern_flipy       = b->m_pattern_flipy;
-            i.m_pattern_scale       = b->m_pattern_scale;
-            i.m_pattern_brightness  = b->m_pattern_brightness;
-            i.m_pattern_contrast    = b->m_pattern_contrast;
-            i.m_pattern_rand_offset = b->m_pattern_rand_offset;
-            i.m_pattern_depth       = b->m_pattern_depth;
-
-            fwrite(&i, sizeof(i), 1, fp);
-            fwrite(b->m_name.c_str(), 1, b->m_name.size(), fp);
-            fwrite(b->m_brush_path.c_str(), 1, b->m_brush_path.size(), fp);
-            fwrite(b->m_brush_thumb_path.c_str(), 1, b->m_brush_thumb_path.size(), fp);
-            fwrite(b->m_dual_path.c_str(), 1, b->m_dual_path.size(), fp);
-            fwrite(b->m_dual_thumb_path.c_str(), 1, b->m_dual_thumb_path.size(), fp);
-            fwrite(b->m_pattern_path.c_str(), 1, b->m_pattern_path.size(), fp);
-            fwrite(b->m_pattern_thumb_path.c_str(), 1, b->m_pattern_thumb_path.size(), fp);
         }
+        fwrite(sw.m_data.data(), sw.m_data.size(), 1, fp);
         fclose(fp);
         return true;
     }
@@ -577,108 +496,20 @@ bool NodePanelBrushPreset::restore()
     auto path = App::I.data_path + "/settings/presets.bin";
     if (FILE* fp = fopen(path.c_str(), "rb"))
     {
-        header_t h;
+        fseek(fp, 0, SEEK_END);
-        fread(&h, sizeof(h), 1, fp);
+        size_t sz = ftell(fp);
-        if (strcmp(h.magic, "PPPR") != 0)
+        fseek(fp, 0, SEEK_SET);
-        {
+        std::vector<uint8_t> data(sz);
-            fclose(fp);
+        fread(data.data(), 1, sz, fp);
-            LOG("Presets file malformed: %s", path.c_str());
+        BinaryStreamReader sr;
-            return false;
+        sr.init(data.data(), sz);
-        }
-        if (h.version < 0 || h.version > 0)
-        {
-            fclose(fp);
-            LOG("Presets file version %d not supported: %s", h.version, path.c_str());
-            return false;
-        }
 
-        for (int k = 0; k < h.count; k++)
+        auto count = sr.ru32();
+
+        for (int k = 0; k < count; k++)
         {
-            item_t i;
-            fread(&i, sizeof(i), 1, fp);
             auto b = std::make_shared<Brush>();
-            b->m_tip_color          = i.m_tip_color;
+            sr >> *b;
-            b->m_tip_scale          = i.m_tip_scale;
-            b->m_tip_size           = i.m_tip_size;
-            b->m_tip_spacing        = i.m_tip_spacing;
-            b->m_tip_flow           = i.m_tip_flow;
-            b->m_tip_opacity        = i.m_tip_opacity;
-            b->m_tip_angle          = i.m_tip_angle;
-            b->m_tip_angle_smooth   = i.m_tip_angle_smooth;
-            b->m_tip_mix            = i.m_tip_mix;
-            b->m_tip_wet            = i.m_tip_wet;
-            b->m_tip_noise          = i.m_tip_noise;
-            b->m_tip_hue            = i.m_tip_hue;
-            b->m_tip_sat            = i.m_tip_sat;
-            b->m_tip_val            = i.m_tip_val;
-            b->m_tip_angle_init     = i.m_tip_angle_init;
-            b->m_tip_angle_follow   = i.m_tip_angle_follow;
-            b->m_tip_flow_pressure  = i.m_tip_flow_pressure;
-            b->m_tip_opacity_pressure = i.m_tip_opacity_pressure;
-            b->m_tip_size_pressure  = i.m_tip_size_pressure;
-            b->m_jitter_scale       = i.m_jitter_scale;
-            b->m_jitter_angle       = i.m_jitter_angle;
-            b->m_jitter_scatter     = i.m_jitter_scatter;
-            b->m_jitter_scatter_bothaxis = i.m_jitter_scatter_bothaxis;
-            b->m_jitter_flow = i.m_jitter_flow;
-            b->m_jitter_opacity     = i.m_jitter_opacity;
-            b->m_jitter_hue         = i.m_jitter_hue;
-            b->m_jitter_sat         = i.m_jitter_sat;
-            b->m_jitter_val         = i.m_jitter_val;
-            b->m_jitter_hsv_eachsample = i.m_jitter_hsv_eachsample;
-            b->m_jitter_aspect      = i.m_jitter_aspect;
-            b->m_jitter_aspect_bothaxis = i.m_jitter_aspect_bothaxis;
-            b->m_blend_mode = i.m_blend_mode;
-
-            b->m_tip_invert         = i.m_tip_invert;
-            b->m_tip_flipx          = i.m_tip_flipx;
-            b->m_tip_flipy          = i.m_tip_flipy;
-            b->m_pattern_enabled    = i.m_pattern_enabled;
-            b->m_dual_enabled       = i.m_dual_enabled;
-            b->m_dual_blend_mode    = i.m_dual_blend_mode;
-            b->m_dual_randflip      = i.m_dual_randflip;
-            b->m_dual_size          = i.m_dual_size;
-            b->m_dual_spacing       = i.m_dual_spacing;
-            b->m_dual_scatter       = i.m_dual_scatter;
-            b->m_dual_scatter_bothaxis = i.m_dual_scatter_bothaxis;
-            b->m_dual_invert        = i.m_dual_invert;
-            b->m_dual_flipx         = i.m_dual_flipx;
-            b->m_dual_flipy         = i.m_dual_flipy;
-            b->m_tip_randflipx      = i.m_tip_randflipx;
-            b->m_tip_randflipy      = i.m_tip_randflipy;
-            b->m_tip_aspect         = i.m_tip_aspect;
-            b->m_dual_flow          = i.m_dual_flow;
-            b->m_dual_opacity       = i.m_dual_opacity;
-            b->m_dual_rotate        = i.m_dual_rotate;
-            b->m_dual_angle         = i.m_dual_angle;
-            b->m_dual_count         = i.m_dual_count;
-            b->m_dual_aspect        = i.m_dual_aspect;
-            b->m_dual_scale         = i.m_dual_scale;
-
-            b->m_pattern_eachsample = i.m_pattern_eachsample;
-            b->m_pattern_invert     = i.m_pattern_invert;
-            b->m_pattern_flipx      = i.m_pattern_flipx;
-            b->m_pattern_flipy      = i.m_pattern_flipy;
-            b->m_pattern_scale      = i.m_pattern_scale;
-            b->m_pattern_brightness = i.m_pattern_brightness;
-            b->m_pattern_contrast   = i.m_pattern_contrast;
-            b->m_pattern_rand_offset = i.m_pattern_rand_offset;
-            b->m_pattern_depth      = i.m_pattern_depth;
-
-            b->m_name.resize(i.m_name_len);
-            b->m_brush_path.resize(i.m_brush_path_len);
-            b->m_brush_thumb_path.resize(i.m_brush_thumb_path_len);
-            b->m_dual_path.resize(i.m_dual_path_len);
-            b->m_dual_thumb_path.resize(i.m_dual_thumb_path_len);
-            b->m_pattern_path.resize(i.m_pattern_path_len);
-            b->m_pattern_thumb_path.resize(i.m_pattern_thumb_path_len);
-            fread((char*)b->m_name.c_str(), 1, b->m_name.size(), fp);
-            fread((char*)b->m_brush_path.c_str(), 1, b->m_brush_path.size(), fp);
-            fread((char*)b->m_brush_thumb_path.c_str(), 1, b->m_brush_thumb_path.size(), fp);
-            fread((char*)b->m_dual_path.c_str(), 1, b->m_dual_path.size(), fp);
-            fread((char*)b->m_dual_thumb_path.c_str(), 1, b->m_dual_thumb_path.size(), fp);
-            fread((char*)b->m_pattern_path.c_str(), 1, b->m_pattern_path.size(), fp);
-            fread((char*)b->m_pattern_thumb_path.c_str(), 1, b->m_pattern_thumb_path.size(), fp);
 
             if (b->valid())
             {

src/node_panel_brush.h

@@ -96,86 +96,7 @@ class NodePanelBrushPreset : public Node
         uint16_t version = 0;
         uint16_t count = 0;
     };
-    struct item_t {
-        int m_name_len = 0;
-        
-        int m_brush_path_len = 0;
-        int m_brush_thumb_path_len = 0;
-        
-        int m_dual_path_len = 0;
-        int m_dual_thumb_path_len = 0;
-        
-        int m_pattern_path_len = 0;
-        int m_pattern_thumb_path_len = 0;
 
-        glm::vec4 m_tip_color{ 0, 0, 0, 1 };
-        glm::vec2 m_tip_scale = { 1.f, 1.f };
-        glm::vec2 m_dual_scale = { 1.f, 1.f };
-        float m_tip_size = 0;
-        float m_tip_spacing = 0;
-        float m_tip_flow = 0;
-        float m_tip_opacity = 0;
-        float m_tip_angle = 0;
-        float m_tip_angle_smooth = 0;
-        float m_tip_mix = 0;
-        float m_tip_wet = 0;
-        float m_tip_noise = 0;
-        float m_tip_hue = 0;
-        float m_tip_sat = 0;
-        float m_tip_val = 0;
-        bool  m_tip_angle_init = false;
-        bool  m_tip_angle_follow = false;
-        bool  m_tip_flow_pressure = false;
-        bool  m_tip_opacity_pressure = false;
-        bool  m_tip_size_pressure = false;
-        float m_jitter_scale = 0;
-        float m_jitter_angle = 0;
-        float m_jitter_scatter = 0;
-        bool  m_jitter_scatter_bothaxis = false;
-        float m_jitter_flow = 0;
-        float m_jitter_opacity = 0;
-        float m_jitter_hue = 0;
-        float m_jitter_sat = 0;
-        float m_jitter_val = 0;
-        bool  m_jitter_hsv_eachsample = false;
-        float m_jitter_aspect = 0;
-        bool  m_jitter_aspect_bothaxis = false;
-        int   m_blend_mode = 0;
-
-        bool  m_tip_invert = false;
-        bool  m_tip_flipx = false;
-        bool  m_tip_flipy = false;
-        bool  m_pattern_enabled = false;
-        bool  m_dual_enabled = false;
-        int   m_dual_blend_mode = 0;
-        bool  m_dual_randflip = false;
-        float m_dual_size = 0;
-        float m_dual_spacing = 0;
-        float m_dual_scatter = 0;
-        bool  m_dual_scatter_bothaxis = false;
-        bool  m_dual_invert = false;
-        bool  m_dual_flipx = false;
-        bool  m_dual_flipy = false;
-        bool  m_tip_randflipx = false;
-        bool  m_tip_randflipy = false;
-        float m_tip_aspect = 0;
-        float m_dual_flow = .75f;
-        float m_dual_opacity = 1.f;
-        float m_dual_rotate = .25f;
-        float m_dual_angle = 0;
-        float m_dual_aspect = 0.5f;
-        int   m_dual_count = 1;
-
-        bool m_pattern_eachsample = false;
-        bool m_pattern_invert = false;
-        bool m_pattern_flipx = false;
-        bool m_pattern_flipy = false;
-        float m_pattern_scale = .25f;
-        float m_pattern_brightness = 0.5f;
-        float m_pattern_contrast = 0.5f;
-        bool m_pattern_rand_offset = false;
-        float m_pattern_depth = 1.f;
-    };
 public:
     Node* m_container;
     std::function<void(Node* target, std::shared_ptr<Brush>& brush)> on_brush_changed;

src/serializer.cpp

@@ -19,5 +19,9 @@ std::map<std::string /*key*/, std::function<Serializer::Type::Ref()>> Serializer
     { "doub", [] { return std::make_shared<Serializer::Double>(); } },
     { "enum", [] { return std::make_shared<Serializer::Enum>(); } },
     { "tdta", [] { return std::make_shared<Serializer::RawData>(); } },
+    { "vec2", [] { return std::make_shared<Serializer::Vec2>(); } },
+    { "vec3", [] { return std::make_shared<Serializer::Vec3>(); } },
+    { "vec4", [] { return std::make_shared<Serializer::Vec4>(); } },
+    { "flt ", [] { return std::make_shared<Serializer::Float>(); } },
+    { "cstr", [] { return std::make_shared<Serializer::CString>(); } },
 };
-

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);
             }
         }