Packman Build Service PMBS

Changes of Revision 47

synfig.spec Changed

@@ -56,8 +56,8 @@
 BuildRequires:  pkgconfig(pangocairo)
 BuildRequires:  pkgconfig(sigc++-2.0)
 BuildRequires:  pkgconfig(zlib)
-Summary:        Shared library part of %name
-Requires:       %name-modules = %version
+Summary:        Shared library part of %pkg
+Requires:       %pkg-modules = %version-%release
 
 %description -n %soname%sover
 Vector based 2D animation render.
@@ -65,34 +65,34 @@
 This package contains the shared library.
 
 %package        modules
-Summary:        Shared library part of %name
-Requires:       %name = %version
+Summary:        Shared library part of %pkg
+Requires:       %pkg = %version-%release
 
 %description    modules
 Vector based 2D animation render.
 
-This package contains modules for %name.
+This package contains modules for %pkg.
 
 %package        devel
-Summary:        Header files and static library for the %name library
-Requires:       %soname%sover = %version
-Provides:       %soname-devel = %version
-Obsoletes:      %soname-devel < %version
+Summary:        Header files and static library for the %pkg library
+Requires:       %soname%sover = %version-%release
+Provides:       %soname-devel = %version-%release
+Obsoletes:      %soname-devel < %version-%release
 
 %description    devel
 Vector based 2D animation render.
 
 This package contains the pkgconfig, header files and libraries needed to
-develop application that use %name.
+develop application that use %pkg.
 
 %package        doc
-Summary:        Documentation for %name
+Summary:        Documentation for %pkg
 BuildArch:      noarch
 
 %description    doc
 Vector based 2D animation render.
 
-This package provides documentation and several examples for %name.
+This package provides documentation and several examples for %pkg.
 
 %lang_package
 %endif
@@ -116,8 +116,8 @@
 BuildRequires:  pkgconfig(synfig)
 BuildRequires:  pkgconfig(gtkmm-3.0)
 BuildRequires:  pkgconfig(fontconfig)
-Summary:        Shared library part of %name
-Requires:       %name-modules = %version
+Summary:        Shared library part of %pkg
+Requires:       %pkg = %version
 
 %description -n synfigstudio
 %endif
@@ -148,7 +148,7 @@
 bash -x bootstrap.sh
 %endif
 CFLAGS='%optflags -Wno-deprecated-declarations'
-CXXFLAGS='%optflags -Wno-deprecated-declarations'
+CXXFLAGS='%optflags -Wno-deprecated-declarations -Wno-unused-parameter'
 %configure --help
 %configure \
 	--disable-update-mimedb \
@@ -169,7 +169,7 @@
 
 %if "%build_flavor" == ""
 popd
-%find_lang %name %{?no_lang_C} --without-gnome --without-kde
+%find_lang %pkg %{?no_lang_C} --without-gnome --without-kde
 
 find %buildroot -type f -name '*.la' -print -delete
 
@@ -196,7 +196,7 @@
 %files doc
 %dir %_libdir/%pkg
 
-%files lang -f %name.lang
+%files lang -f %pkg.lang
 %endif
 #
 %if "%build_flavor" == "ETL"

_service Changed

@@ -230,16 +230,7 @@
 		<param name="exclude">synfig-studio/TODO</param>
 		<param name="exclude">synfig-studio/analyze-clang.sh</param>
 		<param name="exclude">synfig-studio/analyze_cppcheck.sh</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/04_pen.myb</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/04_pen_prev.png</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/08_pen.myb</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/08_pen_prev.png</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/Big_BG.myb</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/Big_BG_prev.png</param>
 		<param name="exclude">synfig-studio/brushes/CD_concept/CMakeLists.txt</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/Eraser.myb</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/Eraser_prev.png</param>
-		<param name="exclude">synfig-studio/brushes/CD_concept/readme.txt</param>
 		<param name="exclude">synfig-studio/brushes/CMakeLists.txt</param>
 		<param name="exclude">synfig-studio/build_tools</param>
 		<param name="exclude">synfig-studio/config</param>
@@ -583,18 +574,11 @@
 		<param name="exclude">synfig-studio/sounds/readme.txt</param>
 		<param name="exclude">synfig-studio/sounds/renderdone.wav</param>
 		<param name="exclude">synfig-studio/src/CMakeLists.txt</param>
-		<param name="exclude">synfig-studio/src/brushlib.h</param>
 		<param name="exclude">synfig-studio/src/brushlib/README</param>
 		<param name="exclude">synfig-studio/src/brushlib/SConscript</param>
 		<param name="exclude">synfig-studio/src/brushlib/__init__.py</param>
-		<param name="exclude">synfig-studio/src/brushlib/brush.hpp</param>
-		<param name="exclude">synfig-studio/src/brushlib/brushlib.hpp</param>
-		<param name="exclude">synfig-studio/src/brushlib/brushsettings.hpp</param>
 		<param name="exclude">synfig-studio/src/brushlib/brushsettings.py</param>
 		<param name="exclude">synfig-studio/src/brushlib/generate.py</param>
-		<param name="exclude">synfig-studio/src/brushlib/helpers.hpp</param>
-		<param name="exclude">synfig-studio/src/brushlib/mapping.hpp</param>
-		<param name="exclude">synfig-studio/src/brushlib/surface.hpp</param>
 		<param name="exclude">synfig-studio/src/config.h.cmake.in</param>
 		<param name="exclude">synfig-studio/src/gui/CMakeLists.txt</param>
 		<param name="exclude">synfig-studio/src/gui/_smach.h</param>

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/04_pen.myb Added

@@ -0,0 +1,43 @@
+# mypaint brush file
+# you can edit this file and then select the brush in mypaint (again) to reload
+version 2
+tracking_noise 0.0
+speed2_gamma 4.0
+speed2_slowness 0.8
+stroke_holdtime 10.0
+stroke_duration_logarithmic 1.18
+slow_tracking 5.9
+change_color_v 0.0
+elliptical_dab_ratio 1.0
+change_color_h 0.0
+change_color_l 0.0
+offset_by_speed_slowness 1.0
+speed1_gamma 2.87
+slow_tracking_per_dab 5.99
+dabs_per_basic_radius 2.18
+opaque 1.0
+color_s 1.0
+opaque_multiply 0.0 | pressure (0.000000 0.000000), (0.015000 0.000000), (0.111765 0.958333), (1.000000 1.000000)
+elliptical_dab_angle 90.0
+lock_alpha 0.0
+eraser 0.0
+stroke_threshold 0.0
+color_h 0.188217257994
+smudge_radius_log 0.0
+speed1_slowness 0.04
+smudge 0.0
+change_color_hsv_s 0.0
+radius_by_random 0.0
+dabs_per_second 15.82
+color_v 0.0
+custom_input 0.0
+hardness 0.3
+opaque_linearize 0.46
+smudge_length 0.5
+radius_logarithmic 0.78 | pressure (0.000000 -0.537760), (0.088235 -0.464844), (0.139706 -0.218750), (0.169118 0.000000), (0.500000 0.000000), (1.000000 0.000000) | speed1 (0.000000 -0.000000), (0.582609 -0.000000), (1.617391 -0.250000), (2.747826 -0.708333), (4.000000 -2.000000)
+change_color_hsl_s 0.0
+custom_input_slowness 0.0
+offset_by_speed 0.0
+dabs_per_actual_radius 2.2
+offset_by_random 0.0
+direction_filter 2.0

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/04_pen_prev.png Added

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/08_pen.myb Added

@@ -0,0 +1,44 @@
+# mypaint brush file
+# you can edit this file and then select the brush in mypaint (again) to reload
+version 2
+tracking_noise 0.0
+speed2_gamma 4.0
+speed2_slowness 0.8
+stroke_holdtime 10.0
+stroke_duration_logarithmic 1.18
+slow_tracking 5.9
+change_color_v 0.0
+elliptical_dab_ratio 1.0
+change_color_h 0.0
+change_color_l 0.0
+offset_by_speed_slowness 1.0
+speed1_gamma 2.87
+slow_tracking_per_dab 5.99
+dabs_per_basic_radius 2.18
+opaque 1.0
+color_s 0.0
+opaque_multiply 0.0 | pressure (0.000000 0.000000), (0.015000 0.000000), (0.041304 0.854167), (1.000000 1.000000)
+elliptical_dab_angle 90.0
+lock_alpha 0.0
+eraser 0.0
+stroke_threshold 0.0
+color_h 0.0
+parent_brush_name CA_concept%2F08_pen%231
+smudge_radius_log 0.0
+speed1_slowness 0.04
+smudge 0.0
+change_color_hsv_s 0.0
+radius_by_random 0.0
+dabs_per_second 15.82
+color_v 0.0
+custom_input 0.0
+hardness 0.46
+opaque_linearize 0.46
+smudge_length 0.5
+radius_logarithmic 1.19 | pressure (0.000000 -0.537760), (0.088235 -0.464844), (0.139706 -0.218750), (0.169118 0.000000), (0.500000 0.000000), (1.000000 0.000000) | speed1 (0.000000 -0.000000), (0.582609 -0.000000), (1.617391 -0.250000), (2.747826 -0.708333), (4.000000 -2.000000)
+change_color_hsl_s 0.0
+custom_input_slowness 0.0
+offset_by_speed 0.0
+dabs_per_actual_radius 2.2
+offset_by_random 0.0
+direction_filter 2.0

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/08_pen_prev.png Added

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/Big_BG.myb Added

