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

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