omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

save presets using serializer

Browse Source
This commit is contained in:
omigamedev
2019-03-08 01:04:42 +01:00
parent bf82505de4
commit 0dcaa7c4a3
7 changed files with 316 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/binary_stream.h
View File

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

171
src/brush.cpp
View File

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

6
src/brush.h
View File

@@ -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

201
src/node_panel_brush.cpp
View File

@@ -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;
h.count = m_container->m_children.size();
fwrite(&h, sizeof(h), 1, fp);
BinaryStreamWriter sw;
sw.init();
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;
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);
sw << *b;
}
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;
fread(&h, sizeof(h), 1, fp);
if (strcmp(h.magic, "PPPR") != 0)
{
fclose(fp);
LOG("Presets file malformed: %s", path.c_str());
return false;
}
if (h.version < 0 || h.version > 0)
{
fclose(fp);
LOG("Presets file version %d not supported: %s", h.version, path.c_str());
return false;
}
fseek(fp, 0, SEEK_END);
size_t sz = ftell(fp);
fseek(fp, 0, SEEK_SET);
std::vector<uint8_t> data(sz);
fread(data.data(), 1, sz, fp);
BinaryStreamReader sr;
sr.init(data.data(), sz);
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;
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);
sr >> *b;
if (b->valid())
{

79
src/node_panel_brush.h
View File

@@ -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;

6
src/serializer.cpp
View File

@@ -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>(); } },
};

121
src/serializer.h
View File

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