@@ -0,0 +1,43 @@
+# mypaint brush file
+# you can edit this file and then select the brush in mypaint (again) to reload
+version 2
+tracking_noise 0.0
+speed2_gamma 4.0
+speed2_slowness 0.9
+stroke_holdtime 0.0
+stroke_duration_logarithmic 4.0
+slow_tracking 0.0
+change_color_v 0.0
+elliptical_dab_ratio 10.0 | speed1 (0.000000 -7.500000), (0.962963 -2.031250), (4.000000 0.000000)
+change_color_h 0.0
+change_color_l 0.0
+offset_by_speed_slowness 1.0
+speed1_gamma 4.0
+slow_tracking_per_dab 0.0
+dabs_per_basic_radius 2.21
+opaque 0.0276044544717 | pressure (0.000000 1.000000), (1.000000 1.000000)
+color_s 0.312922107159
+opaque_multiply 0.0 | pressure (0.000000 0.000000), (0.058642 0.259792), (1.000000 0.430000)
+elliptical_dab_angle 19.29 | direction (0.000000 0.000000), (180.000000 180.000000)
+lock_alpha 0.0
+eraser 0.0
+stroke_threshold 0.0
+color_h 0.639299680067
+smudge_radius_log -1.6
+speed1_slowness 0.04
+smudge 0.9
+change_color_hsv_s 0.0
+radius_by_random 0.0
+dabs_per_second 28.87
+color_v 0.167370007536
+custom_input 0.0
+hardness 0.88
+opaque_linearize 0.9
+smudge_length 0.0
+radius_logarithmic 3.8 | pressure (0.000000 0.000000), (1.000000 1.530000)
+change_color_hsl_s 0.0
+custom_input_slowness 0.0
+offset_by_speed 0.0
+dabs_per_actual_radius 0.0
+offset_by_random 0.0
+direction_filter 2.0

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/Big_BG_prev.png Added

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/Eraser.myb Added

@@ -0,0 +1,44 @@
+# mypaint brush file
+# you can edit this file and then select the brush in mypaint (again) to reload
+version 2
+tracking_noise 0.0
+speed2_gamma 4.0
+speed2_slowness 0.9
+stroke_holdtime 0.0
+stroke_duration_logarithmic 4.0
+slow_tracking 0.0
+change_color_v 0.0
+elliptical_dab_ratio 10.0 | speed1 (0.000000 -7.500000), (0.962963 -2.031250), (4.000000 0.000000)
+change_color_h 0.0
+change_color_l 0.0
+offset_by_speed_slowness 1.0
+speed1_gamma 4.0
+slow_tracking_per_dab 0.0
+dabs_per_basic_radius 2.21
+opaque 1.69 | pressure (0.000000 0.927083), (1.000000 1.000000)
+color_s 0.0
+opaque_multiply 0.0 | pressure (0.000000 0.000000), (0.058642 0.259792), (1.000000 0.430000)
+elliptical_dab_angle 90.0 | direction (0.000000 0.000000), (180.000000 180.000000)
+lock_alpha 0.0
+eraser 1.0
+stroke_threshold 0.0
+color_h 0.0
+parent_brush_name CA_concept%2FEraser%231
+smudge_radius_log 0.0
+speed1_slowness 0.04
+smudge 0.9
+change_color_hsv_s 0.0
+radius_by_random 0.0
+dabs_per_second 11.08
+color_v 0.0
+custom_input 0.0
+hardness 0.52
+opaque_linearize 0.9
+smudge_length 0.5
+radius_logarithmic 1.68 | pressure (0.000000 0.000000), (1.000000 1.970000)
+change_color_hsl_s 0.0
+custom_input_slowness 0.0
+offset_by_speed 0.0
+dabs_per_actual_radius 0.0
+offset_by_random 0.0
+direction_filter 2.0

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/Eraser_prev.png Added

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/brushes/CD_concept/readme.txt Added

@@ -0,0 +1,26 @@
+
+================================================
+MyPaint 0.9.0 (or later) BrushPackage release                                                          
+*****  "Concept Design (C_D)"  *****                           
+                                               
+www.ramonmiranda.com 
+mirandagraphic@gmail.com                                           
+================================================
+A briefs words...
+-----------------
+"Concept Design" idea comes from conceptual design, where Markers and inks are very useful. I thought that it would be fun to have something similar inside mypaint so i made them.in this set we have 16 brushes with specific functions to improve the workflows and productivity.
+so please, feel free to change order, mix with other sets or whatever you want.
+
+Install notes
+-------------
+When install popup menu appears, select "OK" to install and then select the "Rename all" option if you want to have an independent set, or "Replace all" if you want to remove the older brushes.
+
+License
+-------
+Copyright 2011 Ramon Miranda
+
+Except where otherwise noted, these brushes are licensed under a Creative Commons Attribution 3.0 Unported License. See http://creativecommons.org/licenses/by/3.0/ for details.
+
+As an exception to this and to the extent possible under law, Ramon Miranda has waived all copyright and related or neighboring rights to the raw brush settings (those files ending with ".myb"). See http://creativecommons.org/publicdomain/zero/1.0/ for details.
+================================================
+

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib.h Added

@@ -0,0 +1,208 @@
+/* === S Y N F I G ========================================================= */
+/*!	\file brushlib.h
+**	\brief Helper file to integrte brushlib into synfig
+**
+**	\legal
+**	......... ... 2014 Ivan Mahonin
+**
+**	This file is part of Synfig.
+**
+**	Synfig is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 2 of the License, or
+**	(at your option) any later version.
+**
+**	Synfig is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with Synfig.  If not, see <https://www.gnu.org/licenses/>.
+**	\endlegal
+*/
+/* ========================================================================= */
+
+/* === S T A R T =========================================================== */
+
+#ifndef __SYNFIG_BRUSH_H
+#define __SYNFIG_BRUSH_H
+
+/* === H E A D E R S ======================================================= */
+
+#include <brushlib/brushlib.hpp>
+#include <synfig/angle.h> // we need PI
+#include <synfig/surface.h>
+
+/* === M A C R O S ========================================================= */
+
+/* === T Y P E D E F S ===================================================== */
+
+/* === C L A S S E S & S T R U C T S ======================================= */
+
+namespace brushlib {
+	class ActiveSurface: public Surface {
+	public:
+		virtual bool draw_dab(
+			float /* x */, float /* y */,
+			float /* radius */,
+			float /* color_r */, float /* color_g */, float /* color_b */,
+			float /* opaque */, float /* hardness */ = 0.5,
+			float /* alpha_eraser */ = 1.0,
+			float /* aspect_ratio */ = 1.0, float /* angle */ = 0.0,
+			float /* lock_alpha */ = 0.0
+		) { return false; };
+
+		virtual void get_color(
+			float /* x */, float /* y */,
+			float /* radius */,
+			float * color_r, float * color_g, float * color_b, float * color_a
+		) { *color_r = 0.f; *color_g = 0.f; *color_b = 0.f; *color_a = 0.f; };
+	};
+
+	class SurfaceWrapper: public ActiveSurface {
+	public:
+		typedef synfig::Surface surface_type;
+		surface_type *surface;
+		int extra_left;
+		int extra_right;
+		int extra_top;
+		int extra_bottom;
+		int offset_x;
+		int offset_y;
+
+		explicit SurfaceWrapper(surface_type* surface = nullptr):
+			surface(surface),
+			extra_left(0), extra_right(0),
+			extra_top(0), extra_bottom(0),
+			offset_x(0), offset_y(0) { }
+
+		void reset() {
+			extra_left = 0;
+			extra_right = 0;
+			extra_top = 0;
+			extra_bottom = 0;
+			offset_x = 0;
+			offset_y = 0;
+		}
+
+		virtual bool draw_dab(
+			float x, float y,
+			float radius,
+			float color_r, float color_g, float color_b,
+			float opaque, float hardness = 0.5,
+			float alpha_eraser = 1.0,
+			float aspect_ratio = 1.0, float angle = 0.0,
+			float /* lock_alpha */ = 0.0
+		) {
+			if (!surface) return false;
+
+			x += (float)offset_x;
+			y += (float)offset_y;
+
+			float cs = cosf(angle/180.f*(float)PI);
+			float sn = sinf(angle/180.f*(float)PI);
+
+			// calculate bounds
+			if (aspect_ratio < 1.0) aspect_ratio = 1.0;
+			if (hardness > 1.0) hardness = 1.0;
+			if (hardness < 0.0) hardness = 0.0;
+			float maxr = fabsf(radius);
+			int x0 = (int)(x - maxr - 1.f);
+			int x1 = (int)(x + maxr + 1.f);
+			int y0 = (int)(y - maxr - 1.f);
+			int y1 = (int)(y + maxr + 1.f);
+
+			if (x0 < 0
+			 || y0 < 0
+			 || x1+1 > surface->get_w()
+			 || y1+1 > surface->get_h() )
+			{
+				int l = x0 < 0 ? x0 : 0;
+				int t = y0 < 0 ? y0 : 0;
+				int r = x1+1 > surface->get_w() ? x1+1 : surface->get_w();
+				int b = y1+1 > surface->get_h() ? y1+1 : surface->get_h();
+
+				extra_left   -= l; // increase because l and t is negative
+				extra_top    -= t;
+				extra_right  += r - surface->get_w();
+				extra_bottom += b - surface->get_h();
+
+				synfig::Surface tmp;
+				tmp = *surface;
+				surface->set_wh(r-l, b-t);
+				surface->clear();
+				synfig::Surface::pen p(surface->get_pen(-l, -t));
+				tmp.blit_to(p);
+
+				offset_x -= l;
+				offset_y -= t;
+				x -= (float)l; y -= (float)t;
+				x0 -= l; y0 -= t;
+				x1 -= l; y1 -= t;
+			}
+
+			bool erase = alpha_eraser < 1.0;
+			for(int py = y0; py <= y1; py++)
+			{
+				for(int px = x0; px <= x1; px++)
+				{
+					float dx = (float)px - x;
+					float dy = (float)py - y;
+					float dyr = (dy*cs-dx*sn)*aspect_ratio;
+					float dxr = (dy*sn+dx*cs);
+					float dd = (dyr*dyr + dxr*dxr) / (radius*radius);
+					if (dd <= 1.f)
+					{
+						float opa = dd < hardness
+								  ? dd + 1-(dd/hardness)
+								  : hardness/(1-hardness)*(1-dd);
+						opa *= opaque;
+						synfig::Color &c = (*surface)pypx;
+						if (erase)
+						{
+							c.set_a(c.get_a()*(1.0 - (1.0 - alpha_eraser)*opa));
+						}
+						else
+						{
+							float sum_alpha = opa + c.get_a();
+							if (sum_alpha > 1.0) sum_alpha = 1.0;
+							float inv_opa = sum_alpha - opa;
+							c.set_r(c.get_r()*inv_opa + color_r*opa);
+							c.set_g(c.get_g()*inv_opa + color_g*opa);
+							c.set_b(c.get_b()*inv_opa + color_b*opa);
+							c.set_a(sum_alpha);
+						}
+					}
+				}
+			}
+
+			return true;
+		};
+
+		virtual void get_color(
+			float x, float y,
+			float /* radius */,
+			float * color_r, float * color_g, float * color_b, float * color_a
+		) {
+			if (!surface) {
+				*color_r = 0.f; *color_g = 0.f; *color_b = 0.f; *color_a = 0.f;
+				return;
+			}
+
+			x += (float)offset_x;
+			y += (float)offset_y;
+
+			synfig::Color c = surface->cubic_sample(x, y);
+			*color_r = c.get_r();
+			*color_g = c.get_g();
+			*color_b = c.get_b();
+			*color_a = c.get_a();
+		};
+	};
+
+}; // END of namespace brush
+
+/* === E N D =============================================================== */
+
+#endif

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib/brush.hpp Added

