2006-30-01

	* Version 0.3
	==========================

	* Added extended Porter-Duff compositing model to the drawboard class. Supported operations are:

		- Porter-Duff: CLEAR, SRC, DST, SRC_OVER, DST_OVER, SRC_IN, DST_IN, SRC_OUT, DST_OUT, SRC_ATOP, DST_ATOP, XOR
		- Extended: PLUS, MULTIPLY, SCREEN, OVERLAY, DARKEN, LIGHTEN, COLOR_DODGE, COLOR_BURN, HARD_LIGHT, SOFT_LIGHT, DIFFERENCE, EXCLUSION
	
	All operations works, independently, on stroke and fill, so each drawing operation will be affected by the current settings.
	A separate, orthogonal group compositing operation can be also specified (coupled to the already existing group opacity feature). This
	operation tells how the entire group is composite over the background.
	In the OpenGL implementation, all 24 compositing operation are available on those boards equipped with fragment programs. When they are
	not supported, only 15 compositing operations can be used (CLEAR, SRC, DST, SRC_OVER, DST_OVER, SRC_IN, DST_IN, SRC_OUT, DST_OUT,
	SRC_ATOP, DST_ATOP, XOR, PLUS, SCREEN, EXCLUSION).

	* Added caching API, now three new target modes are available: CACHE, COLOR_AND_CACHE, CLIP_AND_CACHE. When one of them is specified
	all drawing operations return the cache slot index into the current cache bank. Only the geometry is cached, so the users can redraw
	cached primitives changing paint types, colors/opacity, gradients, patterns and matrices.

	* Extended GroupBegin/GroupEnd semantic also for clip paths. So with the same API, users can draw complex clip shapes in union.

	* Added support for REFLECT color-ramp spread mode and REFLECT pattern tiling mode for those graphic boards where "mirrored repeat" OpenGL
	extension is not available (OpenGL drawboard class).

	* Added SetRectTextureEnabled function into OpenGL drawboard, to enable/disable the use of rectangular textures (for group compositing).

	* Modified the screen grabbing management, so textures are created once and only expanded when necessary (OpenGL drawboard class).

	* Added ScreenShot method to drawboard class, it permits to take a portion of screen and put it into a GPixelMap.

	* Added SetStrokeColor(R, G, B) and SetStrokeOpacity(A) functions, so the user can separate RGB components from the alpha one.

	* Added SetFillColor(R, G, B) and SetFillOpacity(A) functions, so the user can separate RGB components from the alpha one.

	* Renamed DisableShaders method in SetShadersEnabled (OpenGL drawboard class).

	* Added GAnglesMeasureUnit type and AngleConversion function that converts angles from and to different measure units.
	It supports radians, degrees, grads, mils, minutes, seconds, sextants, octants, quadrants, signs, turns, revolutions, circles, right angles.

	* Added angle measure unit specification inside SVG-like DrawPaths function (the one that takes 'd' attribute).

	* Added a color string conversion function inside GOpenGLBoard class. It supports HTML format and SVG color keywords.

	* Added primitives drawing functions that take geometric points expressed as a couple (abscissa, ordinate) instead of a GPoint2.

	* Added the construction of rotation and scaling matrix with pivot (the center of transformation).

	* Added a new example, it shows Amanith compositing.

	* Added a new drawboard example, a simple GL clock to show caching API.

	* Added a caching test sheet to the drawboard example.

	* Added to drawboard example a key to take a screenshot in png/jpeg format.

	* Added a debug console for Windows examples.

	* Fixed a bug regarding stencil writing when clip paths were disbale (through SetClipEnable()).

	* Fixed a bug with linear gradient.

	* Fixed a bug regarding the use of rectangular textures on some ATI boards.

	* Fixed some bugs in the gradient matrix and modelview matrix.

	* Fixed a bug on dashed stroke (it didn't draw some caps in some rare situations).

	* Fixed a bug related to group opacity on ATI boards.

	* Fixed a bug in group opacity (stencil related underflow).

	* Fixed some documentation stuff.

	* Modified timer settings in Qt example, so now, in the most "static" examples, CPU will not take 100% of usage.

	* Modified drawboard-based examples: now they open the OpenGL context with alpha buffer.



2005-12-12

	* Version 0.2
	==========================

	* Added drawboard (in OpenVG/SVG style) class: current version is implemented on top of OpenGL, going from OpenGL 1.1 to OpenGL 2.0,
	using extensions where available and fragment programs too. This lead to an accelerated drawboard that exploits all hardware features
	present on graphic board to achieve the best possible performance, without renounce to visual quality.
	High level features:

		- The entire drawboard is adaptive; performance and visual quality are scalable using three quality steps: LOW, NORMAL, HIGH.
		- Fragment programs can be forced off by the user. This parameter can be useful on those boards where they
		are badly supported.
		- Logical viewport can be modified independently by the physical one, at any time.
		- Shapes can be stroked and/or filled, independently.
		- Stroke can be solid or dashed (with an optional initial phase), and also stroke thickness can be changed.
		- Supported stroke joins are: BEVEL, ROUND, MITER.
		- Supported stroke caps are: BUTT, SQUARE, ROUND.
		- Supported drawing styles are: PLAIN COLOR, LINEAR GRADIENT, RADIAL GRADIENT, CONICAL GRADIENT, PATTERN.
		- Supported color interpolation modes in gradients are: CONSTANT, LINEAR, HERMITE.
		- Supported spread methods in gradients and patterns are: PAD, REPEAT, REFLECT.
		- Gradients and patterns have their own transformation matrix, that is independent from all other matrices.
		- The opacity is always supported in colors, gradients, gradients color keys and patterns.
		- Group opacity is also supported, but it requires that OpenGL render context has been opened with at least 4bits stencil buffer.
		- Clip paths are supported when the OpenGL render context has been opened with at least 4bits stencil buffer. They can be
		enabled/disabled at any time. From the user point of view, clip paths are exposed through a 'stack', where paths can be
		pushed and popped specifying an AND or REPLACE operator.
		- Stroke and fill can be drawn using any of supported styles, independently.
		- Supported geometric primitives are: LINE, QUADRATIC BEZIER, CUBIC BEZIER, ELLIPTICAL ARC, RECTANGLE, ROUND RECTANGLE,
		CIRCLE, ELLIPSE, POLYGON, PATH.
		- Path can be specified using SVG commands or directly with SVG string (path 'd' attribute).
		- All Amanith curves and path can be drawn directly, this makes the user free to draw also BSpline, high order Bezier and so on.
		- Every shape can be transformed specifying a model-view matrix, that can be changed at any time.

	* Added a new example that shows drawboard capabilities.

	* Added ellipse curve class (derived from GCurve2D class), it supports construction using 2-points fit or center-axes methods.

	* Added two version of Tesselate method (of GTesselator2D class) that return an axes-aligned bounding box of specified contours.

	* Added a ShearToMatrix() method that builds a shear matrix given shear factors.

	* Added antialias (FSAA) to all examples.

	* Added Create() method to GPixelMap class, it resets the image, setting new dimensions and pixel format.

	* Extended OpenGL extension manager class, now it detects used colorbits, stencilbits and used AA samples.

	* Extended lowlevel_stuff example, now it shows all class proxies, using Amanith introspection feature.

	* Ported Amanith to MacOS X Tiger (using XCode 2.2).

	* Fixed a bug into GBezierCurve2D class, that prevent (in some rare cases) correct flattening of cubic curves.

	* Fixed matrix polar decomposition.

	* Fixed Romberg integrator (now minimum number of steps is 2).

	* Fixed all Visual Studio 2005 compiler "deprecation" warnings.

	* Tools and viewimage example have been removed due to some incompatibility issues between Qt3 and Qt4 branches.



2005-09-24

	* Version 0.1.1
	==========================

	* Added animations support. GAnimElement class is the base class to derive to and get animations support automatically.
	GProperty class is the class that realizes animated properties; we have implemented some basic properties (scalar values together
	constant, linear and hermite interpolation methods). GProperty supports also Out-Of-Range behaviors (constant, loop and ping-pong) as
	well as ease curves for time acceleration/deceleration.

	* Added a new class, GAnimTRSNode2D that encapsulates an animated TRS (Translation-Rotation-Scale) transformation.
	It supports a static offset pivot (intended as a full TRS transformation), hierarchy nodes, linking/unlinking.

	* Added an example (called animshape2d) showing how Amanith can be used with semplicity to produce wonderfull accelerated animations.

	* Added an example (called animcolor) showing Amanith animations applied to color ramps generation.

	* Added 64 bits support under Linux (with gcc) and Windows (Visual Studio 2005 Beta2). To achieve this target, we have fixed some
	GTesselator2D code (in particular the Tesselate method that returns indexed tesselation, now indexes are GULong instead of GUInt32).

	* GPath2D class has now be derived from GMultiCurve2D.

	* Added new methods to GMultiCurve class, that make possible to extract derivatives, tangents, normals and curvatures in non-derivable
	point parameter. In this case two values will be returned (left and right one).

	* Implemented correct transformations to GHermiteCurve2D/1D classes (now also tangents are properly handled).

	* Fixed a bug in the font loader plugin, that made it crash under some conditions.

	* Fixed a bug in GFontChar2D class that sometime made incorrect results in the ConvertToPaths() method.

	* Fixed several little bugs into GPath2D class.

	* Fixed a bug in B-Spline SetPoints() method that prevented to build a correct opened spline.

	* Fixed a wrong cubic Bezier flattening in some rare degenerative cases.


2005-08-03

	* Version 0.1 Final.
	==========================

	* Updated to zlib v1.2.3 (that resolves some security issues).

	* Updated to libpng v1.2.8 (that resolves some security issues).

	* Added Visual Studio .Net 2003 build solution (it includes kernel library and examples).

	* Added installer and binaries for Windows platform.

	* Expanded string conversion of number, vectors and quaternions. Now functions accept a standard printf-like
	formatting string (ex: "%5.2f") as parameter.

	* Fixed a bug in the kernel class, that caused some memory leaks and crashes in the automatic memory retrivial (garbage collector).

	* Added full support for paletted images, and implemented an octree color quantization.

	* Changed GMesh2D class, now it's a template.

	* More robust predicates have been introduced into tesselator (dictionary order, segments intersection, CCW smaller angle span).

	* Fixed some minor and major bugs of tesselator. In particular some right diagonal cases made region collector crash, and in some degenerative
	situations (deep otimization under gcc on Mac) an infinitive loop may be occurred.

	* Added filling rules for tesselation (ODD, EVEN, BOTH).

	* Added indexed array output in the tesselator api. So now, plain vertex and indexed output are available.

	* Added a new example, called tesselator2d; it shows the realtime capabilities of Amanith tesselator.

	* Fixed optimized cubic Bézier flattening when compiled using float real type.

	* Added official support of Qt4 for examples and tools. So now the entire framework can be compiled with it. Please look at settings.conf file.

	* Added unofficial support for MinGW compiler. It seems that MinGW has a bug that make not possible to export from dynamic libraries instantied
	template classes. So in the Amanith case, the instantied template classes GMesh2D<GFloat> and GMesh2D<GDouble> could not be seen from the
	delaunay2d example. We wish that this bug will be resolved into next MinGW version. Anyway the entire framework, examples and tools can be
	compiled except for delaunay2d example. Please look at settings.conf file.