@@ -0,0 +1,827 @@
+/* brushlib - The MyPaint Brush Library
+ * Copyright (C) 2007-2011 Martin Renold <martinxyz@gmx.ch>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <cmath>
+//#include "Python.h"
+
+#include "brushsettings.hpp"
+#include "mapping.hpp"
+
+#define ACTUAL_RADIUS_MIN 0.2
+#define ACTUAL_RADIUS_MAX 800 // safety guard against radius like 1e20 and against rendering overload with unexpected brush dynamics
+
+/* The Brush class stores two things:
+   b) settings: constant during a stroke (eg. size, spacing, dynamics, color selected by the user)
+   a) states: modified during a stroke (eg. speed, smudge colors, time/distance to next dab, position filter states)
+
+   FIXME: Actually those are two orthogonal things. Should separate them:
+          a) brush settings class that is saved/loaded/selected  (without states)
+          b) brush core class to draw the dabs (using an instance of the above)
+
+   In python, there are two kinds of instances from this: a "global
+   brush" which does the cursor tracking, and the "brushlist" where
+   the states are ignored. When a brush is selected, its settings are
+   copied into the global one, leaving the state intact.
+ */
+
+namespace brushlib {
+
+class Brush {
+public:
+  bool print_inputs; // debug menu
+  // for stroke splitting (undo/redo)
+  double stroke_total_painting_time;
+  double stroke_current_idling_time; 
+
+private:
+  // see also brushsettings.py
+
+  // the states (get_state, set_state, reset) that change during a stroke
+  float statesSTATE_COUNT;
+  GRand * rng;
+
+  // Those mappings describe how to calculate the current value for each setting.
+  // Most of settings will be constant (eg. only their base_value is used).
+  Mapping * settingsBRUSH_SETTINGS_COUNT;
+
+  // the current value of all settings (calculated using the current state)
+  float settings_valueBRUSH_SETTINGS_COUNT;
+
+  // cached calculation results
+  float speed_mapping_gamma2, speed_mapping_m2, speed_mapping_q2;
+
+  bool reset_requested;
+
+public:
+  Brush() {
+    for (int i=0; i<BRUSH_SETTINGS_COUNT; i++) {
+      settingsi = new Mapping(INPUT_COUNT);
+    }
+    rng = g_rand_new();
+    print_inputs = false;
+    
+    for (int i=0; i<STATE_COUNT; i++) {
+      statesi = 0;
+    }
+    new_stroke();
+
+    settings_base_values_have_changed();
+
+    reset_requested = true;
+  }
+
+  ~Brush() {
+    for (int i=0; i<BRUSH_SETTINGS_COUNT; i++) {
+      delete settingsi;
+    }
+    g_rand_free(rng); rng = nullptr;
+  }
+
+  void reset()
+  {
+    reset_requested = true;
+  }
+
+  void new_stroke()
+  {
+    stroke_current_idling_time = 0;
+    stroke_total_painting_time = 0;
+  }
+
+  void set_base_value (int id, float value) {
+    assert (id >= 0 && id < BRUSH_SETTINGS_COUNT);
+    settingsid->base_value = value;
+
+    settings_base_values_have_changed ();
+  }
+
+  void set_mapping_n (int id, int input, int n) {
+    assert (id >= 0 && id < BRUSH_SETTINGS_COUNT);
+    settingsid->set_n (input, n);
+  }
+
+  void set_mapping_point (int id, int input, int index, float x, float y) {
+    assert (id >= 0 && id < BRUSH_SETTINGS_COUNT);
+    settingsid->set_point (input, index, x, y);
+  }
+
+  float get_state (int i)
+  {
+    assert (i >= 0 && i < STATE_COUNT);
+    return statesi;
+  }
+
+  void set_state (int i, float value)
+  {
+    assert (i >= 0 && i < STATE_COUNT);
+    statesi = value;
+  }
+
+private:
+  // returns the fraction still left after t seconds
+  float exp_decay (float T_const, float t)
+  {
+    // the argument might not make mathematical sense (whatever.)
+    if (T_const <= 0.001) {
+      return 0.0;
+    } else {
+      return exp(- t / T_const);
+    }
+  }
+
+
+  void settings_base_values_have_changed ()
+  {
+    // precalculate stuff that does not change dynamically
+
+    // Precalculate how the physical speed will be mapped to the speed input value.
+    // The formula for this mapping is:
+    //
+    // y = log(gamma+x)*m + q;
+    //
+    // x: the physical speed (pixels per basic dab radius)
+    // y: the speed input that will be reported
+    // gamma: parameter set by this user (small means a logarithmic mapping, big linear)
+    // m, q: parameters to scale and translate the curve
+    //
+    // The code below calculates m and q given gamma and two hardcoded constraints.
+    //
+    for (int i=0; i<2; i++) {
+      float gamma;
+      gamma = settings(i==0)?BRUSH_SPEED1_GAMMA:BRUSH_SPEED2_GAMMA->base_value;
+      gamma = exp(gamma);
+
+      float fix1_x, fix1_y, fix2_x, fix2_dy;
+      fix1_x = 45.0;
+      fix1_y = 0.5;
+      fix2_x = 45.0;
+      fix2_dy = 0.015;
+
+      float m, q;
+      float c1;
+      c1 = log(fix1_x+gamma);
+      m = fix2_dy * (fix2_x + gamma);
+      q = fix1_y - m*c1;
+    
+      speed_mapping_gammai = gamma;
+      speed_mapping_mi = m;
+      speed_mapping_qi = q;
+    }
+  }
+
+  // This function runs a brush "simulation" step. Usually it is
+  // called once or twice per dab. In theory the precision of the
+  // "simulation" gets better when it is called more often. In
+  // practice this only matters if there are some highly nonlinear
+  // mappings in critical places or extremely few events per second.
+  //
+  // note: parameters are is dx/ddab, ..., dtime/ddab (dab is the number, 5.0 = 5th dab)
+  void update_states_and_setting_values (float step_dx, float step_dy, float step_dpressure, float step_declination, float step_ascension, float step_dtime)
+  {
+    float pressure;
+    float inputsINPUT_COUNT;
+
+    if (step_dtime < 0.0) {
+      printf("Time is running backwards!\n");
+      step_dtime = 0.001;
+    } else if (step_dtime == 0.0) {
+      // FIXME: happens about every 10th start, workaround (against division by zero)
+      step_dtime = 0.001;
+    }
+
+    statesSTATE_X        += step_dx;
+    statesSTATE_Y        += step_dy;
+    statesSTATE_PRESSURE += step_dpressure;
+
+    statesSTATE_DECLINATION += step_declination;
+    statesSTATE_ASCENSION += step_ascension;
+
+    float base_radius = expf(settingsBRUSH_RADIUS_LOGARITHMIC->base_value);
+
+    // FIXME: does happen (interpolation problem?)
+    statesSTATE_PRESSURE = CLAMP(statesSTATE_PRESSURE, 0.0, 1.0);
+    pressure = statesSTATE_PRESSURE;
+
+    { // start / end stroke (for "stroke" input only)
+      if (!statesSTATE_STROKE_STARTED) {
+        if (pressure > settingsBRUSH_STROKE_THRESHOLD->base_value + 0.0001) {
+          // start new stroke
+          //printf("stroke start %f\n", pressure);
+          statesSTATE_STROKE_STARTED = 1;
+          statesSTATE_STROKE = 0.0;
+        }
+      } else {
+        if (pressure <= settingsBRUSH_STROKE_THRESHOLD->base_value * 0.9 + 0.0001) {
+          // end stroke
+          //printf("stroke end\n");
+          statesSTATE_STROKE_STARTED = 0;
+        }
+      }
+    }
+
+    // now follows input handling
+
+    float norm_dx, norm_dy, norm_dist, norm_speed;
+    norm_dx = step_dx / step_dtime / base_radius;
+    norm_dy = step_dy / step_dtime / base_radius;
+    norm_speed = sqrt(SQR(norm_dx) + SQR(norm_dy));
+    norm_dist = norm_speed * step_dtime;
+
+    inputsINPUT_PRESSURE = pressure;
+    inputsINPUT_SPEED1 = log(speed_mapping_gamma0 + statesSTATE_NORM_SPEED1_SLOW)*speed_mapping_m0 + speed_mapping_q0;
+    inputsINPUT_SPEED2 = log(speed_mapping_gamma1 + statesSTATE_NORM_SPEED2_SLOW)*speed_mapping_m1 + speed_mapping_q1;
+    inputsINPUT_RANDOM = g_rand_double (rng);
+    inputsINPUT_STROKE = MIN(statesSTATE_STROKE, 1.0);
+    inputsINPUT_DIRECTION = fmodf (atan2f (statesSTATE_DIRECTION_DY, statesSTATE_DIRECTION_DX)/(2*M_PI)*360 + 180.0, 180.0);
+    inputsINPUT_TILT_DECLINATION = statesSTATE_DECLINATION;
+    inputsINPUT_TILT_ASCENSION = statesSTATE_ASCENSION;
+    inputsINPUT_CUSTOM = statesSTATE_CUSTOM_INPUT;
+    if (print_inputs) {
+      g_print("press=% 4.3f, speed1=% 4.4f\tspeed2=% 4.4f\tstroke=% 4.3f\tcustom=% 4.3f\n", (double)inputsINPUT_PRESSURE, (double)inputsINPUT_SPEED1, (double)inputsINPUT_SPEED2, (double)inputsINPUT_STROKE, (double)inputsINPUT_CUSTOM);
+    }
+    // FIXME: this one fails!!!
+    //assert(inputsINPUT_SPEED1 >= 0.0 && inputsINPUT_SPEED1 < 1e8); // checking for inf
+
+    for (int i=0; i<BRUSH_SETTINGS_COUNT; i++) {
+      settings_valuei = settingsi->calculate (inputs);
+    }
+
+    {
+      float fac = 1.0 - exp_decay (settings_valueBRUSH_SLOW_TRACKING_PER_DAB, 1.0);
+      statesSTATE_ACTUAL_X += (statesSTATE_X - statesSTATE_ACTUAL_X) * fac; // FIXME: should this depend on base radius?
+      statesSTATE_ACTUAL_Y += (statesSTATE_Y - statesSTATE_ACTUAL_Y) * fac;
+    }
+
+    { // slow speed
+      float fac;
+      fac = 1.0 - exp_decay (settings_valueBRUSH_SPEED1_SLOWNESS, step_dtime);
+      statesSTATE_NORM_SPEED1_SLOW += (norm_speed - statesSTATE_NORM_SPEED1_SLOW) * fac;
+      fac = 1.0 - exp_decay (settings_valueBRUSH_SPEED2_SLOWNESS, step_dtime);
+      statesSTATE_NORM_SPEED2_SLOW += (norm_speed - statesSTATE_NORM_SPEED2_SLOW) * fac;
+    }
+  
+    { // slow speed, but as vector this time
+
+      // FIXME: offset_by_speed should be removed.
+      //   Is it broken, non-smooth, system-dependent math?!
+      //   A replacement could be a directed random offset.
+
+      float time_constant = exp(settings_valueBRUSH_OFFSET_BY_SPEED_SLOWNESS*0.01)-1.0;
+      // Workaround for a bug that happens mainly on Windows, causing
+      // individual dabs to be placed far far away. Using the speed
+      // with zero filtering is just asking for trouble anyway.
+      if (time_constant < 0.002) time_constant = 0.002;
+      float fac = 1.0 - exp_decay (time_constant, step_dtime);
+      statesSTATE_NORM_DX_SLOW += (norm_dx - statesSTATE_NORM_DX_SLOW) * fac;
+      statesSTATE_NORM_DY_SLOW += (norm_dy - statesSTATE_NORM_DY_SLOW) * fac;
+    }
+
+    { // orientation (similar lowpass filter as above, but use dabtime instead of wallclock time)
+      float dx = step_dx / base_radius;
+      float dy = step_dy / base_radius;
+      float step_in_dabtime = hypotf(dx, dy); // FIXME: are we recalculating something here that we already have?
+      float fac = 1.0 - exp_decay (exp(settings_valueBRUSH_DIRECTION_FILTER*0.5)-1.0, step_in_dabtime);
+
+      float dx_old = statesSTATE_DIRECTION_DX;
+      float dy_old = statesSTATE_DIRECTION_DY;
+      // use the opposite speed vector if it is closer (we don't care about 180 degree turns)
+      if (SQR(dx_old-dx) + SQR(dy_old-dy) > SQR(dx_old-(-dx)) + SQR(dy_old-(-dy))) {
+        dx = -dx;
+        dy = -dy;
+      }
+      statesSTATE_DIRECTION_DX += (dx - statesSTATE_DIRECTION_DX) * fac;
+      statesSTATE_DIRECTION_DY += (dy - statesSTATE_DIRECTION_DY) * fac;
+    }
+
+    { // custom input
+      float fac;
+      fac = 1.0 - exp_decay (settings_valueBRUSH_CUSTOM_INPUT_SLOWNESS, 0.1);
+      statesSTATE_CUSTOM_INPUT += (settings_valueBRUSH_CUSTOM_INPUT - statesSTATE_CUSTOM_INPUT) * fac;
+    }
+
+    { // stroke length
+      float frequency;
+      float wrap;
+      frequency = expf(-settings_valueBRUSH_STROKE_DURATION_LOGARITHMIC);
+      statesSTATE_STROKE += norm_dist * frequency;
+      // can happen, probably caused by rounding
+      if (statesSTATE_STROKE < 0) statesSTATE_STROKE = 0;
+      wrap = 1.0 + settings_valueBRUSH_STROKE_HOLDTIME;
+      if (statesSTATE_STROKE > wrap) {
+        if (wrap > 9.9 + 1.0) {
+          // "infinity", just hold stroke somewhere >= 1.0
+          statesSTATE_STROKE = 1.0;
+        } else {
+          statesSTATE_STROKE = fmodf(statesSTATE_STROKE, wrap);
+          // just in case
+          if (statesSTATE_STROKE < 0) statesSTATE_STROKE = 0;
+        }
+      }
+    }
+
+    // calculate final radius
+    float radius_log;
+    radius_log = settings_valueBRUSH_RADIUS_LOGARITHMIC;
+    statesSTATE_ACTUAL_RADIUS = expf(radius_log);
+    if (statesSTATE_ACTUAL_RADIUS < ACTUAL_RADIUS_MIN) statesSTATE_ACTUAL_RADIUS = ACTUAL_RADIUS_MIN;
+    if (statesSTATE_ACTUAL_RADIUS > ACTUAL_RADIUS_MAX) statesSTATE_ACTUAL_RADIUS = ACTUAL_RADIUS_MAX;
+
+    // aspect ratio (needs to be calculated here because it can affect the dab spacing)
+    statesSTATE_ACTUAL_ELLIPTICAL_DAB_RATIO = settings_valueBRUSH_ELLIPTICAL_DAB_RATIO;
+    statesSTATE_ACTUAL_ELLIPTICAL_DAB_ANGLE = settings_valueBRUSH_ELLIPTICAL_DAB_ANGLE;
+  }
+
+  // Called only from stroke_to(). Calculate everything needed to
+  // draw the dab, then let the surface do the actual drawing.
+  //
+  // This is only gets called right after update_states_and_setting_values().
+  // Returns true if the surface was modified.
+  bool prepare_and_draw_dab (Surface * surface)
+  {
+    float x, y, opaque;
+    float radius;
+
+    // ensure we don't get a positive result with two negative opaque values
+    if (settings_valueBRUSH_OPAQUE < 0) settings_valueBRUSH_OPAQUE = 0;
+    opaque = settings_valueBRUSH_OPAQUE * settings_valueBRUSH_OPAQUE_MULTIPLY;
+    opaque = CLAMP(opaque, 0.0, 1.0);
+    //if (opaque == 0.0) return false; <-- cannot do that, since we need to update smudge state.
+    if (settings_valueBRUSH_OPAQUE_LINEARIZE) {
+      // OPTIMIZE: no need to recalculate this for each dab
+      float alpha, beta, alpha_dab, beta_dab;
+      float dabs_per_pixel;
+      // dabs_per_pixel is just estimated roughly, I didn't think hard
+      // about the case when the radius changes during the stroke
+      dabs_per_pixel = (
+                        settingsBRUSH_DABS_PER_ACTUAL_RADIUS->base_value + 
+                        settingsBRUSH_DABS_PER_BASIC_RADIUS->base_value
+                        ) * 2.0;
+
+      // the correction is probably not wanted if the dabs don't overlap
+      if (dabs_per_pixel < 1.0) dabs_per_pixel = 1.0;
+
+      // interpret the user-setting smoothly
+      dabs_per_pixel = 1.0 + settingsBRUSH_OPAQUE_LINEARIZE->base_value*(dabs_per_pixel-1.0);
+
+      // see doc/brushdab_saturation.png
+      //      beta = beta_dab^dabs_per_pixel
+      // <==> beta_dab = beta^(1/dabs_per_pixel)
+      alpha = opaque;
+      beta = 1.0-alpha;
+      beta_dab = powf(beta, 1.0/dabs_per_pixel);
+      alpha_dab = 1.0-beta_dab;
+      opaque = alpha_dab;
+    }
+
+    x = statesSTATE_ACTUAL_X;
+    y = statesSTATE_ACTUAL_Y;
+
+    float base_radius = expf(settingsBRUSH_RADIUS_LOGARITHMIC->base_value);
+
+    if (settings_valueBRUSH_OFFSET_BY_SPEED) {
+      x += statesSTATE_NORM_DX_SLOW * settings_valueBRUSH_OFFSET_BY_SPEED * 0.1 * base_radius;
+      y += statesSTATE_NORM_DY_SLOW * settings_valueBRUSH_OFFSET_BY_SPEED * 0.1 * base_radius;
+    }
+
+    if (settings_valueBRUSH_OFFSET_BY_RANDOM) {
+      float amp = settings_valueBRUSH_OFFSET_BY_RANDOM;
+      if (amp < 0.0) amp = 0.0;
+      x += rand_gauss (rng) * amp * base_radius;
+      y += rand_gauss (rng) * amp * base_radius;
+    }
+
+  
+    radius = statesSTATE_ACTUAL_RADIUS;
+    if (settings_valueBRUSH_RADIUS_BY_RANDOM) {
+      float radius_log, alpha_correction;
+      // go back to logarithmic radius to add the noise
+      radius_log  = settings_valueBRUSH_RADIUS_LOGARITHMIC;
+      radius_log += rand_gauss (rng) * settings_valueBRUSH_RADIUS_BY_RANDOM;
+      radius = expf(radius_log);
+      radius = CLAMP(radius, ACTUAL_RADIUS_MIN, ACTUAL_RADIUS_MAX);
+      alpha_correction = statesSTATE_ACTUAL_RADIUS / radius;
+      alpha_correction = SQR(alpha_correction);
+      if (alpha_correction <= 1.0) {
+        opaque *= alpha_correction;
+      }
+    }
+
+    // color part
+
+    float color_h = settingsBRUSH_COLOR_H->base_value;
+    float color_s = settingsBRUSH_COLOR_S->base_value;
+    float color_v = settingsBRUSH_COLOR_V->base_value;
+    float eraser_target_alpha = 1.0;
+    if (settings_valueBRUSH_SMUDGE > 0.0) {
+      // mix (in RGB) the smudge color with the brush color
+      hsv_to_rgb_float (&color_h, &color_s, &color_v);
+      float fac = settings_valueBRUSH_SMUDGE;
+      if (fac > 1.0) fac = 1.0;
+      // If the smudge color somewhat transparent, then the resulting
+      // dab will do erasing towards that transparency level.
+      // see also ../doc/smudge_math.png
+      eraser_target_alpha = (1-fac)*1.0 + fac*statesSTATE_SMUDGE_A;
+      // fix rounding errors (they really seem to happen in the previous line)
+      eraser_target_alpha = CLAMP(eraser_target_alpha, 0.0, 1.0);
+      if (eraser_target_alpha > 0) {
+        color_h = (fac*statesSTATE_SMUDGE_RA + (1-fac)*color_h) / eraser_target_alpha;
+        color_s = (fac*statesSTATE_SMUDGE_GA + (1-fac)*color_s) / eraser_target_alpha;
+        color_v = (fac*statesSTATE_SMUDGE_BA + (1-fac)*color_v) / eraser_target_alpha;
+      } else {
+        // we are only erasing; the color does not matter
+        color_h = 1.0;
+        color_s = 0.0;
+        color_v = 0.0;
+      }
+      rgb_to_hsv_float (&color_h, &color_s, &color_v);
+    }
+
+    if (settings_valueBRUSH_SMUDGE_LENGTH < 1.0 &&
+        // optimization, since normal brushes have smudge_length == 0.5 without actually smudging
+        (settings_valueBRUSH_SMUDGE != 0.0 || !settingsBRUSH_SMUDGE->is_constant())) {
+
+      float fac = settings_valueBRUSH_SMUDGE_LENGTH;
+      if (fac < 0.01) fac = 0.01;
+      int px, py;
+      px = ROUND(x);
+      py = ROUND(y);
+
+      // Calling get_color() is almost as expensive as rendering a
+      // dab. Because of this we use the previous value if it is not
+      // expected to hurt quality too much. We call it at most every
+      // second dab.
+      float r, g, b, a;
+      statesSTATE_LAST_GETCOLOR_RECENTNESS *= fac;
+      if (statesSTATE_LAST_GETCOLOR_RECENTNESS < 0.5*fac) {
+        statesSTATE_LAST_GETCOLOR_RECENTNESS = 1.0;
+
+        float smudge_radius = radius * expf(settings_valueBRUSH_SMUDGE_RADIUS_LOG);
+        smudge_radius = CLAMP(smudge_radius, ACTUAL_RADIUS_MIN, ACTUAL_RADIUS_MAX);
+        surface->get_color (px, py, smudge_radius, &r, &g, &b, &a);
+
+        statesSTATE_LAST_GETCOLOR_R = r;
+        statesSTATE_LAST_GETCOLOR_G = g;
+        statesSTATE_LAST_GETCOLOR_B = b;
+        statesSTATE_LAST_GETCOLOR_A = a;
+      } else {
+        r = statesSTATE_LAST_GETCOLOR_R;
+        g = statesSTATE_LAST_GETCOLOR_G;
+        b = statesSTATE_LAST_GETCOLOR_B;
+        a = statesSTATE_LAST_GETCOLOR_A;
+      }
+
+      // updated the smudge color (stored with premultiplied alpha)
+      statesSTATE_SMUDGE_A  = fac*statesSTATE_SMUDGE_A  + (1-fac)*a;
+      // fix rounding errors
+      statesSTATE_SMUDGE_A  = CLAMP(statesSTATE_SMUDGE_A, 0.0, 1.0);
+
+      statesSTATE_SMUDGE_RA = fac*statesSTATE_SMUDGE_RA + (1-fac)*r*a;
+      statesSTATE_SMUDGE_GA = fac*statesSTATE_SMUDGE_GA + (1-fac)*g*a;
+      statesSTATE_SMUDGE_BA = fac*statesSTATE_SMUDGE_BA + (1-fac)*b*a;
+    }
+
+    // eraser
+    if (settings_valueBRUSH_ERASER) {
+      eraser_target_alpha *= (1.0-settings_valueBRUSH_ERASER);
+    }
+
+    // HSV color change
+    color_h += settings_valueBRUSH_CHANGE_COLOR_H;
+    color_s += settings_valueBRUSH_CHANGE_COLOR_HSV_S;
+    color_v += settings_valueBRUSH_CHANGE_COLOR_V;
+
+    // HSL color change
+    if (settings_valueBRUSH_CHANGE_COLOR_L || settings_valueBRUSH_CHANGE_COLOR_HSL_S) {
+      // (calculating way too much here, can be optimized if necessary)
+      // this function will CLAMP the inputs
+      hsv_to_rgb_float (&color_h, &color_s, &color_v);
+      rgb_to_hsl_float (&color_h, &color_s, &color_v);
+      color_v += settings_valueBRUSH_CHANGE_COLOR_L;
+      color_s += settings_valueBRUSH_CHANGE_COLOR_HSL_S;
+      hsl_to_rgb_float (&color_h, &color_s, &color_v);
+      rgb_to_hsv_float (&color_h, &color_s, &color_v);
+    }
+
+    float hardness = CLAMP(settings_valueBRUSH_HARDNESS, 0.0, 1.0);
+
+    // anti-aliasing attempt (works surprisingly well for ink brushes)
+    float current_fadeout_in_pixels = radius * (1.0 - hardness);
+    float min_fadeout_in_pixels = settings_valueBRUSH_ANTI_ALIASING;
+    if (current_fadeout_in_pixels < min_fadeout_in_pixels) {
+      // need to soften the brush (decrease hardness), but keep optical radius
+      // so we tune both radius and hardness, to get the desired fadeout_in_pixels
+      float current_optical_radius = radius - (1.0-hardness)*radius/2.0;
+
+      // Equation 1: (new fadeout must be equal to min_fadeout)
+      //   min_fadeout_in_pixels = radius_new*(1.0 - hardness_new)
+      // Equation 2: (optical radius must remain unchanged)
+      //   current_optical_radius = radius_new - (1.0-hardness_new)*radius_new/2.0
+      //
+      // Solved Equation 1 for hardness_new, using Equation 2: (thanks to mathomatic)
+      float hardness_new = ((current_optical_radius - (min_fadeout_in_pixels/2.0))/(current_optical_radius + (min_fadeout_in_pixels/2.0)));
+      // Using Equation 1:
+      float radius_new = (min_fadeout_in_pixels/(1.0 - hardness_new));
+
+      hardness = hardness_new;
+      radius = radius_new;
+    }
+
+    // the functions below will CLAMP most inputs
+    hsv_to_rgb_float (&color_h, &color_s, &color_v);
+    return surface->draw_dab (x, y, radius, color_h, color_s, color_v, opaque, hardness, eraser_target_alpha,
+                              statesSTATE_ACTUAL_ELLIPTICAL_DAB_RATIO, statesSTATE_ACTUAL_ELLIPTICAL_DAB_ANGLE,
+                              settings_valueBRUSH_LOCK_ALPHA);
+  }
+
+  // How many dabs will be drawn between the current and the next (x, y, pressure, +dt) position?
+  // WARNING: pressure is not used
+  float count_dabs_to (float x, float y, float /* pressure */, float dt)
+  {
+    float xx, yy;
+    float res1, res2, res3;
+    float dist;
+
+    if (statesSTATE_ACTUAL_RADIUS == 0.0) statesSTATE_ACTUAL_RADIUS = expf(settingsBRUSH_RADIUS_LOGARITHMIC->base_value);
+    if (statesSTATE_ACTUAL_RADIUS < ACTUAL_RADIUS_MIN) statesSTATE_ACTUAL_RADIUS = ACTUAL_RADIUS_MIN;
+    if (statesSTATE_ACTUAL_RADIUS > ACTUAL_RADIUS_MAX) statesSTATE_ACTUAL_RADIUS = ACTUAL_RADIUS_MAX;
+
+
+    // OPTIMIZE: expf() called too often
+    float base_radius = expf(settingsBRUSH_RADIUS_LOGARITHMIC->base_value);
+    if (base_radius < ACTUAL_RADIUS_MIN) base_radius = ACTUAL_RADIUS_MIN;
+    if (base_radius > ACTUAL_RADIUS_MAX) base_radius = ACTUAL_RADIUS_MAX;
+    //if (base_radius < 0.5) base_radius = 0.5;
+    //if (base_radius > 500.0) base_radius = 500.0;
+
+    xx = x - statesSTATE_X;
+    yy = y - statesSTATE_Y;
+    //dp = pressure - pressure; // Not useful?
+    // TODO: control rate with pressure (dabs per pressure) (dpressure is useless)
+
+    if (statesSTATE_ACTUAL_ELLIPTICAL_DAB_RATIO > 1.0) {
+      // code duplication, see tiledsurface::draw_dab()
+      float angle_rad=statesSTATE_ACTUAL_ELLIPTICAL_DAB_ANGLE/360*2*M_PI;
+      float cs=cos(angle_rad);
+      float sn=sin(angle_rad);
+      float yyr=(yy*cs-xx*sn)*statesSTATE_ACTUAL_ELLIPTICAL_DAB_RATIO;
+      float xxr=yy*sn+xx*cs;
+      dist = sqrt(yyr*yyr + xxr*xxr);
+    } else {
+      dist = hypotf(xx, yy);
+    }
+
+    // FIXME: no need for base_value or for the range checks above IF always the interpolation
+    //        function will be called before this one
+    res1 = dist / statesSTATE_ACTUAL_RADIUS * settingsBRUSH_DABS_PER_ACTUAL_RADIUS->base_value;
+    res2 = dist / base_radius   * settingsBRUSH_DABS_PER_BASIC_RADIUS->base_value;
+    res3 = dt * settingsBRUSH_DABS_PER_SECOND->base_value;
+    return res1 + res2 + res3;
+  }
+
+public:
+  // This function:
+  // - is called once for each motion event
+  // - does motion event interpolation
+  // - paints zero, one or several dabs
+  // - decides whether the stroke is finished (for undo/redo)
+  // returns true if the stroke is finished or empty
+  bool stroke_to (Surface * surface, float x, float y, float pressure, float xtilt, float ytilt, double dtime)
+  {
+    //printf("%f %f %f %f\n", (double)dtime, (double)x, (double)y, (double)pressure);
+
+    float tilt_ascension = 0.0;
+    float tilt_declination = 90.0;
+    if (xtilt != 0 || ytilt != 0) {
+      // shield us from insane tilt input
+      xtilt = CLAMP(xtilt, -1.0, 1.0);
+      ytilt = CLAMP(ytilt, -1.0, 1.0);
+      assert(std::isfinite(xtilt) && std::isfinite(ytilt));
+
+      tilt_ascension = 180.0*atan2(-xtilt, ytilt)/M_PI;
+      float e;
+	  if (std::fabs(xtilt) > std::fabs(ytilt)) {
+        e = sqrt(1+ytilt*ytilt);
+      } else {
+        e = sqrt(1+xtilt*xtilt);
+      }
+      float rad = hypot(xtilt, ytilt);
+      float cos_alpha = rad/e;
+      if (cos_alpha >= 1.0) cos_alpha = 1.0; // fix numerical inaccuracy
+      tilt_declination = 180.0*acos(cos_alpha)/M_PI;
+
+      assert(std::isfinite(tilt_ascension));
+      assert(std::isfinite(tilt_declination));
+    }
+
+    // printf("xtilt %f, ytilt %f\n", (double)xtilt, (double)ytilt);
+    // printf("ascension %f, declination %f\n", (double)tilt_ascension, (double)tilt_declination);
+      
+    pressure = CLAMP(pressure, 0.0, 1.0);
+    if (!std::isfinite(x) || !std::isfinite(y) ||
+        (x > 1e10 || y > 1e10 || x < -1e10 || y < -1e10)) {
+      // workaround attempt for https://gna.org/bugs/?14372
+      g_print("Warning: ignoring brush::stroke_to with insane inputs (x = %f, y = %f)\n", (double)x, (double)y);
+      x = 0.0;
+      y = 0.0;
+      pressure = 0.0;
+    }
+    // the assertion below is better than out-of-memory later at save time
+    assert(x < 1e8 && y < 1e8 && x > -1e8 && y > -1e8);
+
+    if (dtime < 0) g_print("Time jumped backwards by dtime=%f seconds!\n", dtime);
+    if (dtime <= 0) dtime = 0.0001; // protect against possible division by zero bugs
+    
+    if (dtime > 0.100 && pressure && statesSTATE_PRESSURE == 0) {
+      // Workaround for tablets that don't report motion events without pressure.
+      // This is to avoid linear interpolation of the pressure between two events.
+      stroke_to (surface, x, y, 0.0, 90.0, 0.0, dtime-0.0001);
+      dtime = 0.0001;
+    }
+
+    g_rand_set_seed (rng, statesSTATE_RNG_SEED);
+
+    { // calculate the actual "virtual" cursor position
+
+      // noise first
+      if (settingsBRUSH_TRACKING_NOISE->base_value) {
+        // OPTIMIZE: expf() called too often
+        float base_radius = expf(settingsBRUSH_RADIUS_LOGARITHMIC->base_value);
+
+        x += rand_gauss (rng) * settingsBRUSH_TRACKING_NOISE->base_value * base_radius;
+        y += rand_gauss (rng) * settingsBRUSH_TRACKING_NOISE->base_value * base_radius;
+      }
+
+      float fac = 1.0 - exp_decay (settingsBRUSH_SLOW_TRACKING->base_value, 100.0*dtime);
+      x = statesSTATE_X + (x - statesSTATE_X) * fac;
+      y = statesSTATE_Y + (y - statesSTATE_Y) * fac;
+    }
+
+    // draw many (or zero) dabs to the next position
+
+    // see doc/stroke2dabs.png
+    float dist_moved = statesSTATE_DIST;
+    float dist_todo = count_dabs_to (x, y, pressure, dtime);
+
+    //if (dtime > 5 || dist_todo > 300) {
+    if (dtime > 5 || reset_requested) {
+      reset_requested = false;
+
+      /*
+        TODO:
+        if (dist_todo > 300) {
+        // this happens quite often, eg when moving the cursor back into the window
+        // FIXME: bad to hardcode a distance threshold here - might look at zoomed image
+        //        better detect leaving/entering the window and reset then.
+        g_print ("Warning: NOT drawing %f dabs.\n", dist_todo);
+        g_print ("dtime=%f, dx=%f\n", dtime, x-statesSTATE_X);
+        //must_reset = 1;
+        }
+      */
+
+      //printf("Brush reset.\n");
+      for (int i=0; i<STATE_COUNT; i++) {
+        statesi = 0;
+      }
+
+      statesSTATE_X = x;
+      statesSTATE_Y = y;
+      statesSTATE_PRESSURE = pressure;
+
+      // not resetting, because they will get overwritten below:
+      //dx, dy, dpress, dtime
+
+      statesSTATE_ACTUAL_X = statesSTATE_X;
+      statesSTATE_ACTUAL_Y = statesSTATE_Y;
+      statesSTATE_STROKE = 1.0; // start in a state as if the stroke was long finished
+
+      return true;
+    }
+
+    //g_print("dist = %f\n", statesSTATE_DIST);
+    enum { UNKNOWN, YES, NO } painted = UNKNOWN;
+    double dtime_left = dtime;
+
+    float step_dx, step_dy, step_dpressure, step_dtime;
+    float step_declination, step_ascension;
+    while (dist_moved + dist_todo >= 1.0) { // there are dabs pending
+      { // linear interpolation (nonlinear variant was too slow, see SVN log)
+        float frac; // fraction of the remaining distance to move
+        if (dist_moved > 0) {
+          // "move" the brush exactly to the first dab (moving less than one dab)
+          frac = (1.0 - dist_moved) / dist_todo;
+          dist_moved = 0;
+        } else {
+          // "move" the brush from one dab to the next
+          frac = 1.0 / dist_todo;
+        }
+        step_dx        = frac * (x - statesSTATE_X);
+        step_dy        = frac * (y - statesSTATE_Y);
+        step_dpressure = frac * (pressure - statesSTATE_PRESSURE);
+        step_dtime     = frac * (dtime_left - 0.0);
+        step_declination = frac * (tilt_declination - statesSTATE_DECLINATION);
+        step_ascension   = frac * (tilt_ascension - statesSTATE_ASCENSION);
+        // Though it looks different, time is interpolated exactly like x/y/pressure.
+      }
+    
+      update_states_and_setting_values (step_dx, step_dy, step_dpressure, step_declination, step_ascension, step_dtime);
+      bool painted_now = prepare_and_draw_dab (surface);
+      if (painted_now) {
+        painted = YES;
+      } else if (painted == UNKNOWN) {
+        painted = NO;
+      }
+
+      dtime_left   -= step_dtime;
+      dist_todo  = count_dabs_to (x, y, pressure, dtime_left);
+    }
+
+    {
+      // "move" the brush to the current time (no more dab will happen)
+      // Important to do this at least once every event, because
+      // brush_count_dabs_to depends on the radius and the radius can
+      // depend on something that changes much faster than only every
+      // dab (eg speed).
+    
+      step_dx        = x - statesSTATE_X;
+      step_dy        = y - statesSTATE_Y;
+      step_dpressure = pressure - statesSTATE_PRESSURE;
+      step_declination = tilt_declination - statesSTATE_DECLINATION;
+      step_ascension = tilt_ascension - statesSTATE_ASCENSION;
+      step_dtime     = dtime_left;
+    
+      //dtime_left = 0; but that value is not used any more
+
+      update_states_and_setting_values (step_dx, step_dy, step_dpressure, step_declination, step_ascension, step_dtime);
+    }
+
+    // save the fraction of a dab that is already done now
+    statesSTATE_DIST = dist_moved + dist_todo;
+    //g_print("dist_final = %f\n", statesSTATE_DIST);
+
+    // next seed for the RNG (GRand has no get_state() and states must always contain our full state)
+    statesSTATE_RNG_SEED = g_rand_int(rng);
+
+    // stroke separation logic (for undo/redo)
+
+    if (painted == UNKNOWN) {
+      if (stroke_current_idling_time > 0 || stroke_total_painting_time == 0) {
+        // still idling
+        painted = NO;
+      } else {
+        // probably still painting (we get more events than brushdabs)
+        painted = YES;
+        //if (pressure == 0) g_print ("info: assuming 'still painting' while there is no pressure\n");
+      }
+    }
+    if (painted == YES) {
+      //if (stroke_current_idling_time > 0) g_print ("idling ==> painting\n");
+      stroke_total_painting_time += dtime;
+      stroke_current_idling_time = 0;
+      // force a stroke split after some time
+      if (stroke_total_painting_time > 4 + 3*pressure) {
+        // but only if pressure is not being released
+        // FIXME: use some smoothed state for dpressure, not the output of the interpolation code
+        //        (which might easily wrongly give dpressure == 0)
+        if (step_dpressure >= 0) {
+          return true;
+        }
+      }
+    } else if (painted == NO) {
+      //if (stroke_current_idling_time == 0) g_print ("painting ==> idling\n");
+      stroke_current_idling_time += dtime;
+      if (stroke_total_painting_time == 0) {
+        // not yet painted, start a new stroke if we have accumulated a lot of irrelevant motion events
+        if (stroke_current_idling_time > 1.0) {
+          return true;
+        }
+      } else {
+        // Usually we have pressure==0 here. But some brushes can paint
+        // nothing at full pressure (eg gappy lines, or a stroke that
+        // fades out). In either case this is the preferred moment to split.
+        if (stroke_total_painting_time+stroke_current_idling_time > 0.9 + 5*pressure) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+};
+
+}

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib/brushlib.hpp Added

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib/brushsettings.hpp Added

@@ -0,0 +1,88 @@
+// DO NOT EDIT - autogenerated by ./generate.py
+
+#define INPUT_PRESSURE 0
+#define INPUT_SPEED1 1
+#define INPUT_SPEED2 2
+#define INPUT_RANDOM 3
+#define INPUT_STROKE 4
+#define INPUT_DIRECTION 5
+#define INPUT_TILT_DECLINATION 6
+#define INPUT_TILT_ASCENSION 7
+#define INPUT_CUSTOM 8
+#define INPUT_COUNT 9
+
+#define BRUSH_OPAQUE 0
+#define BRUSH_OPAQUE_MULTIPLY 1
+#define BRUSH_OPAQUE_LINEARIZE 2
+#define BRUSH_RADIUS_LOGARITHMIC 3
+#define BRUSH_HARDNESS 4
+#define BRUSH_ANTI_ALIASING 5
+#define BRUSH_DABS_PER_BASIC_RADIUS 6
+#define BRUSH_DABS_PER_ACTUAL_RADIUS 7
+#define BRUSH_DABS_PER_SECOND 8
+#define BRUSH_RADIUS_BY_RANDOM 9
+#define BRUSH_SPEED1_SLOWNESS 10
+#define BRUSH_SPEED2_SLOWNESS 11
+#define BRUSH_SPEED1_GAMMA 12
+#define BRUSH_SPEED2_GAMMA 13
+#define BRUSH_OFFSET_BY_RANDOM 14
+#define BRUSH_OFFSET_BY_SPEED 15
+#define BRUSH_OFFSET_BY_SPEED_SLOWNESS 16
+#define BRUSH_SLOW_TRACKING 17
+#define BRUSH_SLOW_TRACKING_PER_DAB 18
+#define BRUSH_TRACKING_NOISE 19
+#define BRUSH_COLOR_H 20
+#define BRUSH_COLOR_S 21
+#define BRUSH_COLOR_V 22
+#define BRUSH_RESTORE_COLOR 23
+#define BRUSH_CHANGE_COLOR_H 24
+#define BRUSH_CHANGE_COLOR_L 25
+#define BRUSH_CHANGE_COLOR_HSL_S 26
+#define BRUSH_CHANGE_COLOR_V 27
+#define BRUSH_CHANGE_COLOR_HSV_S 28
+#define BRUSH_SMUDGE 29
+#define BRUSH_SMUDGE_LENGTH 30
+#define BRUSH_SMUDGE_RADIUS_LOG 31
+#define BRUSH_ERASER 32
+#define BRUSH_STROKE_THRESHOLD 33
+#define BRUSH_STROKE_DURATION_LOGARITHMIC 34
+#define BRUSH_STROKE_HOLDTIME 35
+#define BRUSH_CUSTOM_INPUT 36
+#define BRUSH_CUSTOM_INPUT_SLOWNESS 37
+#define BRUSH_ELLIPTICAL_DAB_RATIO 38
+#define BRUSH_ELLIPTICAL_DAB_ANGLE 39
+#define BRUSH_DIRECTION_FILTER 40
+#define BRUSH_LOCK_ALPHA 41
+#define BRUSH_SETTINGS_COUNT 42
+
+#define STATE_X 0
+#define STATE_Y 1
+#define STATE_PRESSURE 2
+#define STATE_DIST 3
+#define STATE_ACTUAL_RADIUS 4
+#define STATE_SMUDGE_RA 5
+#define STATE_SMUDGE_GA 6
+#define STATE_SMUDGE_BA 7
+#define STATE_SMUDGE_A 8
+#define STATE_LAST_GETCOLOR_R 9
+#define STATE_LAST_GETCOLOR_G 10
+#define STATE_LAST_GETCOLOR_B 11
+#define STATE_LAST_GETCOLOR_A 12
+#define STATE_LAST_GETCOLOR_RECENTNESS 13
+#define STATE_ACTUAL_X 14
+#define STATE_ACTUAL_Y 15
+#define STATE_NORM_DX_SLOW 16
+#define STATE_NORM_DY_SLOW 17
+#define STATE_NORM_SPEED1_SLOW 18
+#define STATE_NORM_SPEED2_SLOW 19
+#define STATE_STROKE 20
+#define STATE_STROKE_STARTED 21
+#define STATE_CUSTOM_INPUT 22
+#define STATE_RNG_SEED 23
+#define STATE_ACTUAL_ELLIPTICAL_DAB_RATIO 24
+#define STATE_ACTUAL_ELLIPTICAL_DAB_ANGLE 25
+#define STATE_DIRECTION_DX 26
+#define STATE_DIRECTION_DY 27
+#define STATE_DECLINATION 28
+#define STATE_ASCENSION 29
+#define STATE_COUNT 30

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib/helpers.hpp Added

@@ -0,0 +1,344 @@
+/* brushlib - The MyPaint Brush Library
+ * Copyright (C) 2007-2008 Martin Renold <martinxyz@gmx.ch>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef __helpers_h__
+#define __helpers_h__
+
+#include <glib.h>
+#include <assert.h>
+
+// MAX, MIN, ABS, CLAMP are already available from gmacros.h
+#define ROUND(x) ((int) ((x) + 0.5))
+#define SIGN(x) ((x)>0?1:(-1))
+#define SQR(x) ((x)*(x))
+
+#define MAX3(a, b, c) ((a)>(b)?MAX((a),(c)):MAX((b),(c)))
+#define MIN3(a, b, c) ((a)<(b)?MIN((a),(c)):MIN((b),(c)))
+
+namespace brushlib {
+
+typedef struct { int x, y, w, h; } Rect;
+// originally from my mass project (mass.sourceforge.net)
+inline void ExpandRectToIncludePoint(Rect * r, int x, int y)
+{
+  if (r->w == 0) {
+    r->w = 1; r->h = 1;
+    r->x = x; r->y = y;
+  } else {
+    if (x < r->x) { r->w += r->x-x; r->x = x; } else
+    if (x >= r->x+r->w) { r->w = x - r->x + 1; }
+
+    if (y < r->y) { r->h += r->y-y; r->y = y; } else
+    if (y >= r->y+r->h) { r->h = y - r->y + 1; }
+  }
+}
+
+// Optimized version from one in GIMP (noisify.c), where it was
+// adapted from ppmforge.c, which is part of PBMPLUS. The algorithm
+// comes from: 'The Science Of Fractal Images'. Peitgen, H.-O., and
+// Saupe, D. eds.  Springer Verlag, New York, 1988.
+inline float rand_gauss (GRand * rng)
+{
+  float sum = 0.0;
+  uint32_t rand1 = g_rand_int(rng);
+  uint32_t rand2 = g_rand_int(rng);
+  sum +=  rand1        & 0x7FFF;
+  sum += (rand1 >> 16) & 0x7FFF;
+  sum +=  rand2        & 0x7FFF;
+  sum += (rand2 >> 16) & 0x7FFF;
+  return sum * 5.28596089837e-5 - 3.46410161514;
+}
+
+// stolen from GIMP (gimpcolorspace.c)
+// (from gimp_rgb_to_hsv)
+inline void
+rgb_to_hsv_float (float *r_ /*h*/, float *g_ /*s*/, float *b_ /*v*/)
+{
+  float max, min, delta;
+  float h, s, v;
+  float r, g, b;
+
+  h = 0.0; // silence gcc warning
+
+  r = *r_;
+  g = *g_;
+  b = *b_;
+
+  r = CLAMP(r, 0.0, 1.0);
+  g = CLAMP(g, 0.0, 1.0);
+  b = CLAMP(b, 0.0, 1.0);
+
+  max = MAX3(r, g, b);
+  min = MIN3(r, g, b);
+
+  v = max;
+  delta = max - min;
+
+  if (delta > 0.0001)
+    {
+      s = delta / max;
+
+      if (r == max)
+        {
+          h = (g - b) / delta;
+          if (h < 0.0)
+            h += 6.0;
+        }
+      else if (g == max)
+        {
+          h = 2.0 + (b - r) / delta;
+        }
+      else if (b == max)
+        {
+          h = 4.0 + (r - g) / delta;
+        }
+
+      h /= 6.0;
+    }
+  else
+    {
+      s = 0.0;
+      h = 0.0;
+    }
+
+  *r_ = h;
+  *g_ = s;
+  *b_ = v;
+}
+
+// (from gimp_hsv_to_rgb)
+inline void
+hsv_to_rgb_float (float *h_, float *s_, float *v_)
+{
+  gint    i;
+  gdouble f, w, q, t;
+  float h, s, v;
+  float r, g, b;
+  r = g = b = 0.0; // silence gcc warning
+
+  h = *h_;
+  s = *s_;
+  v = *v_;
+
+  h = h - floor(h);
+  s = CLAMP(s, 0.0, 1.0);
+  v = CLAMP(v, 0.0, 1.0);
+
+  gdouble hue;
+
+  if (s == 0.0)
+    {
+      r = v;
+      g = v;
+      b = v;
+    }
+  else
+    {
+      hue = h;
+
+      if (hue == 1.0)
+        hue = 0.0;
+
+      hue *= 6.0;
+
+      i = (gint) hue;
+      f = hue - i;
+      w = v * (1.0 - s);
+      q = v * (1.0 - (s * f));
+      t = v * (1.0 - (s * (1.0 - f)));
+
+      switch (i)
+        {
+        case 0:
+          r = v;
+          g = t;
+          b = w;
+          break;
+        case 1:
+          r = q;
+          g = v;
+          b = w;
+          break;
+        case 2:
+          r = w;
+          g = v;
+          b = t;
+          break;
+        case 3:
+          r = w;
+          g = q;
+          b = v;
+          break;
+        case 4:
+          r = t;
+          g = w;
+          b = v;
+          break;
+        case 5:
+          r = v;
+          g = w;
+          b = q;
+          break;
+        }
+    }
+
+  *h_ = r;
+  *s_ = g;
+  *v_ = b;
+}
+
+// (from gimp_rgb_to_hsl)
+inline void
+rgb_to_hsl_float (float *r_, float *g_, float *b_)
+{
+  gdouble max, min, delta;
+
+  float h, s, l;
+  float r, g, b;
+
+  // silence gcc warnings
+  h=0;
+
+  r = *r_;
+  g = *g_;
+  b = *b_;
+
+  r = CLAMP(r, 0.0, 1.0);
+  g = CLAMP(g, 0.0, 1.0);
+  b = CLAMP(b, 0.0, 1.0);
+
+  max = MAX3(r, g, b);
+  min = MIN3(r, g, b);
+
+  l = (max + min) / 2.0;
+
+  if (max == min)
+    {
+      s = 0.0;
+      h = 0.0; //GIMP_HSL_UNDEFINED;
+    }
+  else
+    {
+      if (l <= 0.5)
+        s = (max - min) / (max + min);
+      else
+        s = (max - min) / (2.0 - max - min);
+
+      delta = max - min;
+
+      if (delta == 0.0)
+        delta = 1.0;
+
+      if (r == max)
+        {
+          h = (g - b) / delta;
+        }
+      else if (g == max)
+        {
+          h = 2.0 + (b - r) / delta;
+        }
+      else if (b == max)
+        {
+          h = 4.0 + (r - g) / delta;
+        }
+
+      h /= 6.0;
+
+      if (h < 0.0)
+        h += 1.0;
+    }
+
+  *r_ = h;
+  *g_ = s;
+  *b_ = l;
+}
+
+static inline double
+hsl_value (gdouble n1,
+           gdouble n2,
+           gdouble hue)
+{
+  gdouble val;
+
+  if (hue > 6.0)
+    hue -= 6.0;
+  else if (hue < 0.0)
+    hue += 6.0;
+
+  if (hue < 1.0)
+    val = n1 + (n2 - n1) * hue;
+  else if (hue < 3.0)
+    val = n2;
+  else if (hue < 4.0)
+    val = n1 + (n2 - n1) * (4.0 - hue);
+  else
+    val = n1;
+
+  return val;
+}
+
+
+/**
+ * gimp_hsl_to_rgb:
+ * @hsl: A color value in the HSL colorspace
+ * @rgb: The value converted to a value in the RGB colorspace
+ *
+ * Convert a HSL color value to an RGB color value.
+ **/
+inline void
+hsl_to_rgb_float (float *h_, float *s_, float *l_)
+{
+  float h, s, l;
+  float r, g, b;
+
+  h = *h_;
+  s = *s_;
+  l = *l_;
+
+  h = h - floor(h);
+  s = CLAMP(s, 0.0, 1.0);
+  l = CLAMP(l, 0.0, 1.0);
+
+  if (s == 0)
+    {
+      /*  achromatic case  */
+      r = l;
+      g = l;
+      b = l;
+    }
+  else
+    {
+      gdouble m1, m2;
+
+      if (l <= 0.5)
+        m2 = l * (1.0 + s);
+      else
+        m2 = l + s - l * s;
+
+      m1 = 2.0 * l - m2;
+
+      r = hsl_value (m1, m2, h * 6.0 + 2.0);
+      g = hsl_value (m1, m2, h * 6.0);
+      b = hsl_value (m1, m2, h * 6.0 - 2.0);
+    }
+
+  *h_ = r;
+  *s_ = g;
+  *l_ = b;
+}
+
+}
+#endif

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib/mapping.hpp Added

@@ -0,0 +1,140 @@
+/* brushlib - The MyPaint Brush Library
+ * Copyright (C) 2007-2008 Martin Renold <martinxyz@gmx.ch>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef __MAPPING_H__
+#define __MAPPING_H__
+
+// user-defined mappings
+// (the curves you can edit in the brush settings)
+
+namespace brushlib {
+
+class Mapping {
+private:
+  typedef struct {
+    // a set of control points (stepwise linear)
+    float xvalues8;
+    float yvalues8;
+    int n;
+  } ControlPoints;
+
+  int inputs;
+  ControlPoints * pointsList; // one for each input
+  int inputs_used; // optimization
+public:
+  float base_value;
+
+  Mapping(int inputs_) {
+    inputs = inputs_;
+    pointsList = new ControlPointsinputs;
+    for (int i=0; i<inputs; i++) pointsListi.n = 0;
+    inputs_used = 0;
+    base_value = 0;
+  }
+  ~Mapping() {
+    delete  pointsList;
+  }
+
+  void set_n (int input, int n)
+  {
+    assert (input >= 0 && input < inputs);
+    assert (n >= 0 && n <= 8);
+    assert (n != 1); // cannot build a linear mapping with only one point
+    ControlPoints * p = pointsList + input;
+
+    if (n != 0 && p->n == 0) inputs_used++;
+    if (n == 0 && p->n != 0) inputs_used--;
+    assert(inputs_used >= 0);
+    assert(inputs_used <= inputs);
+
+    p->n = n;
+  }
+
+  void set_point (int input, int index, float x, float y)
+  {
+    assert (input >= 0 && input < inputs);
+    assert (index >= 0 && index < 8);
+    ControlPoints * p = pointsList + input;
+    assert (index < p->n);
+
+    if (index > 0) {
+      assert (x >= p->xvaluesindex-1);
+    }
+
+    p->xvaluesindex = x;
+    p->yvaluesindex = y;
+  }
+
+  bool is_constant()
+  {
+    return inputs_used == 0;
+  }
+
+  float calculate (float * data)
+  {
+    int j;
+    float result;
+    result = base_value;
+
+    // constant mapping (common case)
+    if (inputs_used == 0) return result;
+
+    for (j=0; j<inputs; j++) {
+      ControlPoints * p = pointsList + j;
+
+      if (p->n) {
+        float x, y;
+        x = dataj;
+
+        // find the segment with the slope that we need to use
+        float x0, y0, x1, y1;
+        x0 = p->xvalues0;
+        y0 = p->yvalues0;
+        x1 = p->xvalues1;
+        y1 = p->yvalues1;
+
+        int i;
+        for (i=2; i<p->n && x>x1; i++) {
+          x0 = x1;
+          y0 = y1;
+          x1 = p->xvaluesi;
+          y1 = p->yvaluesi;
+        }
+
+        if (x0 == x1) {
+          y = y0;
+        } else {
+          // linear interpolation
+          y = (y1*(x - x0) + y0*(x1 - x)) / (x1 - x0);
+        }
+
+        result += y;
+      }
+    }
+    return result;
+  }
+
+  // used in python for the global pressure mapping
+  float calculate_single_input (float input)
+  {
+    assert(inputs == 1);
+    return calculate(&input);
+  }
+};
+
+}
+
+#endif

_service:obs_scm:synfig-1.5.3.obscpio/synfig-studio/src/brushlib/surface.hpp Added

@@ -0,0 +1,40 @@
+/* brushlib - The MyPaint Brush Library
+ * Copyright (C) 2008 Martin Renold <martinxyz@gmx.ch>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+namespace brushlib {
+
+// surface interface required by brush.hpp
+class Surface {
+public:
+
+  virtual ~Surface() {}
+
+  virtual bool draw_dab (float x, float y, 
+                         float radius, 
+                         float color_r, float color_g, float color_b,
+                         float opaque, float hardness = 0.5,
+                         float alpha_eraser = 1.0,
+                         float aspect_ratio = 1.0, float angle = 0.0,
+                         float lock_alpha = 0.0
+                         ) = 0;
+
+  virtual void get_color (float x, float y, 
+                          float radius, 
+                          float * color_r, float * color_g, float * color_b, float * color_a
+                          ) = 0;
+};
+
+}