Changeset 522 for GraphicTest/Packages/Graphics32

Timestamp:

Apr 17, 2019, 10:42:18 AM (6 years ago)

Author:

chronos

Message:

• Modified: Updated Graphics32 library.

Location:

GraphicTest/Packages/Graphics32

Files:

• . (modified) (1 prop)
• Examples (deleted)
• GR32.inc (modified) (1 diff)
• GR32.pas (modified) (135 diffs)
• GR32_ArrowHeads.pas (added)
• GR32_Backends.pas (modified) (4 diffs)
• GR32_Backends_Generic.pas (modified) (1 diff)
• GR32_Backends_LCL_Win.pas (modified) (16 diffs)
• GR32_Backends_VCL.pas (modified) (26 diffs)
• GR32_Bindings.pas (modified) (2 diffs)
• GR32_Blend.pas (modified) (33 diffs)
• GR32_BlendASM.pas (added)
• GR32_BlendMMX.pas (added)
• GR32_BlendSSE2.pas (added)
• GR32_Blurs.pas (added)
• GR32_Brushes.pas (added)
• GR32_Clipper.pas (added)
• GR32_ColorGradients.pas (added)
• GR32_ColorPicker.pas (added)
• GR32_ColorSwatch.pas (added)
• GR32_Compiler.inc (modified) (16 diffs)
• GR32_Containers.pas (modified) (9 diffs)
• GR32_DrawingEx.pas (deleted)
• GR32_Dsgn_Bitmap.pas (modified) (2 diffs)
• GR32_Dsgn_Color.pas (modified) (7 diffs)
• GR32_Dsgn_ColorPicker.dfm (added)
• GR32_Dsgn_ColorPicker.pas (added)
• GR32_ExtImage.pas (modified) (1 diff)
• GR32_Filters.pas (modified) (9 diffs)
• GR32_Gamma.pas (added)
• GR32_Geometry.pas (modified) (4 diffs)
• GR32_Image.pas (modified) (24 diffs)
• GR32_Layers.pas (modified) (62 diffs)
• GR32_LowLevel.pas (modified) (40 diffs)
• GR32_Math.pas (modified) (27 diffs)
• GR32_MicroTiles.pas (modified) (2 diffs)
• GR32_OrdinalMaps.pas (modified) (18 diffs)
• GR32_Paths.pas (added)
• GR32_Polygons.pas (modified) (11 diffs)
• GR32_PolygonsAggLite.pas (added)
• GR32_RangeBars.pas (modified) (24 diffs)
• GR32_Rasterizers.pas (modified) (8 diffs)
• GR32_Reg.dcr (modified) ( previous)
• GR32_Reg.pas (modified) (3 diffs)
• GR32_RepaintOpt.pas (modified) (1 diff)
• GR32_Resamplers.pas (modified) (21 diffs)
• GR32_System.pas (modified) (11 diffs)
• GR32_Text_LCL_Win.pas (added)
• GR32_Text_VCL.pas (added)
• GR32_Text_VCL_D2D.pas (added)
• GR32_Transforms.pas (modified) (36 diffs)
• GR32_VPR.pas (added)
• GR32_VPR2.pas (added)
• GR32_VectorMaps.pas (modified) (9 diffs)
• GR32_VectorUtils.pas (added)
• GR32_XPThemes.pas (modified) (2 diffs)
• Graphics32.chm (deleted)
• Packages/2010 (added)
• Packages/2010/GR32.groupproj (added)
• Packages/2010/GR32_D.dpk (added)
• Packages/2010/GR32_D.dproj (added)
• Packages/2010/GR32_R.dpk (added)
• Packages/2010/GR32_R.dproj (added)
• Packages/GR32_D2005.dpk (modified) (1 diff)
• Packages/GR32_D5.dpk (deleted)
• Packages/GR32_D5.res (deleted)
• Packages/GR32_D6.dpk (deleted)
• Packages/GR32_D6.res (deleted)
• Packages/GR32_D7.dpk (modified) (3 diffs)
• Packages/GR32_D7.res (modified) ( previous)
• Packages/GR32_DSGN_D5.dpk (modified) (1 diff)
• Packages/GR32_DSGN_D6.dpk (modified) (2 diffs)
• Packages/GR32_DSGN_D7.dpk (modified) (1 diff)
• Packages/GR32_DSGN_D7.res (modified) ( previous)
• Packages/GR32_DSGN_L.lpk (deleted)
• Packages/GR32_DSGN_L.pas (deleted)
• Packages/GR32_DSGN_Lazarus.lpk (added)
• Packages/GR32_DSGN_Lazarus.pas (added)
• Packages/GR32_DSGN_RS2007.dpk (modified) (1 diff)
• Packages/GR32_DSGN_RS2010.dpk (deleted)
• Packages/GR32_DSGN_RSXE1.dpk (deleted)
• Packages/GR32_DSGN_RSXE2.dpk (deleted)
• Packages/GR32_L.lpk (deleted)
• Packages/GR32_L.pas (modified) (1 diff)
• Packages/GR32_Lazarus.lpk (added)
• Packages/GR32_Lazarus.pas (added)
• Packages/GR32_RS2006.dpk (modified) (1 diff)
• Packages/GR32_RS2007.dpk (modified) (2 diffs)
• Packages/GR32_RS2009.dpk (modified) (2 diffs)
• Packages/GR32_RS2010.dpk (deleted)
• Packages/GR32_RSXE1.dpk (deleted)
• Packages/GR32_RSXE2.dpk (deleted)
• Packages/Gen.bat (added)
• Packages/PackagesGenerator.ini (added)
• Packages/RX (added)
• Packages/RX/GR32.groupproj (added)
• Packages/RX/GR32_D.dpk (added)
• Packages/RX/GR32_D.dproj (added)
• Packages/RX/GR32_R.dpk (added)
• Packages/RX/GR32_R.dproj (added)
• Packages/RX1 (added)
• Packages/RX1/GR32.groupproj (added)
• Packages/RX1/GR32_D.dpk (added)
• Packages/RX1/GR32_D.dproj (added)
• Packages/RX1/GR32_R.dpk (added)
• Packages/RX1/GR32_R.dproj (added)
• Packages/RX2 (added)
• Packages/RX2/GR32.groupproj (added)
• Packages/RX2/GR32_D.dpk (added)
• Packages/RX2/GR32_D.dproj (added)
• Packages/RX2/GR32_R.dpk (added)
• Packages/RX2/GR32_R.dproj (added)
• Packages/RX3 (added)
• Packages/RX3/GR32.groupproj (added)
• Packages/RX3/GR32_D.dpk (added)
• Packages/RX3/GR32_D.dproj (added)
• Packages/RX3/GR32_R.dpk (added)
• Packages/RX3/GR32_R.dproj (added)
• Packages/XE (added)
• Packages/XE/GR32.groupproj (added)
• Packages/XE/GR32_D.dpk (added)
• Packages/XE/GR32_D.dproj (added)
• Packages/XE/GR32_R.dpk (added)
• Packages/XE/GR32_R.dproj (added)
• Packages/XE2 (added)
• Packages/XE2/GR32.groupproj (added)
• Packages/XE2/GR32_D.dpk (added)
• Packages/XE2/GR32_D.dproj (added)
• Packages/XE2/GR32_R.dpk (added)
• Packages/XE2/GR32_R.dproj (added)
• Packages/XE3 (added)
• Packages/XE3/GR32.groupproj (added)
• Packages/XE3/GR32_D.dpk (added)
• Packages/XE3/GR32_D.dproj (added)
• Packages/XE3/GR32_R.dpk (added)
• Packages/XE3/GR32_R.dproj (added)
• Packages/XE4 (added)
• Packages/XE4/GR32.groupproj (added)
• Packages/XE4/GR32_D.dpk (added)
• Packages/XE4/GR32_D.dproj (added)
• Packages/XE4/GR32_R.dpk (added)
• Packages/XE4/GR32_R.dproj (added)
• Packages/XE5 (added)
• Packages/XE5/GR32.groupproj (added)
• Packages/XE5/GR32_D.dpk (added)
• Packages/XE5/GR32_D.dproj (added)
• Packages/XE5/GR32_R.dpk (added)
• Packages/XE5/GR32_R.dproj (added)
• Packages/XE6 (added)
• Packages/XE6/GR32.groupproj (added)
• Packages/XE6/GR32_D.dpk (added)
• Packages/XE6/GR32_D.dproj (added)
• Packages/XE6/GR32_R.dpk (added)
• Packages/XE6/GR32_R.dproj (added)
• Packages/XE7 (added)
• Packages/XE7/GR32.groupproj (added)
• Packages/XE7/GR32_D.dpk (added)
• Packages/XE7/GR32_D.dproj (added)
• Packages/XE7/GR32_R.dpk (added)
• Packages/XE7/GR32_R.dproj (added)
• Packages/XE8 (added)
• Packages/XE8/GR32.groupproj (added)
• Packages/XE8/GR32_D.dpk (added)
• Packages/XE8/GR32_D.dproj (added)
• Packages/XE8/GR32_R.dpk (added)
• Packages/XE8/GR32_R.dproj (added)
• _clean.bat (added)

GraphicTest/Packages/Graphics32/GR32.inc

@@ -174 +174 @@
   ----------------
 
-     If defined SSE2 optimizations are not used (omitted)
-
-   For faster pixel/color processing, SSE2 can be used which results in a huge
-   performance boost over PUREPASCAL code or native assembler code.
+    If defined SSE2 optimizations are not used (omitted)
+
+  For faster pixel/color processing, SSE2 can be used which results in a huge
+  performance boost over PUREPASCAL code or native assembler code.
 
 *)
 
   {-$DEFINE OMIT_SSE2}
+
+
+(*
+  Symbol: USEGR32GAMMA
+  --------------------
+
+    If defined the polygon rasterizer will use the GR32 gamma correction LUT.
+
+  Disable for a slight performance increase.
+*)
+
+{$DEFINE USEGR32GAMMA}
+
+
+
+(*
+  Symbol: CHANGENOTIFICATIONS
+  ---------------------------
+
+    If defined the polygon rasterizer will trigger change notifications.
+
+  Undefining this will avoid bounding box computations, which may
+  improve performance slightly.
+*)
+
+{$DEFINE CHANGENOTIFICATIONS}
+
+
+
+(*
+  Symbol: USESTACKALLOC
+  ---------------------
+
+    If defined stack allocation routines will be used in some functions.
+
+  Allocating memory on the stack is usually more efficient than using the
+  memory manager. If a routine uses StackAllock/StackFree then it should
+  always be wrapped inside a {$W+}...{$W-} block in order to generate
+  a stack frame.
+
+  NOTE: Undefine this symbol if you get stack overflow errors.
+*)
+
+{-$DEFINE USESTACKALLOC}
+
+(*
+  Symbol: RGBA_FORMAT
+  -------------------
+
+     Assume RGBA pixel format instead of BGRA (used by e.g. OpenGL.)
+*)
+
+{-$DEFINE RGBA_FORMAT}
+
+(*
+  Symbol: NOHINTING
+  -----------------
+
+    Disables font hinting by default when using TextToPath() method.
+
+  It is usually preferrable to disable hinting when using a high quality
+  polygon renderer like VPR. However, hinting can sometimes improve
+  visual quality when rendering small text (text is adjusted to pixel
+  boundaries which makes it more crisp.)
+*)
+
+{$DEFINE NOHINTING}
+
+
+(*
+  Symbol: NOHORIZONTALHINTING
+  ---------------------------
+
+    Disables horizontal font hinting when using TextToPath() method.
+
+  The following should not be used in conjunction with NOHINTING.
+  It will attempt to address the problem of extreme font hinting in the
+  GDI by disabling horizontal, but keeping vertical hinting.
+*)
+
+{-$DEFINE NOHORIZONTALHINTING}
+
+
+(*
+  Symbol: USEKERNING
+  -----------------
+
+    Enables font kerning when using TextToPath() method.
+
+  Kerning is the process of adjusting the spacing between characters in a
+  proportional font, usually to achieve a visually pleasing result. However,
+  parsing for kerning pairs is quite expensive in terms of CPU usage while the
+  effect is often very little. Thus kerning is not enabled by default.
+*)
+
+{-$DEFINE USEKERNING}
+
+
+{-$DEFINE TEST_BLENDMEMRGB128SSE4}

GraphicTest/Packages/Graphics32/GR32.pas

@@ -44 +44 @@
 
 uses
-  {$IFDEF FPC} LCLIntf, LCLType, Types, Controls, Graphics,{$ELSE}
-  Windows, Messages, Controls, Graphics,{$ENDIF}
-  Classes, SysUtils, GR32_System;
-  
+  {$IFDEF FPC} LCLIntf, LCLType, Types, {$ELSE}
+  {$IFDEF COMPILERXE2_UP}UITypes, Types, {$ENDIF} Windows, {$ENDIF}
+  Controls, Graphics, Classes, SysUtils;
+
 { Version Control }
 
 const
-  Graphics32Version = '1.9.1';
+  Graphics32Version = '2.0.0 alpha';
 
 { 32-bit Color }
@@ -63 +63 @@
   TArrayOfColor32 = array of TColor32;
 
+{$IFNDEF RGBA_FORMAT}
   TColor32Component = (ccBlue, ccGreen, ccRed, ccAlpha);
+{$ELSE}
+  TColor32Component = (ccRed, ccGreen, ccBlue, ccAlpha);
+{$ENDIF}
   TColor32Components = set of TColor32Component;
 
@@ -69 +73 @@
   TColor32Entry = packed record
     case Integer of
+{$IFNDEF RGBA_FORMAT}
       0: (B, G, R, A: Byte);
+{$ELSE}
+      0: (R, G, B, A: Byte);
+{$ENDIF}
       1: (ARGB: TColor32);
       2: (Planes: array[0..3] of Byte);
@@ -236 +244 @@
   // Some semi-transparent color constants
   clTrWhite32             = TColor32($7FFFFFFF);
+  clTrGray32              = TColor32($7F7F7F7F);
   clTrBlack32             = TColor32($7F000000);
   clTrRed32               = TColor32($7FFF0000);
@@ -258 +267 @@
 function AlphaComponent(Color32: TColor32): Integer; {$IFDEF USEINLINING} inline; {$ENDIF}
 function Intensity(Color32: TColor32): Integer; {$IFDEF USEINLINING} inline; {$ENDIF}
+function InvertColor(Color32: TColor32): TColor32; {$IFDEF USEINLINING} inline; {$ENDIF}
 function SetAlpha(Color32: TColor32; NewAlpha: Integer): TColor32; {$IFDEF USEINLINING} inline; {$ENDIF}
+procedure ModifyAlpha(var Color32: TColor32; NewAlpha: Byte); {$IFDEF USEINLINING} inline; {$ENDIF}
+procedure ScaleAlpha(var Color32: TColor32; Scale: Single); {$IFDEF USEINLINING} inline; {$ENDIF}
 
 // Color space conversion
 function HSLtoRGB(H, S, L: Single): TColor32; overload;
 procedure RGBtoHSL(RGB: TColor32; out H, S, L : Single); overload;
-function HSLtoRGB(H, S, L: Integer): TColor32; overload;
+function HSLtoRGB(H, S, L: Integer; A: Integer = $ff): TColor32; overload;
 procedure RGBtoHSL(RGB: TColor32; out H, S, L: Byte); overload;
+function HSVtoRGB(H, S, V: Single): TColor32;
+procedure RGBToHSV(Color: TColor32; out H, S, V: Single);
 
 {$IFNDEF PLATFORM_INDEPENDENT}
@@ -277 +291 @@
   PFixed = ^TFixed;
   TFixed = type Integer;
-
+  {$NODEFINE TFixed}
+
+  {$NODEFINE PFixedRec}
   PFixedRec = ^TFixedRec;
+  {$NODEFINE TFixedRec}
   TFixedRec = packed record
     case Integer of
@@ -315 +332 @@
   TArrayOfArrayOfInteger = array of TArrayOfInteger;
 
+  PCardinalArray = ^TCardinalArray;
+  TCardinalArray = array [0..0] of Cardinal;
+  PArrayOfCardinal = ^TArrayOfCardinal;
+  TArrayOfCardinal = array of Cardinal;
+  PArrayOfArrayOfCardinal = ^TArrayOfArrayOfCardinal;
+  TArrayOfArrayOfCardinal = array of TArrayOfCardinal;
+
   PSingleArray = ^TSingleArray;
   TSingleArray = array [0..0] of Single;
@@ -330 +354 @@
   FixedHalf = $7FFF;
   FixedPI  = Round(PI * FixedOne);
-  FixedToFloat = 1/FixedOne;
+  FixedToFloat = 1 / FixedOne;
+
+  COne255th = 1 / $FF;
 
 function Fixed(S: Single): TFixed; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
@@ -355 +381 @@
   TFloatPoint = record
     X, Y: TFloat;
+  {$IFDEF SUPPORT_ENHANCED_RECORDS}
+  public
+    {$IFNDEF FPC}
+    {$IFDEF COMPILERXE2_UP}
+    constructor Create(P: TPointF); overload;
+    {$ENDIF}
+    constructor Create(P: TPoint); overload;
+    constructor Create(X, Y: Integer); overload;
+    constructor Create(X, Y: Single); overload;
+    {$ENDIF}
+
+    // operator overloads
+    class operator Equal(const Lhs, Rhs: TFloatPoint): Boolean;
+    class operator NotEqual(const Lhs, Rhs: TFloatPoint): Boolean;
+    class operator Add(const Lhs, Rhs: TFloatPoint): TFloatPoint;
+    class operator Subtract(const Lhs, Rhs: TFloatPoint): TFloatPoint;
+    {$IFDEF COMPILERXE2_UP}
+    class operator Explicit(A: TPointF): TFloatPoint;
+    class operator Implicit(A: TPointF): TFloatPoint;
+    {$ENDIF}
+
+    class function Zero: TFloatPoint; inline; static;
+  {$ENDIF}
   end;
 
@@ -367 +416 @@
   TFixedPoint = record
     X, Y: TFixed;
-  end;
+  {$IFDEF SUPPORT_ENHANCED_RECORDS}
+  public
+    {$IFNDEF FPC}
+    {$IFDEF COMPILERXE2_UP}
+    constructor Create(P: TPointF); overload;
+    {$ENDIF}
+    constructor Create(P: TFloatPoint); overload;
+    constructor Create(X, Y: TFixed); overload;
+    constructor Create(X, Y: Integer); overload;
+    constructor Create(X, Y: TFloat); overload;
+    {$ENDIF}
+
+    // operator overloads
+    class operator Equal(const Lhs, Rhs: TFixedPoint): Boolean;
+    class operator NotEqual(const Lhs, Rhs: TFixedPoint): Boolean;
+    class operator Add(const Lhs, Rhs: TFixedPoint): TFixedPoint;
+    class operator Subtract(const Lhs, Rhs: TFixedPoint): TFixedPoint;
+
+    class function Zero: TFixedPoint; inline; static;
+  {$ENDIF}
+  end;
+  {$NODEFINE TFixedPoint}
 
   PFixedPointArray = ^TFixedPointArray;
@@ -397 +467 @@
 
   PFloatRect = ^TFloatRect;
+  {$NODEFINE TFloatRect}
+{$IFDEF SupportsBoost}
+  (*$HPPEMIT '#include <boost/strong_typedef.hpp>'*)
+{$ENDIF}
+  (*$HPPEMIT 'namespace Gr32 {'*)
+{$IFDEF SupportsBoost}
+  (*$HPPEMIT 'BOOST_STRONG_TYPEDEF(int, TFixed)'*)
+{$ELSE}
+  (*$HPPEMIT 'typedef int TFixed;'*)
+{$ENDIF}
+  (*$HPPEMIT 'struct TFixedPoint { float X, Y; }; typedef struct TFixedPoint TFixedPoint;'*)
+  (*$HPPEMIT 'struct TFloatRect { float Left, Top, Right, Bottom; }; typedef struct TFloatRect TFloatRect;'*)
+  (*$HPPEMIT 'struct TFixedRect { TFixed Left, Top, Right, Bottom; }; typedef struct TFixedRect TFixedRect;'*)
+  (*$HPPEMIT '} // namespace Gr32 '*)
   TFloatRect = packed record
     case Integer of
@@ -403 +487 @@
   end;
 
+  {$NODEFINE PFixedRect}
   PFixedRect = ^TFixedRect;
+  {$NODEFINE TFixedRect}
   TFixedRect = packed record
     case Integer of
@@ -417 +503 @@
 function MakeRect(const FXR: TFixedRect; Rounding: TRectRounding = rrClosest): TRect; overload;
 function FixedRect(const L, T, R, B: TFixed): TFixedRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
+function FixedRect(const TopLeft, BottomRight: TFixedPoint): TFixedRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
 function FixedRect(const ARect: TRect): TFixedRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
 function FixedRect(const FR: TFloatRect): TFixedRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
 function FloatRect(const L, T, R, B: TFloat): TFloatRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
+function FloatRect(const TopLeft, BottomRight: TFloatPoint): TFloatRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
 function FloatRect(const ARect: TRect): TFloatRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
 function FloatRect(const FXR: TFixedRect): TFloatRect; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
@@ -458 +546 @@
 {$ENDIF}
 
-{ Gamma bias for line/pixel antialiasing }
-
-var
-  GAMMA_TABLE: array [Byte] of Byte;
-
-procedure SetGamma(Gamma: Single = 0.7);
-
 type
   { TPlainInterfacedPersistent }
@@ -475 +556 @@
   protected
     { IInterface }
-    function _AddRef: Integer; {$IFNDEF WINDOWS}cdecl{$ELSE}stdcall{$ENDIF};
-    function _Release: Integer; {$IFNDEF WINDOWS}cdecl{$ELSE}stdcall{$ENDIF};
-    function QueryInterface({$IFDEF FPC_HAS_CONSTREF}constref{$ELSE}const{$ENDIF}IID: TGUID; out Obj): HResult; virtual; {$IFNDEF WINDOWS}cdecl{$ELSE}stdcall{$ENDIF};
-
+{$IFDEF FPC_HAS_CONSTREF}
+    function QueryInterface(constref iid: TGuid; out obj): HResult; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
+    function _AddRef: LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
+    function _Release: LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
+{$ELSE}
+    function QueryInterface(const iid: TGuid; out obj): HResult; stdcall;
+    function _AddRef: LongInt; stdcall;
+    function _Release: LongInt; stdcall;
+{$ENDIF}
     property RefCounted: Boolean read FRefCounted write FRefCounted;
   public
@@ -535 +621 @@
     procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); virtual;
   public
+    constructor Create(Width, Height: Integer); reintroduce; overload;
+
     procedure Delete; virtual;
     function  Empty: Boolean; virtual;
@@ -540 +628 @@
     function SetSizeFrom(Source: TPersistent): Boolean;
     function SetSize(NewWidth, NewHeight: Integer): Boolean; virtual;
+
     property Height: Integer read FHeight write SetHeight;
     property Width: Integer read FWidth write SetWidth;
@@ -602 +691 @@
 
 {$IFDEF BITS_GETTER}
-    function GetBits: PColor32Array;     {$IFDEF USEINLINING} inline; {$ENDIF}
+    function GetBits: PColor32Array; {$IFDEF USEINLINING} inline; {$ENDIF}
 {$ENDIF}
 
@@ -618 +707 @@
     procedure SetResampler(Resampler: TCustomResampler);
     function GetResamplerClassName: string;
-    procedure SetResamplerClassName(Value: string);
+    procedure SetResamplerClassName(const Value: string);
+    function GetPenPos: TPoint;
+    procedure SetPenPos(const Value: TPoint);
+    function GetPenPosF: TFixedPoint;
+    procedure SetPenPosF(const Value: TFixedPoint);
   protected
     WrapProcHorz: TWrapProcEx;
@@ -638 +731 @@
     procedure DefineProperties(Filer: TFiler); override;
 
-    procedure InitializeBackend; virtual;
+    procedure InitializeBackend(Backend: TCustomBackendClass); virtual;
     procedure FinalizeBackend; virtual;
     procedure SetBackend(const Backend: TCustomBackend); virtual;
 
-    function QueryInterface({$IFDEF FPC_HAS_CONSTREF}constref{$ELSE}const{$ENDIF} IID: TGUID; out Obj): HResult; override;
+{$IFDEF FPC_HAS_CONSTREF}
+    function QueryInterface(constref iid: TGuid; out obj): HResult; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
+{$ELSE}
+    function QueryInterface(const iid: TGuid; out obj): HResult; stdcall;
+{$ENDIF}
 
     function  GetPixel(X, Y: Integer): TColor32; {$IFDEF USEINLINING} inline; {$ENDIF}
@@ -673 +770 @@
     procedure SetPixelXW(X, Y: TFixed; Value: TColor32);
   public
-    constructor Create; override;
+    constructor Create(Backend: TCustomBackendClass); reintroduce; overload; virtual;
+    constructor Create; reintroduce; overload; virtual;
+    constructor Create(Width, Height: Integer); reintroduce; overload; virtual;
     destructor Destroy; override;
+
+    class function GetPlatformBackendClass: TCustomBackendClass; virtual;
 
     procedure Assign(Source: TPersistent); override;
@@ -713 +814 @@
 
     procedure DrawTo(Dst: TCustomBitmap32); overload;
+    procedure DrawTo(Dst: TCustomBitmap32; DstX, DstY: Integer); overload;
     procedure DrawTo(Dst: TCustomBitmap32; DstX, DstY: Integer; const SrcRect: TRect); overload;
-    procedure DrawTo(Dst: TCustomBitmap32; DstX, DstY: Integer); overload;
     procedure DrawTo(Dst: TCustomBitmap32; const DstRect: TRect); overload;
     procedure DrawTo(Dst: TCustomBitmap32; const DstRect, SrcRect: TRect); overload;
@@ -765 +866 @@
     procedure LineToXSP(X, Y: TFixed);
     procedure LineToFSP(X, Y: Single);
+    property PenPos: TPoint read GetPenPos write SetPenPos;
+    property PenPosF: TFixedPoint read GetPenPosF write SetPenPosF;
 
     procedure FillRect(X1, Y1, X2, Y2: Integer; Value: TColor32);
@@ -840 +943 @@
   private
     FOnHandleChanged: TNotifyEvent;
-      
+
     procedure BackendChangedHandler(Sender: TObject); override;
     procedure BackendChangingHandler(Sender: TObject); override;
@@ -855 +958 @@
     procedure SetFont(Value: TFont);
   protected
-    procedure InitializeBackend; override;
     procedure FinalizeBackend; override;
     procedure SetBackend(const Backend: TCustomBackend); override;
-    
+
     procedure HandleChanged; virtual;
     procedure CopyPropertiesTo(Dst: TCustomBitmap32); override;
   public
+    class function GetPlatformBackendClass: TCustomBackendClass; override;
+
   {$IFDEF BCB}
     procedure Draw(const DstRect, SrcRect: TRect; hSrc: Cardinal); overload;
@@ -871 +975 @@
     procedure DrawTo(hDst: Cardinal; DstX, DstY: Integer); overload;
     procedure DrawTo(hDst: Cardinal; const DstRect, SrcRect: TRect); overload;
-    procedure TileTo(hDst: Cardinal; const DstRect, SrcRect: TRect);
+    procedure TileTo(hDst: Cardinal; const DstRect, SrcRect: TRect); overload;
 {$ELSE}
-    procedure DrawTo(hDst: HDC; DstX, DstY: Integer); overload;
+    procedure DrawTo(hDst: HDC; DstX: Integer = 0; DstY: Integer = 0); overload;
     procedure DrawTo(hDst: HDC; const DstRect, SrcRect: TRect); overload;
-    procedure TileTo(hDst: HDC; const DstRect, SrcRect: TRect);
+    procedure TileTo(hDst: HDC; const DstRect, SrcRect: TRect); overload;
 {$ENDIF}
 
+{$IFDEF COMPILER2009_UP}
+    procedure DrawTo(Dst: TControlCanvas; DstX: Integer = 0; DstY: Integer = 0); overload;
+    procedure DrawTo(Dst: TControlCanvas; const DstRect, SrcRect: TRect); overload;
+    procedure TileTo(Dst: TControlCanvas; const DstRect, SrcRect: TRect); overload;
+{$ENDIF}
+
     procedure UpdateFont;
-    procedure Textout(X, Y: Integer; const Text: String); overload;
-    procedure Textout(X, Y: Integer; const ClipRect: TRect; const Text: String); overload;
-    procedure Textout(DstRect: TRect; const Flags: Cardinal; const Text: String); overload;
-    function  TextExtent(const Text: String): TSize;
-    function  TextHeight(const Text: String): Integer;
-    function  TextWidth(const Text: String): Integer;
-    procedure RenderText(X, Y: Integer; const Text: String; AALevel: Integer; Color: TColor32);
+    procedure Textout(X, Y: Integer; const Text: string); overload;
+    procedure Textout(X, Y: Integer; const ClipRect: TRect; const Text: string); overload;
+    procedure Textout(var DstRect: TRect; const Flags: Cardinal; const Text: string); overload;
+    function  TextExtent(const Text: string): TSize;
+    function  TextHeight(const Text: string): Integer;
+    function  TextWidth(const Text: string): Integer;
+    procedure RenderText(X, Y: Integer; const Text: string; AALevel: Integer; Color: TColor32);
     procedure TextoutW(X, Y: Integer; const Text: Widestring); overload;
     procedure TextoutW(X, Y: Integer; const ClipRect: TRect; const Text: Widestring); overload;
-    procedure TextoutW(DstRect: TRect; const Flags: Cardinal; const Text: Widestring); overload;
+    procedure TextoutW(var DstRect: TRect; const Flags: Cardinal; const Text: Widestring); overload;
     function  TextExtentW(const Text: Widestring): TSize;
     function  TextHeightW(const Text: Widestring): Integer;
@@ -936 +1046 @@
     function Empty: Boolean; virtual;
 
-    procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer; ClearBuffer: Boolean = True); virtual;
+    procedure ChangeSize(out Width, Height: Integer; NewWidth, NewHeight: Integer; ClearBuffer: Boolean = True); virtual;
 
 {$IFDEF BITS_GETTER}
@@ -992 +1102 @@
   TCustomResamplerClass = class of TCustomResampler;
 
-function GetPlatformBackendClass: TCustomBackendClass;
-
 var
   StockBitmap: TBitmap;
 
+resourcestring
+  RCStrUnmatchedReferenceCounting = 'Unmatched reference counting.';
+  RCStrCannotSetSize = 'Can''t set size from ''%s''';
+  RCStrInpropriateBackend = 'Inappropriate Backend';
+
 implementation
 
 uses
-  Math, GR32_Blend, GR32_Filters, GR32_LowLevel, GR32_Math,
-  GR32_Resamplers, GR32_Containers, GR32_Backends, GR32_Backends_Generic,
+  Math, GR32_Blend, GR32_LowLevel, GR32_Math, GR32_Resamplers,
+  GR32_Containers, GR32_Gamma, GR32_Backends, GR32_Backends_Generic,
 {$IFDEF FPC}
   Clipbrd,
@@ -1019 +1132 @@
   Clipbrd, GR32_Backends_VCL,
 {$ENDIF}
-  GR32_DrawingEx;
+  GR32_VectorUtils;
 
 type
@@ -1045 +1158 @@
 const
   ZERO_RECT: TRect = (Left: 0; Top: 0; Right: 0; Bottom: 0);
-
-resourcestring
-  RCStrUnmatchedReferenceCounting = 'Unmatched reference counting.';
-  RCStrCannotSetSize = 'Can''t set size from ''%s''';
-  RCStrInpropriateBackend = 'Inpropriate Backend';
 
 { Color construction and conversion functions }
@@ -1128 +1236 @@
 {$ENDIF}
         // the alpha channel byte is set to zero!
-        ROL     EAX, 8  // ABGR  ->  BGRA
+        ROL     EAX, 8  // ABGR  ->  RGBA
         XOR     AL, AL  // BGRA  ->  BGR0
         BSWAP   EAX     // BGR0  ->  0RGB
@@ -1199 +1307 @@
 end;
 
+function InvertColor(Color32: TColor32): TColor32;
+begin
+  TColor32Entry(Result).R := $FF - TColor32Entry(Color32).R;
+  TColor32Entry(Result).G := $FF - TColor32Entry(Color32).G;
+  TColor32Entry(Result).B := $FF - TColor32Entry(Color32).B;
+  TColor32Entry(Result).A := TColor32Entry(Color32).A;
+end;
+
 function SetAlpha(Color32: TColor32; NewAlpha: Integer): TColor32;
 begin
-  if NewAlpha < 0 then NewAlpha := 0
-  else if NewAlpha > 255 then NewAlpha := 255;
+  if NewAlpha < 0 then
+    NewAlpha := 0
+  else if NewAlpha > $FF then
+    NewAlpha := $FF;
   Result := (Color32 and $00FFFFFF) or (TColor32(NewAlpha) shl 24);
+end;
+
+procedure ModifyAlpha(var Color32: TColor32; NewAlpha: Byte);
+begin
+  TColor32Entry(Color32).A := NewAlpha;
+end;
+
+procedure ScaleAlpha(var Color32: TColor32; Scale: Single);
+begin
+  TColor32Entry(Color32).A := Round(Scale * TColor32Entry(Color32).A);
 end;
 
@@ -1213 +1341 @@
 var
   M1, M2: Single;
-  R, G, B: Byte;
 
   function HueToColor(Hue: Single): Byte;
@@ -1220 +1347 @@
   begin
     Hue := Hue - Floor(Hue);
-    if 6 * Hue < 1 then V := M1 + (M2 - M1) * Hue * 6
-    else if 2 * Hue < 1 then V := M2
-    else if 3 * Hue < 2 then V := M1 + (M2 - M1) * (2 * OneOverThree - Hue) * 6
+    if 6 * Hue < 1 then
+      V := M1 + (M2 - M1) * Hue * 6
+    else if 2 * Hue < 1 then
+      V := M2
+    else if 3 * Hue < 2 then
+      V := M1 + (M2 - M1) * (2 * OneOverThree - Hue) * 6
     else V := M1;
-    Result := Round(255 * V);
+    Result := Round($FF * V);
   end;
 
@@ -1230 +1360 @@
   if S = 0 then
   begin
-    R := Round(255 * L);
-    G := R;
-    B := R;
-  end
+    Result := Gray32(Round($FF * L));
+    Exit;
+  end;
+
+  if L <= 0.5 then
+    M2 := L * (1 + S)
   else
-  begin
-    if L <= 0.5 then M2 := L * (1 + S)
-    else M2 := L + S - L * S;
-    M1 := 2 * L - M2;
-    R := HueToColor(H + OneOverThree);
-    G := HueToColor(H);
-    B := HueToColor(H - OneOverThree)
-  end;
-  Result := Color32(R, G, B);
+    M2 := L + S - L * S;
+  M1 := 2 * L - M2;
+  Result := Color32(
+    HueToColor(H + OneOverThree),
+    HueToColor(H),
+    HueToColor(H - OneOverThree));
 end;
 
@@ -1249 +1378 @@
 const
   // reciprocal mul. opt.
-  R255 = 1 / 255;
   R6 = 1 / 6;
 
@@ -1255 +1383 @@
   R, G, B, D, Cmax, Cmin: Single;
 begin
-  R := RedComponent(RGB) * R255;
-  G := GreenComponent(RGB) * R255;
-  B := BlueComponent(RGB) * R255;
+  R := RedComponent(RGB) * COne255th;
+  G := GreenComponent(RGB) * COne255th;
+  B := BlueComponent(RGB) * COne255th;
   Cmax := Max(R, Max(G, B));
   Cmin := Min(R, Min(G, B));
@@ -1288 +1416 @@
 end;
 
-function HSLtoRGB(H, S, L: Integer): TColor32;
+function HSLtoRGB(H, S, L, A: Integer): TColor32;
 var
   V, M, M1, M2, VSF: Integer;
@@ -1306 +1434 @@
     M2 := V - VSF;
     case H shr 8 of
-      0: Result := Color32(V, M1, M);
-      1: Result := Color32(M2, V, M);
-      2: Result := Color32(M, V, M1);
-      3: Result := Color32(M, M2, V);
-      4: Result := Color32(M1, M, V);
-      5: Result := Color32(V, M, M2);
+      0: Result := Color32(V, M1, M, A);
+      1: Result := Color32(M2, V, M, A);
+      2: Result := Color32(M, V, M1, A);
+      3: Result := Color32(M, M2, V, A);
+      4: Result := Color32(M1, M, V, A);
+      5: Result := Color32(V, M, M2, A);
     else
       Result := 0;
@@ -1337 +1465 @@
   else
   begin
-    D := (Cmax - Cmin) * 255;
+    D := (Cmax - Cmin) * $FF;
     if L <= $7F then
       S := D div (Cmax + Cmin)
     else
-      S := D div (255 * 2 - Cmax - Cmin);
+      S := D div ($FF * 2 - Cmax - Cmin);
 
     D := D * 6;
     if R = Cmax then
-      HL := (G - B) * 255 * 255 div D
+      HL := (G - B) * $FF * $FF div D
     else if G = Cmax then
-      HL := 255 * 2 div 6 + (B - R) * 255 * 255 div D
+      HL := $FF * 2 div 6 + (B - R) * $FF * $FF div D
     else
-      HL := 255 * 4 div 6 + (R - G) * 255 * 255 div D;
-
-    if HL < 0 then HL := HL + 255 * 2;
+      HL := $FF * 4 div 6 + (R - G) * $FF * $FF div D;
+
+    if HL < 0 then HL := HL + $FF * 2;
     H := HL;
+  end;
+end;
+
+function HSVtoRGB(H, S, V: Single): TColor32;
+var
+  Tmp: TFloat;
+  Sel, Q, P: Integer;
+begin
+  V := 255 * V;
+  if S = 0 then
+  begin
+    Result := Gray32(Trunc(V));
+    Exit;
+  end;  
+
+  H := H - Floor(H);
+  Tmp := 6 * H - Floor(6 * H);
+
+  Sel := Trunc(6 * H);
+  if (Sel mod 2) = 0 then
+    Tmp := 1 - Tmp;
+
+  Q := Trunc(V * (1 - S));
+  P := Trunc(V * (1 - S * Tmp));
+
+  case Sel of
+    0:
+      Result := Color32(Trunc(V), P, Q);
+    1:
+      Result := Color32(P, Trunc(V), Q);
+    2:
+      Result := Color32(Q, Trunc(V), P);
+    3:
+      Result := Color32(Q, P, Trunc(V));
+    4:
+      Result := Color32(P, Q, Trunc(V));
+    5:
+      Result := Color32(Trunc(V), Q, P);
+  else
+    Result := Gray32(0);
+  end;
+end;
+
+procedure RGBToHSV(Color: TColor32; out H, S, V: Single);
+var
+  Delta, Min, Max: Single;
+  R, G, B: Integer;
+const
+  COneSixth = 1 / 6;
+begin
+  R := RedComponent(Color);
+  G := GreenComponent(Color);
+  B := BlueComponent(Color);
+
+  Min := MinIntValue([R, G, B]);
+  Max := MaxIntValue([R, G, B]);
+  V := Max / 255;
+
+  Delta := Max - Min;
+  if Max = 0 then
+    S := 0
+  else
+    S := Delta / Max;
+
+  if S = 0.0 then
+    H := 0
+  else
+  begin
+    if R = Max then
+      H := COneSixth * (G - B) / Delta
+    else if G = Max then
+      H := COneSixth * (2 + (B - R) / Delta)
+    else if B = Max then
+      H := COneSixth * (4 + (R - G) / Delta);
+
+    if H < 0.0 then
+      H := H + 1;
   end;
 end;
@@ -1367 +1572 @@
   L.palVersion := $300;
   L.palNumEntries := 256;
-  for I := 0 to 255 do
+  for I := 0 to $FF do
   begin
     Cl := P[I];
@@ -1386 +1591 @@
 function Fixed(S: Single): TFixed;
 begin
-  Result := Round(S * 65536);
+  Result := Round(S * FixedOne);
 end;
 
@@ -1428 +1633 @@
 
 function FloatPoint(const FXP: TFixedPoint): TFloatPoint;
-const
-  F = 1 / 65536;
 begin
   with FXP do
   begin
-    Result.X := X * F;
-    Result.Y := Y * F;
-  end;
-end;
+    Result.X := X * FixedToFloat;
+    Result.Y := Y * FixedToFloat;
+  end;
+end;
+
+{$IFDEF SUPPORT_ENHANCED_RECORDS}
+{$IFNDEF FPC}
+constructor TFloatPoint.Create(P: TPoint);
+begin
+  Self.X := P.X;
+  Self.Y := P.Y;
+end;
+
+{$IFDEF COMPILERXE2_UP}
+constructor TFloatPoint.Create(P: TPointF);
+begin
+  Self.X := P.X;
+  Self.Y := P.Y;
+end;
+{$ENDIF}
+
+constructor TFloatPoint.Create(X, Y: Integer);
+begin
+  Self.X := X;
+  Self.Y := Y;
+end;
+
+constructor TFloatPoint.Create(X, Y: TFloat);
+begin
+  Self.X := X;
+  Self.Y := Y;
+end;
+{$ENDIF}
+
+// operator overloads
+class operator TFloatPoint.Equal(const Lhs, Rhs: TFloatPoint): Boolean;
+begin
+  Result := (Lhs.X = Rhs.X) and (Lhs.Y = Rhs.Y);
+end;
+
+class operator TFloatPoint.NotEqual(const Lhs, Rhs: TFloatPoint): Boolean;
+begin
+  Result := (Lhs.X <> Rhs.X) or (Lhs.Y <> Rhs.Y);
+end;
+
+class operator TFloatPoint.Add(const Lhs, Rhs: TFloatPoint): TFloatPoint;
+begin
+  Result.X := Lhs.X + Rhs.X;
+  Result.Y := Lhs.Y + Rhs.Y;
+end;
+
+class operator TFloatPoint.Subtract(const Lhs, Rhs: TFloatPoint): TFloatPoint;
+begin
+  Result.X := Lhs.X - Rhs.X;
+  Result.Y := Lhs.Y - Rhs.Y;
+end;
+
+{$IFDEF COMPILERXE2_UP}
+class operator TFloatPoint.Explicit(A: TPointF): TFloatPoint;
+begin
+  Result.X := A.X;
+  Result.Y := A.Y;
+end;
+
+class operator TFloatPoint.Implicit(A: TPointF): TFloatPoint;
+begin
+  Result.X := A.X;
+  Result.Y := A.Y;
+end;
+{$ENDIF}
+
+class function TFloatPoint.Zero: TFloatPoint;
+begin
+  Result.X := 0;
+  Result.Y := 0;
+end;
+
+{$IFNDEF FPC}
+{$IFDEF COMPILERXE2_UP}
+constructor TFixedPoint.Create(P: TPointF);
+begin
+  Self.X := Fixed(P.X);
+  Self.Y := Fixed(P.Y);
+end;
+{$ENDIF}
+
+constructor TFixedPoint.Create(P: TFloatPoint);
+begin
+  Self.X := Fixed(P.X);
+  Self.Y := Fixed(P.Y);
+end;
+
+constructor TFixedPoint.Create(X, Y: TFixed);
+begin
+  Self.X := X;
+  Self.Y := Y;
+end;
+
+constructor TFixedPoint.Create(X, Y: Integer);
+begin
+  Self.X := Fixed(X);
+  Self.Y := Fixed(Y);
+end;
+
+constructor TFixedPoint.Create(X, Y: TFloat);
+begin
+  Self.X := Fixed(X);
+  Self.Y := Fixed(Y);
+end;
+{$ENDIF}
+
+// operator overloads
+class operator TFixedPoint.Equal(const Lhs, Rhs: TFixedPoint): Boolean;
+begin
+  Result := (Lhs.X = Rhs.X) and (Lhs.Y = Rhs.Y);
+end;
+
+class operator TFixedPoint.NotEqual(const Lhs, Rhs: TFixedPoint): Boolean;
+begin
+  Result := (Lhs.X <> Rhs.X) or (Lhs.Y <> Rhs.Y);
+end;
+
+class operator TFixedPoint.Add(const Lhs, Rhs: TFixedPoint): TFixedPoint;
+begin
+  Result.X := Lhs.X + Rhs.X;
+  Result.Y := Lhs.Y + Rhs.Y;
+end;
+
+class operator TFixedPoint.Subtract(const Lhs, Rhs: TFixedPoint): TFixedPoint;
+begin
+  Result.X := Lhs.X - Rhs.X;
+  Result.Y := Lhs.Y - Rhs.Y;
+end;
+
+class function TFixedPoint.Zero: TFixedPoint;
+begin
+  Result.X := 0;
+  Result.Y := 0;
+end;
+{$ENDIF}
 
 function FixedPoint(X, Y: Integer): TFixedPoint; overload;
@@ -1446 +1785 @@
 function FixedPoint(X, Y: Single): TFixedPoint; overload;
 begin
-  Result.X := Round(X * 65536);
-  Result.Y := Round(Y * 65536);
+  Result.X := Round(X * FixedOne);
+  Result.Y := Round(Y * FixedOne);
 end;
 
@@ -1458 +1797 @@
 function FixedPoint(const FP: TFloatPoint): TFixedPoint; overload;
 begin
-  Result.X := Round(FP.X * 65536);
-  Result.Y := Round(FP.Y * 65536);
+  Result.X := Round(FP.X * FixedOne);
+  Result.Y := Round(FP.Y * FixedOne);
 end;
 
@@ -1551 +1890 @@
 end;
 
+function FixedRect(const TopLeft, BottomRight: TFixedPoint): TFixedRect;
+begin
+  Result.TopLeft := TopLeft;
+  Result.BottomRight := BottomRight;
+end;
+
 function FixedRect(const ARect: TRect): TFixedRect;
 begin
@@ -1582 +1927 @@
     Bottom := B;
   end;
+end;
+
+function FloatRect(const TopLeft, BottomRight: TFloatPoint): TFloatRect;
+begin
+  Result.TopLeft := TopLeft;
+  Result.BottomRight := BottomRight;
 end;
 
@@ -1745 +2096 @@
 end;
 
-{ Gamma / Pixel Shape Correction table }
-
-procedure SetGamma(Gamma: Single);
-var
-  i: Integer;
-begin
-  for i := 0 to 255 do
-    GAMMA_TABLE[i] := Round(255 * Power(i / 255, Gamma));
-end;
-
-function GetPlatformBackendClass: TCustomBackendClass;
-begin
-{$IFDEF FPC}
-  Result := TLCLBackend;
-{$ELSE}
-  Result := TGDIBackend;
-{$ENDIF}
-end;
-
 { TSimpleInterfacedPersistent }
 
@@ -1869 +2201 @@
 
 { TCustomMap }
+
+constructor TCustomMap.Create(Width, Height: Integer);
+begin
+  Create;
+  SetSize(Width, Height);
+end;
 
 procedure TCustomMap.ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer);
@@ -1931 +2269 @@
 { TCustomBitmap32 }
 
-constructor TCustomBitmap32.Create;
-begin
-  inherited;
-
-  InitializeBackend;
+constructor TCustomBitmap32.Create(Backend: TCustomBackendClass);
+begin
+  inherited Create;
+
+  InitializeBackend(Backend);
 
   FOuterColor := $00000000;  // by default as full transparency black
@@ -1949 +2287 @@
 end;
 
+constructor TCustomBitmap32.Create;
+begin
+  Create(GetPlatformBackendClass);
+end;
+
 destructor TCustomBitmap32.Destroy;
 begin
@@ -1963 +2306 @@
 end;
 
-procedure TCustomBitmap32.InitializeBackend;
-begin
-  TMemoryBackend.Create(Self);
+procedure TCustomBitmap32.InitializeBackend(Backend: TCustomBackendClass);
+begin
+  Backend.Create(Self);
 end;
 
@@ -1988 +2331 @@
   http://qc.codegear.com/wc/qcmain.aspx?d=9500
 
-  If any backend interface is used within the same procedure in which
+  if any backend interface is used within the same procedure in which
   the owner bitmap is also freed, the magic procedure cleanup will
   clear that particular interface long after the bitmap and its backend
@@ -2239 +2582 @@
         // this checks for transparency by comparing the pixel-color of the
         // temporary bitmap (red masked) with the pixel of our
-        // bitmap (white masked). If they match, make that pixel opaque
+        // bitmap (white masked). if they match, make that pixel opaque
         if DstColor = (SrcP^ and $00FFFFFF) then
           DstP^ := DstColor or $FF000000
@@ -2292 +2635 @@
 
     // Check if the icon was painted with a merged alpha channel.
-    // The happens transparently for new-style 32-bit icons.
+    // That happens transparently for new-style 32-bit icons.
     // For all other bit depths GDI will reset our alpha channel to opaque.
     ReassignFromMasked := True;
@@ -2320 +2663 @@
     else if SrcGraphic is TMetaFile then
       AssignFromGraphicMasked(TargetBitmap, SrcGraphic)
+{$IFDEF COMPILER2005_UP}
+    else if SrcGraphic is TWICImage then
+      AssignFromGraphicPlain(TargetBitmap, SrcGraphic, 0, False)
+{$ENDIF}
 {$ENDIF}
     else
@@ -2385 +2732 @@
 end;
 
+constructor TCustomBitmap32.Create(Width, Height: Integer);
+begin
+  Create;
+  SetSize(Width, Height);
+end;
+
 {$IFDEF BITS_GETTER}
 function TCustomBitmap32.GetBits: PColor32Array;
@@ -2391 +2744 @@
 end;
 {$ENDIF}
+
+procedure TCustomBitmap32.SetPenPos(const Value: TPoint);
+begin
+  MoveTo(Value.X, Value.Y);
+end;
+
+procedure TCustomBitmap32.SetPenPosF(const Value: TFixedPoint);
+begin
+  MoveTo(Value.X, Value.Y);
+end;
 
 procedure TCustomBitmap32.SetPixel(X, Y: Integer; Value: TColor32);
@@ -2412 +2775 @@
 begin
   Result := @Bits[Y * FWidth];
+end;
+
+function TCustomBitmap32.GetPenPos: TPoint;
+begin
+  Result.X := RasterX;
+  Result.Y := RasterY;
+end;
+
+function TCustomBitmap32.GetPenPosF: TFixedPoint;
+begin
+  Result.X := RasterXF;
+  Result.Y := RasterYF;
 end;
 
@@ -2438 +2813 @@
 end;
 
-procedure TCustomBitmap32.Draw(DstX, DstY: Integer; const SrcRect: TRect; Src: TCustomBitmap32);
+procedure TCustomBitmap32.Draw(DstX, DstY: Integer; const SrcRect: TRect;
+  Src: TCustomBitmap32);
 begin
   if Assigned(Src) then Src.DrawTo(Self, DstX, DstY, SrcRect);
@@ -2450 +2826 @@
 procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32);
 begin
-  BlockTransfer(Dst, 0, 0, Dst.ClipRect, Self, BoundsRect, DrawMode, FOnPixelCombine);
+  BlockTransfer(Dst, 0, 0, Dst.ClipRect, Self, BoundsRect, DrawMode,
+    FOnPixelCombine);
 end;
 
 procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32; DstX, DstY: Integer);
 begin
-  BlockTransfer(Dst, DstX, DstY, Dst.ClipRect, Self, BoundsRect, DrawMode, FOnPixelCombine);
-end;
-
-procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32; DstX, DstY: Integer; const SrcRect: TRect);
-begin
-  BlockTransfer(Dst, DstX, DstY, Dst.ClipRect, Self, SrcRect, DrawMode, FOnPixelCombine);
+  BlockTransfer(Dst, DstX, DstY, Dst.ClipRect, Self, BoundsRect, DrawMode,
+    FOnPixelCombine);
+end;
+
+procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32; DstX, DstY: Integer;
+    const SrcRect: TRect);
+begin
+  BlockTransfer(Dst, DstX, DstY, Dst.ClipRect, Self, SrcRect,
+    DrawMode, FOnPixelCombine);
 end;
 
 procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32; const DstRect: TRect);
 begin
-  StretchTransfer(Dst, DstRect, Dst.ClipRect, Self, BoundsRect, Resampler, DrawMode, FOnPixelCombine);
-end;
-
-procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32; const DstRect, SrcRect: TRect);
-begin
-  StretchTransfer(Dst, DstRect, Dst.ClipRect, Self, SrcRect, Resampler, DrawMode, FOnPixelCombine);
+  StretchTransfer(Dst, DstRect, Dst.ClipRect, Self, BoundsRect, Resampler,
+    DrawMode, FOnPixelCombine);
+end;
+
+procedure TCustomBitmap32.DrawTo(Dst: TCustomBitmap32; const DstRect,
+  SrcRect: TRect);
+begin
+  StretchTransfer(Dst, DstRect, Dst.ClipRect, Self, SrcRect, Resampler,
+    DrawMode, FOnPixelCombine);
 end;
 
@@ -2610 +2993 @@
   begin
     A := C shr 24;  // opacity
-    celx := A * GAMMA_TABLE[flrx xor 255];
-    cely := GAMMA_TABLE[flry xor 255];
-    flrx := A * GAMMA_TABLE[flrx];
-    flry := GAMMA_TABLE[flry];
+    celx := A * GAMMA_ENCODING_TABLE[flrx xor $FF];
+    cely := GAMMA_ENCODING_TABLE[flry xor $FF];
+    flrx := A * GAMMA_ENCODING_TABLE[flrx];
+    flry := GAMMA_ENCODING_TABLE[flry];
 
     CombineMem(C, P^, celx * cely shr 16); Inc(P);
@@ -2622 +3005 @@
   else
   begin
-    celx := GAMMA_TABLE[flrx xor 255];
-    cely := GAMMA_TABLE[flry xor 255];
-    flrx := GAMMA_TABLE[flrx];
-    flry := GAMMA_TABLE[flry];
-    
+    celx := GAMMA_ENCODING_TABLE[flrx xor $FF];
+    cely := GAMMA_ENCODING_TABLE[flry xor $FF];
+    flrx := GAMMA_ENCODING_TABLE[flrx];
+    flry := GAMMA_ENCODING_TABLE[flry];
+
     CombineMem(MergeReg(C, P^), P^, celx * cely shr 8); Inc(P);
     CombineMem(MergeReg(C, P^), P^, flrx * cely shr 8); Inc(P, FWidth);
@@ -2663 +3046 @@
   begin
     A := C shr 24;  // opacity
-    celx := A * GAMMA_TABLE[flrx xor 255];
-    cely := GAMMA_TABLE[flry xor 255];
-    flrx := A * GAMMA_TABLE[flrx];
-    flry := GAMMA_TABLE[flry];
+    celx := A * GAMMA_ENCODING_TABLE[flrx xor $FF];
+    cely := GAMMA_ENCODING_TABLE[flry xor $FF];
+    flrx := A * GAMMA_ENCODING_TABLE[flrx];
+    flry := GAMMA_ENCODING_TABLE[flry];
 
     if (X >= FClipRect.Left) and (Y >= FClipRect.Top) and
@@ -2687 +3070 @@
   else
   begin
-    celx := GAMMA_TABLE[flrx xor 255];
-    cely := GAMMA_TABLE[flry xor 255];
-    flrx := GAMMA_TABLE[flrx];
-    flry := GAMMA_TABLE[flry];
+    celx := GAMMA_ENCODING_TABLE[flrx xor $FF];
+    cely := GAMMA_ENCODING_TABLE[flry xor $FF];
+    flrx := GAMMA_ENCODING_TABLE[flrx];
+    flry := GAMMA_ENCODING_TABLE[flry];
 
     if (X >= FClipRect.Left) and (Y >= FClipRect.Top) and
@@ -2789 +3172 @@
 begin
   Pos := (X shr 8) + (Y shr 8) * FWidth;
-  Result := Interpolator(GAMMA_TABLE[X and $FF xor 255],
-                         GAMMA_TABLE[Y and $FF xor 255],
+  Result := Interpolator(GAMMA_ENCODING_TABLE[X and $FF xor $FF],
+                         GAMMA_ENCODING_TABLE[Y and $FF xor $FF],
                          @Bits[Pos], @Bits[Pos + FWidth]);
 end;
@@ -2861 +3244 @@
 {$ELSE}
 asm
+{$IFDEF TARGET_x64}
+          PUSH    RBP
+          SUB     RSP,$30
+{$ENDIF}
           ADD     X, $7F
           ADD     Y, $7F
@@ -2873 +3260 @@
 {$ENDIF}
 
+{$IFDEF TARGET_x64}
+          LEA     RSP,[RBP+$30]
+          POP     RBP
+{$ENDIF}
+
 {$ENDIF}
 end;
@@ -2922 +3314 @@
                        WordRec(TFixedRec(Y).Frac).Hi);
   EMMS;
+end;
+
+class function TCustomBitmap32.GetPlatformBackendClass: TCustomBackendClass;
+begin
+  Result := TMemoryBackend;
 end;
 
@@ -2986 +3383 @@
   end;
   FStippleCounter := Wrap(FStippleCounter, L);
+  {$IFDEF FPC}
+  PrevIndex := Trunc(FStippleCounter);
+  {$ELSE}
   PrevIndex := Round(FStippleCounter - 0.5);
-  PrevWeight := 255 - Round(255 * (FStippleCounter - PrevIndex));
+  {$ENDIF}
+  PrevWeight := $FF - Round($FF * (FStippleCounter - PrevIndex));
   if PrevIndex < 0 then FStippleCounter := L - 1;
   NextIndex := PrevIndex + 1;
   if NextIndex >= L then NextIndex := 0;
-  if PrevWeight = 255 then Result := FStipplePattern[PrevIndex]
+  if PrevWeight = $FF then Result := FStipplePattern[PrevIndex]
   else
   begin
@@ -3128 +3529 @@
     if Wy > 0 then
     begin
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wy * Wx1) shr 24]);
-      Wt := GAMMA_TABLE[Wy shr 8];
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wy * Wx1) shr 24]);
+      Wt := GAMMA_ENCODING_TABLE[Wy shr 8];
       Inc(PDst);
       for I := 0 to Count - 1 do
@@ -3136 +3537 @@
         Inc(PDst);
       end;
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wy * Wx2) shr 24]);
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wy * Wx2) shr 24]);
     end;
 
@@ -3144 +3545 @@
     if Wy > 0 then
     begin
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wy * Wx1) shr 24]);
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wy * Wx1) shr 24]);
       Inc(PDst);
-      Wt := GAMMA_TABLE[Wy shr 8];
+      Wt := GAMMA_ENCODING_TABLE[Wy shr 8];
       for I := 0 to Count - 1 do
       begin
@@ -3152 +3553 @@
         Inc(PDst);
       end;
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wy * Wx2) shr 24]);
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wy * Wx2) shr 24]);
     end;
 
@@ -3322 +3723 @@
     if Wx > 0 then
     begin
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wx * Wy1) shr 24]);
-      Wt := GAMMA_TABLE[Wx shr 8];
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wx * Wy1) shr 24]);
+      Wt := GAMMA_ENCODING_TABLE[Wx shr 8];
       Inc(PDst, FWidth);
       for I := 0 to Count - 1 do
@@ -3330 +3731 @@
         Inc(PDst, FWidth);
       end;
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wx * Wy2) shr 24]);
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wx * Wy2) shr 24]);
     end;
 
@@ -3338 +3739 @@
     if Wx > 0 then
     begin
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wx * Wy1) shr 24]);
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wx * Wy1) shr 24]);
       Inc(PDst, FWidth);
-      Wt := GAMMA_TABLE[Wx shr 8];
+      Wt := GAMMA_ENCODING_TABLE[Wx shr 8];
       for I := 0 to Count - 1 do
       begin
@@ -3346 +3747 @@
         Inc(PDst, FWidth);
       end;
-      CombineMem(Value, PDst^, GAMMA_TABLE[(Wx * Wy2) shr 24]);
+      CombineMem(Value, PDst^, GAMMA_ENCODING_TABLE[(Wx * Wy2) shr 24]);
     end;
 
@@ -3545 +3946 @@
           Inc(e, Dy2);
         end;
-        CheckAux := False; // to avoid ugly labels we set this to omit the next check
+        CheckAux := False; // to avoid ugly goto we set this to omit the next check
       end;
     end;
@@ -3565 +3966 @@
     end;
 
-    // set auxiliary var to indicate that temp is not clipped, since
-    // temp still has the unclipped value assigned at setup.
+    // set auxiliary var to indicate that term is not clipped, since
+    // term still has the unclipped value assigned at setup.
     CheckAux := False;
 
@@ -3572 +3973 @@
     if Y2 > Cy2 then
     begin
-      OC := Dx2 * (Cy2 - Y1) + Dx;
+      OC := Int64(Dx2) * (Cy2 - Y1) + Dx;
       term := X1 + OC div Dy2;
       rem := OC mod Dy2;
       if rem = 0 then Dec(term);
-      CheckAux := True; // set auxiliary var to indicate that temp is clipped
+      CheckAux := True; // set auxiliary var to indicate that term is clipped
     end;
 
@@ -3582 +3983 @@
     begin
       term := Cx2;
-      CheckAux := True; // set auxiliary var to indicate that temp is clipped
+      CheckAux := True; // set auxiliary var to indicate that term is clipped
     end;
 
@@ -3610 +4011 @@
     end;
 
-    // do we need to skip the last pixel of the line and is temp not clipped?
+    // do we need to skip the last pixel of the line and is term not clipped?
     if not(L or CheckAux) then
     begin
@@ -3814 +4215 @@
           Inc(e, Dy2);
         end;
-        CheckAux := False; // to avoid ugly labels we set this to omit the next check
+        CheckAux := False; // to avoid ugly goto we set this to omit the next check
       end;
     end;
@@ -3834 +4235 @@
     end;
 
-    // set auxiliary var to indicate that temp is not clipped, since
-    // temp still has the unclipped value assigned at setup.
+    // set auxiliary var to indicate that term is not clipped, since
+    // term still has the unclipped value assigned at setup.
     CheckAux := False;
 
@@ -3845 +4246 @@
       rem := OC mod Dy2;
       if rem = 0 then Dec(term);
-      CheckAux := True; // set auxiliary var to indicate that temp is clipped
+      CheckAux := True; // set auxiliary var to indicate that term is clipped
     end;
 
@@ -3851 +4252 @@
     begin
       term := Cx2;
-      CheckAux := True; // set auxiliary var to indicate that temp is clipped
+      CheckAux := True; // set auxiliary var to indicate that term is clipped
     end;
 
@@ -3879 +4280 @@
     end;
 
-    // do we need to skip the last pixel of the line and is temp not clipped?
+    // do we need to skip the last pixel of the line and is term not clipped?
     if not(L or CheckAux) then
     begin
@@ -3915 +4316 @@
 var
   n, i: Integer;
-  nx, ny, hyp: Integer;
+  nx, ny, hyp, hypl: Integer;
   A: TColor32;
   h: Single;
@@ -3925 +4326 @@
     Inc(X1, 127); Inc(Y1, 127); Inc(X2, 127); Inc(Y2, 127);
     hyp := Hypot(nx, ny);
-    if L then Inc(hyp, 65536);
-    if hyp < 256 then Exit;
-    n := hyp shr 16;
+    if hyp = 0 then Exit;
+    hypl := hyp + (Integer(L) * FixedOne);
+    if (hypl < 256) then Exit;
+    n := hypl shr 16;
     if n > 0 then
     begin
@@ -3940 +4342 @@
     end;
     A := Value shr 24;
-    hyp := hyp - n shl 16;
+    hyp := hypl - n shl 16;
     A := A * Cardinal(hyp) shl 8 and $FF000000;
     SET_T256((X1 + X2 - nx) shr 9, (Y1 + Y2 - ny) shr 9, Value and $00FFFFFF + A);
@@ -3957 +4359 @@
 var
   n, i: Integer;
-  ex, ey, nx, ny, hyp: Integer;
+  ex, ey, nx, ny, hyp, hypl: Integer;
   A: TColor32;
   h: Single;
@@ -3970 +4372 @@
     // Check for visibility and clip the coordinates
     if not ClipLine(Integer(X1), Integer(Y1), Integer(X2), Integer(Y2),
-      FFixedClipRect.Left - $10000, FFixedClipRect.Top - $10000,
+      FFixedClipRect.Left - $10000,
+      FFixedClipRect.Top - $10000,
       FFixedClipRect.Right, FFixedClipRect.Bottom) then Exit;
 
@@ -3988 +4391 @@
     end;
 
-    // If we are still here, it means that the line touches one or several bitmap
+    // if we are still here, it means that the line touches one or several bitmap
     // boundaries. Use the safe version of antialiased pixel routine
     try
@@ -3994 +4397 @@
       Inc(X1, 127); Inc(Y1, 127); Inc(X2, 127); Inc(Y2, 127);
       hyp := Hypot(nx, ny);
-      if L then Inc(Hyp, 65536);
-      if hyp < 256 then Exit;
-      n := hyp shr 16;
+      if hyp = 0 then Exit;
+      hypl := hyp + (Integer(L) * FixedOne);
+      if hypl < 256 then Exit;
+      n := hypl shr 16;
       if n > 0 then
       begin
@@ -4009 +4413 @@
       end;
       A := Value shr 24;
-      hyp := hyp - n shl 16;
-      A := A * Longword(hyp) shl 8 and $FF000000;
+      hyp := hypl - n shl 16;
+      A := A * Cardinal(hyp) shl 8 and $FF000000;
       SET_TS256(SAR_9(X1 + X2 - nx), SAR_9(Y1 + Y2 - ny), Value and $00FFFFFF + A);
     finally
@@ -4027 +4431 @@
 var
   n, i: Integer;
-  nx, ny, hyp: Integer;
+  nx, ny, hyp, hypl: Integer;
   A, C: TColor32;
   ChangedRect: TRect;
@@ -4036 +4440 @@
     Inc(X1, 127); Inc(Y1, 127); Inc(X2, 127); Inc(Y2, 127);
     hyp := Hypot(nx, ny);
-    if L then Inc(hyp, 65536);
-    if hyp < 256 then Exit;
-    n := hyp shr 16;
+    if hyp = 0 then Exit;
+    hypl := hyp + (Integer(L) * FixedOne);
+    if hypl < 256 then Exit;
+    n := hypl shr 16;
     if n > 0 then
     begin
@@ -4054 +4459 @@
     C := GetStippleColor;
     A := C shr 24;
-    hyp := hyp - n shl 16;
+    hyp := hypl - n shl 16;
     A := A * Longword(hyp) shl 8 and $FF000000;
     SET_T256((X1 + X2 - nx) shr 9, (Y1 + Y2 - ny) shr 9, C and $00FFFFFF + A);
@@ -4070 +4475 @@
 procedure TCustomBitmap32.LineXSP(X1, Y1, X2, Y2: TFixed; L: Boolean);
 const
-  StippleInc: array [Boolean] of Single = (0, 1);
+  StippleInc: array [Boolean] of Integer = (0, 1);
 var
   n, i: Integer;
-  sx, sy, ex, ey, nx, ny, hyp: Integer;
+  sx, sy, ex, ey, nx, ny, hyp, hypl: Integer;
   A, C: TColor32;
   ChangedRect: TRect;
@@ -4110 +4515 @@
         Integer((Y1 - sy) shr 16)));
 
-    // If we are still here, it means that the line touches one or several bitmap
+    // if we are still here, it means that the line touches one or several bitmap
     // boundaries. Use the safe version of antialiased pixel routine
     nx := X2 - X1; ny := Y2 - Y1;
     Inc(X1, 127); Inc(Y1, 127); Inc(X2, 127); Inc(Y2, 127);
     hyp := GR32_Math.Hypot(nx, ny);
-    if L then Inc(hyp, 65536);
-    if hyp < 256 then Exit;
-    n := hyp shr 16;
+    if hyp = 0 then Exit;
+    hypl := hyp + (Integer(L) * FixedOne);
+    if hypl < 256 then Exit;
+    n := hypl shr 16;
     if n > 0 then
     begin
@@ -4132 +4538 @@
     C := GetStippleColor;
     A := C shr 24;
-    hyp := hyp - n shl 16;
+    hyp := hypl - n shl 16;
     A := A * Longword(hyp) shl 8 and $FF000000;
     SET_TS256(SAR_9(X1 + X2 - nx), SAR_9(Y1 + Y2 - ny), C and $00FFFFFF + A);
@@ -4199 +4605 @@
         CI := EC shr 8;
         P := @Bits[X1 + Y1 * Width];
-        BlendMemEx(Value, P^, GAMMA_TABLE[CI xor 255]);
+        BlendMemEx(Value, P^, GAMMA_ENCODING_TABLE[CI xor $FF]);
         Inc(P, Sx);
-        BlendMemEx(Value, P^, GAMMA_TABLE[CI]);
+        BlendMemEx(Value, P^, GAMMA_ENCODING_TABLE[CI]);
       end;
     end
@@ -4217 +4623 @@
         CI := EC shr 8;
         P := @Bits[X1 + Y1 * Width];
-        BlendMemEx(Value, P^, GAMMA_TABLE[CI xor 255]);
+        BlendMemEx(Value, P^, GAMMA_ENCODING_TABLE[CI xor $FF]);
         if Sy = 1 then Inc(P, Width) else Dec(P, Width);
-        BlendMemEx(Value, P^, GAMMA_TABLE[CI]);
+        BlendMemEx(Value, P^, GAMMA_ENCODING_TABLE[CI]);
       end;
     end;
@@ -4231 +4637 @@
 var
   Cx1, Cx2, Cy1, Cy2, PI, Sx, Sy, Dx, Dy, xd, yd, rem, term, tmp: Integer;
-  CheckVert, CornerAA, TempClipped: Boolean;
+  CheckVert, CornerAA, TermClipped: Boolean;
   D1, D2: PInteger;
   EC, EA, ED, D: Word;
@@ -4376 +4782 @@
           begin
             Inc(xd, -Sx);
-            BlendMemEx(Value, Bits[D1^ + D2^ * Width], GAMMA_TABLE[ED shr 8]);
+            BlendMemEx(Value, Bits[D1^ + D2^ * Width], GAMMA_ENCODING_TABLE[ED shr 8]);
             Dec(ED, EA);
           end;
@@ -4395 +4801 @@
         if Sy = -1 then yd := -yd;  // negate back
         xd := rem;  // restore old xd
-        CheckVert := False; // to avoid ugly labels we set this to omit the next check
+        CheckVert := False; // to avoid ugly goto we set this to omit the next check
       end;
     end;
@@ -4413 +4819 @@
 
     term := X2;
-    TempClipped := False;
+    TermClipped := False;
     CheckVert := False;
 
@@ -4436 +4842 @@
       end;
 
-      TempClipped := True;
+      TermClipped := True;
     end;
 
@@ -4442 +4848 @@
     begin
       term := Cx2;
-      TempClipped := True;
+      TermClipped := True;
     end;
 
@@ -4458 +4864 @@
     if not CornerAA then
     try
-      // do we need to skip the last pixel of the line and is temp not clipped?
-      if not(L or TempClipped) and not CheckVert then
+      // do we need to skip the last pixel of the line and is term not clipped?
+      if not(L or TermClipped) and not CheckVert then
       begin
         if xd < term then
@@ -4467 +4873 @@
       end;
 
-      Assert(term >= 0);
       while xd <> term do
       begin
         CI := EC shr 8;
         P := @Bits[D1^ + D2^ * Width];
-        BlendMemEx(Value, P^, GAMMA_TABLE[CI xor 255]);
+        BlendMemEx(Value, P^, GAMMA_ENCODING_TABLE[CI xor $FF]);
         Inc(P, PI);
-        BlendMemEx(Value, P^, GAMMA_TABLE[CI]);
+        BlendMemEx(Value, P^, GAMMA_ENCODING_TABLE[CI]);
         // check for overflow and jump to next line...
         D := EC;
@@ -4492 +4897 @@
       while xd <> rem do
       begin
-        BlendMemEx(Value, Bits[D1^ + D2^ * Width], GAMMA_TABLE[EC shr 8 xor 255]);
+        BlendMemEx(Value, Bits[D1^ + D2^ * Width], GAMMA_ENCODING_TABLE[EC shr 8 xor $FF]);
         Inc(EC, EA);
         Inc(xd, Sx);
@@ -4758 +5163 @@
     begin
       C1 := SetAlpha(clWhite32, Clamp(Contrast * 512 div 100));
-      C2 := SetAlpha(clBlack32, Clamp(Contrast * 255 div 100));
+      C2 := SetAlpha(clBlack32, Clamp(Contrast * $FF div 100));
     end
     else if Contrast < 0 then
     begin
       Contrast := -Contrast;
-      C1 := SetAlpha(clBlack32, Clamp(Contrast * 255 div 100));
+      C1 := SetAlpha(clBlack32, Clamp(Contrast * $FF div 100));
       C2 := SetAlpha(clWhite32, Clamp(Contrast * 512 div 100));
     end
@@ -4862 +5267 @@
     W := Width shl 2;
     for I := Height - 1 downto 0 do
-      Stream.WriteBuffer(PixelPtr[0, I]^, W);
+      Stream.WriteBuffer(ScanLine[I]^, W);
   end
   else
@@ -4991 +5396 @@
 procedure TCustomBitmap32.ReadData(Stream: TStream);
 var
-  w, h: Integer;
+  Width, Height: Integer;
 begin
   try
-    Stream.ReadBuffer(w, 4);
-    Stream.ReadBuffer(h, 4);
-    SetSize(w, h);
+    Stream.ReadBuffer(Width, 4);
+    Stream.ReadBuffer(Height, 4);
+    SetSize(Width, Height);
     Stream.ReadBuffer(Bits[0], FWidth * FHeight * 4);
   finally
@@ -5101 +5506 @@
     OffsetRect(R, Dx, Dy);
     IntersectRect(R, R, MakeRect(0, 0, Width, Height));
-    if R.Top > 0 then FillRect(0, 0, Width, R.Top, FillColor)
-    else if R.Top = 0 then FillRect(0, R.Bottom, Width, Height, FillColor);
-    if R.Left > 0 then FillRect(0, R.Top, R.Left, R.Bottom, FillColor)
-    else if R.Left = 0 then FillRect(R.Right, R.Top, Width, R.Bottom, FillColor);
+    if R.Top > 0 then
+      FillRect(0, 0, Width, R.Top, FillColor)
+    else
+    if R.Top = 0 then
+      FillRect(0, R.Bottom, Width, Height, FillColor);
+    if R.Left > 0 then
+      FillRect(0, R.Top, R.Left, R.Bottom, FillColor)
+    else
+    if R.Left = 0 then
+      FillRect(R.Right, R.Top, Width, R.Bottom, FillColor);
   end;
 
@@ -5176 +5587 @@
     for J := 0 to Height div 2 - 1 do
     begin
-      P1 := PixelPtr[0, J];
-      P2 := PixelPtr[0, J2];
+      P1 := PColor32(ScanLine[J]);
+      P2 := PColor32(ScanLine[J2]);
       MoveLongword(P1^, Buffer^, Width);
       MoveLongword(P2^, P1^, Width);
@@ -5192 +5603 @@
     for J := 0 to Height - 1 do
     begin
-      MoveLongword(PixelPtr[0, J]^, Dst.PixelPtr[0, J2]^, Width);
+      MoveLongword(ScanLine[J]^, Dst.ScanLine[J2]^, Width);
       Dec(J2);
     end;
@@ -5387 +5798 @@
 end;
 
-procedure TCustomBitmap32.SetResamplerClassName(Value: string);
+procedure TCustomBitmap32.SetResamplerClassName(const Value: string);
 var
   ResamplerClass: TCustomResamplerClass;
@@ -5399 +5810 @@
 
 { TBitmap32 }
-
-procedure TBitmap32.InitializeBackend;
-begin
-  Backend := GetPlatformBackendClass.Create;
-end;
 
 procedure TBitmap32.FinalizeBackend;
@@ -5466 +5872 @@
 begin
   Result := (FBackend as IDeviceContextSupport).Handle;
+end;
+
+class function TBitmap32.GetPlatformBackendClass: TCustomBackendClass;
+begin
+{$IFDEF FPC}
+  Result := TLCLBackend;
+{$ELSE}
+  Result := TGDIBackend;
+{$ENDIF}
 end;
 
@@ -5567 +5982 @@
 end;
 
+{$IFDEF COMPILER2009_UP}
+procedure TBitmap32.DrawTo(Dst: TControlCanvas; DstX, DstY: Integer);
+begin
+  DrawTo(Dst.Handle, DstX, DstY);
+end;
+
+procedure TBitmap32.DrawTo(Dst: TControlCanvas; const DstRect, SrcRect: TRect);
+begin
+  DrawTo(Dst.Handle, DstRect, SrcRect);
+end;
+
+procedure TBitmap32.TileTo(Dst: TControlCanvas; const DstRect, SrcRect: TRect);
+begin
+  TileTo(Dst.Handle, DstRect, SrcRect);
+end;
+{$ENDIF}
+
 procedure TBitmap32.UpdateFont;
 begin
@@ -5574 +6006 @@
 // Text and Fonts //
 
-function TBitmap32.TextExtent(const Text: String): TSize;
+function TBitmap32.TextExtent(const Text: string): TSize;
 begin
   Result := (FBackend as ITextSupport).TextExtent(Text);
@@ -5586 +6018 @@
 // -------------------------------------------------------------------
 
-procedure TBitmap32.Textout(X, Y: Integer; const Text: String);
+procedure TBitmap32.Textout(X, Y: Integer; const Text: string);
 begin
   (FBackend as ITextSupport).Textout(X, Y, Text);
@@ -5598 +6030 @@
 // -------------------------------------------------------------------
 
-procedure TBitmap32.Textout(X, Y: Integer; const ClipRect: TRect; const Text: String);
+procedure TBitmap32.Textout(X, Y: Integer; const ClipRect: TRect; const Text: string);
 begin
   (FBackend as ITextSupport).Textout(X, Y, ClipRect, Text);
@@ -5610 +6042 @@
 // -------------------------------------------------------------------
 
-procedure TBitmap32.Textout(DstRect: TRect; const Flags: Cardinal; const Text: String);
+procedure TBitmap32.Textout(var DstRect: TRect; const Flags: Cardinal; const Text: string);
 begin
   (FBackend as ITextSupport).Textout(DstRect, Flags, Text);
 end;
 
-procedure TBitmap32.TextoutW(DstRect: TRect; const Flags: Cardinal; const Text: Widestring);
+procedure TBitmap32.TextoutW(var DstRect: TRect; const Flags: Cardinal; const Text: Widestring);
 begin
   (FBackend as ITextSupport).TextoutW(DstRect, Flags, Text);
@@ -5622 +6054 @@
 // -------------------------------------------------------------------
 
-function TBitmap32.TextHeight(const Text: String): Integer;
+function TBitmap32.TextHeight(const Text: string): Integer;
 begin
   Result := (FBackend as ITextSupport).TextExtent(Text).cY;
@@ -5634 +6066 @@
 // -------------------------------------------------------------------
 
-function TBitmap32.TextWidth(const Text: String): Integer;
+function TBitmap32.TextWidth(const Text: string): Integer;
 begin
   Result := (FBackend as ITextSupport).TextExtent(Text).cX;
@@ -5674 +6106 @@
     lfCharSet := Byte(Font.Charset);
 
-    // TODO DVT Added cast to fix TFontDataName to String warning. Need to verify is OK
+    // TODO DVT Added cast to fix TFontDataName to string warning. Need to verify is OK
     if AnsiCompareText(Font.Name, 'Default') = 0 then  // do not localize
       StrPCopy(lfFaceName, string(DefFontData.Name))
@@ -5746 +6178 @@
 begin
   Sz := 1 shl N - 1;
-  Dst := B.PixelPtr[0, 0];
+  Dst := PColor32(B.ScanLine[0]);
   for J := 0 to B.Height - 1 do
   begin
@@ -5770 +6202 @@
 end;
 
-procedure TBitmap32.RenderText(X, Y: Integer; const Text: String; AALevel: Integer; Color: TColor32);
+procedure TBitmap32.RenderText(X, Y: Integer; const Text: string; AALevel: Integer; Color: TColor32);
 var
   B, B2: TBitmap32;
   Sz: TSize;
   Alpha: TColor32;
-  PaddedText: String;
+  PaddedText: string;
 begin
   if Empty then Exit;
@@ -5835 +6267 @@
     DrawMode := dmBlend;
     MasterAlpha := Alpha;
-    CombineMode := Self.CombineMode;
+    CombineMode := CombineMode;
 
     DrawTo(Self, X, Y);
@@ -5879 +6311 @@
   B := TBitmap32.Create;
   try
-    if AALevel = 0 then
+    if AALevel <= 0 then
     begin
       Sz := TextExtentW(PaddedText);
@@ -5997 +6429 @@
 {$ENDIF}
 
-procedure TCustomBackend.ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer; ClearBuffer: Boolean);
+procedure TCustomBackend.ChangeSize(out Width, Height: Integer; NewWidth, NewHeight: Integer; ClearBuffer: Boolean);
 begin
   try

GraphicTest/Packages/Graphics32/GR32_Backends.pas

@@ -44 +44 @@
   Windows, Messages, Controls, Graphics,
 {$ENDIF}
-  Classes, SysUtils, GR32, GR32_Containers, GR32_Image;
+  Classes, SysUtils, GR32, GR32_Containers, GR32_Image, GR32_Paths;
 
 type
+  EBackend = class(Exception);
+
   ITextSupport = interface(IUnknown)
   ['{225997CC-958A-423E-8B60-9EDE0D3B53B5}']
@@ -70 +72 @@
     property Font: TFont read GetFont write SetFont;
     property OnFontChange: TNotifyEvent read GetOnFontChange write SetOnFontChange;
+  end;
+
+  ITextToPathSupport = interface(IUnknown)
+  ['{6C4037E4-FF4D-4EE2-9C20-B9DB9C64B42D}']
+    procedure TextToPath(Path: TCustomPath; const X, Y: TFloat; const Text: WideString); overload;
+    procedure TextToPath(Path: TCustomPath; const DstRect: TFloatRect; const Text: WideString; Flags: Cardinal); overload;
+    function MeasureText(const DstRect: TFloatRect; const Text: WideString; Flags: Cardinal): TFloatRect;
   end;
 
@@ -130 +139 @@
 implementation
 
-uses
-  GR32_LowLevel;
-
 procedure RequireBackendSupport(TargetBitmap: TCustomBitmap32;
   RequiredInterfaces: array of TGUID;
@@ -159 +165 @@
     // TODO: Try to find a back-end that supports the required interfaces
     //       instead of resorting to the default platform back-end class...
-    TargetBitmap.Backend := GetPlatformBackendClass.Create;
+    TargetBitmap.Backend := TargetBitmap.GetPlatformBackendClass.Create;
   end
   else

GraphicTest/Packages/Graphics32/GR32_Backends_Generic.pas

@@ -49 +49 @@
   ActiveX,
 {$ENDIF}
-  SysUtils, Classes, GR32, GR32_Backends;
+  SysUtils, Classes, GR32;
 
 type

GraphicTest/Packages/Graphics32/GR32_Backends_LCL_Win.pas

@@ -42 +42 @@
   {$IFDEF LCLWin32} Windows, {$ENDIF} LCLIntf, LCLType, Types, Controls,
   SysUtils, Classes, Graphics, GR32, GR32_Backends, GR32_Backends_Generic,
-  GR32_Containers, GR32_Image;
+  GR32_Containers, GR32_Image, GR32_Paths;
 
 type
@@ -51 +51 @@
   TLCLBackend = class(TCustomBackend, IPaintSupport,
     IBitmapContextSupport, IDeviceContextSupport,
-    ITextSupport, IFontSupport, ICanvasSupport)
+    ITextSupport, IFontSupport, ITextToPathSupport, ICanvasSupport)
   private
     procedure FontChangedHandler(Sender: TObject);
@@ -104 +104 @@
 
     { ITextSupport }
-    procedure Textout(X, Y: Integer; const Text: String); overload;
-    procedure Textout(X, Y: Integer; const ClipRect: TRect; const Text: String); overload;
-    procedure Textout(var DstRect: TRect; const Flags: Cardinal; const Text: String); overload;
-    function  TextExtent(const Text: String): TSize;
+    procedure Textout(X, Y: Integer; const Text: string); overload;
+    procedure Textout(X, Y: Integer; const ClipRect: TRect; const Text: string); overload;
+    procedure Textout(var DstRect: TRect; const Flags: Cardinal; const Text: string); overload;
+    function  TextExtent(const Text: string): TSize;
 
     procedure TextoutW(X, Y: Integer; const Text: Widestring); overload;
@@ -123 +123 @@
     property Font: TFont read GetFont write SetFont;
     property OnFontChange: TNotifyEvent read FOnFontChange write FOnFontChange;
+
+    { ITextToPathSupport }
+    procedure TextToPath(Path: TCustomPath; const X, Y: TFloat; const Text: WideString); overload;
+    procedure TextToPath(Path: TCustomPath; const DstRect: TFloatRect; const Text: WideString; Flags: Cardinal); overload;
+    function MeasureText(const DstRect: TFloatRect; const Text: WideString; Flags: Cardinal): TFloatRect;
 
     { ICanvasSupport }
@@ -182 +187 @@
 implementation
 
+uses
+  GR32_Text_LCL_Win;
+
 var
   StockFont: HFONT;
@@ -293 +301 @@
 end;
 
-function TLCLBackend.TextExtent(const Text: String): TSize;
+function TLCLBackend.TextExtent(const Text: string): TSize;
 var
   DC: HDC;
@@ -342 +350 @@
 end;
 
-procedure TLCLBackend.Textout(X, Y: Integer; const Text: String);
+procedure TLCLBackend.Textout(X, Y: Integer; const Text: string);
 var
   Extent: TSize;
@@ -360 +368 @@
 end;
 
-procedure TLCLBackend.TextoutW(X, Y: Integer; const Text: WideString);
+procedure TLCLBackend.TextoutW(X, Y: Integer; const Text: Widestring);
 var
   Extent: TSize;
@@ -378 +386 @@
 end;
 
-procedure TLCLBackend.TextoutW(X, Y: Integer; const ClipRect: TRect;
-  const Text: Widestring);
+procedure TLCLBackend.TextoutW(X, Y: Integer; const ClipRect: TRect; const Text: Widestring);
 var
   Extent: TSize;
@@ -386 +393 @@
 
   if not FOwner.MeasuringMode then
-    ExtTextoutW(Handle, X, Y, ETO_CLIPPED, @ClipRect, PWideChar(Text),
-      Length(Text), nil);
+    ExtTextoutW(Handle, X, Y, ETO_CLIPPED, @ClipRect, PWideChar(Text), Length(Text), nil);
 
   Extent := TextExtentW(Text);
@@ -393 +399 @@
 end;
 
-procedure TLCLBackend.Textout(X, Y: Integer; const ClipRect: TRect;
-  const Text: String);
+procedure TLCLBackend.Textout(X, Y: Integer; const ClipRect: TRect; const Text: string);
 var
   Extent: TSize;
@@ -407 +412 @@
 end;
 
-procedure TLCLBackend.TextoutW(var DstRect: TRect; const Flags: Cardinal;
-  const Text: Widestring);
+procedure TLCLBackend.TextoutW(var DstRect: TRect; const Flags: Cardinal; const Text: Widestring);
 begin
   UpdateFont;
@@ -435 +439 @@
 end;
 
-procedure TLCLBackend.Textout(var DstRect: TRect; const Flags: Cardinal;
-  const Text: String);
+procedure TLCLBackend.TextToPath(Path: TCustomPath; const X, Y: TFloat;
+  const Text: WideString);
+var
+  R: TFloatRect;
+begin
+  R := FloatRect(X, Y, X, Y);
+  GR32_Text_LCL_Win.TextToPath(Font.Handle, Path, R, Text, 0);
+end;
+
+procedure TLCLBackend.TextToPath(Path: TCustomPath; const DstRect: TFloatRect;
+  const Text: WideString; Flags: Cardinal);
+begin
+  GR32_Text_LCL_Win.TextToPath(Font.Handle, Path, DstRect, Text, Flags);
+end;
+
+function TLCLBackend.MeasureText(const DstRect: TFloatRect;
+  const Text: WideString; Flags: Cardinal): TFloatRect;
+begin
+  Result := GR32_Text_LCL_Win.MeasureText(Font.Handle, DstRect, Text, Flags);
+end;
+
+procedure TLCLBackend.Textout(var DstRect: TRect; const Flags: Cardinal; const Text: string);
 begin
   UpdateFont;
@@ -703 +727 @@
 procedure TLCLMemoryBackend.DrawTo(hDst: HDC; DstX, DstY: Integer);
 var
-  Bitmap        : HBITMAP;
-  DeviceContext : HDC;
-  Buffer        : Pointer;
-  OldObject     : HGDIOBJ;
+  Bitmap: HBITMAP;
+  DeviceContext: HDC;
+  Buffer: Pointer;
+  OldObject: HGDIOBJ;
 begin
   {$IFDEF LCLWin32}
@@ -746 +770 @@
 procedure TLCLMemoryBackend.DrawTo(hDst: HDC; const DstRect, SrcRect: TRect);
 var
-  Bitmap        : HBITMAP;
-  DeviceContext : HDC;
-  Buffer        : Pointer;
-  OldObject     : HGDIOBJ;
+  Bitmap: HBITMAP;
+  DeviceContext: HDC;
+  Buffer: Pointer;
+  OldObject: HGDIOBJ;
 begin
   {$IFDEF LCLWin32}
@@ -761 +785 @@
     if DeviceContext <> 0 then
     try
+      Buffer := nil;
       Bitmap := CreateDIBSection(DeviceContext, FBitmapInfo, DIB_RGB_COLORS,
         Buffer, 0, 0);

GraphicTest/Packages/Graphics32/GR32_Backends_VCL.pas

@@ -40 +40 @@
 uses
   SysUtils, Classes, Windows, Graphics, GR32, GR32_Backends, GR32_Containers,
-  GR32_Image, GR32_Backends_Generic;
+  GR32_Image, GR32_Backends_Generic, GR32_Paths;
 
 type
@@ -50 +50 @@
   TGDIBackend = class(TCustomBackend, IPaintSupport,
     IBitmapContextSupport, IDeviceContextSupport,
-    ITextSupport, IFontSupport, ICanvasSupport)
+    ITextSupport, IFontSupport, ICanvasSupport, ITextToPathSupport)
   private
     procedure FontChangedHandler(Sender: TObject);
@@ -96 +96 @@
 
     procedure Draw(const DstRect, SrcRect: TRect; hSrc: HDC); overload;
-    procedure DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; DstX, DstY: Integer); overload;
-    procedure DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; const DstRect, SrcRect: TRect); overload;
+    procedure DrawTo(hDst: HDC; DstX, DstY: Integer); overload;
+    procedure DrawTo(hDst: HDC; const DstRect, SrcRect: TRect); overload;
 
     property Handle: HDC read GetHandle;
 
     { ITextSupport }
-    procedure Textout(X, Y: Integer; const Text: String); overload;
-    procedure Textout(X, Y: Integer; const ClipRect: TRect; const Text: String); overload;
-    procedure Textout(var DstRect: TRect; const Flags: Cardinal; const Text: String); overload;
-    function  TextExtent(const Text: String): TSize;
+    procedure Textout(X, Y: Integer; const Text: string); overload;
+    procedure Textout(X, Y: Integer; const ClipRect: TRect; const Text: string); overload;
+    procedure Textout(var DstRect: TRect; const Flags: Cardinal; const Text: string); overload;
+    function  TextExtent(const Text: string): TSize;
 
     procedure TextoutW(X, Y: Integer; const Text: Widestring); overload;
@@ -121 +121 @@
     property Font: TFont read GetFont write SetFont;
     property OnFontChange: TNotifyEvent read FOnFontChange write FOnFontChange;
+
+    { ITextToPathSupport }
+    procedure TextToPath(Path: TCustomPath; const X, Y: TFloat; const Text: WideString); overload;
+    procedure TextToPath(Path: TCustomPath; const DstRect: TFloatRect; const Text: WideString; Flags: Cardinal); overload;
+    function MeasureText(const DstRect: TFloatRect; const Text: WideString; Flags: Cardinal): TFloatRect;
 
     { ICanvasSupport }
@@ -158 +163 @@
     procedure DoPaintRect(ABuffer: TBitmap32; ARect: TRect; ACanvas: TCanvas);
 
-    function GetHandle: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; // Dummy
+    function GetHandle: HDC; // Dummy
   protected
     FBitmapInfo: TBitmapInfo;
@@ -173 +178 @@
 
     { IDeviceContextSupport }
-    procedure Draw(const DstRect, SrcRect: TRect; hSrc: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}); overload;
-    procedure DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; DstX, DstY: Integer); overload;
-    procedure DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; const DstRect, SrcRect: TRect); overload;
+    procedure Draw(const DstRect, SrcRect: TRect; hSrc: HDC); overload;
+    procedure DrawTo(hDst: HDC; DstX, DstY: Integer); overload;
+    procedure DrawTo(hDst: HDC; const DstRect, SrcRect: TRect); overload;
   end;
 
 implementation
+
+uses
+  GR32_Text_VCL;
 
 var
@@ -227 +235 @@
 
   if FBits = nil then
-    raise Exception.Create(RCStrCannotAllocateDIBHandle);
+    raise EBackend.Create(RCStrCannotAllocateDIBHandle);
 
   FHDC := CreateCompatibleDC(0);
@@ -235 +243 @@
     FBitmapHandle := 0;
     FBits := nil;
-    raise Exception.Create(RCStrCannotCreateCompatibleDC);
+    raise EBackend.Create(RCStrCannotCreateCompatibleDC);
   end;
 
@@ -245 +253 @@
     FBitmapHandle := 0;
     FBits := nil;
-    raise Exception.Create(RCStrCannotSelectAnObjectIntoDC);
-  end;
+    raise EBackend.Create(RCStrCannotSelectAnObjectIntoDC);
+  end;
+end;
+
+function TGDIBackend.MeasureText(const DstRect: TFloatRect;
+  const Text: WideString; Flags: Cardinal): TFloatRect;
+begin
+  Result := GR32_Text_VCL.MeasureText(Font.Handle, DstRect, Text, Flags);
 end;
 
@@ -292 +306 @@
 end;
 
-function TGDIBackend.TextExtent(const Text: String): TSize;
-var
-  DC: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+function TGDIBackend.TextExtent(const Text: string): TSize;
+var
+  DC: HDC;
   OldFont: HGDIOBJ;
 begin
@@ -318 +332 @@
 function TGDIBackend.TextExtentW(const Text: Widestring): TSize;
 var
-  DC: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+  DC: HDC;
   OldFont: HGDIOBJ;
 begin
@@ -341 +355 @@
 end;
 
-procedure TGDIBackend.Textout(X, Y: Integer; const Text: String);
+procedure TGDIBackend.Textout(X, Y: Integer; const Text: string);
 var
   Extent: TSize;
@@ -390 +404 @@
 end;
 
-procedure TGDIBackend.Textout(X, Y: Integer; const ClipRect: TRect; const Text: String);
+procedure TGDIBackend.Textout(X, Y: Integer; const ClipRect: TRect; const Text: string);
 var
   Extent: TSize;
@@ -411 +425 @@
 
   FOwner.Changed(DstRect);
+end;
+
+procedure TGDIBackend.TextToPath(Path: TCustomPath; const X, Y: TFloat;
+  const Text: WideString);
+var
+  R: TFloatRect;
+begin
+  R := FloatRect(X, Y, X, Y);
+  GR32_Text_VCL.TextToPath(Font.Handle, Path, R, Text, 0);
+end;
+
+procedure TGDIBackend.TextToPath(Path: TCustomPath; const DstRect: TFloatRect;
+  const Text: WideString; Flags: Cardinal);
+begin
+  GR32_Text_VCL.TextToPath(Font.Handle, Path, DstRect, Text, Flags);
 end;
 
@@ -430 +459 @@
 end;
 
-procedure TGDIBackend.Textout(var DstRect: TRect; const Flags: Cardinal; const Text: String);
+procedure TGDIBackend.Textout(var DstRect: TRect; const Flags: Cardinal; const Text: string);
 begin
   UpdateFont;
@@ -440 +469 @@
 end;
 
-procedure TGDIBackend.DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; DstX, DstY: Integer);
+procedure TGDIBackend.DrawTo(hDst: HDC; DstX, DstY: Integer);
 begin
   StretchDIBits(
@@ -447 +476 @@
 end;
 
-procedure TGDIBackend.DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; const DstRect, SrcRect: TRect);
+procedure TGDIBackend.DrawTo(hDst: HDC; const DstRect, SrcRect: TRect);
 begin
   StretchBlt(
@@ -486 +515 @@
 end;
 
-function TGDIBackend.GetHandle: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+function TGDIBackend.GetHandle: HDC;
 begin
   Result := FHDC;
@@ -512 +541 @@
 end;
 
-procedure TGDIBackend.Draw(const DstRect, SrcRect: TRect; hSrc: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF});
+procedure TGDIBackend.Draw(const DstRect, SrcRect: TRect; hSrc: HDC);
 begin
   if FOwner.Empty then Exit;
@@ -642 +671 @@
 var
   Bitmap        : HBITMAP;
-  DeviceContext : {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+  DeviceContext : HDC;
   Buffer        : Pointer;
   OldObject     : HGDIOBJ;
@@ -671 +700 @@
         end;
       end else
-        raise Exception.Create('Can''t create compatible DC''');
+        raise EBackend.Create(RCStrCannotCreateCompatibleDC);
     finally
       DeleteDC(DeviceContext);
@@ -678 +707 @@
 end;
 
-procedure TGDIMemoryBackend.Draw(const DstRect, SrcRect: TRect; hSrc: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF});
+procedure TGDIMemoryBackend.Draw(const DstRect, SrcRect: TRect; hSrc: HDC);
 begin
   if FOwner.Empty then Exit;
 
   if not FOwner.MeasuringMode then
-    raise Exception.Create('Not supported!');
+    raise EBackend.Create('Not supported!');
 
   FOwner.Changed(DstRect);
 end;
 
-procedure TGDIMemoryBackend.DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; DstX, DstY: Integer);
+procedure TGDIMemoryBackend.DrawTo(hDst: HDC; DstX, DstY: Integer);
 var
   Bitmap        : HBITMAP;
-  DeviceContext : {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+  DeviceContext : HDC;
   Buffer        : Pointer;
   OldObject     : HGDIOBJ;
 begin
-  if SetDIBitsToDevice(hDst, DstX, DstY,
-    FOwner.Width, FOwner.Height, 0, 0, 0, FOwner.Height, FBits, FBitmapInfo,
-    DIB_RGB_COLORS) = 0 then
+  if SetDIBitsToDevice(hDst, DstX, DstY, FOwner.Width, FOwner.Height, 0, 0, 0,
+    FOwner.Height, FBits, FBitmapInfo, DIB_RGB_COLORS) = 0 then
   begin
     // create compatible device context
@@ -720 +748 @@
         end;
       end else
-        raise Exception.Create('Can''t create compatible DC''');
+        raise EBackend.Create(RCStrCannotCreateCompatibleDC);
     finally
       DeleteDC(DeviceContext);
@@ -727 +755 @@
 end;
 
-procedure TGDIMemoryBackend.DrawTo(hDst: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF}; 
+procedure TGDIMemoryBackend.DrawTo(hDst: HDC; 
   const DstRect, SrcRect: TRect);
 var
   Bitmap        : HBITMAP;
-  DeviceContext : {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+  DeviceContext : HDC;
   Buffer        : Pointer;
   OldObject     : HGDIOBJ;
@@ -761 +789 @@
         end;
       end else
-        raise Exception.Create('Can''t create compatible DC''');
+        raise EBackend.Create(RCStrCannotCreateCompatibleDC);
     finally
       DeleteDC(DeviceContext);
@@ -768 +796 @@
 end;
 
-function TGDIMemoryBackend.GetHandle: {$IFDEF BCB}Cardinal{$ELSE}HDC{$ENDIF};
+function TGDIMemoryBackend.GetHandle: HDC;
 begin
   Result := 0;

GraphicTest/Packages/Graphics32/GR32_Bindings.pas

@@ -80 +80 @@
     procedure Clear;
 
-    procedure Add(FunctionID: Integer; Proc: Pointer; CPUFeatures: TCPUFeatures = []; Flags: Integer = 0);
+    procedure Add(FunctionID: Integer; Proc: Pointer; CPUFeatures: TCPUFeatures = [];
+      Flags: Integer = 0);
 
     // function rebinding support
@@ -116 +117 @@
     Registers := TList.Create;
   Result := TFunctionRegistry.Create;
+  {$IFDEF NEXTGEN}
+  Result.__ObjAddRef;
+  {$ENDIF}
   Result.Name := Name;
   Registers.Add(Result);

GraphicTest/Packages/Graphics32/GR32_Blend.pas

@@ -41 +41 @@
  *      - 2004/08/25 - ColorDiv
  *
+ *  Christian-W. Budde
+ *      - 2019/04/01 - Refactoring
+ *
  * ***** END LICENSE BLOCK ***** *)
 
@@ -48 +51 @@
 
 uses
-  GR32, GR32_System, GR32_Bindings, SysUtils;
+  GR32, GR32_Bindings, SysUtils;
 
 var
@@ -57 +60 @@
   TBlendReg    = function(F, B: TColor32): TColor32;
   TBlendMem    = procedure(F: TColor32; var B: TColor32);
+  TBlendMems   = procedure(F: TColor32; B: PColor32; Count: Integer);
   TBlendRegEx  = function(F, B, M: TColor32): TColor32;
   TBlendMemEx  = procedure(F: TColor32; var B: TColor32; M: TColor32);
+  TBlendRegRGB = function(F, B, W: TColor32): TColor32;
+  TBlendMemRGB = procedure(F: TColor32; var B: TColor32; W: TColor32);
+{$IFDEF TEST_BLENDMEMRGB128SSE4}
+  TBlendMemRGB128 = procedure(F: TColor32; var B: TColor32; W: UInt64);
+{$ENDIF}
   TBlendLine   = procedure(Src, Dst: PColor32; Count: Integer);
   TBlendLineEx = procedure(Src, Dst: PColor32; Count: Integer; M: TColor32);
+  TBlendLine1  = procedure(Src: TColor32; Dst: PColor32; Count: Integer);
   TCombineReg  = function(X, Y, W: TColor32): TColor32;
   TCombineMem  = procedure(X: TColor32; var Y: TColor32; W: TColor32);
@@ -74 +84 @@
   BlendReg: TBlendReg;
   BlendMem: TBlendMem;
+  BlendMems: TBlendMems;
 
   BlendRegEx: TBlendRegEx;
   BlendMemEx: TBlendMemEx;
 
+  BlendRegRGB: TBlendRegRGB;
+  BlendMemRGB: TBlendMemRGB;
+{$IFDEF TEST_BLENDMEMRGB128SSE4}
+  BlendMemRGB128: TBlendMemRGB128;
+{$ENDIF}
+
   BlendLine: TBlendLine;
   BlendLineEx: TBlendLineEx;
+  BlendLine1: TBlendLine1;
 
   CombineReg: TCombineReg;
@@ -93 +111 @@
   MergeLine: TBlendLine;
   MergeLineEx: TBlendLineEx;
+  MergeLine1: TBlendLine1;
 
 { Color algebra functions }
@@ -105 +124 @@
   ColorExclusion: TBlendReg;
   ColorScale: TBlendReg;
+  ColorScreen: TBlendReg;
+  ColorDodge: TBlendReg;
+  ColorBurn: TBlendReg;
+
+{ Blended color algebra functions }
+  BlendColorAdd: TBlendReg;
+  BlendColorModulate: TBlendReg;
 
 { Special LUT pointers }
@@ -119 +145 @@
 { Access to alpha composite functions corresponding to a combine mode }
 
+type
+  PBlendReg = ^TBlendReg;
+  PBlendMem = ^TBlendMem;
+  PBlendRegEx = ^TBlendRegEx;
+  PBlendMemEx = ^TBlendMemEx;
+  PBlendLine = ^TBlendLine;
+  PBlendLineEx = ^TBlendLineEx;
+
+  TBlendRegCombineModeArray = array[TCombineMode] of PBlendReg;
+  TBlendMemCombineModeArray = array[TCombineMode] of PBlendMem;
+  TBlendRegExCombineModeArray = array[TCombineMode] of PBlendRegEx;
+  TBlendMemExCombineModeArray = array[TCombineMode] of PBlendMemEx;
+  TBlendLineCombineModeArray = array[TCombineMode] of PBlendLine;
+  TBlendLineExCombineModeArray = array[TCombineMode] of PBlendLineEx;
+
 const
-  BLEND_REG: array[TCombineMode] of ^TBlendReg = ((@@BlendReg),(@@MergeReg));
-  BLEND_MEM: array[TCombineMode] of ^TBlendMem = ((@@BlendMem),(@@MergeMem));
-  BLEND_REG_EX: array[TCombineMode] of ^TBlendRegEx = ((@@BlendRegEx),(@@MergeRegEx));
-  BLEND_MEM_EX: array[TCombineMode] of ^TBlendMemEx = ((@@BlendMemEx),(@@MergeMemEx));
-  BLEND_LINE: array[TCombineMode] of ^TBlendLine = ((@@BlendLine),(@@MergeLine));
-  BLEND_LINE_EX: array[TCombineMode] of ^TBlendLineEx = ((@@BlendLineEx),(@@MergeLineEx));
+  BLEND_REG: TBlendRegCombineModeArray = ((@@BlendReg),(@@MergeReg));
+  BLEND_MEM: TBlendMemCombineModeArray = ((@@BlendMem),(@@MergeMem));
+  BLEND_REG_EX: TBlendRegExCombineModeArray = ((@@BlendRegEx),(@@MergeRegEx));
+  BLEND_MEM_EX: TBlendMemExCombineModeArray = ((@@BlendMemEx),(@@MergeMemEx));
+  BLEND_LINE: TBlendLineCombineModeArray = ((@@BlendLine),(@@MergeLine));
+  BLEND_LINE_EX: TBlendLineExCombineModeArray = ((@@BlendLineEx),(@@MergeLineEx));
 
 var
@@ -134 +175 @@
 {$ENDIF}
 
-implementation
-
-{$IFDEF TARGET_x86}
-uses GR32_LowLevel;
-{$ENDIF}
-
 var
   RcTable: array [Byte, Byte] of Byte;
   DivTable: array [Byte, Byte] of Byte;
+
+implementation
+
+uses
+  GR32_LowLevel,
+{$IFNDEF PUREPASCAL}
+  GR32_BlendASM,
+{$IFNDEF OMIT_MMX}
+  GR32_BlendMMX,
+{$ENDIF}
+{$IFNDEF OMIT_SSE2}
+  GR32_BlendSSE2,
+{$ENDIF}
+{$ENDIF}
+  GR32_System;
 
 {$IFDEF OMIT_MMX}
@@ -173 +223 @@
   end;
 
+  Af := @DivTable[FA];
+  Ab := @DivTable[not FA];
   with BX do
   begin
-    Af := @DivTable[FA];
-    Ab := @DivTable[not FA];
     R := Af[FX.R] + Ab[R];
     G := Af[FX.G] + Ab[G];
     B := Af[FX.B] + Ab[B];
+    A := $FF;
   end;
   Result := B;
@@ -201 +252 @@
   end;
 
+  Af := @DivTable[FA];
+  Ab := @DivTable[not FA];
   with BX do
   begin
-    Af := @DivTable[FA];
-    Ab := @DivTable[not FA];
     R := Af[FX.R] + Ab[R];
     G := Af[FX.G] + Ab[G];
     B := Af[FX.B] + Ab[B];
+    A := $FF;
+  end;
+end;
+
+procedure BlendMems_Pas(F: TColor32; B: PColor32; Count: Integer);
+begin
+  while Count > 0 do
+  begin
+    BlendMem(F, B^);
+    Inc(B);
+    Dec(Count);
   end;
 end;
@@ -233 +295 @@
   end;
 
+  Ab := @DivTable[255 - M];
   with BX do
   begin
-    Af := @DivTable[M];
-    Ab := @DivTable[255 - M];
     R := Af[FX.R] + Ab[R];
     G := Af[FX.G] + Ab[G];
     B := Af[FX.B] + Ab[B];
+    A := $FF;
   end;
   Result := B;
@@ -265 +327 @@
   end;
 
+  Ab := @DivTable[255 - M];
   with BX do
   begin
-    Af := @DivTable[M];
-    Ab := @DivTable[255 - M];
     R := Af[FX.R] + Ab[R];
     G := Af[FX.G] + Ab[G];
     B := Af[FX.B] + Ab[B];
+    A := $FF;
+  end;
+end;
+
+function BlendRegRGB_Pas(F, B, W: TColor32): TColor32;
+var
+  FX: TColor32Entry absolute F;
+  BX: TColor32Entry absolute B;
+  WX: TColor32Entry absolute W;
+  RX: TColor32Entry absolute Result;
+begin
+  RX.R := (FX.R - BX.R) * WX.B div 255 + BX.R;
+  RX.G := (FX.G - BX.G) * WX.G div 255 + BX.G;
+  RX.B := (FX.B - BX.B) * WX.R div 255 + BX.B;
+end;
+
+procedure BlendMemRGB_Pas(F: TColor32; var B: TColor32; W: TColor32);
+var
+  FX: TColor32Entry absolute F;
+  BX: TColor32Entry absolute B;
+  WX: TColor32Entry absolute W;
+begin
+  BX.R := (FX.R - BX.R) * WX.B div 255 + BX.R;
+  BX.G := (FX.G - BX.G) * WX.G div 255 + BX.G;
+  BX.B := (FX.B - BX.B) * WX.R div 255 + BX.B;
+end;
+
+procedure BlendLine1_Pas(Src: TColor32; Dst: PColor32; Count: Integer);
+begin
+  while Count > 0 do
+  begin
+    BlendMem(Src, Dst^);
+    Inc(Dst);
+    Dec(Count);
   end;
 end;
@@ -315 +410 @@
   end;
 
+  Af := @DivTable[W];
+  Ab := @DivTable[255 - W];
   with Xe do
   begin
-    Af := @DivTable[W];
-    Ab := @DivTable[255 - W];
     R := Ab[Ye.R] + Af[R];
     G := Ab[Ye.G] + Af[G];
     B := Ab[Ye.B] + Af[B];
+    A := Ab[Ye.A] + Af[A];
   end;
   Result := X;
@@ -343 +439 @@
   end;
 
+  Af := @DivTable[W];
+  Ab := @DivTable[255 - W];
   with Xe do
   begin
-    Af := @DivTable[W];
-    Ab := @DivTable[255 - W];
     R := Ab[Ye.R] + Af[R];
     G := Ab[Ye.G] + Af[G];
     B := Ab[Ye.B] + Af[B];
+    A := Ab[Ye.A] + Af[A];
   end;
   Y := X;
@@ -367 +464 @@
 function MergeReg_Pas(F, B: TColor32): TColor32;
 var
- Fa, Ba, Wa: TColor32;
- Fw, Bw: PByteArray;
- Fx: TColor32Entry absolute F;
- Bx: TColor32Entry absolute B;
- Rx: TColor32Entry absolute Result;
-begin
- Fa := F shr 24;
- Ba := B shr 24;
- if Fa = $FF then
-   Result := F
- else if Fa = $0 then
-   Result := B
- else if Ba = $0 then
-   Result := F
- else
- begin
-   Rx.A := DivTable[Fa xor 255, Ba xor 255] xor 255;
-   Wa := RcTable[Rx.A, Fa];
-   Fw := @DivTable[Wa];
-   Bw := @DivTable[Wa xor $ff];
-   Rx.R := Fw[Fx.R] + Bw[Bx.R];
-   Rx.G := Fw[Fx.G] + Bw[Bx.G];
-   Rx.B := Fw[Fx.B] + Bw[Bx.B];
- end;
+  Fa, Ba, Wa: TColor32;
+  Fw, Bw: PByteArray;
+  Fx: TColor32Entry absolute F;
+  Bx: TColor32Entry absolute B;
+  Rx: TColor32Entry absolute Result;
+begin
+  Fa := F shr 24;
+  Ba := B shr 24;
+  if Fa = $FF then
+    Result := F
+  else if Fa = $0 then
+    Result := B
+  else if Ba = $0 then
+    Result := F
+  else
+  begin
+    Rx.A := DivTable[Fa xor 255, Ba xor 255] xor 255;
+    Wa := RcTable[Rx.A, Fa];
+    Fw := @DivTable[Wa];
+    Bw := @DivTable[Wa xor $FF];
+    Rx.R := Fw[Fx.R] + Bw[Bx.R];
+    Rx.G := Fw[Fx.G] + Bw[Bx.G];
+    Rx.B := Fw[Fx.B] + Bw[Bx.B];
+  end;
 end;
 
@@ -406 +503 @@
 begin
   B := MergeReg(DivTable[M, F shr 24] shl 24 or F and $00FFFFFF, B);
+end;
+
+procedure MergeLine1_Pas(Src: TColor32; Dst: PColor32; Count: Integer);
+begin
+  while Count > 0 do
+  begin
+    Dst^ := MergeReg(Src, Dst^);
+    Inc(Dst);
+    Dec(Count);
+  end;
 end;
 
@@ -435 +542 @@
 procedure EMMS_Pas;
 begin
-//Dummy
+  // Dummy
 end;
 
 function LightenReg_Pas(C: TColor32; Amount: Integer): TColor32;
 var
-  r, g, b, a: Integer;
+  r, g, b: Integer;
   CX: TColor32Entry absolute C;
   RX: TColor32Entry absolute Result;
 begin
-  a := CX.A;
   r := CX.R;
   g := CX.G;
@@ -457 +563 @@
   if b > 255 then b := 255 else if b < 0 then b := 0;
 
-  RX.A := a;
+  // preserve alpha
+  RX.A := CX.A;
   RX.R := r;
   RX.G := g;
@@ -467 +574 @@
 function ColorAdd_Pas(C1, C2: TColor32): TColor32;
 var
-  r1, g1, b1, a1: Integer;
-  r2, g2, b2, a2: Integer;
-begin
-  a1 := C1 shr 24;
-  r1 := C1 and $00FF0000;
-  g1 := C1 and $0000FF00;
-  b1 := C1 and $000000FF;
-
-  a2 := C2 shr 24;
-  r2 := C2 and $00FF0000;
-  g2 := C2 and $0000FF00;
-  b2 := C2 and $000000FF;
-
-  a1 := a1 + a2;
-  r1 := r1 + r2;
-  g1 := g1 + g2;
-  b1 := b1 + b2;
-
-  if a1 > $FF then a1 := $FF;
-  if r1 > $FF0000 then r1 := $FF0000;
-  if g1 > $FF00 then g1 := $FF00;
-  if b1 > $FF then b1 := $FF;
-
-  Result := a1 shl 24 + r1 + g1 + b1;
+  Xe: TColor32Entry absolute C1;
+  Ye: TColor32Entry absolute C2;
+  R: TColor32Entry absolute Result;
+begin
+  R.A := Clamp(Xe.A + Ye.A, 255);
+  R.R := Clamp(Xe.R + Ye.R, 255);
+  R.G := Clamp(Xe.G + Ye.G, 255);
+  R.B := Clamp(Xe.B + Ye.B, 255);
 end;
 
 function ColorSub_Pas(C1, C2: TColor32): TColor32;
 var
-  r1, g1, b1, a1: Integer;
-  r2, g2, b2, a2: Integer;
-begin
-  a1 := C1 shr 24;
-  r1 := C1 and $00FF0000;
-  g1 := C1 and $0000FF00;
-  b1 := C1 and $000000FF;
-
-  r1 := r1 shr 16;
-  g1 := g1 shr 8;
-
-  a2 := C2 shr 24;
-  r2 := C2 and $00FF0000;
-  g2 := C2 and $0000FF00;
-  b2 := C2 and $000000FF;
-
-  r2 := r2 shr 16;
-  g2 := g2 shr 8;
-
-  a1 := a1 - a2;
-  r1 := r1 - r2;
-  g1 := g1 - g2;
-  b1 := b1 - b2;
-
-  if a1 < 0 then a1 := 0;
-  if r1 < 0 then r1 := 0;
-  if g1 < 0 then g1 := 0;
-  if b1 < 0 then b1 := 0;
-
-  Result := a1 shl 24 + r1 shl 16 + g1 shl 8 + b1;
+  Xe: TColor32Entry absolute C1;
+  Ye: TColor32Entry absolute C2;
+  R: TColor32Entry absolute Result;
+  Temp: SmallInt;
+begin
+  Temp := Xe.A - Ye.A;
+  if Temp < 0 then
+    R.A := 0
+  else
+    R.A := Temp;
+  Temp := Xe.R - Ye.R;
+  if Temp < 0 then
+    R.R := 0
+  else
+    R.R := Temp;
+  Temp := Xe.G - Ye.G;
+  if Temp < 0 then
+    R.G := 0
+  else
+    R.G := Temp;
+  Temp := Xe.B - Ye.B;
+  if Temp < 0 then
+    R.B := 0
+  else
+    R.B := Temp;
 end;
 
 function ColorDiv_Pas(C1, C2: TColor32): TColor32;
 var
-  r1, g1, b1, a1: Integer;
-  r2, g2, b2, a2: Integer;
-begin
-  a1 := C1 shr 24;
-  r1 := (C1 and $00FF0000) shr 16;
-  g1 := (C1 and $0000FF00) shr 8;
-  b1 := C1 and $000000FF;
-
-  a2 := C2 shr 24;
-  r2 := (C2 and $00FF0000) shr 16;
-  g2 := (C2 and $0000FF00) shr 8;
-  b2 := C2 and $000000FF;
-
-  if a1 = 0 then a1:=$FF
-  else a1 := (a2 shl 8) div a1;
-  if r1 = 0 then r1:=$FF
-  else r1 := (r2 shl 8) div r1;
-  if g1 = 0 then g1:=$FF
-  else g1 := (g2 shl 8) div g1;
-  if b1 = 0 then b1:=$FF
-  else b1 := (b2 shl 8) div b1;
-
-  if a1 > $FF then a1 := $FF;
-  if r1 > $FF then r1 := $FF;
-  if g1 > $FF then g1 := $FF;
-  if b1 > $FF then b1 := $FF;
-
-  Result := a1 shl 24 + r1 shl 16 + g1 shl 8 + b1;
+  C1e: TColor32Entry absolute C1;
+  C2e: TColor32Entry absolute C2;
+  Re: TColor32Entry absolute Result;
+  Temp: Word;
+begin
+  if C1e.A = 0 then
+    Re.A := $FF
+  else
+  begin
+    Temp := (C2e.A shl 8) div C1e.A;
+    if Temp > $FF then
+      Re.A := $FF
+    else
+      Re.A := Temp;
+  end;
+
+  if C1e.R = 0 then
+    Re.R := $FF
+  else
+  begin
+    Temp := (C2e.R shl 8) div C1e.R;
+    if Temp > $FF then
+      Re.R := $FF
+    else
+      Re.R := Temp;
+  end;
+
+  if C1e.G = 0 then
+    Re.G := $FF
+  else
+  begin
+    Temp := (C2e.G shl 8) div C1e.G;
+    if Temp > $FF then
+      Re.G := $FF
+    else
+      Re.G := Temp;
+  end;
+
+  if C1e.B = 0 then
+    Re.B := $FF
+  else
+  begin
+    Temp := (C2e.B shl 8) div C1e.B;
+    if Temp > $FF then
+      Re.B := $FF
+    else
+      Re.B := Temp;
+  end;
 end;
 
 function ColorModulate_Pas(C1, C2: TColor32): TColor32;
 var
-  REnt: TColor32Entry absolute Result;
-  C2Ent: TColor32Entry absolute C2;
-begin
-  Result := C1;
-  REnt.A := (C2Ent.A * REnt.A) shr 8;
-  REnt.R := (C2Ent.R * REnt.R) shr 8;
-  REnt.G := (C2Ent.G * REnt.G) shr 8;
-  REnt.B := (C2Ent.B * REnt.B) shr 8;
+  C1e: TColor32Entry absolute C2;
+  C2e: TColor32Entry absolute C2;
+  Re: TColor32Entry absolute Result;
+begin
+  Re.A := (C2e.A * C1e.A + $80) shr 8;
+  Re.R := (C2e.R * C1e.R + $80) shr 8;
+  Re.G := (C2e.G * C1e.G + $80) shr 8;
+  Re.B := (C2e.B * C1e.B + $80) shr 8;
 end;
 
@@ -603 +709 @@
 function ColorDifference_Pas(C1, C2: TColor32): TColor32;
 var
-  r1, g1, b1, a1: TColor32;
-  r2, g2, b2, a2: TColor32;
-begin
-  a1 := C1 shr 24;
-  r1 := C1 and $00FF0000;
-  g1 := C1 and $0000FF00;
-  b1 := C1 and $000000FF;
-
-  r1 := r1 shr 16;
-  g1 := g1 shr 8;
-
-  a2 := C2 shr 24;
-  r2 := C2 and $00FF0000;
-  g2 := C2 and $0000FF00;
-  b2 := C2 and $000000FF;
-
-  r2 := r2 shr 16;
-  g2 := g2 shr 8;
-
-  a1 := abs(a2 - a1);
-  r1 := abs(r2 - r1);
-  g1 := abs(g2 - g1);
-  b1 := abs(b2 - b1);
-
-  Result := a1 shl 24 + r1 shl 16 + g1 shl 8 + b1;
+  Xe: TColor32Entry absolute C1;
+  Ye: TColor32Entry absolute C2;
+  R: TColor32Entry absolute Result;
+begin
+  R.A := Abs(Xe.A - Ye.A);
+  R.R := Abs(Xe.R - Ye.R);
+  R.G := Abs(Xe.G - Ye.G);
+  R.B := Abs(Xe.B - Ye.B);
 end;
 
 function ColorExclusion_Pas(C1, C2: TColor32): TColor32;
 var
-  r1, g1, b1, a1: TColor32;
-  r2, g2, b2, a2: TColor32;
-begin
-  a1 := C1 shr 24;
-  r1 := C1 and $00FF0000;
-  g1 := C1 and $0000FF00;
-  b1 := C1 and $000000FF;
-
-  r1 := r1 shr 16;
-  g1 := g1 shr 8;
-
-  a2 := C2 shr 24;
-  r2 := C2 and $00FF0000;
-  g2 := C2 and $0000FF00;
-  b2 := C2 and $000000FF;
-
-  r2 := r2 shr 16;
-  g2 := g2 shr 8;
-
-  a1 := a1 + a2 - (a1 * a2 shr 7);
-  r1 := r1 + r2 - (r1 * r2 shr 7);
-  g1 := g1 + g2 - (g1 * g2 shr 7);
-  b1 := b1 + b2 - (b1 * b2 shr 7);
-
-  Result := a1 shl 24 + r1 shl 16 + g1 shl 8 + b1;
+  Xe: TColor32Entry absolute C1;
+  Ye: TColor32Entry absolute C2;
+  R: TColor32Entry absolute Result;
+begin
+  R.A := Xe.A + Ye.A - ((Xe.A * Ye.A) shl 7);
+  R.R := Xe.R + Ye.R - ((Xe.R * Ye.R) shr 7);
+  R.G := Xe.G + Ye.G - ((Xe.G * Ye.G) shr 7);
+  R.B := Xe.B + Ye.B - ((Xe.B * Ye.B) shr 7);
 end;
 
@@ -674 +746 @@
 function ColorScale_Pas(C, W: TColor32): TColor32;
 var
+  Ce: TColor32Entry absolute C;
+var
   r1, g1, b1, a1: Cardinal;
 begin
-  a1 := C shr 24;
-  r1 := C and $00FF0000;
-  g1 := C and $0000FF00;
-  b1 := C and $000000FF;
-
-  r1 := r1 shr 16;
-  g1 := g1 shr 8;
-
-  a1 := a1 * W shr 8;
-  r1 := r1 * W shr 8;
-  g1 := g1 * W shr 8;
-  b1 := b1 * W shr 8;
+  a1 := Ce.A * W shr 8;
+  r1 := Ce.R * W shr 8;
+  g1 := Ce.G * W shr 8;
+  b1 := Ce.B * W shr 8;
 
   if a1 > 255 then a1 := 255;
@@ -697 +763 @@
 end;
 
+function ColorScreen_Pas(B, S: TColor32): TColor32;
+var
+  Be: TColor32Entry absolute B;
+  Se: TColor32Entry absolute S;
+  R: TColor32Entry absolute Result;
+begin
+  R.A := Be.A + Se.A - (Be.A * Se.A) div 255;
+  R.R := Be.R + Se.R - (Be.R * Se.R) div 255;
+  R.G := Be.G + Se.G - (Be.G * Se.G) div 255;
+  R.B := Be.B + Se.B - (Be.B * Se.B) div 255;
+end;
+
+function ColorDodge_Pas(B, S: TColor32): TColor32;
+
+  function Dodge(B, S: Byte): Byte;
+  begin
+    if B = 0 then
+      Result := 0
+    else
+    if S = 255 then
+      Result := 255
+    else
+      Result := Clamp((255 * B) div (255 - S), 255);
+  end;
+
+var
+  Be: TColor32Entry absolute B;
+  Se: TColor32Entry absolute S;
+  R: TColor32Entry absolute Result;
+begin
+  R.A := Dodge(Be.A, Se.A);
+  R.R := Dodge(Be.R, Se.R);
+  R.G := Dodge(Be.G, Se.G);
+  R.B := Dodge(Be.B, Se.B);
+end;
+
+function ColorBurn_Pas(B, S: TColor32): TColor32;
+
+  function Burn(B, S: Byte): Byte;
+  begin
+    if B = 255 then
+      Result := 255
+    else
+    if S = 0 then
+      Result := 0
+    else
+      Result := 255 - Clamp(255 * (255 - B) div S, 255);
+  end;
+
+var
+  Be: TColor32Entry absolute B;
+  Se: TColor32Entry absolute S;
+  R: TColor32Entry absolute Result;
+begin
+  R.A := Burn(Be.A, Se.A);
+  R.R := Burn(Be.R, Se.R);
+  R.G := Burn(Be.G, Se.G);
+  R.B := Burn(Be.B, Se.B);
+end;
+
+
+{ Blended color algebra }
+
+function BlendColorAdd_Pas(C1, C2: TColor32): TColor32;
+var
+  Xe: TColor32Entry absolute C1;
+  Ye: TColor32Entry absolute C2;
+  R: TColor32Entry absolute Result;
+  Af, Ab: PByteArray;
+begin
+  Af := @DivTable[Xe.A];
+  Ab := @DivTable[not Xe.A];
+  R.A := Af[Clamp(Xe.A + Ye.A, 255)] + Ab[Ye.A];
+  R.R := Af[Clamp(Xe.R + Ye.R, 255)] + Ab[Ye.R];
+  R.G := Af[Clamp(Xe.G + Ye.G, 255)] + Ab[Ye.G];
+  R.B := Af[Clamp(Xe.B + Ye.B, 255)] + Ab[Ye.B];
+end;
+
+function BlendColorModulate_Pas(C1, C2: TColor32): TColor32;
+var
+  C1e: TColor32Entry absolute C1;
+  C2e: TColor32Entry absolute C2;
+  R: TColor32Entry absolute Result;
+  Af, Ab: PByteArray;
+begin
+  Af := @DivTable[C1e.A];
+  Ab := @DivTable[not C1e.A];
+  R.A := Af[(C2e.A * C1e.A + $80) shr 8] + Ab[C2e.A];
+  R.R := Af[(C2e.R * C1e.R + $80) shr 8] + Ab[C2e.R];
+  R.G := Af[(C2e.G * C1e.G + $80) shr 8] + Ab[C2e.G];
+  R.B := Af[(C2e.B * C1e.B + $80) shr 8] + Ab[C2e.B];
+end;
+
 {$IFNDEF PUREPASCAL}
-
-{ Assembler versions }
-
-const
-  bias = $00800080;
-
-
-function BlendReg_ASM(F, B: TColor32): TColor32;
-asm
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // Result Z = Fa * Frgb + (1 - Fa) * Brgb
-
-{$IFDEF TARGET_x86}
-  // EAX <- F
-  // EDX <- B
-
-// Test Fa = 255 ?
-        CMP     EAX,$FF000000   // Fa = 255 ? => Result = EAX
-        JNC     @2
-
-  // Test Fa = 0 ?
-        TEST    EAX,$FF000000   // Fa = 0 ?   => Result = EDX
-        JZ      @1
-
-  // Get weight W = Fa * M
-        MOV     ECX,EAX         // ECX  <-  Fa Fr Fg Fb
-        SHR     ECX,24          // ECX  <-  00 00 00 Fa
-
-        PUSH    EBX
-
-  // P = W * F
-        MOV     EBX,EAX         // EBX  <-  Fa Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     EBX,$FF00FF00   // EBX  <-  Fa 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 Fa 00 Fg
-        IMUL    EBX,ECX         // EBX  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Pa 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  Pa Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,EDX         // EBX  <-  Ba Br Bg Bb
-        AND     EDX,$00FF00FF   // EDX  <-  00 Br 00 Bb
-        AND     EBX,$FF00FF00   // EBX  <-  Ba 00 Bg 00
-        IMUL    EDX,ECX         // EDX  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 Ba 00 Bg
-        IMUL    EBX,ECX         // EBX  <-  Qa ** Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // EDX  <-  Qr 00 Qb 00
-        SHR     EDX,8           // EDX  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Qa 00 Qg 00
-        OR      EBX,EDX         // EBX  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  Za Zr Zg Zb
-
-        POP     EBX
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     EAX,EDX
-@2:
-{$ENDIF}
-
-  // EAX <- F
-  // EDX <- B
-{$IFDEF TARGET_x64}
-        MOV     RAX, RCX
-
-  // Test Fa = 255 ?
-        CMP     EAX,$FF000000   // Fa = 255 ? => Result = EAX
-        JNC     @2
-
-  // Test Fa = 0 ?
-        TEST    EAX,$FF000000   // Fa = 0 ?   => Result = EDX
-        JZ      @1
-
-  // Get weight W = Fa * M
-        MOV     ECX,EAX         // ECX  <-  Fa Fr Fg Fb
-        SHR     ECX,24          // ECX  <-  00 00 00 Fa
-
-  // P = W * F
-        MOV     R9D,EAX         // R9D  <-  Fa Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     R9D,$FF00FF00   // R9D  <-  Fa 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     R9D,8           // R9D  <-  00 Fa 00 Fg
-        IMUL    R9D,ECX         // R9D  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     R9D,bias
-        AND     R9D,$FF00FF00   // R9D  <-  Pa 00 Pg 00
-        OR      EAX,R9D         // EAX  <-  Pa Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     R9D,EDX         // R9D  <-  Ba Br Bg Bb
-        AND     EDX,$00FF00FF   // EDX  <-  00 Br 00 Bb
-        AND     R9D,$FF00FF00   // R9D  <-  Ba 00 Bg 00
-        IMUL    EDX,ECX         // EDX  <-  Qr ** Qb **
-        SHR     R9D,8           // R9D  <-  00 Ba 00 Bg
-        IMUL    R9D,ECX         // R9D  <-  Qa ** Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // EDX  <-  Qr 00 Qb 00
-        SHR     EDX,8           // EDX  <-  00 Qr ** Qb
-        ADD     R9D,bias
-        AND     R9D,$FF00FF00   // R9D  <-  Qa 00 Qg 00
-        OR      R9D,EDX         // R9D  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,R9D         // EAX  <-  Za Zr Zg Zb
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     EAX,EDX
-@2:
-{$ENDIF}
-end;
-
-procedure BlendMem_ASM(F: TColor32; var B: TColor32);
-asm
-{$IFDEF TARGET_x86}
-  // EAX <- F
-  // [EDX] <- B
-
-  // Test Fa = 0 ?
-        TEST    EAX,$FF000000   // Fa = 0 ?   => do not write
-        JZ      @2
-
-  // Get weight W = Fa * M
-        MOV     ECX,EAX         // ECX  <-  Fa Fr Fg Fb
-        SHR     ECX,24          // ECX  <-  00 00 00 Fa
-
-  // Test Fa = 255 ?
-        CMP     ECX,$FF
-        JZ      @1
-
-        PUSH    EBX
-        PUSH    ESI
-
-  // P = W * F
-        MOV     EBX,EAX         // EBX  <-  Fa Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     EBX,$FF00FF00   // EBX  <-  Fa 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 Fa 00 Fg
-        IMUL    EBX,ECX         // EBX  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Pa 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  Pa Pr Pg Pb
-
-        MOV     ESI,[EDX]
-
-// W = 1 - W; Q = W * B
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,ESI         // EBX  <-  Ba Br Bg Bb
-        AND     ESI,$00FF00FF   // ESI  <-  00 Br 00 Bb
-        AND     EBX,$FF00FF00   // EBX  <-  Ba 00 Bg 00
-        IMUL    ESI,ECX         // ESI  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 Ba 00 Bg
-        IMUL    EBX,ECX         // EBX  <-  Qa ** Qg **
-        ADD     ESI,bias
-        AND     ESI,$FF00FF00   // ESI  <-  Qr 00 Qb 00
-        SHR     ESI,8           // ESI  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Qa 00 Qg 00
-        OR      EBX,ESI         // EBX  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  Za Zr Zg Zb
-
-        MOV     [EDX],EAX
-        POP     ESI
-        POP     EBX
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     [EDX],EAX
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX <- F
-  // [RDX] <- B
-
-  // Test Fa = 0 ?
-        TEST    ECX,$FF000000   // Fa = 0 ?   => do not write
-        JZ      @2
-
-        MOV     EAX, ECX        // EAX  <-  Fa Fr Fg Fb
-
-        // Get weight W = Fa * M
-        SHR     ECX,24          // ECX  <-  00 00 00 Fa
-
-        // Test Fa = 255 ?
-        CMP     ECX,$FF
-        JZ      @1
-
-  // P = W * F
-        MOV     R8D,EAX         // R8D  <-  Fa Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     R8D,$FF00FF00   // R8D  <-  Fa 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     R8D,8           // R8D  <-  00 Fa 00 Fg
-        IMUL    R8D,ECX         // R8D  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     R8D,bias
-        AND     R8D,$FF00FF00   // R8D  <-  Pa 00 Pg 00
-        OR      EAX,R8D         // EAX  <-  Pa Pr Pg Pb
-
-        MOV     R9D,[RDX]
-
-  // W = 1 - W; Q = W * B
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     R8D,R9D         // R8D  <-  Ba Br Bg Bb
-        AND     R9D,$00FF00FF   // R9D  <-  00 Br 00 Bb
-        AND     R8D,$FF00FF00   // R8D  <-  Ba 00 Bg 00
-        IMUL    R9D,ECX         // R9D  <-  Qr ** Qb **
-        SHR     R8D,8           // R8D  <-  00 Ba 00 Bg
-        IMUL    R8D,ECX         // R8D  <-  Qa ** Qg **
-        ADD     R9D,bias
-        AND     R9D,$FF00FF00   // R9D  <-  Qr 00 Qb 00
-        SHR     R9D,8           // R9D  <-  00 Qr ** Qb
-        ADD     R8D,bias
-        AND     R8D,$FF00FF00   // R8D  <-  Qa 00 Qg 00
-        OR      R8D,R9D         // R8D  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,R8D         // EAX  <-  Za Zr Zg Zb
-
-        MOV     [RDX],EAX
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     [RDX],EAX
-@2:
-{$ENDIF}
-end;
-
-function BlendRegEx_ASM(F, B, M: TColor32): TColor32;
-asm
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F multiplied by master alpha (M)
-  // no checking for M = $FF, in this case Graphics32 uses BlendReg
-  // Result Z = Fa * M * Frgb + (1 - Fa * M) * Brgb
-  // EAX <- F
-  // EDX <- B
-  // ECX <- M
-
-{$IFDEF TARGET_x86}
-
-// Check Fa > 0 ?
-        TEST    EAX,$FF000000   // Fa = 0? => Result := EDX
-        JZ      @2
-
-        PUSH    EBX
-
-  // Get weight W = Fa * M
-        MOV     EBX,EAX         // EBX  <-  Fa Fr Fg Fb
-        INC     ECX             // 255:256 range bias
-        SHR     EBX,24          // EBX  <-  00 00 00 Fa
-        IMUL    ECX,EBX         // ECX  <-  00 00  W **
-        SHR     ECX,8           // ECX  <-  00 00 00  W
-        JZ      @1              // W = 0 ?  => Result := EDX
-
-  // P = W * F
-        MOV     EBX,EAX         // EBX  <-  ** Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 00 00 Fg
-        IMUL    EBX,ECX         // EBX  <-  00 00 Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     EBX,bias
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  00 Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,EDX         // EBX  <-  00 Br Bg Bb
-        AND     EDX,$00FF00FF   // EDX  <-  00 Br 00 Bb
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Bg 00
-        IMUL    EDX,ECX         // EDX  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 00 00 Bg
-        IMUL    EBX,ECX         // EBX  <-  00 00 Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // EDX  <-  Qr 00 Qb 00
-        SHR     EDX,8           // EDX  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Qg 00
-        OR      EBX,EDX         // EBX  <-  00 Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  00 Zr Zg Zb
-
-        POP     EBX
-{$IFDEF FPC}
-        JMP @3
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:
-        POP     EBX
-
-@2:     MOV     EAX,EDX
-@3:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-        MOV     EAX,ECX         // EAX  <-  Fa Fr Fg Fb
-        TEST    EAX,$FF000000   // Fa = 0? => Result := EDX
-        JZ      @1
-
-  // Get weight W = Fa * M
-        INC     R8D             // 255:256 range bias
-        SHR     ECX,24          // ECX  <-  00 00 00 Fa
-        IMUL    R8D,ECX         // R8D  <-  00 00  W **
-        SHR     R8D,8           // R8D  <-  00 00 00  W
-        JZ      @1              // W = 0 ?  => Result := EDX
-
-  // P = W * F
-        MOV     ECX,EAX         // ECX  <-  ** Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     ECX,$0000FF00   // ECX  <-  00 00 Fg 00
-        IMUL    EAX,R8D         // EAX  <-  Pr ** Pb **
-        SHR     ECX,8           // ECX  <-  00 00 00 Fg
-        IMUL    ECX,R8D         // ECX  <-  00 00 Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     ECX,bias
-        AND     ECX,$0000FF00   // ECX  <-  00 00 Pg 00
-        OR      EAX,ECX         // EAX  <-  00 Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        XOR     R8D,$000000FF   // R8D  <-  1 - R8D
-        MOV     ECX,EDX         // ECX  <-  00 Br Bg Bb
-        AND     EDX,$00FF00FF   // EDX  <-  00 Br 00 Bb
-        AND     ECX,$0000FF00   // ECX  <-  00 00 Bg 00
-        IMUL    EDX,R8D         // EDX  <-  Qr ** Qb **
-        SHR     ECX,8           // ECX  <-  00 00 00 Bg
-        IMUL    ECX,R8D         // ECX  <-  00 00 Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // EDX  <-  Qr 00 Qb 00
-        SHR     EDX,8           // EDX  <-  00 Qr ** Qb
-        ADD     ECX,bias
-        AND     ECX,$0000FF00   // ECX  <-  00 00 Qg 00
-        OR      ECX,EDX         // ECX  <-  00 Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,ECX         // EAX  <-  00 Zr Zg Zb
-
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     EAX,EDX
-@2:
-{$ENDIF}
-end;
-
-procedure BlendMemEx_ASM(F: TColor32; var B: TColor32; M: TColor32);
-asm
-{$IFDEF TARGET_x86}
-  // EAX <- F
-  // [EDX] <- B
-  // ECX <- M
-
-  // Check Fa > 0 ?
-        TEST    EAX,$FF000000   // Fa = 0? => write nothing
-        JZ      @2
-
-        PUSH    EBX
-
-  // Get weight W = Fa * M
-        MOV     EBX,EAX         // EBX  <-  Fa Fr Fg Fb
-        INC     ECX             // 255:256 range bias
-        SHR     EBX,24          // EBX  <-  00 00 00 Fa
-        IMUL    ECX,EBX         // ECX  <-  00 00  W **
-        SHR     ECX,8           // ECX  <-  00 00 00  W
-        JZ      @1              // W = 0 ?  => write nothing
-
-        PUSH    ESI
-
-  // P = W * F
-        MOV     EBX,EAX         // EBX  <-  ** Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 00 00 Fg
-        IMUL    EBX,ECX         // EBX  <-  00 00 Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     EBX,bias
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  00 Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        MOV     ESI,[EDX]
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,ESI         // EBX  <-  00 Br Bg Bb
-        AND     ESI,$00FF00FF   // ESI  <-  00 Br 00 Bb
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Bg 00
-        IMUL    ESI,ECX         // ESI  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 00 00 Bg
-        IMUL    EBX,ECX         // EBX  <-  00 00 Qg **
-        ADD     ESI,bias
-        AND     ESI,$FF00FF00   // ESI  <-  Qr 00 Qb 00
-        SHR     ESI,8           // ESI  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$0000FF00   // EBX  <-  00 00 Qg 00
-        OR      EBX,ESI         // EBX  <-  00 Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  00 Zr Zg Zb
-
-        MOV     [EDX],EAX
-        POP     ESI
-
-@1:     POP     EBX
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX <- F
-  // [RDX] <- B
-  // R8 <- M
-
-  // ECX <- F
-  // [EDX] <- B
-  // R8 <- M
-
-  // Check Fa > 0 ?
-        TEST    ECX,$FF000000   // Fa = 0? => write nothing
-        JZ      @1
-
-  // Get weight W = Fa * M
-        MOV     EAX,ECX         // EAX  <-  Fa Fr Fg Fb
-        INC     R8D             // 255:256 range bias
-        SHR     EAX,24          // EAX  <-  00 00 00 Fa
-        IMUL    R8D,EAX         // R8D <-  00 00  W **
-        SHR     R8D,8           // R8D <-  00 00 00  W
-        JZ      @1              // W = 0 ?  => write nothing
-
-  // P = W * F
-        MOV     EAX,ECX         // EAX  <-  ** Fr Fg Fb
-        AND     ECX,$00FF00FF   // ECX  <-  00 Fr 00 Fb
-        AND     EAX,$0000FF00   // EAX  <-  00 00 Fg 00
-        IMUL    ECX,R8D         // ECX  <-  Pr ** Pb **
-        SHR     EAX,8           // EAX  <-  00 00 00 Fg
-        IMUL    EAX,R8D         // EAX  <-  00 00 Pg **
-        ADD     ECX,bias
-        AND     ECX,$FF00FF00   // ECX  <-  Pr 00 Pb 00
-        SHR     ECX,8           // ECX  <-  00 Pr ** Pb
-        ADD     EAX,bias
-        AND     EAX,$0000FF00   // EAX  <-  00 00 Pg 00
-        OR      ECX,EAX         // ECX  <-  00 Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        MOV     R9D,[RDX]
-        XOR     R8D,$000000FF   // R8D  <-  1 - R8
-        MOV     EAX,R9D         // EAX  <-  00 Br Bg Bb
-        AND     R9D,$00FF00FF   // R9D  <-  00 Br 00 Bb
-        AND     EAX,$0000FF00   // EAX  <-  00 00 Bg 00
-        IMUL    R9D,R8D         // R9D  <-  Qr ** Qb **
-        SHR     EAX,8           // EAX  <-  00 00 00 Bg
-        IMUL    EAX,R8D         // EAX  <-  00 00 Qg **
-        ADD     R9D,bias
-        AND     R9D,$FF00FF00   // R9D  <-  Qr 00 Qb 00
-        SHR     R9D,8           // R9D  <-  00 Qr ** Qb
-        ADD     EAX,bias
-        AND     EAX,$0000FF00   // EAX  <-  00 00 Qg 00
-        OR      EAX,R9D         // EAX  <-  00 Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     ECX,EAX         // ECX  <-  00 Zr Zg Zb
-
-        MOV     [RDX],ECX
-
-@1:
-{$ENDIF}
-end;
-
-procedure BlendLine_ASM(Src, Dst: PColor32; Count: Integer);
-asm
-{$IFDEF TARGET_x86}
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-  // test the counter for zero or negativity
-        TEST    ECX,ECX
-        JS      @4
-
-        PUSH    EBX
-        PUSH    ESI
-        PUSH    EDI
-
-        MOV     ESI,EAX         // ESI <- Src
-        MOV     EDI,EDX         // EDI <- Dst
-
-  // loop start
-@1:     MOV     EAX,[ESI]
-        TEST    EAX,$FF000000
-        JZ      @3              // complete transparency, proceed to next point
-
-        PUSH    ECX             // store counter
-
-  // Get weight W = Fa * M
-        MOV     ECX,EAX         // ECX  <-  Fa Fr Fg Fb
-        SHR     ECX,24          // ECX  <-  00 00 00 Fa
-
-  // Test Fa = 255 ?
-        CMP     ECX,$FF
-        JZ      @2
-
-  // P = W * F
-        MOV     EBX,EAX         // EBX  <-  Fa Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     EBX,$FF00FF00   // EBX  <-  Fa 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 Fa 00 Fg
-        IMUL    EBX,ECX         // EBX  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Pa 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  Pa Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        MOV     EDX,[EDI]
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,EDX         // EBX  <-  Ba Br Bg Bb
-        AND     EDX,$00FF00FF   // ESI  <-  00 Br 00 Bb
-        AND     EBX,$FF00FF00   // EBX  <-  Ba 00 Bg 00
-        IMUL    EDX,ECX         // ESI  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 Ba 00 Bg
-        IMUL    EBX,ECX         // EBX  <-  Qa ** Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // ESI  <-  Qr 00 Qb 00
-        SHR     EDX,8           // ESI  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Qa 00 Qg 00
-        OR      EBX,EDX         // EBX  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  Za Zr Zg Zb
-@2:
-        MOV     [EDI],EAX
-
-        POP     ECX             // restore counter
-
-@3:
-        ADD     ESI,4
-        ADD     EDI,4
-
-  // loop end
-        DEC     ECX
-        JNZ     @1
-
-        POP     EDI
-        POP     ESI
-        POP     EBX
-
-@4:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // RCX <- Src
-  // RDX <- Dst
-  // R8 <- Count
-
-  // test the counter for zero or negativity
-        TEST    R8D,R8D
-        JS      @4
-
-        MOV     R10,RCX         // R10 <- Src
-        MOV     R11,RDX         // R11 <- Dst
-        MOV     ECX,R8D         // RCX <- Count
-
-  // loop start
-@1:
-        MOV     EAX,[R10]
-        TEST    EAX,$FF000000
-        JZ      @3              // complete transparency, proceed to next point
-
-  // Get weight W = Fa * M
-        MOV     R9D,EAX        // R9D  <-  Fa Fr Fg Fb
-        SHR     R9D,24         // R9D  <-  00 00 00 Fa
-
-  // Test Fa = 255 ?
-        CMP     R9D,$FF
-        JZ      @2
-
-  // P = W * F
-        MOV     R8D,EAX         // R8D  <-  Fa Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     R8D,$FF00FF00   // R8D  <-  Fa 00 Fg 00
-        IMUL    EAX,R9D         // EAX  <-  Pr ** Pb **
-        SHR     R8D,8           // R8D  <-  00 Fa 00 Fg
-        IMUL    R8D,R9D         // R8D  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr ** Pb
-        ADD     R8D,bias
-        AND     R8D,$FF00FF00   // R8D  <-  Pa 00 Pg 00
-        OR      EAX,R8D         // EAX  <-  Pa Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        MOV     EDX,[R11]
-        XOR     R9D,$000000FF   // R9D  <-  1 - R9D
-        MOV     R8D,EDX         // R8D  <-  Ba Br Bg Bb
-        AND     EDX,$00FF00FF   // ESI  <-  00 Br 00 Bb
-        AND     R8D,$FF00FF00   // R8D  <-  Ba 00 Bg 00
-        IMUL    EDX,R9D         // ESI  <-  Qr ** Qb **
-        SHR     R8D,8           // R8D  <-  00 Ba 00 Bg
-        IMUL    R8D,R9D         // R8D  <-  Qa ** Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // ESI  <-  Qr 00 Qb 00
-        SHR     EDX,8           // ESI  <-  00 Qr ** Qb
-        ADD     R8D,bias
-        AND     R8D,$FF00FF00   // R8D  <-  Qa 00 Qg 00
-        OR      R8D,EDX         // R8D  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,R8D         // EAX  <-  Za Zr Zg Zb
-@2:
-        MOV     [R11],EAX
-
-@3:
-        ADD     R10,4
-        ADD     R11,4
-
-  // loop end
-        DEC     ECX
-        JNZ     @1
-
-@4:
-{$ENDIF}
-end;
-
-{$IFDEF TARGET_x86}
-
-function MergeReg_ASM(F, B: TColor32): TColor32;
-asm
-        // EAX <- F
-        // EDX <- B
-
-        // if F.A = 0 then
-        TEST    EAX,$FF000000
-        JZ      @exit0
-
-        // else if B.A = 255 then
-        CMP     EDX,$FF000000
-        JNC     @blend
-
-        // else if F.A = 255 then
-        CMP     EAX,$FF000000
-        JNC     @Exit
-
-        // else if B.A = 0 then
-        TEST    EDX,$FF000000
-        JZ      @Exit
-
-@4:
-        PUSH    EBX
-        PUSH    ESI
-        PUSH    EDI
-        ADD     ESP,-$0C
-        MOV     [ESP+$04],EDX
-        MOV     [ESP],EAX
-
-        // AH <- F.A
-        // DL, CL <- B.A
-        SHR     EAX,16
-        AND     EAX,$0000FF00
-        SHR     EDX,24
-        MOV     CL,DL
-        NOP
-        NOP
-        NOP
-
-        // EDI <- PF
-        // EDX <- PB
-        // ESI <- PR
-
-        // PF := @DivTable[F.A];
-        LEA     EDI,[EAX+DivTable]
-        // PB := @DivTable[B.A];
-        SHL     EDX,$08
-        LEA     EDX,[EDX+DivTable]
-        // Result.A := B.A + F.A - PB[F.A];
-        SHR     EAX,8
-        //ADD CL,al
-        ADD     ECX,EAX
-        //SUB CL,[EDX+EAX]
-        SUB     ECX,[EDX+EAX]
-        MOV     [ESP+$0B],CL
-        // PR := @RcTable[Result.A];
-        SHL     ECX,$08
-        AND     ECX,$0000FFFF
-        LEA     ESI,[ECX+RcTable]
-
-  { Red component }
-
-        // Result.R := PB[B.R];
-        XOR     EAX,EAX
-        MOV     AL,[ESP+$06]
-        MOV     CL,[EDX+EAX]
-        MOV     [ESP+$0a],CL
-        // X := F.R - Result.R;
-        MOV     AL,[ESP+$02]
-        XOR     EBX,EBX
-        MOV     BL,CL
-        SUB     EAX,EBX
-        // if X >= 0 then
-        JL      @5
-        // Result.R := PR[PF[X] + Result.R]
-        MOVZX   EAX,BYTE PTR[EDI+EAX]
-        AND     ECX,$000000FF
-        ADD     EAX,ECX
-        MOV     AL,[ESI+EAX]
-        MOV     [ESP+$0a],al
-        JMP     @6
-@5:
-        // Result.R := PR[Result.R - PF[-X]];
-        NEG     EAX
-        MOVZX   EAX,BYTE PTR[EDI+EAX]
-        XOR     ECX,ECX
-        MOV     CL,[ESP+$0A]
-        SUB     ECX,EAX
-        MOV     AL,[ESI+ECX]
-        MOV     [ESP+$0A],al
-
-
-  { Green component }
-
-@6:
-  // Result.G := PB[B.G];
-        XOR     EAX,EAX
-        MOV     AL,[ESP+$05]
-        MOV     CL,[EDX+EAX]
-        MOV     [ESP+$09],CL
-  // X := F.G - Result.G;
-        MOV     AL,[ESP+$01]
-        XOR     EBX,EBX
-        MOV     BL,CL
-        SUB     EAX,EBX
-  // if X >= 0 then
-        JL      @7
-  // Result.G := PR[PF[X] + Result.G]
-        MOVZX   EAX,BYTE PTR[EDI+EAX]
-        AND     ECX,$000000FF
-        ADD     EAX,ECX
-        MOV     AL,[ESI+EAX]
-        MOV     [ESP+$09],AL
-        JMP     @8
-@7:
-  // Result.G := PR[Result.G - PF[-X]];
-        NEG     EAX
-        MOVZX   EAX,BYTE PTR[EDI+EAX]
-        XOR     ECX,ECX
-        MOV     CL,[ESP+$09]
-        SUB     ECX,EAX
-        MOV     AL,[ESI+ECX]
-        MOV     [ESP+$09],AL
-
-
-  { Blue component }
-@8:
-  // Result.B := PB[B.B];
-        XOR     EAX,EAX
-        MOV     AL,[ESP+$04]
-        MOV     CL,[EDX+EAX]
-        MOV     [ESP+$08],CL
-  // X := F.B - Result.B;
-        MOV     AL,[ESP]
-        XOR     EDX,EDX
-        MOV     DL,CL
-        SUB     EAX,EDX
-  // if X >= 0 then
-        JL      @9
-  // Result.B := PR[PF[X] + Result.B]
-        MOVZX   EAX,BYTE PTR[EDI+EAX]
-        XOR     EDX,EDX
-        MOV     DL,CL
-        ADD     EAX,EDX
-        MOV     AL,[ESI+EAX]
-        MOV     [ESP+$08],al
-        JMP     @10
-@9:
-  // Result.B := PR[Result.B - PF[-X]];
-        NEG     EAX
-        MOVZX   EAX,BYTE PTR[EDI+EAX]
-        XOR     EDX,EDX
-        MOV     DL,CL
-        SUB     EDX,EAX
-        MOV     AL,[ESI+EDX]
-        MOV     [ESP+$08],AL
-
-@10:
-  // EAX <- Result
-        MOV     EAX,[ESP+$08]
-
-  // end;
-        ADD     ESP,$0C
-        POP     EDI
-        POP     ESI
-        POP     EBX
-{$IFDEF FPC}
-        JMP @Exit
-{$ELSE}
-        RET
-{$ENDIF}
-@blend:
-        CALL    DWORD PTR [BlendReg]
-        OR      EAX,$FF000000
-{$IFDEF FPC}
-        JMP @Exit
-{$ELSE}
-        RET
-{$ENDIF}
-@exit0:
-        MOV     EAX,EDX
-@Exit:
-end;
-
-{$ENDIF}
-
-function CombineReg_ASM(X, Y, W: TColor32): TColor32;
-asm
-  // combine RGBA channels of colors X and Y with the weight of X given in W
-  // Result Z = W * X + (1 - W) * Y (all channels are combined, including alpha)
-{$IFDEF TARGET_x86}
-  // EAX <- X
-  // EDX <- Y
-  // ECX <- W
-
-  // W = 0 or $FF?
-        JCXZ    @1              // CX = 0 ?  => Result := EDX
-        CMP     ECX,$FF         // CX = $FF ?  => Result := EDX
-        JE      @2
-
-        PUSH    EBX
-
-  // P = W * X
-        MOV     EBX,EAX         // EBX  <-  Xa Xr Xg Xb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Xr 00 Xb
-        AND     EBX,$FF00FF00   // EBX  <-  Xa 00 Xg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 Xa 00 Xg
-        IMUL    EBX,ECX         // EBX  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pa 00 Pg 00
-        SHR     EAX,8           // EAX  <-  00 Pr 00 Pb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Pa 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  Pa Pr Pg Pb
-
-  // W = 1 - W; Q = W * Y
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,EDX         // EBX  <-  Ya Yr Yg Yb
-        AND     EDX,$00FF00FF   // EDX  <-  00 Yr 00 Yb
-        AND     EBX,$FF00FF00   // EBX  <-  Ya 00 Yg 00
-        IMUL    EDX,ECX         // EDX  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 Ya 00 Yg
-        IMUL    EBX,ECX         // EBX  <-  Qa ** Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // EDX  <-  Qr 00 Qb 00
-        SHR     EDX,8           // EDX  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Qa 00 Qg 00
-        OR      EBX,EDX         // EBX  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  Za Zr Zg Zb
-
-        POP     EBX
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     EAX,EDX
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX <- X
-  // EDX <- Y
-  // R8D <- W
-
-  // W = 0 or $FF?
-        TEST    R8D,R8D
-        JZ      @1              // W = 0 ?  => Result := EDX
-        MOV     EAX,ECX         // EAX  <-  Xa Xr Xg Xb
-        CMP     R8B,$FF         // W = $FF ?  => Result := EDX
-        JE      @2
-
-  // P = W * X
-        AND     EAX,$00FF00FF   // EAX  <-  00 Xr 00 Xb
-        AND     ECX,$FF00FF00   // ECX  <-  Xa 00 Xg 00
-        IMUL    EAX,R8D         // EAX  <-  Pr ** Pb **
-        SHR     ECX,8           // ECX  <-  00 Xa 00 Xg
-        IMUL    ECX,R8D         // ECX  <-  Pa ** Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pa 00 Pg 00
-        SHR     EAX,8           // EAX  <-  00 Pr 00 Pb
-        ADD     ECX,bias
-        AND     ECX,$FF00FF00   // ECX  <-  Pa 00 Pg 00
-        OR      EAX,ECX         // EAX  <-  Pa Pr Pg Pb
-
-  // W = 1 - W; Q = W * Y
-        XOR     R8D,$000000FF   // R8D  <-  1 - R8D
-        MOV     ECX,EDX         // ECX  <-  Ya Yr Yg Yb
-        AND     EDX,$00FF00FF   // EDX  <-  00 Yr 00 Yb
-        AND     ECX,$FF00FF00   // ECX  <-  Ya 00 Yg 00
-        IMUL    EDX,R8D         // EDX  <-  Qr ** Qb **
-        SHR     ECX,8           // ECX  <-  00 Ya 00 Yg
-        IMUL    ECX,R8D         // ECX  <-  Qa ** Qg **
-        ADD     EDX,bias
-        AND     EDX,$FF00FF00   // EDX  <-  Qr 00 Qb 00
-        SHR     EDX,8           // EDX  <-  00 Qr ** Qb
-        ADD     ECX,bias
-        AND     ECX,$FF00FF00   // ECX  <-  Qa 00 Qg 00
-        OR      ECX,EDX         // ECX  <-  Qa Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,ECX         // EAX  <-  Za Zr Zg Zb
-
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV     EAX,EDX
-@2:
-{$ENDIF}
-end;
-
-procedure CombineMem_ASM(X: TColor32; var Y: TColor32; W: TColor32);
-asm
-{$IFDEF TARGET_x86}
-  // EAX <- F
-  // [EDX] <- B
-  // ECX <- W
-
-  // Check W
-        JCXZ    @1              // W = 0 ?  => write nothing
-        CMP     ECX,$FF         // W = 255? => write F
-{$IFDEF FPC}
-        DB      $74,$76         //Prob with FPC 2.2.2 and below
-{$ELSE}
-        JZ      @2
-{$ENDIF}
-
-
-        PUSH    EBX
-        PUSH    ESI
-
-  // P = W * F
-        MOV     EBX,EAX         // EBX  <-  ** Fr Fg Fb
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     EBX,$FF00FF00   // EBX  <-  Fa 00 Fg 00
-        IMUL    EAX,ECX         // EAX  <-  Pr ** Pb **
-        SHR     EBX,8           // EBX  <-  00 Fa 00 Fg
-        IMUL    EBX,ECX         // EBX  <-  00 00 Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr 00 Pb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Pa 00 Pg 00
-        OR      EAX,EBX         // EAX  <-  00 Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        MOV     ESI,[EDX]
-        XOR     ECX,$000000FF   // ECX  <-  1 - ECX
-        MOV     EBX,ESI         // EBX  <-  Ba Br Bg Bb
-        AND     ESI,$00FF00FF   // ESI  <-  00 Br 00 Bb
-        AND     EBX,$FF00FF00   // EBX  <-  Ba 00 Bg 00
-        IMUL    ESI,ECX         // ESI  <-  Qr ** Qb **
-        SHR     EBX,8           // EBX  <-  00 Ba 00 Bg
-        IMUL    EBX,ECX         // EBX  <-  Qa 00 Qg **
-        ADD     ESI,bias
-        AND     ESI,$FF00FF00   // ESI  <-  Qr 00 Qb 00
-        SHR     ESI,8           // ESI  <-  00 Qr ** Qb
-        ADD     EBX,bias
-        AND     EBX,$FF00FF00   // EBX  <-  Qa 00 Qg 00
-        OR      EBX,ESI         // EBX  <-  00 Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,EBX         // EAX  <-  00 Zr Zg Zb
-
-        MOV     [EDX],EAX
-
-        POP     ESI
-        POP     EBX
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV     [EDX],EAX
-@3:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX <- F
-  // [RDX] <- B
-  // R8 <- W
-
-  // Check W
-        TEST    R8D,R8D         // Set flags for R8
-        JZ      @2              // W = 0 ?  => Result := EDX
-        MOV     EAX,ECX         // EAX  <-  ** Fr Fg Fb
-        CMP     R8B,$FF         // W = 255? => write F
-        JZ      @1
-
-  // P = W * F
-        AND     EAX,$00FF00FF   // EAX  <-  00 Fr 00 Fb
-        AND     ECX,$FF00FF00   // ECX  <-  Fa 00 Fg 00
-        IMUL    EAX,R8D         // EAX  <-  Pr ** Pb **
-        SHR     ECX,8           // ECX  <-  00 Fa 00 Fg
-        IMUL    ECX,R8D         // ECX  <-  00 00 Pg **
-        ADD     EAX,bias
-        AND     EAX,$FF00FF00   // EAX  <-  Pr 00 Pb 00
-        SHR     EAX,8           // EAX  <-  00 Pr 00 Pb
-        ADD     ECX,bias
-        AND     ECX,$FF00FF00   // ECX  <-  Pa 00 Pg 00
-        OR      EAX,ECX         // EAX  <-  00 Pr Pg Pb
-
-  // W = 1 - W; Q = W * B
-        MOV     R9D,[RDX]
-        XOR     R8D,$000000FF   // R8D  <-  1 - R8D
-        MOV     ECX,R9D         // ECX  <-  Ba Br Bg Bb
-        AND     R9D,$00FF00FF   // R9D  <-  00 Br 00 Bb
-        AND     ECX,$FF00FF00   // ECX  <-  Ba 00 Bg 00
-        IMUL    R9D,R8D         // R9D  <-  Qr ** Qb **
-        SHR     ECX,8           // ECX  <-  00 Ba 00 Bg
-        IMUL    ECX,R8D         // ECX  <-  Qa 00 Qg **
-        ADD     R9D,bias
-        AND     R9D,$FF00FF00   // R9D  <-  Qr 00 Qb 00
-        SHR     R9D,8           // R9D  <-  00 Qr ** Qb
-        ADD     ECX,bias
-        AND     ECX,$FF00FF00   // ECX  <-  Qa 00 Qg 00
-        OR      ECX,R9D         // ECX  <-  00 Qr Qg Qb
-
-  // Z = P + Q (assuming no overflow at each byte)
-        ADD     EAX,ECX         // EAX  <-  00 Zr Zg Zb
-
-@1:     MOV     [RDX],EAX
-@2:
-
-{$ENDIF}
-end;
-
-procedure EMMS_ASM;
-asm
-end;
 
 procedure GenAlphaTable;
@@ -1830 +895 @@
   FreeMem(AlphaTable);
 end;
-
-{$IFNDEF OMIT_MMX}
-
-{ MMX versions }
-
-function BlendReg_MMX(F, B: TColor32): TColor32;
-asm
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-{$IFDEF TARGET_x86}
-  // EAX <- F
-  // EDX <- B
-  // Result := Fa * (Frgb - Brgb) + Brgb
-        MOVD      MM0,EAX
-        PXOR      MM3,MM3
-        MOVD      MM2,EDX
-        PUNPCKLBW MM0,MM3
-        MOV       ECX,bias_ptr
-        PUNPCKLBW MM2,MM3
-        MOVQ      MM1,MM0
-        PUNPCKHWD MM1,MM1
-        PSUBW     MM0,MM2
-        PUNPCKHDQ MM1,MM1
-        PSLLW     MM2,8
-        PMULLW    MM0,MM1
-        PADDW     MM2,[ECX]
-        PADDW     MM2,MM0
-        PSRLW     MM2,8
-        PACKUSWB  MM2,MM3
-        MOVD      EAX,MM2
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX <- F
-  // EDX <- B
-  // Result := Fa * (Frgb - Brgb) + Brgb
-        MOVD      MM0,ECX
-        PXOR      MM3,MM3
-        MOVD      MM2,EDX
-        PUNPCKLBW MM0,MM3
-        MOV       RAX,bias_ptr
-        PUNPCKLBW MM2,MM3
-        MOVQ      MM1,MM0
-        PUNPCKHWD MM1,MM1
-        PSUBW     MM0,MM2
-        PUNPCKHDQ MM1,MM1
-        PSLLW     MM2,8
-        PMULLW    MM0,MM1
-        PADDW     MM2,[RAX]
-        PADDW     MM2,MM0
-        PSRLW     MM2,8
-        PACKUSWB  MM2,MM3
-        MOVD      EAX,MM2
-{$ENDIF}
-end;
-
-{$IFDEF TARGET_x86}
-
-procedure BlendMem_MMX(F: TColor32; var B: TColor32);
-asm
-  // EAX - Color X
-  // [EDX] - Color Y
-  // Result := W * (X - Y) + Y
-
-        TEST      EAX,$FF000000
-        JZ        @1
-        CMP       EAX,$FF000000
-        JNC       @2
-
-        PXOR      MM3,MM3
-        MOVD      MM0,EAX
-        MOVD      MM2,[EDX]
-        PUNPCKLBW MM0,MM3
-        MOV       ECX,bias_ptr
-        PUNPCKLBW MM2,MM3
-        MOVQ      MM1,MM0
-        PUNPCKHWD MM1,MM1
-        PSUBW     MM0,MM2
-        PUNPCKHDQ MM1,MM1
-        PSLLW     MM2,8
-        PMULLW    MM0,MM1
-        PADDW     MM2,[ECX]
-        PADDW     MM2,MM0
-        PSRLW     MM2,8
-        PACKUSWB  MM2,MM3
-        MOVD      [EDX],MM2
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [EDX],EAX
-@3:
-end;
-
-function BlendRegEx_MMX(F, B, M: TColor32): TColor32;
-asm
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // EAX <- F
-  // EDX <- B
-  // ECX <- M
-  // Result := M * Fa * (Frgb - Brgb) + Brgb
-        PUSH      EBX
-        MOV       EBX,EAX
-        SHR       EBX,24
-        INC       ECX             // 255:256 range bias
-        IMUL      ECX,EBX
-        SHR       ECX,8
-        JZ        @1
-
-        PXOR      MM0,MM0
-        MOVD      MM1,EAX
-        SHL       ECX,4
-        MOVD      MM2,EDX
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-        ADD       ECX,alpha_ptr
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[ECX]
-        PSLLW     MM2,8
-        MOV       ECX,bias_ptr
-        PADDW     MM2,[ECX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      EAX,MM1
-
-        POP       EBX
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV       EAX,EDX
-        POP       EBX
-@2:
-end;
-
-{$ENDIF}
-
-procedure BlendMemEx_MMX(F: TColor32; var B:TColor32; M: TColor32);
-asm
-{$IFDEF TARGET_x86}
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // EAX <- F
-  // [EDX] <- B
-  // ECX <- M
-  // Result := M * Fa * (Frgb - Brgb) + Brgb
-        TEST      EAX,$FF000000
-        JZ        @2
-
-        PUSH      EBX
-        MOV       EBX,EAX
-        SHR       EBX,24
-        INC       ECX             // 255:256 range bias
-        IMUL      ECX,EBX
-        SHR       ECX,8
-        JZ        @1
-
-        PXOR      MM0,MM0
-        MOVD      MM1,EAX
-        SHL       ECX,4
-        MOVD      MM2,[EDX]
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-        ADD       ECX,alpha_ptr
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[ECX]
-        PSLLW     MM2,8
-        MOV       ECX,bias_ptr
-        PADDW     MM2,[ECX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      [EDX],MM1
-
-@1:     POP       EBX
-
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // ECX <- F
-  // [EDX] <- B
-  // R8 <- M
-  // Result := M * Fa * (Frgb - Brgb) + Brgb
-        TEST      ECX,$FF000000
-        JZ        @1
-
-        MOV       EAX,ECX
-        SHR       EAX,24
-        INC       R8D             // 255:256 range bias
-        IMUL      R8D,EAX
-        SHR       R8D,8
-        JZ        @1
-
-        PXOR      MM0,MM0
-        MOVD      MM1,ECX
-        SHL       R8D,4
-        MOVD      MM2,[RDX]
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-        ADD       R8,alpha_ptr
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[R8]
-        PSLLW     MM2,8
-        MOV       RAX,bias_ptr
-        PADDW     MM2,[RAX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      [RDX],MM1
-
-@1:
-{$ENDIF}
-end;
-
-{$IFDEF TARGET_x86}
-procedure BlendLine_MMX(Src, Dst: PColor32; Count: Integer);
-asm
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-  // test the counter for zero or negativity
-        TEST      ECX,ECX
-        JS        @4
-
-        PUSH      ESI
-        PUSH      EDI
-
-        MOV       ESI,EAX         // ESI <- Src
-        MOV       EDI,EDX         // EDI <- Dst
-
-  // loop start
-@1:     MOV       EAX,[ESI]
-        TEST      EAX,$FF000000
-        JZ        @3              // complete transparency, proceed to next point
-        CMP       EAX,$FF000000
-        JNC       @2              // opaque pixel, copy without blending
-
-  // blend
-        MOVD      MM0,EAX         // MM0  <-  00 00 00 00 Fa Fr Fg Fb
-        PXOR      MM3,MM3         // MM3  <-  00 00 00 00 00 00 00 00
-        MOVD      MM2,[EDI]       // MM2  <-  00 00 00 00 Ba Br Bg Bb
-        PUNPCKLBW MM0,MM3         // MM0  <-  00 Fa 00 Fr 00 Fg 00 Fb
-        MOV       EAX,bias_ptr
-        PUNPCKLBW MM2,MM3         // MM2  <-  00 Ba 00 Br 00 Bg 00 Bb
-        MOVQ      MM1,MM0         // MM1  <-  00 Fa 00 Fr 00 Fg 00 Fb
-        PUNPCKHWD MM1,MM1         // MM1  <-  00 Fa 00 Fa 00 ** 00 **
-        PSUBW     MM0,MM2         // MM0  <-  00 Da 00 Dr 00 Dg 00 Db
-        PUNPCKHDQ MM1,MM1         // MM1  <-  00 Fa 00 Fa 00 Fa 00 Fa
-        PSLLW     MM2,8           // MM2  <-  Ba 00 Br 00 Bg 00 Bb 00
-        PMULLW    MM0,MM1         // MM2  <-  Pa ** Pr ** Pg ** Pb **
-        PADDW     MM2,[EAX]       // add bias
-        PADDW     MM2,MM0         // MM2  <-  Qa ** Qr ** Qg ** Qb **
-        PSRLW     MM2,8           // MM2  <-  00 Qa 00 Qr 00 Qg 00 Qb
-        PACKUSWB  MM2,MM3         // MM2  <-  00 00 00 00 Qa Qr Qg Qb
-        MOVD      EAX,MM2
-
-@2:     MOV       [EDI],EAX
-
-@3:     ADD       ESI,4
-        ADD       EDI,4
-
-  // loop end
-        DEC       ECX
-        JNZ       @1
-
-        POP       EDI
-        POP       ESI
-
-@4:
-end;
-
-procedure BlendLineEx_MMX(Src, Dst: PColor32; Count: Integer; M: TColor32);
-asm
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-  // test the counter for zero or negativity
-        TEST      ECX,ECX
-        JS        @4
-
-        PUSH      ESI
-        PUSH      EDI
-        PUSH      EBX
-
-        MOV       ESI,EAX         // ESI <- Src
-        MOV       EDI,EDX         // EDI <- Dst
-        MOV       EDX,M           // EDX <- Master Alpha
-
-  // loop start
-@1:     MOV       EAX,[ESI]
-        TEST      EAX,$FF000000
-        JZ        @3             // complete transparency, proceed to next point
-        MOV       EBX,EAX
-        SHR       EBX,24
-        INC       EBX            // 255:256 range bias
-        IMUL      EBX,EDX
-        SHR       EBX,8
-        JZ        @3              // complete transparency, proceed to next point
-
-  // blend
-        PXOR      MM0,MM0
-        MOVD      MM1,EAX
-        SHL       EBX,4
-        MOVD      MM2,[EDI]
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-        ADD       EBX,alpha_ptr
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[EBX]
-        PSLLW     MM2,8
-        MOV       EBX,bias_ptr
-        PADDW     MM2,[EBX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      EAX,MM1
-
-@2:     MOV       [EDI],EAX
-
-@3:     ADD       ESI,4
-        ADD       EDI,4
-
-  // loop end
-        DEC       ECX
-        JNZ       @1
-
-        POP       EBX
-        POP       EDI
-        POP       ESI
-@4:
-end;
-
-{$ENDIF}
-
-function CombineReg_MMX(X, Y, W: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-  // EAX - Color X
-  // EDX - Color Y
-  // ECX - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        MOVD      MM1,EAX
-        PXOR      MM0,MM0
-        SHL       ECX,4
-
-        MOVD      MM2,EDX
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-
-        ADD       ECX,alpha_ptr
-
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[ECX]
-        PSLLW     MM2,8
-
-        MOV       ECX,bias_ptr
-
-        PADDW     MM2,[ECX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      EAX,MM1
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-  // ECX - Color X
-  // EDX - Color Y
-  // R8 - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        MOVD      MM1,ECX
-        PXOR      MM0,MM0
-        SHL       R8D,4
-
-        MOVD      MM2,EDX
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-
-        ADD       R8,alpha_ptr
-
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[R8]
-        PSLLW     MM2,8
-
-        MOV       RAX,bias_ptr
-
-        PADDW     MM2,[RAX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      EAX,MM1
-{$ENDIF}
-end;
-
-procedure CombineMem_MMX(F: TColor32; var B: TColor32; W: TColor32);
-asm
-{$IFDEF TARGET_X86}
-  // EAX - Color X
-  // [EDX] - Color Y
-  // ECX - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        JCXZ      @1
-        CMP       ECX,$FF
-        JZ        @2
-
-        MOVD      MM1,EAX
-        PXOR      MM0,MM0
-
-        SHL       ECX,4
-
-        MOVD      MM2,[EDX]
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-
-        ADD       ECX,alpha_ptr
-
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[ECX]
-        PSLLW     MM2,8
-
-        MOV       ECX,bias_ptr
-
-        PADDW     MM2,[ECX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      [EDX],MM1
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [EDX],EAX
-@3:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX - Color X
-  // [RDX] - Color Y
-  // R8 - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        TEST      R8D,R8D            // Set flags for R8
-        JZ        @1                 // W = 0 ?  => Result := EDX
-        CMP       R8D,$FF
-        JZ        @2
-
-        MOVD      MM1,ECX
-        PXOR      MM0,MM0
-
-        SHL       R8D,4
-
-        MOVD      MM2,[RDX]
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-
-        ADD       R8,alpha_ptr
-
-        PSUBW     MM1,MM2
-        PMULLW    MM1,[R8]
-        PSLLW     MM2,8
-
-        MOV       RAX,bias_ptr
-
-        PADDW     MM2,[RAX]
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      [RDX],MM1
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [RDX],RCX
-@3:
-{$ENDIF}
-end;
-
-{$IFDEF TARGET_x86}
-
-procedure CombineLine_MMX(Src, Dst: PColor32; Count: Integer; W: TColor32);
-asm
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-  // Result := W * (X - Y) + Y
-
-        TEST      ECX,ECX
-        JS        @3
-
-        PUSH      EBX
-        MOV       EBX,W
-
-        TEST      EBX,EBX
-        JZ        @2              // weight is zero
-
-        CMP       EBX,$FF
-        JZ        @4              // weight = 255  =>  copy src to dst
-
-        SHL       EBX,4
-        ADD       EBX,alpha_ptr
-        MOVQ      MM3,[EBX]
-        MOV       EBX,bias_ptr
-        MOVQ      MM4,[EBX]
-
-   // loop start
-@1:     MOVD      MM1,[EAX]
-        PXOR      MM0,MM0
-        MOVD      MM2,[EDX]
-        PUNPCKLBW MM1,MM0
-        PUNPCKLBW MM2,MM0
-
-        PSUBW     MM1,MM2
-        PMULLW    MM1,MM3
-        PSLLW     MM2,8
-
-        PADDW     MM2,MM4
-        PADDW     MM1,MM2
-        PSRLW     MM1,8
-        PACKUSWB  MM1,MM0
-        MOVD      [EDX],MM1
-
-        ADD       EAX,4
-        ADD       EDX,4
-
-        DEC       ECX
-        JNZ       @1
-@2:     POP       EBX
-        POP       EBP
-@3:     RET       $0004
-
-@4:     CALL      GR32_LowLevel.MoveLongword
-        POP       EBX
-end;
-
-{$ENDIF}
-
-procedure EMMS_MMX;
-asm
-  EMMS
-end;
-
-function LightenReg_MMX(C: TColor32; Amount: Integer): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD    MM0,EAX
-        TEST    EDX,EDX
-        JL      @1
-        IMUL    EDX,$010101
-        MOVD    MM1,EDX
-        PADDUSB MM0,MM1
-        MOVD    EAX,MM0
-        RET
-@1:     NEG     EDX
-        IMUL    EDX,$010101
-        MOVD    MM1,EDX
-        PSUBUSB MM0,MM1
-        MOVD    EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD    MM0,ECX
-        TEST    EDX,EDX
-        JL      @1
-        IMUL    EDX,$010101
-        MOVD    MM1,EDX
-        PADDUSB MM0,MM1
-        MOVD    EAX,MM0
-        RET
-@1:     NEG     EDX
-        IMUL    EDX,$010101
-        MOVD    MM1,EDX
-        PSUBUSB MM0,MM1
-        MOVD    EAX,MM0
-{$ENDIF}
-end;
-
-{ MMX Color algebra versions }
-
-function ColorAdd_MMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      MM0,EAX
-        MOVD      MM1,EDX
-        PADDUSB   MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      MM0,ECX
-        MOVD      MM1,EDX
-        PADDUSB   MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorSub_MMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      MM0,EAX
-        MOVD      MM1,EDX
-        PSUBUSB   MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      MM0,ECX
-        MOVD      MM1,EDX
-        PSUBUSB   MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorModulate_MMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        PXOR      MM2,MM2
-        MOVD      MM0,EAX
-        PUNPCKLBW MM0,MM2
-        MOVD      MM1,EDX
-        PUNPCKLBW MM1,MM2
-        PMULLW    MM0,MM1
-        PSRLW     MM0,8
-        PACKUSWB  MM0,MM2
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        PXOR      MM2,MM2
-        MOVD      MM0,ECX
-        PUNPCKLBW MM0,MM2
-        MOVD      MM1,EDX
-        PUNPCKLBW MM1,MM2
-        PMULLW    MM0,MM1
-        PSRLW     MM0,8
-        PACKUSWB  MM0,MM2
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorMax_EMMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      MM0,EAX
-        MOVD      MM1,EDX
-        PMAXUB    MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      MM0,ECX
-        MOVD      MM1,EDX
-        PMAXUB    MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorMin_EMMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      MM0,EAX
-        MOVD      MM1,EDX
-        PMINUB    MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      MM0,ECX
-        MOVD      MM1,EDX
-        PMINUB    MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorDifference_MMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      MM0,EAX
-        MOVD      MM1,EDX
-        MOVQ      MM2,MM0
-        PSUBUSB   MM0,MM1
-        PSUBUSB   MM1,MM2
-        POR       MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      MM0,ECX
-        MOVD      MM1,EDX
-        MOVQ      MM2,MM0
-        PSUBUSB   MM0,MM1
-        PSUBUSB   MM1,MM2
-        POR       MM0,MM1
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorExclusion_MMX(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        PXOR      MM2,MM2
-        MOVD      MM0,EAX
-        PUNPCKLBW MM0,MM2
-        MOVD      MM1,EDX
-        PUNPCKLBW MM1,MM2
-        MOVQ      MM3,MM0
-        PADDW     MM0,MM1
-        PMULLW    MM1,MM3
-        PSRLW     MM1,7
-        PSUBUSW   MM0,MM1
-        PACKUSWB  MM0,MM2
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        PXOR      MM2,MM2
-        MOVD      MM0,ECX
-        PUNPCKLBW MM0,MM2
-        MOVD      MM1,EDX
-        PUNPCKLBW MM1,MM2
-        MOVQ      MM3,MM0
-        PADDW     MM0,MM1
-        PMULLW    MM1,MM3
-        PSRLW     MM1,7
-        PSUBUSW   MM0,MM1
-        PACKUSWB  MM0,MM2
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-
-function ColorScale_MMX(C, W: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        PXOR      MM2,MM2
-        SHL       EDX,4
-        MOVD      MM0,EAX
-        PUNPCKLBW MM0,MM2
-        ADD       EDX,alpha_ptr
-        PMULLW    MM0,[EDX]
-        PSRLW     MM0,8
-        PACKUSWB  MM0,MM2
-        MOVD      EAX,MM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        PXOR      MM2,MM2
-        SHL       RDX,4
-        MOVD      MM0,ECX
-        PUNPCKLBW MM0,MM2
-        ADD       RDX,alpha_ptr
-        PMULLW    MM0,[RDX]
-        PSRLW     MM0,8
-        PACKUSWB  MM0,MM2
-        MOVD      EAX,MM0
-{$ENDIF}
-end;
-{$ENDIF}
-
-
-{ SSE2 versions }
-
-{$IFNDEF OMIT_SSE2}
-
-function BlendReg_SSE2(F, B: TColor32): TColor32;
-asm
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // EAX <- F
-  // EDX <- B
-  // Result := Fa * (Frgb - Brgb) + Brgb
-
-{$IFDEF TARGET_x86}
-        MOVD      XMM0,EAX
-        PXOR      XMM3,XMM3
-        MOVD      XMM2,EDX
-        PUNPCKLBW XMM0,XMM3
-        MOV       ECX,bias_ptr
-        PUNPCKLBW XMM2,XMM3
-        MOVQ      XMM1,XMM0
-        PSHUFLW   XMM1,XMM1, $FF
-        PSUBW     XMM0,XMM2
-        PSLLW     XMM2,8
-        PMULLW    XMM0,XMM1
-        PADDW     XMM2,[ECX]
-        PADDW     XMM2,XMM0
-        PSRLW     XMM2,8
-        PACKUSWB  XMM2,XMM3
-        MOVD      EAX,XMM2
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-        MOVD      XMM0,ECX
-        PXOR      XMM3,XMM3
-        MOVD      XMM2,EDX
-        PUNPCKLBW XMM0,XMM3
-        MOV       RAX,bias_ptr
-        PUNPCKLBW XMM2,XMM3
-        MOVQ      XMM1,XMM0
-        PSHUFLW   XMM1,XMM1, $FF
-        PSUBW     XMM0,XMM2
-        PSLLW     XMM2,8
-        PMULLW    XMM0,XMM1
-        PADDW     XMM2,[RAX]
-        PADDW     XMM2,XMM0
-        PSRLW     XMM2,8
-        PACKUSWB  XMM2,XMM3
-        MOVD      EAX,XMM2
-{$ENDIF}
-end;
-
-procedure BlendMem_SSE2(F: TColor32; var B: TColor32);
-asm
-{$IFDEF TARGET_x86}
-  // EAX - Color X
-  // [EDX] - Color Y
-  // Result := W * (X - Y) + Y
-
-        TEST      EAX,$FF000000
-        JZ        @1
-        CMP       EAX,$FF000000
-        JNC       @2
-
-        PXOR      XMM3,XMM3
-        MOVD      XMM0,EAX
-        MOVD      XMM2,[EDX]
-        PUNPCKLBW XMM0,XMM3
-        MOV       ECX,bias_ptr
-        PUNPCKLBW XMM2,XMM3
-        MOVQ      XMM1,XMM0
-        PSHUFLW   XMM1,XMM1, $FF
-        PSUBW     XMM0,XMM2
-        PSLLW     XMM2,8
-        PMULLW    XMM0,XMM1
-        PADDW     XMM2,[ECX]
-        PADDW     XMM2,XMM0
-        PSRLW     XMM2,8
-        PACKUSWB  XMM2,XMM3
-        MOVD      [EDX],XMM2
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [EDX], EAX
-@3:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX - Color X
-  // [EDX] - Color Y
-  // Result := W * (X - Y) + Y
-
-        TEST      ECX,$FF000000
-        JZ        @1
-        CMP       ECX,$FF000000
-        JNC       @2
-
-        PXOR      XMM3,XMM3
-        MOVD      XMM0,ECX
-        MOVD      XMM2,[RDX]
-        PUNPCKLBW XMM0,XMM3
-        MOV       RAX,bias_ptr
-        PUNPCKLBW XMM2,XMM3
-        MOVQ      XMM1,XMM0
-        PSHUFLW   XMM1,XMM1, $FF
-        PSUBW     XMM0,XMM2
-        PSLLW     XMM2,8
-        PMULLW    XMM0,XMM1
-        PADDW     XMM2,[RAX]
-        PADDW     XMM2,XMM0
-        PSRLW     XMM2,8
-        PACKUSWB  XMM2,XMM3
-        MOVD      [RDX],XMM2
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [RDX], ECX
-@3:
-{$ENDIF}
-end;
-
-function BlendRegEx_SSE2(F, B, M: TColor32): TColor32;
-asm
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // Result := M * Fa * (Frgb - Brgb) + Brgb
-
-{$IFDEF TARGET_x86}
-  // EAX <- F
-  // EDX <- B
-  // ECX <- M
-        PUSH      EBX
-        MOV       EBX,EAX
-        SHR       EBX,24
-        INC       ECX             // 255:256 range bias
-        IMUL      ECX,EBX
-        SHR       ECX,8
-        JZ        @1
-
-        PXOR      XMM0,XMM0
-        MOVD      XMM1,EAX
-        SHL       ECX,4
-        MOVD      XMM2,EDX
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-        ADD       ECX,alpha_ptr
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[ECX]
-        PSLLW     XMM2,8
-        MOV       ECX,bias_ptr
-        PADDW     XMM2,[ECX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      EAX,XMM1
-
-        POP       EBX
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV       EAX,EDX
-        POP       EBX
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // ECX <- F
-  // EDX <- B
-  // R8D <- M
-
-        MOV       EAX,ECX
-        SHR       EAX,24
-        INC       R8D             // 255:256 range bias
-        IMUL      R8D,EAX
-        SHR       R8D,8
-        JZ        @1
-
-        PXOR      XMM0,XMM0
-        MOVD      XMM1,ECX
-        SHL       R8D,4
-        MOVD      XMM2,EDX
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-        ADD       R8,alpha_ptr
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[R8]
-        PSLLW     XMM2,8
-        MOV       R8,bias_ptr
-        PADDW     XMM2,[R8]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      EAX,XMM1
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-
-@1:     MOV       EAX,EDX
-@2:
-{$ENDIF}
-end;
-
-procedure BlendMemEx_SSE2(F: TColor32; var B:TColor32; M: TColor32);
-asm
-{$IFDEF TARGET_x86}
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // EAX <- F
-  // [EDX] <- B
-  // ECX <- M
-  // Result := M * Fa * (Frgb - Brgb) + Brgb
-        TEST      EAX,$FF000000
-        JZ        @2
-
-        PUSH      EBX
-        MOV       EBX,EAX
-        SHR       EBX,24
-        INC       ECX             // 255:256 range bias
-        IMUL      ECX,EBX
-        SHR       ECX,8
-        JZ        @1
-
-        PXOR      XMM0,XMM0
-        MOVD      XMM1,EAX
-        SHL       ECX,4
-        MOVD      XMM2,[EDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-        ADD       ECX,alpha_ptr
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[ECX]
-        PSLLW     XMM2,8
-        MOV       ECX,bias_ptr
-        PADDW     XMM2,[ECX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      [EDX],XMM1
-
-@1:
-        POP       EBX
-
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_x64}
-  // blend foreground color (F) to a background color (B),
-  // using alpha channel value of F
-  // RCX <- F
-  // [RDX] <- B
-  // R8 <- M
-  // Result := M * Fa * (Frgb - Brgb) + Brgb
-
-        TEST      ECX, $FF000000
-        JZ        @1
-
-        MOV       R9D,ECX
-        SHR       R9D,24
-        INC       R8D            // 255:256 range bias
-        IMUL      R8D,R9D
-        SHR       R8D,8
-        JZ        @1
-
-        PXOR      XMM0,XMM0
-        MOVD      XMM1,ECX
-        SHL       R8D,4
-        MOVD      XMM2,[RDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-        ADD       R8,alpha_ptr
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[R8]
-        PSLLW     XMM2,8
-        MOV       R8,bias_ptr
-        PADDW     XMM2,[R8]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      DWORD PTR [RDX],XMM1
-@1:
-{$ENDIF}
-end;
-
-procedure BlendLine_SSE2(Src, Dst: PColor32; Count: Integer);
-asm
-{$IFDEF TARGET_X86}
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-        TEST      ECX,ECX
-        JZ        @4
-
-        PUSH      EBX
-
-        MOV       EBX,EAX
-
-@1:     MOV       EAX,[EBX]
-        TEST      EAX,$FF000000
-        JZ        @3
-        CMP       EAX,$FF000000
-        JNC       @2
-
-        MOVD      XMM0,EAX
-        PXOR      XMM3,XMM3
-        MOVD      XMM2,[EDX]
-        PUNPCKLBW XMM0,XMM3
-        MOV       EAX,bias_ptr
-        PUNPCKLBW XMM2,XMM3
-        MOVQ      XMM1,XMM0
-        PUNPCKLBW XMM1,XMM3
-        PUNPCKHWD XMM1,XMM1
-        PSUBW     XMM0,XMM2
-        PUNPCKHDQ XMM1,XMM1
-        PSLLW     XMM2,8
-        PMULLW    XMM0,XMM1
-        PADDW     XMM2,[EAX]
-        PADDW     XMM2,XMM0
-        PSRLW     XMM2,8
-        PACKUSWB  XMM2,XMM3
-        MOVD      EAX, XMM2
-
-@2:     MOV       [EDX],EAX
-
-@3:     ADD       EBX,4
-        ADD       EDX,4
-
-        DEC       ECX
-        JNZ       @1
-
-        POP       EBX
-
-@4:
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-  // ECX <- Src
-  // EDX <- Dst
-  // R8D <- Count
-
-        TEST      R8D,R8D
-        JZ        @4
-
-@1:     MOV       EAX,[RCX]
-        TEST      EAX,$FF000000
-        JZ        @3
-        CMP       EAX,$FF000000
-        JNC       @2
-
-        MOVD      XMM0,EAX
-        PXOR      XMM3,XMM3
-        MOVD      XMM2,[RDX]
-        PUNPCKLBW XMM0,XMM3
-        MOV       RAX,bias_ptr
-        PUNPCKLBW XMM2,XMM3
-        MOVQ      XMM1,XMM0
-        PUNPCKLBW XMM1,XMM3
-        PUNPCKHWD XMM1,XMM1
-        PSUBW     XMM0,XMM2
-        PUNPCKHDQ XMM1,XMM1
-        PSLLW     XMM2,8
-        PMULLW    XMM0,XMM1
-        PADDW     XMM2,[RAX]
-        PADDW     XMM2,XMM0
-        PSRLW     XMM2,8
-        PACKUSWB  XMM2,XMM3
-        MOVD      EAX, XMM2
-
-@2:     MOV       [RDX],EAX
-
-@3:     ADD       RCX,4
-        ADD       RDX,4
-
-        DEC       R8D
-        JNZ       @1
-
-@4:
-{$ENDIF}
-end;
-
-
-procedure BlendLineEx_SSE2(Src, Dst: PColor32; Count: Integer; M: TColor32);
-asm
-{$IFDEF TARGET_X86}
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-  // test the counter for zero or negativity
-        TEST      ECX,ECX
-        JS        @4
-
-        PUSH      ESI
-        PUSH      EDI
-        PUSH      EBX
-
-        MOV       ESI,EAX         // ESI <- Src
-        MOV       EDI,EDX         // EDI <- Dst
-        MOV       EDX,M           // EDX <- Master Alpha
-
-  // loop start
-@1:     MOV       EAX,[ESI]
-        TEST      EAX,$FF000000
-        JZ        @3             // complete transparency, proceed to next point
-        MOV       EBX,EAX
-        SHR       EBX,24
-        INC       EBX            // 255:256 range bias
-        IMUL      EBX,EDX
-        SHR       EBX,8
-        JZ        @3             // complete transparency, proceed to next point
-
-  // blend
-        PXOR      XMM0,XMM0
-        MOVD      XMM1,EAX
-        SHL       EBX,4
-        MOVD      XMM2,[EDI]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-        ADD       EBX,alpha_ptr
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[EBX]
-        PSLLW     XMM2,8
-        MOV       EBX,bias_ptr
-        PADDW     XMM2,[EBX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      EAX,XMM1
-
-@2:     MOV       [EDI],EAX
-
-@3:     ADD       ESI,4
-        ADD       EDI,4
-
-  // loop end
-        DEC       ECX
-        JNZ       @1
-
-        POP       EBX
-        POP       EDI
-        POP       ESI
-@4:
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-  // ECX <- Src
-  // EDX <- Dst
-  // R8D <- Count
-  // R9D <- M
-
-  // test the counter for zero or negativity
-        TEST      R8D,R8D
-        JS        @4
-        TEST      R9D,R9D
-        JZ        @4
-
-        MOV       R10,RCX         // ESI <- Src
-
-  // loop start
-@1:     MOV       ECX,[R10]
-        TEST      ECX,$FF000000
-        JZ        @3              // complete transparency, proceed to next point
-        MOV       EAX,ECX
-        SHR       EAX,24
-        INC       EAX             // 255:256 range bias
-        IMUL      EAX,R9D
-        SHR       EAX,8
-        JZ        @3              // complete transparency, proceed to next point
-
-  // blend
-        PXOR      XMM0,XMM0
-        MOVD      XMM1,ECX
-        SHL       EAX,4
-        MOVD      XMM2,[RDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-        ADD       RAX,alpha_ptr
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[RAX]
-        PSLLW     XMM2,8
-        MOV       RAX,bias_ptr
-        PADDW     XMM2,[RAX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      ECX,XMM1
-
-@2:     MOV       [RDX],ECX
-
-@3:     ADD       R10,4
-        ADD       RDX,4
-
-  // loop end
-        DEC       R8D
-        JNZ       @1
-@4:
-{$ENDIF}
-end;
-
-function CombineReg_SSE2(X, Y, W: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-  // EAX - Color X
-  // EDX - Color Y
-  // ECX - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        MOVD      XMM1,EAX
-        PXOR      XMM0,XMM0
-        SHL       ECX,4
-
-        MOVD      XMM2,EDX
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-
-        ADD       ECX,alpha_ptr
-
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[ECX]
-        PSLLW     XMM2,8
-
-        MOV       ECX,bias_ptr
-
-        PADDW     XMM2,[ECX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      EAX,XMM1
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-  // ECX - Color X
-  // EDX - Color Y
-  // R8D - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        MOVD      XMM1,ECX
-        PXOR      XMM0,XMM0
-        SHL       R8D,4
-
-        MOVD      XMM2,EDX
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-
-        ADD       R8,alpha_ptr
-
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[R8]
-        PSLLW     XMM2,8
-
-        MOV       R8,bias_ptr
-
-        PADDW     XMM2,[R8]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      EAX,XMM1
-{$ENDIF}
-end;
-
-procedure CombineMem_SSE2(F: TColor32; var B: TColor32; W: TColor32);
-asm
-{$IFDEF TARGET_X86}
-  // EAX - Color X
-  // [EDX] - Color Y
-  // ECX - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        JCXZ    @1
-
-        CMP       ECX,$FF
-        JZ        @2
-
-        MOVD      XMM1,EAX
-        PXOR      XMM0,XMM0
-
-        SHL       ECX,4
-
-        MOVD      XMM2,[EDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-
-        ADD       ECX,alpha_ptr
-
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[ECX]
-        PSLLW     XMM2,8
-
-        MOV       ECX,bias_ptr
-
-        PADDW     XMM2,[ECX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      [EDX],XMM1
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [EDX],EAX
-@3:
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-  // ECX - Color X
-  // [RDX] - Color Y
-  // R8D - Weight of X [0..255]
-  // Result := W * (X - Y) + Y
-
-        TEST      R8D,R8D            // Set flags for R8
-        JZ        @1                 // W = 0 ?  => Result := EDX
-        CMP       R8D,$FF
-        JZ        @2
-
-        MOVD      XMM1,ECX
-        PXOR      XMM0,XMM0
-
-        SHL       R8D,4
-
-        MOVD      XMM2,[RDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-
-        ADD       R8,alpha_ptr
-
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,[R8]
-        PSLLW     XMM2,8
-
-        MOV       RAX,bias_ptr
-
-        PADDW     XMM2,[RAX]
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      [RDX],XMM1
-
-{$IFDEF FPC}
-@1:     JMP @3
-{$ELSE}
-@1:     RET
-{$ENDIF}
-
-@2:     MOV       [RDX],ECX
-@3:
-{$ENDIF}
-end;
-
-
-procedure CombineLine_SSE2(Src, Dst: PColor32; Count: Integer; W: TColor32);
-asm
-{$IFDEF TARGET_X86}
-  // EAX <- Src
-  // EDX <- Dst
-  // ECX <- Count
-
-  // Result := W * (X - Y) + Y
-
-        TEST      ECX,ECX
-        JZ        @3
-
-        PUSH      EBX
-        MOV       EBX,W
-
-        TEST      EBX,EBX
-        JZ        @2
-
-        CMP       EBX,$FF
-        JZ        @4
-
-        SHL       EBX,4
-        ADD       EBX,alpha_ptr
-        MOVQ      XMM3,[EBX]
-        MOV       EBX,bias_ptr
-        MOVQ      XMM4,[EBX]
-
-@1:     MOVD      XMM1,[EAX]
-        PXOR      XMM0,XMM0
-        MOVD      XMM2,[EDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,XMM3
-        PSLLW     XMM2,8
-
-        PADDW     XMM2,XMM4
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      [EDX],XMM1
-
-        ADD       EAX,4
-        ADD       EDX,4
-
-        DEC       ECX
-        JNZ       @1
-
-@2:     POP       EBX
-        POP       EBP
-
-@3:     RET       $0004
-
-@4:     SHL       ECX,2
-        CALL      Move
-        POP       EBX
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-  // ECX <- Src
-  // EDX <- Dst
-  // R8D <- Count
-
-  // Result := W * (X - Y) + Y
-
-        TEST      R8D,R8D
-        JZ        @2
-
-        TEST      R9D,R9D
-        JZ        @2
-
-        CMP       R9D,$FF
-        JZ        @3
-
-        SHL       R9D,4
-        ADD       R9,alpha_ptr
-        MOVQ      XMM3,[R9]
-        MOV       R9,bias_ptr
-        MOVQ      XMM4,[R9]
-
-@1:     MOVD      XMM1,[RCX]
-        PXOR      XMM0,XMM0
-        MOVD      XMM2,[RDX]
-        PUNPCKLBW XMM1,XMM0
-        PUNPCKLBW XMM2,XMM0
-
-        PSUBW     XMM1,XMM2
-        PMULLW    XMM1,XMM3
-        PSLLW     XMM2,8
-
-        PADDW     XMM2,XMM4
-        PADDW     XMM1,XMM2
-        PSRLW     XMM1,8
-        PACKUSWB  XMM1,XMM0
-        MOVD      [RDX],XMM1
-
-        ADD       RCX,4
-        ADD       RDX,4
-
-        DEC       R8D
-        JNZ       @1
-
-{$IFDEF FPC}
-@2:     JMP @4
-{$ELSE}
-@2:     RET
-{$ENDIF}
-
-@3:     SHL       R8D,2
-        CALL      Move
-@4:
-{$ENDIF}
-end;
-
-function MergeReg_SSE2(F, B: TColor32): TColor32;
-asm
-  { This is an implementation of the merge formula, as described
-    in a paper by Bruce Wallace in 1981. Merging is associative,
-    that is, A over (B over C) = (A over B) over C. The formula is,
-
-      Ra = Fa + Ba - Fa * Ba
-      Rc = (Fa (Fc - Bc * Ba) + Bc * Ba) / Ra
-
-    where
-
-      Rc is the resultant color,
-      Ra is the resultant alpha,
-      Fc is the foreground color,
-      Fa is the foreground alpha,
-      Bc is the background color,
-      Ba is the background alpha.
-
-    Implementation:
-
-      Ra := 1 - (1 - Fa) * (1 - Ba);
-      Wa := Fa / Ra;
-      Rc := Bc + Wa * (Fc - Bc);
-      // Rc := Bc + Wa * (Fc - Bc)
-
-      (1 - Fa) * (1 - Ba) = 1 - Fa - Ba + Fa * Ba = (1 - Ra)
-  }
-
-{$IFDEF TARGET_X86}
-        TEST      EAX,$FF000000  // foreground completely transparent =>
-        JZ        @1             // result = background
-        CMP       EAX,$FF000000  // foreground completely opaque =>
-        JNC       @2             // result = foreground
-        TEST      EDX,$FF000000  // background completely transparent =>
-        JZ        @2             // result = foreground
-
-        PXOR      XMM7,XMM7       // XMM7  <-  00
-        MOVD      XMM0,EAX        // XMM0  <-  Fa Fr Fg Fb
-        SHR       EAX,24          //  EAX  <-  Fa
-        ROR       EDX,24
-        MOVZX     ECX,DL          //  ECX  <-  Ba
-        PUNPCKLBW XMM0,XMM7       // XMM0  <-  00 Fa 00 Fr 00 Fg 00 Fb
-        SUB       EAX,$FF         //  EAX  <-  (Fa - 1)
-        XOR       ECX,$FF         //  ECX  <-  (1 - Ba)
-        IMUL      ECX,EAX         //  ECX  <-  (Fa - 1) * (1 - Ba)  =  Ra - 1
-        IMUL      ECX,$8081       //  ECX  <-  Xa 00 00 00
-        ADD       ECX,$8081*$FF*$FF
-        SHR       ECX,15          //  ECX  <-  Ra
-        MOV       DL,CH           //  EDX  <-  Br Bg Bb Ra
-        ROR       EDX,8           //  EDX  <-  Ra Br Bg Bb
-        MOVD      XMM1,EDX        // XMM1  <-  Ra Br Bg Bb
-        PUNPCKLBW XMM1,XMM7       // XMM1  <-  00 Ra 00 Br 00 Bg 00 Bb
-        SHL       EAX,20          //  EAX  <-  Fa 00 00
-        PSUBW     XMM0,XMM1       // XMM0  <-  ** Da ** Dr ** Dg ** Db
-        ADD       EAX,$0FF01000
-        PSLLW     XMM0,4
-        XOR       EDX,EDX         //  EDX  <-  00
-        DIV       ECX             //  EAX  <-  Fa / Ra  =  Wa
-        MOVD      XMM4,EAX        // XMM3  <-  Wa
-        PSHUFLW   XMM4,XMM4,$C0   // XMM3  <-  00 00 ** Wa ** Wa ** Wa
-        PMULHW    XMM0,XMM4       // XMM0  <-  00 00 ** Pr ** Pg ** Pb
-        PADDW     XMM0,XMM1       // XMM0  <-  00 Ra 00 Rr 00 Rg 00 Rb
-        PACKUSWB  XMM0,XMM7       // XMM0  <-  Ra Rr Rg Rb
-        MOVD      EAX,XMM0
-
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-@1:     MOV       EAX,EDX
-@2:
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        TEST      ECX,$FF000000   // foreground completely transparent =>
-        JZ        @1              // result = background
-        MOV       EAX,ECX         //  EAX  <-  Fa
-        CMP       EAX,$FF000000   // foreground completely opaque =>
-        JNC       @2              // result = foreground
-        TEST      EDX,$FF000000   // background completely transparent =>
-        JZ        @2              // result = foreground
-
-        PXOR      XMM7,XMM7       // XMM7  <-  00
-        MOVD      XMM0,EAX        // XMM0  <-  Fa Fr Fg Fb
-        SHR       EAX,24          //  EAX  <-  Fa
-        ROR       EDX,24
-        MOVZX     ECX,DL          //  ECX  <-  Ba
-        PUNPCKLBW XMM0,XMM7       // XMM0  <-  00 Fa 00 Fr 00 Fg 00 Fb
-        SUB       EAX,$FF         //  EAX  <-  (Fa - 1)
-        XOR       ECX,$FF         //  ECX  <-  (1 - Ba)
-        IMUL      ECX,EAX         //  ECX  <-  (Fa - 1) * (1 - Ba)  =  Ra - 1
-        IMUL      ECX,$8081       //  ECX  <-  Xa 00 00 00
-        ADD       ECX,$8081*$FF*$FF
-        SHR       ECX,15          //  ECX  <-  Ra
-        MOV       DL,CH           //  EDX  <-  Br Bg Bb Ra
-        ROR       EDX,8           //  EDX  <-  Ra Br Bg Bb
-        MOVD      XMM1,EDX        // XMM1  <-  Ra Br Bg Bb
-        PUNPCKLBW XMM1,XMM7       // XMM1  <-  00 Ra 00 Br 00 Bg 00 Bb
-        SHL       EAX,20          //  EAX  <-  Fa 00 00
-        PSUBW     XMM0,XMM1       // XMM0  <-  ** Da ** Dr ** Dg ** Db
-        ADD       EAX,$0FF01000
-        PSLLW     XMM0,4
-        XOR       EDX,EDX         //  EDX  <-  00
-        DIV       ECX             //  EAX  <-  Fa / Ra  =  Wa
-        MOVD      XMM4,EAX        // XMM3  <-  Wa
-        PSHUFLW   XMM4,XMM4,$C0   // XMM3  <-  00 00 ** Wa ** Wa ** Wa
-        PMULHW    XMM0,XMM4       // XMM0  <-  00 00 ** Pr ** Pg ** Pb
-        PADDW     XMM0,XMM1       // XMM0  <-  00 Ra 00 Rr 00 Rg 00 Rb
-        PACKUSWB  XMM0,XMM7       // XMM0  <-  Ra Rr Rg Rb
-        MOVD      EAX,XMM0
-
-{$IFDEF FPC}
-        JMP @2
-{$ELSE}
-        RET
-{$ENDIF}
-@1:     MOV       EAX,EDX
-@2:
-{$ENDIF}
-end;
-
-procedure EMMS_SSE2;
-asm
-end;
-
-
-function LightenReg_SSE2(C: TColor32; Amount: Integer): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD    XMM0,EAX
-        TEST    EDX,EDX
-        JL      @1
-        IMUL    EDX,$010101
-        MOVD    XMM1,EDX
-        PADDUSB XMM0,XMM1
-        MOVD    EAX,XMM0
-        RET
-@1:     NEG     EDX
-        IMUL    EDX,$010101
-        MOVD    XMM1,EDX
-        PSUBUSB XMM0,XMM1
-        MOVD    EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD    XMM0,ECX
-        TEST    EDX,EDX
-        JL      @1
-        IMUL    EDX,$010101
-        MOVD    XMM1,EDX
-        PADDUSB XMM0,XMM1
-        MOVD    EAX,XMM0
-        RET
-@1:     NEG     EDX
-        IMUL    EDX,$010101
-        MOVD    XMM1,EDX
-        PSUBUSB XMM0,XMM1
-        MOVD    EAX,XMM0
-{$ENDIF}
-end;
-
-
-{ SSE2 Color algebra}
-
-function ColorAdd_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      XMM0,EAX
-        MOVD      XMM1,EDX
-        PADDUSB   XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      XMM0,ECX
-        MOVD      XMM1,EDX
-        PADDUSB   XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorSub_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      XMM0,EAX
-        MOVD      XMM1,EDX
-        PSUBUSB   XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      XMM0,ECX
-        MOVD      XMM1,EDX
-        PSUBUSB   XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorModulate_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        PXOR      XMM2,XMM2
-        MOVD      XMM0,EAX
-        PUNPCKLBW XMM0,XMM2
-        MOVD      XMM1,EDX
-        PUNPCKLBW XMM1,XMM2
-        PMULLW    XMM0,XMM1
-        PSRLW     XMM0,8
-        PACKUSWB  XMM0,XMM2
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        PXOR      XMM2,XMM2
-        MOVD      XMM0,ECX
-        PUNPCKLBW XMM0,XMM2
-        MOVD      XMM1,EDX
-        PUNPCKLBW XMM1,XMM2
-        PMULLW    XMM0,XMM1
-        PSRLW     XMM0,8
-        PACKUSWB  XMM0,XMM2
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorMax_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      XMM0,EAX
-        MOVD      XMM1,EDX
-        PMAXUB    XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      XMM0,ECX
-        MOVD      XMM1,EDX
-        PMAXUB    XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorMin_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      XMM0,EAX
-        MOVD      XMM1,EDX
-        PMINUB    XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      XMM0,ECX
-        MOVD      XMM1,EDX
-        PMINUB    XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorDifference_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        MOVD      XMM0,EAX
-        MOVD      XMM1,EDX
-        MOVQ      XMM2,XMM0
-        PSUBUSB   XMM0,XMM1
-        PSUBUSB   XMM1,XMM2
-        POR       XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        MOVD      XMM0,ECX
-        MOVD      XMM1,EDX
-        MOVQ      XMM2,XMM0
-        PSUBUSB   XMM0,XMM1
-        PSUBUSB   XMM1,XMM2
-        POR       XMM0,XMM1
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorExclusion_SSE2(C1, C2: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        PXOR      XMM2,XMM2
-        MOVD      XMM0,EAX
-        PUNPCKLBW XMM0,XMM2
-        MOVD      XMM1,EDX
-        PUNPCKLBW XMM1,XMM2
-        MOVQ      XMM3,XMM0
-        PADDW     XMM0,XMM1
-        PMULLW    XMM1,XMM3
-        PSRLW     XMM1,7
-        PSUBUSW   XMM0,XMM1
-        PACKUSWB  XMM0,XMM2
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        PXOR      XMM2,XMM2
-        MOVD      XMM0,ECX
-        PUNPCKLBW XMM0,XMM2
-        MOVD      XMM1,EDX
-        PUNPCKLBW XMM1,XMM2
-        MOVQ      XMM3,XMM0
-        PADDW     XMM0,XMM1
-        PMULLW    XMM1,XMM3
-        PSRLW     XMM1,7
-        PSUBUSW   XMM0,XMM1
-        PACKUSWB  XMM0,XMM2
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-function ColorScale_SSE2(C, W: TColor32): TColor32;
-asm
-{$IFDEF TARGET_X86}
-        PXOR      XMM2,XMM2
-        SHL       EDX,4
-        MOVD      XMM0,EAX
-        PUNPCKLBW XMM0,XMM2
-        ADD       EDX,alpha_ptr
-        PMULLW    XMM0,[EDX]
-        PSRLW     XMM0,8
-        PACKUSWB  XMM0,XMM2
-        MOVD      EAX,XMM0
-{$ENDIF}
-
-{$IFDEF TARGET_X64}
-        PXOR      XMM2,XMM2
-        SHL       RDX,4
-        MOVD      XMM0,ECX
-        PUNPCKLBW XMM0,XMM2
-        ADD       RDX,alpha_ptr
-        PMULLW    XMM0,[RDX]
-        PSRLW     XMM0,8
-        PACKUSWB  XMM0,XMM2
-        MOVD      EAX,XMM0
-{$ENDIF}
-end;
-
-{$ENDIF}
 {$ENDIF}
 
@@ -3744 +907 @@
 var
   I, J: Integer;
-const
-  OneByteth : Double = 1 / 255;
 begin
   for J := 0 to 255 do
-    for I := 0 to 255 do
+  begin
+    DivTable[0, J] := 0;
+    RcTable[0, J] := 0;
+  end;
+  for J := 0 to 255 do
+    for I := 1 to 255 do
     begin
-      DivTable[I, J] := Round(I * J * OneByteth);
-      if I > 0 then
-        RcTable[I, J] := Round(J * 255 / I)
-      else
-        RcTable[I, J] := 0;
+      DivTable[I, J] := Round(I * J * COne255th);
+      RcTable[I, J] := Round(J * 255 / I)
     end;
 end;
@@ -3763 +926 @@
   FID_MERGEMEM = 2;
   FID_MERGELINE = 3;
-  FID_MERGEREGEX = 4;
-  FID_MERGEMEMEX = 5;
-  FID_MERGELINEEX = 6;
-  FID_COMBINEREG = 7;
-  FID_COMBINEMEM = 8;
-  FID_COMBINELINE = 9;
-
-  FID_BLENDREG = 10;
-  FID_BLENDMEM = 11;
-  FID_BLENDLINE = 12;
-  FID_BLENDREGEX = 13;
-  FID_BLENDMEMEX = 14;
-  FID_BLENDLINEEX = 15;
-
-  FID_COLORMAX = 16;
-  FID_COLORMIN = 17;
-  FID_COLORAVERAGE = 18;
-  FID_COLORADD = 19;
-  FID_COLORSUB = 20;
-  FID_COLORDIV = 21;
-  FID_COLORMODULATE = 22;
-  FID_COLORDIFFERENCE = 23;
-  FID_COLOREXCLUSION = 24;
-  FID_COLORSCALE = 25;
-  FID_Lighten = 26;
+  FID_MERGELINE1 = 4;
+  FID_MERGEREGEX = 5;
+  FID_MERGEMEMEX = 6;
+  FID_MERGELINEEX = 7;
+  FID_COMBINEREG = 8;
+  FID_COMBINEMEM = 9;
+  FID_COMBINELINE = 10;
+
+  FID_BLENDREG = 11;
+  FID_BLENDMEM = 12;
+  FID_BLENDMEMS = 13;
+  FID_BLENDLINE = 14;
+  FID_BLENDREGEX = 15;
+  FID_BLENDMEMEX = 16;
+  FID_BLENDLINEEX = 17;
+  FID_BLENDLINE1 = 18;
+
+  FID_COLORMAX = 19;
+  FID_COLORMIN = 20;
+  FID_COLORAVERAGE = 21;
+  FID_COLORADD = 22;
+  FID_COLORSUB = 23;
+  FID_COLORDIV = 24;
+  FID_COLORMODULATE = 25;
+  FID_COLORDIFFERENCE = 26;
+  FID_COLOREXCLUSION = 27;
+  FID_COLORSCALE = 28;
+  FID_COLORSCREEN = 29;
+  FID_COLORDODGE = 30;
+  FID_COLORBURN = 31;
+  FID_BLENDCOLORADD = 32;
+  FID_BLENDCOLORMODULATE = 33;
+  FID_LIGHTEN = 34;
+
+  FID_BLENDREGRGB = 35;
+  FID_BLENDMEMRGB = 36;
+{$IFDEF TEST_BLENDMEMRGB128SSE4}
+  FID_BLENDMEMRGB128 = 37;
+{$ENDIF}
+
+const
+  BlendBindingFlagPascal = $0001;
+
 
 procedure RegisterBindings;
@@ -3807 +988 @@
   BlendRegistry.RegisterBinding(FID_BLENDREG, @@BlendReg);
   BlendRegistry.RegisterBinding(FID_BLENDMEM, @@BlendMem);
+  BlendRegistry.RegisterBinding(FID_BLENDMEMS, @@BlendMems);
   BlendRegistry.RegisterBinding(FID_BLENDLINE, @@BlendLine);
   BlendRegistry.RegisterBinding(FID_BLENDREGEX, @@BlendRegEx);
   BlendRegistry.RegisterBinding(FID_BLENDMEMEX, @@BlendMemEx);
   BlendRegistry.RegisterBinding(FID_BLENDLINEEX, @@BlendLineEx);
+  BlendRegistry.RegisterBinding(FID_BLENDLINE1, @@BlendLine1);
 
   BlendRegistry.RegisterBinding(FID_COLORMAX, @@ColorMax);
@@ -3822 +1005 @@
   BlendRegistry.RegisterBinding(FID_COLOREXCLUSION, @@ColorExclusion);
   BlendRegistry.RegisterBinding(FID_COLORSCALE, @@ColorScale);
+  BlendRegistry.RegisterBinding(FID_COLORSCREEN, @@ColorScreen);
+  BlendRegistry.RegisterBinding(FID_COLORDODGE, @@ColorDodge);
+  BlendRegistry.RegisterBinding(FID_COLORBURN, @@ColorBurn);
+
+  BlendRegistry.RegisterBinding(FID_BLENDCOLORADD, @@BlendColorAdd);
+  BlendRegistry.RegisterBinding(FID_BLENDCOLORMODULATE, @@BlendColorModulate);
 
   BlendRegistry.RegisterBinding(FID_LIGHTEN, @@LightenReg);
+  BlendRegistry.RegisterBinding(FID_BLENDREGRGB, @@BlendRegRGB);
+  BlendRegistry.RegisterBinding(FID_BLENDMEMRGB, @@BlendMemRGB);
+{$IFDEF TEST_BLENDMEMRGB128SSE4}
+  BlendRegistry.RegisterBinding(FID_BLENDMEMRGB128, @@BlendMemRGB128);
+{$ENDIF}
 
   // pure pascal
-  BlendRegistry.Add(FID_EMMS, @EMMS_Pas);
-  BlendRegistry.Add(FID_MERGEREG, @MergeReg_Pas);
-  BlendRegistry.Add(FID_MERGEMEM, @MergeMem_Pas);
-  BlendRegistry.Add(FID_MERGEMEMEX, @MergeMemEx_Pas);
-  BlendRegistry.Add(FID_MERGEREGEX, @MergeRegEx_Pas);
-  BlendRegistry.Add(FID_MERGELINE, @MergeLine_Pas);
-  BlendRegistry.Add(FID_MERGELINEEX, @MergeLineEx_Pas);
-  BlendRegistry.Add(FID_COLORDIV, @ColorDiv_Pas);
-  BlendRegistry.Add(FID_COLORAVERAGE, @ColorAverage_Pas);
-  BlendRegistry.Add(FID_COMBINEREG, @CombineReg_Pas);
-  BlendRegistry.Add(FID_COMBINEMEM, @CombineMem_Pas);
-  BlendRegistry.Add(FID_COMBINELINE, @CombineLine_Pas);
-  BlendRegistry.Add(FID_BLENDREG, @BlendReg_Pas);
-  BlendRegistry.Add(FID_BLENDMEM, @BlendMem_Pas);
-  BlendRegistry.Add(FID_BLENDLINE, @BlendLine_Pas);
-  BlendRegistry.Add(FID_BLENDREGEX, @BlendRegEx_Pas);
-  BlendRegistry.Add(FID_BLENDMEMEX, @BlendMemEx_Pas);
-  BlendRegistry.Add(FID_BLENDLINEEX, @BlendLineEx_Pas);
-  BlendRegistry.Add(FID_COLORMAX, @ColorMax_Pas);
-  BlendRegistry.Add(FID_COLORMIN, @ColorMin_Pas);
-  BlendRegistry.Add(FID_COLORADD, @ColorAdd_Pas);
-  BlendRegistry.Add(FID_COLORSUB, @ColorSub_Pas);
-  BlendRegistry.Add(FID_COLORMODULATE, @ColorModulate_Pas);
-  BlendRegistry.Add(FID_COLORDIFFERENCE, @ColorDifference_Pas);
-  BlendRegistry.Add(FID_COLOREXCLUSION, @ColorExclusion_Pas);
-  BlendRegistry.Add(FID_COLORSCALE, @ColorScale_Pas);
-  BlendRegistry.Add(FID_LIGHTEN, @LightenReg_Pas);
+  BlendRegistry.Add(FID_EMMS, @EMMS_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGEREG, @MergeReg_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGEMEM, @MergeMem_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGEMEMEX, @MergeMemEx_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGEREGEX, @MergeRegEx_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGELINE, @MergeLine_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGELINEEX, @MergeLineEx_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_MERGELINE1, @MergeLine1_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORDIV, @ColorDiv_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORAVERAGE, @ColorAverage_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COMBINEREG, @CombineReg_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COMBINEMEM, @CombineMem_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COMBINELINE, @CombineLine_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDREG, @BlendReg_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDMEM, @BlendMem_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDMEMS, @BlendMems_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDLINE, @BlendLine_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDREGEX, @BlendRegEx_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDMEMEX, @BlendMemEx_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDLINEEX, @BlendLineEx_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDLINE1, @BlendLine1_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORMAX, @ColorMax_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORMIN, @ColorMin_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORADD, @ColorAdd_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORSUB, @ColorSub_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORMODULATE, @ColorModulate_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORDIFFERENCE, @ColorDifference_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLOREXCLUSION, @ColorExclusion_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORSCALE, @ColorScale_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORSCREEN, @ColorScreen_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORDODGE, @ColorDodge_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_COLORBURN, @ColorBurn_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDCOLORADD, @BlendColorAdd_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDCOLORMODULATE, @BlendColorModulate_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_LIGHTEN, @LightenReg_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDREGRGB, @BlendRegRGB_Pas, [], BlendBindingFlagPascal);
+  BlendRegistry.Add(FID_BLENDMEMRGB, @BlendMemRGB_Pas, [], BlendBindingFlagPascal);
 
 {$IFNDEF PUREPASCAL}
@@ -3860 +1064 @@
   BlendRegistry.Add(FID_BLENDREG, @BlendReg_ASM, []);
   BlendRegistry.Add(FID_BLENDMEM, @BlendMem_ASM, []);
+  BlendRegistry.Add(FID_BLENDMEMS, @BlendMems_ASM, []);
   BlendRegistry.Add(FID_BLENDREGEX, @BlendRegEx_ASM, []);
   BlendRegistry.Add(FID_BLENDMEMEX, @BlendMemEx_ASM, []);
   BlendRegistry.Add(FID_BLENDLINE, @BlendLine_ASM, []);
-  BlendRegistry.Add(FID_LIGHTEN, @LightenReg_Pas, []);   // no ASM version available
+  BlendRegistry.Add(FID_BLENDLINE1, @BlendLine1_ASM, []);
+{$IFNDEF TARGET_x64}
+  BlendRegistry.Add(FID_MERGEREG, @MergeReg_ASM, []);
+{$ENDIF}
 {$IFNDEF OMIT_MMX}
   BlendRegistry.Add(FID_EMMS, @EMMS_MMX, [ciMMX]);
@@ -3884 +1092 @@
   BlendRegistry.Add(FID_COLORSCALE, @ColorScale_MMX, [ciMMX]);
   BlendRegistry.Add(FID_LIGHTEN, @LightenReg_MMX, [ciMMX]);
+  BlendRegistry.Add(FID_BLENDREGRGB, @BlendRegRGB_MMX, [ciMMX]);
+  BlendRegistry.Add(FID_BLENDMEMRGB, @BlendMemRGB_MMX, [ciMMX]);
 {$ENDIF}
 {$IFNDEF OMIT_SSE2}
@@ -3893 +1103 @@
   BlendRegistry.Add(FID_BLENDREG, @BlendReg_SSE2, [ciSSE2]);
   BlendRegistry.Add(FID_BLENDMEM, @BlendMem_SSE2, [ciSSE2]);
+  BlendRegistry.Add(FID_BLENDMEMS, @BlendMems_SSE2, [ciSSE2]);
   BlendRegistry.Add(FID_BLENDMEMEX, @BlendMemEx_SSE2, [ciSSE2]);
   BlendRegistry.Add(FID_BLENDLINE, @BlendLine_SSE2, [ciSSE2]);
@@ -3906 +1117 @@
   BlendRegistry.Add(FID_COLORSCALE, @ColorScale_SSE2, [ciSSE2]);
   BlendRegistry.Add(FID_LIGHTEN, @LightenReg_SSE2, [ciSSE]);
-{$ENDIF}
-{$IFNDEF TARGET_x64}
-  BlendRegistry.Add(FID_MERGEREG, @MergeReg_ASM, []);
+  BlendRegistry.Add(FID_BLENDREGRGB, @BlendRegRGB_SSE2, [ciSSE2]);
+  BlendRegistry.Add(FID_BLENDMEMRGB, @BlendMemRGB_SSE2, [ciSSE2]);
+{$IFDEF TEST_BLENDMEMRGB128SSE4}
+  BlendRegistry.Add(FID_BLENDMEMRGB128, @BlendMemRGB128_SSE4, [ciSSE2]);
+{$ENDIF}
 {$ENDIF}
 {$ENDIF}
@@ -3916 +1129 @@
 
 initialization
+  BlendColorAdd := BlendColorAdd_Pas;
+
   RegisterBindings;
   MakeMergeTables;
@@ -3929 +1144 @@
 finalization
 {$IFNDEF PUREPASCAL}
-{$IFNDEF OMIT_MMX}
-  if (ciMMX in CPUFeatures) then FreeAlphaTable;
-{$ENDIF}
+  if [ciMMX, ciSSE2] * CPUFeatures <> [] then
+    FreeAlphaTable;
 {$ENDIF}
 

GraphicTest/Packages/Graphics32/GR32_Compiler.inc

@@ -49 +49 @@
     COMPILERXE1  - Delphi XE
     COMPILERXE2  - Delphi XE2
+    COMPILERXE3  - Delphi XE3
+    COMPILERXE4  - Delphi XE4
+    COMPILERXE5  - Delphi XE5
+    COMPILERXE6  - Delphi XE6
+    COMPILERXE7  - Delphi XE7
+    COMPILERXE8  - Delphi XE8
+    COMPILERRX   - Delphi RX
+    COMPILERRX1  - Delphi RX1
+          COMPILERRX2  - Delphi RX2 (10.2 Tokyo)
+    COMPILERRX3  - Delphi RX3 (10.3 Rio)
 
 
@@ -66 +76 @@
 {$ENDIF}
 
+{$IFDEF VER_LATEST} // adjust for newer version (always use latest version)
+  {$DEFINE COMPILERRX3}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIRX3}
+  {$ELSE}
+    {$DEFINE BCBRX3}
+  {$ENDIF}
+  {$UNDEF VER_LATEST}
+{$ENDIF}
+
+{$IFDEF VER330}
+  {$DEFINE COMPILERRX3}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIRX3}
+  {$ELSE}
+    {$DEFINE BCBRX3}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER320}
+  {$DEFINE COMPILERRX2}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIRX2}
+  {$ELSE}
+    {$DEFINE BCBRX2}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER310}
+  {$DEFINE COMPILERRX1}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIRX1}
+  {$ELSE}
+    {$DEFINE BCBRX1}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER300}
+  {$DEFINE COMPILERRX}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIRX}
+  {$ELSE}
+    {$DEFINE BCBRX}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER290}
+  {$DEFINE COMPILERXE8}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIXE8}
+  {$ELSE}
+    {$DEFINE BCBXE8}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER280}
+  {$DEFINE COMPILERXE7}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIXE7}
+  {$ELSE}
+    {$DEFINE BCBXE7}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER270}
+  {$DEFINE COMPILERXE6}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIXE6}
+  {$ELSE}
+    {$DEFINE BCBXE6}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER260}
+  {$DEFINE COMPILERXE5}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIXE5}
+  {$ELSE}
+    {$DEFINE BCBXE5}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER250}
+  {$DEFINE COMPILERXE4}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIXE4}
+  {$ELSE}
+    {$DEFINE BCBXE4}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VER240}
+  {$DEFINE COMPILERXE3}
+  {$IFNDEF BCB}
+    {$DEFINE DELPHIXE3}
+  {$ELSE}
+    {$DEFINE BCBXE3}
+  {$ENDIF}
+{$ENDIF}
+
 {$IFDEF VER230}
   {$DEFINE COMPILERXE2}
   {$IFNDEF BCB}
-    {$DEFINE DELPHIXE1}
     {$DEFINE DELPHIXE2}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCBXE2}
   {$ENDIF}
 {$ENDIF}
@@ -81 +190 @@
     {$DEFINE DELPHIXE1}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCBXE1}
   {$ENDIF}
 {$ENDIF}
@@ -90 +199 @@
     {$DEFINE DELPHI2010}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCB14}
   {$ENDIF}
 {$ENDIF}
@@ -99 +208 @@
     {$DEFINE DELPHI2009}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCB12}
   {$ENDIF}
 {$ENDIF}
@@ -108 +217 @@
     {$DEFINE DELPHI2007}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCB11}
   {$ENDIF}
 {$ENDIF}
@@ -117 +226 @@
     {$DEFINE DELPHI2006}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCB10}
   {$ENDIF}
 {$ENDIF}
@@ -126 +235 @@
     {$DEFINE DELPHI2005}
   {$ELSE}
-    {$DEFINE BCB7}
+    {$DEFINE BCB8}
   {$ENDIF}
 {$ENDIF}
@@ -146 +255 @@
     {$DEFINE BCB6}
   {$ENDIF}
+{$ENDIF}
+
+{$IFDEF COMPILERRX3}
+  {$DEFINE COMPILERRX3_UP}
+  {$DEFINE COMPILERRX2_UP}
+  {$DEFINE COMPILERRX1_UP}
+  {$DEFINE COMPILERRX_UP}
+  {$DEFINE COMPILERXE8_UP}
+  {$DEFINE COMPILERXE7_UP}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERRX2}
+  {$DEFINE COMPILERRX2_UP}
+  {$DEFINE COMPILERRX1_UP}
+  {$DEFINE COMPILERRX_UP}
+  {$DEFINE COMPILERXE8_UP}
+  {$DEFINE COMPILERXE7_UP}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERRX1}
+  {$DEFINE COMPILERRX1_UP}
+  {$DEFINE COMPILERRX_UP}
+  {$DEFINE COMPILERXE8_UP}
+  {$DEFINE COMPILERXE7_UP}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERRX}
+  {$DEFINE COMPILERRX_UP}
+  {$DEFINE COMPILERXE8_UP}
+  {$DEFINE COMPILERXE7_UP}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERXE8}
+  {$DEFINE COMPILERXE8_UP}
+  {$DEFINE COMPILERXE7_UP}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERXE7}
+  {$DEFINE COMPILERXE7_UP}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERXE6}
+  {$DEFINE COMPILERXE6_UP}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERXE5}
+  {$DEFINE COMPILERXE5_UP}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERXE4}
+  {$DEFINE COMPILERXE4_UP}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
+{$ENDIF}
+
+{$IFDEF COMPILERXE3}
+  {$DEFINE COMPILERXE3_UP}
+  {$DEFINE COMPILERXE2_UP}
+  {$DEFINE COMPILERXE1_UP}
+  {$DEFINE COMPILER2010_UP}
+  {$DEFINE COMPILER2009_UP}
+  {$DEFINE COMPILER2007_UP}
+  {$DEFINE COMPILER2006_UP}
+  {$DEFINE COMPILER2005_UP}
+  {$DEFINE COMPILER7_UP}
+  {$DEFINE COMPILER6_UP}
 {$ENDIF}
 
@@ -223 +507 @@
   {$DEFINE PLATFORM_INDEPENDENT}
   {$MODE Delphi}
-  {$ASMMODE INTEL}
 {$ENDIF}
 
@@ -275 +558 @@
       // target is an Intel 80386 or later.
       {$DEFINE TARGET_x86}
+      {$ASMMODE INTEL}
     {$ENDIF}
 
@@ -280 +564 @@
       // target is a 64-bit processor (AMD or INTEL).
       {$DEFINE TARGET_x64}
+      {$ASMMODE INTEL}
     {$ENDIF}
 
@@ -293 +578 @@
     // target is a 64-bit processor (AMD or INTEL).
     {$DEFINE TARGET_x64}
+    {$ASMMODE INTEL}
+  {$ENDIF}
+
+  {$IFDEF CPUARM}
+    // target is an ARM processor.
+    {$DEFINE TARGET_ARM}
   {$ENDIF}
 {$ELSE}
@@ -338 +629 @@
 
 {$IFDEF COMPILERFPC}
-  {$DEFINE PUREPASCAL}
+  {-$DEFINE PUREPASCAL}
 {$ENDIF}
 
 {$IFDEF TARGET_x64}
   {-$DEFINE PUREPASCAL}
+{$ENDIF}
+
+{$IFDEF TARGET_ARM}
+  {$DEFINE PUREPASCAL}
+  {$DEFINE OMIT_MMX}
+  {$DEFINE OMIT_SSE2}
 {$ENDIF}
 
@@ -433 +730 @@
 {$R-}{$Q-}  // switch off overflow and range checking
 
-{$IFDEF COMPILER6}
+{$IFDEF COMPILER6_UP}
   {$DEFINE EXT_PROP_EDIT}
+{$ENDIF}
+
+{$IFDEF COMPILER2005_UP}
+  {$DEFINE HasParentBackground}
+{$ENDIF}
+
+{$IFDEF COMPILER2010_UP}
+  {$DEFINE SUPPORT_ENHANCED_RECORDS}
 {$ENDIF}
 
@@ -486 +791 @@
   {$DEFINE COMPILERXE2}
 {$ENDIF}
+
+{$IFDEF COMPILERXE3_UP}
+  {$DEFINE COMPILERXE3}
+{$ENDIF}
+
+{$IFDEF COMPILERXE4_UP}
+  {$DEFINE COMPILERXE4}
+{$ENDIF}
+
+{$IFDEF COMPILERXE5_UP}
+  {$DEFINE COMPILERXE5}
+{$ENDIF}
+
+{$IFDEF COMPILERXE6_UP}
+  {$DEFINE COMPILERXE6}
+{$ENDIF}
+
+{$IFDEF COMPILERXE7_UP}
+  {$DEFINE COMPILERXE7}
+{$ENDIF}
+
+{$IFDEF COMPILERXE8_UP}
+  {$DEFINE COMPILERXE8}
+{$ENDIF}
+
+{$IFDEF COMPILERRX_UP}
+  {$DEFINE COMPILERRX8}
+{$ENDIF}
+
+{$IFDEF COMPILERRX1_UP}
+  {$DEFINE COMPILERRX1}
+{$ENDIF}
+
+{$IFDEF COMPILERRX2_UP}
+  {$DEFINE COMPILERRX2}
+{$ENDIF}

GraphicTest/Packages/Graphics32/GR32_Containers.pas

@@ -40 +40 @@
 uses
 {$IFDEF FPC}
-  Types,
   {$IFDEF Windows}
   Windows,
+  {$ELSE}
+  Types,
   {$ENDIF}
 {$ELSE}
-  Windows,
+  Types, Windows,
 {$ENDIF}
   RTLConsts,
-  GR32, SysUtils, GR32_LowLevel, Classes, TypInfo;
+  GR32, SysUtils, Classes, TypInfo;
 
 const
@@ -180 +181 @@
     function First: TClass;
     function Last: TClass;
-    function Find(AClassName: string): TClass;
+    function Find(const AClassName: string): TClass;
     procedure GetClassNames(Strings: TStrings);
     procedure Insert(Index: Integer; AClass: TClass);
@@ -231 +232 @@
 implementation
 
+uses
+  GR32_LowLevel;
+
 procedure SmartAssign(Src, Dst: TPersistent; TypeKinds: TTypeKinds = tkProperties);
 var
@@ -247 +251 @@
     Count := GetPropList(Src.ClassInfo, TypeKinds, Props, False);
 
+    {$IFNDEF NEXTGEN}
     for I := 0 to Count - 1 do
     with Props^[I]^ do
@@ -262 +267 @@
         SetPropValue(Dst, string(Name), GetPropValue(Src, string(Name), True));
     end;
+    {$ENDIF}
   finally
     FreeMem(Props, Count * SizeOf(PPropInfo));
@@ -422 +428 @@
   I: Integer;
 begin
+{$IFDEF HAS_NATIVEINT}
+  BucketIndex := NativeUInt(Item) shr 8 and BUCKET_MASK; // KISS pointer hash(TM)
+{$ELSE}
   BucketIndex := Cardinal(Item) shr 8 and BUCKET_MASK; // KISS pointer hash(TM)
+{$ENDIF}
   // due to their randomness, pointers most commonly differ at byte 1, we use
   // this characteristic for our hash and just apply the mask to it.
@@ -444 +454 @@
 begin
   if not Exists(Item, BucketIndex, ItemIndex) then
+{$IFDEF FPC}
+    raise EListError.CreateFmt(SItemNotFound, [Item])
+{$ELSE}
+{$IFDEF HAS_NATIVEINT}
+    raise EListError.CreateFmt(SItemNotFound, [NativeInt(Item)])
+{$ELSE}
     raise EListError.CreateFmt(SItemNotFound, [Integer(Item)])
+{$ENDIF}
+{$ENDIF}
   else
     Result := FBuckets[BucketIndex].Items[ItemIndex].Data;
@@ -454 +472 @@
 begin
   if not Exists(Item, BucketIndex, ItemIndex) then
+{$IFDEF FPC}
+    raise EListError.CreateFmt(SItemNotFound, [Item])
+{$ELSE}
+{$IFDEF HAS_NATIVEINT}
+    raise EListError.CreateFmt(SItemNotFound, [NativeInt(Item)])
+{$ELSE}
     raise EListError.CreateFmt(SItemNotFound, [Integer(Item)])
+{$ENDIF}
+{$ENDIF}
   else
     FBuckets[BucketIndex].Items[ItemIndex].Data := Data;
@@ -644 +670 @@
 end;
 
-function TClassList.Find(AClassName: string): TClass;
+function TClassList.Find(const AClassName: string): TClass;
 var
   I: Integer;

GraphicTest/Packages/Graphics32/GR32_Dsgn_Bitmap.pas

@@ -43 +43 @@
 {$ELSE}
   Windows, ExtDlgs, ToolWin, Registry, ImgList, Consts, DesignIntf,
-DesignEditors, VCLEditors,
+  DesignEditors, VCLEditors,
 {$ENDIF}
   Forms, Controls, ComCtrls, ExtCtrls, StdCtrls, Graphics, Dialogs, Menus,
@@ -373 +373 @@
     BitmapEditor := TBitmap32Editor.Create(nil);
     try
+      {$IFDEF FPC}
+      BitmapEditor.Bitmap32 := TBitmap32(GetObjectValue);
+      {$ELSE}
       BitmapEditor.Bitmap32 := TBitmap32(Pointer(GetOrdValue));
+      {$ENDIF}
       if BitmapEditor.Execute then
       begin

GraphicTest/Packages/Graphics32/GR32_Dsgn_Color.pas

@@ -47 +47 @@
   Consts,
   DesignIntf, DesignEditors, VCLEditors,
-  Windows, Registry, Graphics, Dialogs, Forms,
+  Windows, Registry, Graphics, Dialogs, Forms, Controls,
 {$ENDIF}
   GR32, GR32_Image;
@@ -70 +70 @@
     procedure RemoveColor(const AName: string);
   end;
+
+{$IFDEF COMPILER2010_UP}
+  TColor32Dialog = class(TCommonDialog)
+  private
+    FColor: TColor32;
+    FCustomColors: TStrings;
+    procedure SetCustomColors(Value: TStrings);
+  public
+    function Execute(ParentWnd: HWND): Boolean; override;
+  published
+    property Color: TColor32 read FColor write FColor default clBlack32;
+    property CustomColors: TStrings read FCustomColors write SetCustomColors;
+    property Ctl3D default True;
+  end;
+{$ENDIF}
 
   { TColor32Property }
@@ -106 +121 @@
 
 implementation
+
+{$IFDEF COMPILER2010_UP}
+uses
+  GR32_Dsgn_ColorPicker;
+{$ENDIF}
 
 { TColorManager }
@@ -387 +407 @@
 
 
+{ TColor32Dialog }
+
+{$IFDEF COMPILER2010_UP}
+procedure TColor32Dialog.SetCustomColors(Value: TStrings);
+begin
+  FCustomColors.Assign(Value);
+end;
+
+function TColor32Dialog.Execute(ParentWnd: HWND): Boolean;
+var
+  ColorPicker: TFormColorPicker;
+begin
+  ColorPicker := TFormColorPicker.Create(nil);
+  try
+    ColorPicker.Color := FColor;
+    Result := ColorPicker.ShowModal = mrOK;
+    if Result then
+      FColor := ColorPicker.Color;
+  finally
+    ColorPicker.Free;
+  end;
+end;
+{$ENDIF}
+
+
 { TColor32Property }
 
@@ -392 +437 @@
 procedure TColor32Property.Edit;
 var
+{$IFDEF COMPILER2010_UP}
+  ColorDialog: TColor32Dialog;
+{$ELSE}
   ColorDialog: TColorDialog;
+{$ENDIF}
   IniFile: TRegIniFile;
 
@@ -427 +476 @@
 begin
   IniFile := nil;
+{$IFDEF COMPILER2010_UP}
+  ColorDialog := TColor32Dialog.Create(Application);
+{$ELSE}
   ColorDialog := TColorDialog.Create(Application);
+{$ENDIF}
   try
     GetCustomColors;
-    ColorDialog.Color := WinColor(GetOrdValue);
+    ColorDialog.Color := GetOrdValue;
     ColorDialog.HelpContext := 25010;
+{$IFNDEF COMPILER2010_UP}
     ColorDialog.Options := [cdShowHelp];
+{$ENDIF}
     if ColorDialog.Execute then
-      SetOrdValue(Cardinal(Color32(ColorDialog.Color)));
+      SetOrdValue(Cardinal(ColorDialog.Color));
     SaveCustomColors;
   finally
@@ -446 +501 @@
 begin
   Result := [paMultiSelect, {$IFDEF EXT_PROP_EDIT}paDialog,{$ENDIF} paValueList,
-  paRevertable];
+    paRevertable];
 end;
 

GraphicTest/Packages/Graphics32/GR32_ExtImage.pas

@@ -309 +309 @@
   FDest := Dst;
   FDstRect := DstRect;
-  Priority := tpNormal;
 {$IFDEF USETHREADRESUME}
   if not Suspended then Resume;

GraphicTest/Packages/Graphics32/GR32_Filters.pas

@@ -50 +50 @@
   Windows,
 {$ENDIF}
-  Classes, SysUtils, GR32, GR32_Blend, GR32_System, GR32_Bindings;
+  Classes, SysUtils, GR32;
 
 { Basic processing }
@@ -83 +83 @@
 
 uses
+  {$IFDEF COMPILERXE2_UP}Types, {$ENDIF} GR32_System, GR32_Bindings,
   GR32_Lowlevel;
 
@@ -89 +90 @@
   SEmptySource = 'The source is nil';
   SEmptyDestination = 'Destination is nil';
-  SNoInPlace = 'In-place operation is not supported here';
 
 type
@@ -115 +115 @@
     (@@LogicalMaskLineOr)
   );
-  
+
   LOGICAL_MASK_LINE_EX: array[TLogicalOperator] of ^TLogicalMaskLineEx = (
     (@@LogicalMaskLineXorEx),
@@ -181 +181 @@
   with Dst do
   begin
-    IntersectRect(SrcRect, SrcRect, Src.BoundsRect);
+    GR32.IntersectRect(SrcRect, SrcRect, Src.BoundsRect);
     if (SrcRect.Right < SrcRect.Left) or (SrcRect.Bottom < SrcRect.Top) then Exit;
 
@@ -187 +187 @@
     DstY := Clamp(DstY, 0, Height);
 
-    DstRect.TopLeft := Point(DstX, DstY);
+    DstRect.TopLeft := GR32.Point(DstX, DstY);
     DstRect.Right := DstX + SrcRect.Right - SrcRect.Left;
     DstRect.Bottom := DstY + SrcRect.Bottom - SrcRect.Top;
 
-    IntersectRect(DstRect, DstRect, BoundsRect);
-    IntersectRect(DstRect, DstRect, ClipRect);
+    GR32.IntersectRect(DstRect, DstRect, BoundsRect);
+    GR32.IntersectRect(DstRect, DstRect, ClipRect);
     if (DstRect.Right < DstRect.Left) or (DstRect.Bottom < DstRect.Top) then Exit;
 
@@ -480 +480 @@
   with Dst do
   begin
-    IntersectRect(SrcRect, SrcRect, Src.BoundsRect);
+    GR32.IntersectRect(SrcRect, SrcRect, Src.BoundsRect);
     if (SrcRect.Right < SrcRect.Left) or (SrcRect.Bottom < SrcRect.Top) then Exit;
 
@@ -486 +486 @@
     DstY := Clamp(DstY, 0, Height);
 
-    DstRect.TopLeft := Point(DstX, DstY);
+    DstRect.TopLeft := GR32.Point(DstX, DstY);
     DstRect.Right := DstX + SrcRect.Right - SrcRect.Left;
     DstRect.Bottom := DstY + SrcRect.Bottom - SrcRect.Top;
 
-    IntersectRect(DstRect, DstRect, Dst.BoundsRect);
-    IntersectRect(DstRect, DstRect, Dst.ClipRect);
-    if (DstRect.Right < DstRect.Left) or (DstRect.Bottom < DstRect.Top) then Exit;
-
+    GR32.IntersectRect(DstRect, DstRect, Dst.BoundsRect);
+    GR32.IntersectRect(DstRect, DstRect, Dst.ClipRect);
+    if (DstRect.Right < DstRect.Left) or (DstRect.Bottom < DstRect.Top) then
+      Exit;
 
     if not MeasuringMode then
@@ -530 +530 @@
   with ABitmap do
   begin
-    IntersectRect(ARect, ARect, BoundsRect);
-    IntersectRect(ARect, ARect, ClipRect);
+    GR32.IntersectRect(ARect, ARect, BoundsRect);
+    GR32.IntersectRect(ARect, ARect, ClipRect);
     if (ARect.Right < ARect.Left) or (ARect.Bottom < ARect.Top) then Exit;
 

GraphicTest/Packages/Graphics32/GR32_Geometry.pas

@@ -27 +27 @@
  * Michael Hansen <dyster_tid@hotmail.com>
  *
- * Portions created by the Initial Developers are Copyright (C) 2005-2009
+ * Portions created by the Initial Developers are Copyright (C) 2005-2012
  * the Initial Developers. All Rights Reserved.
  *
@@ -38 +38 @@
 
 uses
-  Math, GR32, GR32_Math;
+  Math, Types, GR32;
 
 type
-  PFixedVector = ^TFixedVector;
-  TFixedVector = TFixedPoint;
-
-  PFloatVector = ^TFloatVector;
-  TFloatVector = TFloatPoint;
-
-function Add(const V1, V2: TFloatVector): TFloatVector;  overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Add(const V: TFloatVector; Value: TFloat): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Sub(const V1, V2: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Sub(const V: TFloatVector; Value: TFloat): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Mul(const V1, V2: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Mul(const V: TFloatVector; Multiplier: TFloat): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Divide(const V: TFloatVector; Divisor: TFloat): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Divide(const V1, V2: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-
-function Combine(const V1, V2: TFloatVector; W: TFloat): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function AbsV(const V: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Neg(const V: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Average(const V1, V2: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Max(const V1, V2: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Min(const V1, V2: TFloatVector): TFloatVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-
-function Dot(const V1, V2: TFloatVector): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Distance(const V1, V2: TFloatVector): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function SqrDistance(const V1, V2: TFloatVector): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-
-// Fixed Overloads
-function Add(const V1, V2: TFixedVector): TFixedVector;  overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Add(const V: TFixedVector; Value: TFixed): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Sub(const V1, V2: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Sub(const V: TFixedVector; Value: TFixed): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Mul(const V1, V2: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Mul(const V: TFixedVector; Multiplier: TFixed): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Divide(const V: TFixedVector; Divisor: TFixed): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Divide(const V1, V2: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-
-function Combine(const V1, V2: TFixedVector; W: TFixed): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function AbsV(const V: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Neg(const V: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Average(const V1, V2: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Max(const V1, V2: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Min(const V1, V2: TFixedVector): TFixedVector; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-
-function Dot(const V1, V2: TFixedVector): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function Distance(const V1, V2: TFixedVector): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
-function SqrDistance(const V1, V2: TFixedVector): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+  TLinePos = (lpStart, lpEnd, lpBoth, lpNeither);
+
+// TFloat Overloads
+function Average(const V1, V2: TFloatPoint): TFloatPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function CrossProduct(V1, V2: TFloatPoint): TFloat; overload; {$IFDEF USEINLINING} inline; {$ENDIF}
+function Dot(const V1, V2: TFloatPoint): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Distance(const V1, V2: TFloatPoint): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function SqrDistance(const V1, V2: TFloatPoint): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function GetPointAtAngleFromPoint(const Pt: TFloatPoint; const Dist, Radians: Single): TFloatPoint; overload;
+function GetAngleOfPt2FromPt1(const Pt1, Pt2: TFloatPoint): Single; overload;
+function GetUnitNormal(const Pt1, Pt2: TFloatPoint): TFloatPoint; overload;
+function GetUnitVector(const Pt1, Pt2: TFloatPoint): TFloatPoint; overload;
+function OffsetPoint(const Pt: TFloatPoint; DeltaX, DeltaY: TFloat): TFloatPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetPoint(const Pt, Delta: TFloatPoint): TFloatPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetRect(const Rct: TFloatRect; const DeltaX, DeltaY: TFloat): TFloatRect; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetRect(const Rct: TFloatRect; const Delta: TFloatPoint): TFloatRect; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Shorten(const Pts: TArrayOfFloatPoint;
+  Delta: TFloat; LinePos: TLinePos): TArrayOfFloatPoint; overload;
+function PointInPolygon(const Pt: TFloatPoint; const Pts: TArrayOfFloatPoint): Boolean; overload;
+function SegmentIntersect(const P1, P2, P3, P4: TFloatPoint;
+  out IntersectPoint: TFloatPoint): Boolean; overload;
+function PerpendicularDistance(const P, P1, P2: TFloatPoint): TFloat; overload;
+
+
+// TFixed Overloads
+function Average(const V1, V2: TFixedPoint): TFixedPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function CrossProduct(V1, V2: TFixedPoint): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Dot(const V1, V2: TFixedPoint): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Distance(const V1, V2: TFixedPoint): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function SqrDistance(const V1, V2: TFixedPoint): TFixed; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function GetPointAtAngleFromPoint(const Pt: TFixedPoint; const Dist, Radians: Single): TFixedPoint; overload;
+function GetAngleOfPt2FromPt1(Pt1, Pt2: TFixedPoint): Single; overload;
+function GetUnitVector(const Pt1, Pt2: TFixedPoint): TFloatPoint; overload;
+function GetUnitNormal(const Pt1, Pt2: TFixedPoint): TFloatPoint; overload;
+function OffsetPoint(const Pt: TFixedPoint; DeltaX, DeltaY: TFixed): TFixedPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetPoint(const Pt: TFixedPoint; DeltaX, DeltaY: TFloat): TFixedPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetPoint(const Pt: TFixedPoint; const Delta: TFixedPoint): TFixedPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetPoint(const Pt: TFixedPoint; const Delta: TFloatPoint): TFixedPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetRect(const Rct: TFixedRect; const DeltaX, DeltaY: TFixed): TFixedRect; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetRect(const Rct: TFixedRect; const DeltaX, DeltaY: TFloat): TFixedRect; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetRect(const Rct: TFixedRect; const Delta: TFixedPoint): TFixedRect; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetRect(const Rct: TFixedRect; const Delta: TFloatPoint): TFixedRect; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Shorten(const Pts: TArrayOfFixedPoint;
+  Delta: TFloat; LinePos: TLinePos): TArrayOfFixedPoint; overload;
+function PointInPolygon(const Pt: TFixedPoint; const Pts: array of TFixedPoint): Boolean; overload;
+function SegmentIntersect(const P1, P2, P3, P4: TFixedPoint;
+  out IntersectPoint: TFixedPoint): Boolean; overload;
+function PerpendicularDistance(const P, P1, P2: TFixedPoint): TFixed; overload;
+
+// Integer Overloads
+function Average(const V1, V2: TPoint): TPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function CrossProduct(V1, V2: TPoint): Integer; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Dot(const V1, V2: TPoint): Integer; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function Distance(const V1, V2: TPoint): TFloat; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function SqrDistance(const V1, V2: TPoint): Integer; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetPoint(const Pt: TPoint; DeltaX, DeltaY: Integer): TPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function OffsetPoint(const Pt, Delta: TPoint): TPoint; overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+function PerpendicularDistance(const P, P1, P2: TPoint): TFloat; overload;
+
+const
+  CRad01 = Pi / 180;
+  CRad30 = Pi / 6;
+  CRad45 = Pi / 4;
+  CRad60 = Pi / 3;
+  CRad90 = Pi / 2;
+  CRad180 = Pi;
+  CRad270 = CRad90 * 3;
+  CRad360 = CRad180 * 2;
+  CDegToRad = Pi / 180;
+  CRadToDeg = 180 / Pi;
 
 implementation
 
-function Add(const V1, V2: TFloatVector): TFloatVector;
-begin
-  Result.X := V1.X + V2.X;
-  Result.Y := V1.Y + V2.Y;
-end;
-
-function Add(const V: TFloatVector; Value: TFloat): TFloatVector;
-begin
-  Result.X := V.X + Value;
-  Result.Y := V.Y + Value;
-end;
-
-function Sub(const V1, V2: TFloatVector): TFloatVector;
-begin
-  Result.X := V1.X - V2.X;
-  Result.Y := V1.Y - V2.Y;
-end;
-
-function Sub(const V: TFloatVector; Value: TFloat): TFloatVector;
-begin
-  Result.X := V.X - Value;
-  Result.Y := V.Y - Value;
-end;
-
-function Mul(const V1, V2: TFloatVector): TFloatVector;
-begin
-  Result.X := V1.X * V2.X;
-  Result.Y := V1.Y * V2.Y;
-end;
-
-function Mul(const V: TFloatVector; Multiplier: TFloat): TFloatVector;
-begin
-  Result.X := V.X * Multiplier;
-  Result.Y := V.Y * Multiplier;
-end;
-
-function Divide(const V: TFloatVector; Divisor: TFloat): TFloatVector;
-begin
-  Divisor := 1 / Divisor;
-  Result.X := V.X * Divisor;
-  Result.Y := V.Y * Divisor;
-end;
-
-function Divide(const V1, V2: TFloatVector): TFloatVector;
-begin
-  Result.X := V1.X / V2.X;
-  Result.Y := V1.Y / V2.Y;
-end;
-
-function Combine(const V1, V2: TFloatVector; W: TFloat): TFloatVector;
-begin
-  Result.X := V2.X + (V1.X - V2.X) * W;
-  Result.Y := V2.Y + (V1.Y - V2.Y) * W;
-end;
-
-function AbsV(const V: TFloatVector): TFloatVector;
-begin
-  Result.X := System.Abs(V.X);
-  Result.Y := System.Abs(V.Y);
-end;
-
-function Neg(const V: TFloatVector): TFloatVector;
-begin
-  Result.X := - V.X;
-  Result.Y := - V.Y;
-end;
-
-function Average(const V1, V2: TFloatVector): TFloatVector;
+uses
+  GR32_Math;
+
+function Average(const V1, V2: TFloatPoint): TFloatPoint;
 begin
   Result.X := (V1.X + V2.X) * 0.5;
@@ -163 +123 @@
 end;
 
-function Max(const V1, V2: TFloatVector): TFloatVector;
-begin
-  Result := V1;
-  if V2.X > V1.X then Result.X := V2.X;
-  if V2.Y > V1.Y then Result.Y := V2.Y;
-end;
-
-function Min(const V1, V2: TFloatVector): TFloatVector;
-begin
-  Result := V1;
-  if V2.X < V1.X then Result.X := V2.X;
-  if V2.Y < V1.Y then Result.Y := V2.Y;
-end;
-
-function Dot(const V1, V2: TFloatVector): TFloat;
+function CrossProduct(V1, V2: TFloatPoint): TFloat;
+begin
+  Result := V1.X * V2.Y - V1.Y * V2.X;
+end;
+
+function Dot(const V1, V2: TFloatPoint): TFloat;
 begin
   Result := V1.X * V2.X + V1.Y * V2.Y;
 end;
 
-function Distance(const V1, V2: TFloatVector): TFloat;
-begin
-  Result := Hypot(V2.X - V1.X, V2.Y - V1.Y);
-end;
-
-function SqrDistance(const V1, V2: TFloatVector): TFloat;
+function Distance(const V1, V2: TFloatPoint): TFloat;
+begin
+  Result := GR32_Math.Hypot(V2.X - V1.X, V2.Y - V1.Y);
+end;
+
+function SqrDistance(const V1, V2: TFloatPoint): TFloat;
 begin
   Result := Sqr(V2.X - V1.X) + Sqr(V2.Y - V1.Y);
 end;
 
+function GetPointAtAngleFromPoint(const Pt: TFloatPoint;
+  const Dist, Radians: TFloat): TFloatPoint; overload;
+var
+  SinAng, CosAng: TFloat;
+begin
+  GR32_Math.SinCos(Radians, SinAng, CosAng);
+  Result.X :=  Dist * CosAng + Pt.X;
+  Result.Y := -Dist * SinAng + Pt.Y; // Y axis is positive down
+end;
+
+function GetAngleOfPt2FromPt1(const Pt1, Pt2: TFloatPoint): Single;
+var
+  X, Y: TFloat;
+begin
+  X := Pt2.X - Pt1.X;
+  Y := Pt2.Y - Pt1.Y;
+  if X = 0 then
+  begin
+    if Y > 0 then Result := CRad270 else Result := CRad90;
+  end else
+  begin
+    Result := ArcTan2(-Y, X);
+    if Result < 0 then Result := Result + CRad360;
+  end;
+end;
+
+function GetUnitVector(const Pt1, Pt2: TFloatPoint): TFloatPoint;
+var
+  Delta: TFloatPoint;
+  Temp: TFloat;
+begin
+  Delta.X := (Pt2.X - Pt1.X);
+  Delta.Y := (Pt2.Y - Pt1.Y);
+  if (Delta.X = 0) and (Delta.Y = 0) then
+    Result := FloatPoint(0, 0)
+  else
+  begin
+    Temp := 1 / GR32_Math.Hypot(Delta.X, Delta.Y);
+    Result.X := Delta.X * Temp;
+    Result.Y := Delta.Y * Temp;
+  end;
+end;
+
+function GetUnitNormal(const Pt1, Pt2: TFloatPoint): TFloatPoint;
+var
+  Delta: TFloatPoint;
+  Temp: TFloat;
+begin
+  Delta.X := (Pt2.X - Pt1.X);
+  Delta.Y := (Pt2.Y - Pt1.Y);
+
+  if (Delta.X = 0) and (Delta.Y = 0) then
+    Result := FloatPoint(0, 0)
+  else
+  begin
+    Temp := 1 / GR32_Math.Hypot(Delta.X, Delta.Y);
+    Delta.X := Delta.X * Temp;
+    Delta.Y := Delta.Y * Temp;
+  end;
+  Result.X :=  Delta.Y; // ie perpendicular to
+  Result.Y := -Delta.X; // the unit vector
+end;
+
+function OffsetPoint(const Pt: TFloatPoint; DeltaX, DeltaY: TFloat): TFloatPoint;
+begin
+  Result.X := Pt.X + DeltaX;
+  Result.Y := Pt.Y + DeltaY;
+end;
+
+function OffsetPoint(const Pt, Delta: TFloatPoint): TFloatPoint;
+begin
+  Result.X := Pt.X + Delta.X;
+  Result.Y := Pt.Y + Delta.Y;
+end;
+
+function OffsetRect(const Rct: TFloatRect; const DeltaX, DeltaY: TFloat): TFloatRect;
+begin
+  Result.TopLeft := OffsetPoint(Rct.TopLeft, DeltaX, DeltaY);
+  Result.BottomRight := OffsetPoint(Rct.BottomRight, DeltaX, DeltaY);
+end;
+
+function OffsetRect(const Rct: TFloatRect; const Delta: TFloatPoint): TFloatRect;
+begin
+  Result.TopLeft := OffsetPoint(Rct.TopLeft, Delta);
+  Result.BottomRight := OffsetPoint(Rct.BottomRight, Delta);
+end;
+
+
+function Shorten(const Pts: TArrayOfFloatPoint;
+  Delta: TFloat; LinePos: TLinePos): TArrayOfFloatPoint;
+var
+  Index, HighI: integer;
+  Dist, DeltaSqr: TFloat;
+  UnitVec: TFloatPoint;
+
+  procedure FixStart;
+  begin
+    Index := 1;
+    while (Index < HighI) and (SqrDistance(Pts[Index], Pts[0]) < DeltaSqr) do
+      Inc(Index);
+    UnitVec := GetUnitVector(Pts[Index], Pts[0]);
+    Dist := Distance(Pts[Index], Pts[0]) - Delta;
+    if Index > 1 then
+    begin
+      HighI := HighI - Index + 1;
+      Move(Result[Index], Result[1], SizeOf(TFloatPoint) * HighI);
+      SetLength(Result, HighI + 1);
+    end;
+    Result[0] := OffsetPoint(Result[1], UnitVec.X * Dist, UnitVec.Y * Dist);
+  end;
+
+  procedure FixEnd;
+  begin
+    Index := HighI - 1;
+    while (Index > 0) and (SqrDistance(Pts[Index],Pts[HighI]) < DeltaSqr) do
+      Dec(Index);
+    UnitVec := GetUnitVector(Pts[Index],Pts[HighI]);
+    Dist := Distance(Pts[Index], Pts[HighI]) - Delta;
+    if Index + 1 < HighI then SetLength(Result, Index + 2);
+    Result[Index + 1] := OffsetPoint(Result[Index], UnitVec.X * Dist, UnitVec.Y * Dist);
+  end;
+
+begin
+  Result := Pts;
+  HighI := High(Pts);
+  DeltaSqr := Delta * Delta;
+  if HighI < 1 then Exit;
+
+  case LinePos of
+    lpStart: FixStart;
+    lpEnd  : FixEnd;
+    lpBoth : begin FixStart; FixEnd; end;
+  end;
+end;
+
+function PointInPolygon(const Pt: TFloatPoint; const Pts: TArrayOfFloatPoint): Boolean;
+var
+  Index: Integer;
+  iPt, jPt: PFloatPoint;
+begin
+  Result := False;
+  iPt := @Pts[0];
+  jPt := @Pts[High(Pts)];
+  for Index := 0 to High(Pts) do
+  begin
+    Result := Result xor (((Pt.Y >= iPt.Y) xor (Pt.Y >= jPt.Y)) and
+      ((Pt.X - iPt.X) < ((jPt.X - iPt.X) * (Pt.Y -iPt.Y) / (jPt.Y - iPt.Y))));
+    jPt := iPt;
+    Inc(iPt);
+  end;
+end;
+
+function SegmentIntersect(const P1, P2, P3, P4: TFloatPoint;
+  out IntersectPoint: TFloatPoint): Boolean;
+var
+  m1, b1, m2, b2: TFloat;
+begin
+  // see http://astronomy.swin.edu.au/~pbourke/geometry/lineline2d/
+  Result := False;
+  if (P2.X = P1.X) then
+  begin
+    if (P4.X = P3.X) then Exit; // parallel lines
+    m2 := (P4.Y - P3.Y) / (P4.X - P3.X);
+    b2 := P3.Y - m2 * P3.X;
+    IntersectPoint.X := P1.X;
+    IntersectPoint.Y := m2 * P1.X + b2;
+    Result := (((IntersectPoint.Y < P2.Y) = (IntersectPoint.Y > P1.Y)) or
+      (IntersectPoint.Y = P2.Y) or (IntersectPoint.Y = P1.Y)) and
+      (((IntersectPoint.Y < P3.Y) = (IntersectPoint.Y > P4.Y)) or
+      (IntersectPoint.Y = P3.Y) or (IntersectPoint.Y = P4.Y));
+  end
+  else if (P4.X = P3.X) then
+  begin
+    m1 := (P2.Y - P1.Y) / (P2.X - P1.X);
+    b1 := P1.Y - m1 * P1.X;
+    IntersectPoint.X := P3.X;
+    IntersectPoint.Y := m1 * P3.X + b1;
+    Result := (((IntersectPoint.Y < P2.Y) = (IntersectPoint.Y > P1.Y)) or
+      (IntersectPoint.Y = P2.Y) or (IntersectPoint.Y = P1.Y)) and
+      (((IntersectPoint.Y < P3.Y) = (IntersectPoint.Y > P4.Y)) or
+      (IntersectPoint.Y = P3.Y) or (IntersectPoint.Y = P4.Y));
+  end else
+  begin
+    m1 := (P2.Y - P1.Y) / (P2.X - P1.X);
+    b1 := P1.Y - m1 * P1.X;
+    m2 := (P4.Y - P3.Y) / (P4.X - P3.X);
+    b2 := P3.Y - m2 * P3.X;
+    if m1 = m2 then Exit; // parallel lines
+    IntersectPoint.X := (b2 - b1) / (m1 - m2);
+    IntersectPoint.Y := m1 * IntersectPoint.X + b1;
+    Result := (((IntersectPoint.X < P2.X) = (IntersectPoint.X > P1.X)) or
+      (IntersectPoint.X = P2.X) or (IntersectPoint.X = P1.X)) and
+      (((IntersectPoint.X < P3.X) = (IntersectPoint.X > P4.X)) or
+      (IntersectPoint.X = P3.X) or (IntersectPoint.X = P4.X));
+  end;
+end;
+
+function PerpendicularDistance(const P, P1, P2: TFloatPoint): TFloat;
+begin
+  Result := Abs((P.x - P2.x) * (P1.y - P2.y) - (P.y - P2.y) * (P1.x - P2.x)) /
+    GR32_Math.Hypot(P1.x - P2.x, P1.y - P2.y);
+end;
+
+
 // Fixed overloads
 
-function Add(const V1, V2: TFixedVector): TFixedVector;
-begin
-  Result.X := V1.X + V2.X;
-  Result.Y := V1.Y + V2.Y;
-end;
-
-function Add(const V: TFixedVector; Value: TFixed): TFixedVector;
-begin
-  Result.X := V.X + Value;
-  Result.Y := V.Y + Value;
-end;
-
-function Sub(const V1, V2: TFixedVector): TFixedVector;
-begin
-  Result.X := V1.X - V2.X;
-  Result.Y := V1.Y - V2.Y;
-end;
-
-function Sub(const V: TFixedVector; Value: TFixed): TFixedVector;
-begin
-  Result.X := V.X - Value;
-  Result.Y := V.Y - Value;
-end;
-
-function Mul(const V1, V2: TFixedVector): TFixedVector;
-begin
-  Result.X := FixedMul(V1.X, V2.X);
-  Result.Y := FixedMul(V1.Y, V2.Y);
-end;
-
-function Mul(const V: TFixedVector; Multiplier: TFixed): TFixedVector;
-begin
-  Result.X := FixedMul(V.X, Multiplier);
-  Result.Y := FixedMul(V.Y, Multiplier);
-end;
-
-function Divide(const V: TFixedVector; Divisor: TFixed): TFixedVector;
-var
-  D: TFloat;
-begin
-  D := FIXEDONE / Divisor;
-  Result.X := Round(V.X * D);
-  Result.Y := Round(V.Y * D);
-end;
-
-function Divide(const V1, V2: TFixedVector): TFixedVector;
-begin
-  Result.X := FixedDiv(V1.X, V2.X);
-  Result.Y := FixedDiv(V1.Y, V2.Y);
-end;
-
-function Combine(const V1, V2: TFixedVector; W: TFixed): TFixedVector;
-begin
-  Result.X := V2.X + FixedMul(V1.X - V2.X, W);
-  Result.Y := V2.Y + FixedMul(V1.Y - V2.Y, W);
-end;
-
-function AbsV(const V: TFixedVector): TFixedVector;
-begin
-  Result.X := System.Abs(V.X);
-  Result.Y := System.Abs(V.Y);
-end;
-
-function Neg(const V: TFixedVector): TFixedVector;
-begin
-  Result.X := - V.X;
-  Result.Y := - V.Y;
-end;
-
-function Average(const V1, V2: TFixedVector): TFixedVector;
+function Average(const V1, V2: TFixedPoint): TFixedPoint;
 begin
   Result.X := (V1.X + V2.X) div 2;
@@ -269 +355 @@
 end;
 
-function Max(const V1, V2: TFixedVector): TFixedVector;
-begin
-  Result := V1;
-  if V2.X > V1.X then Result.X := V2.X;
-  if V2.Y > V1.Y then Result.Y := V2.Y;
-end;
-
-function Min(const V1, V2: TFixedVector): TFixedVector;
-begin
-  Result := V1;
-  if V2.X < V1.X then Result.X := V2.X;
-  if V2.Y < V1.Y then Result.Y := V2.Y;
-end;
-
-function Dot(const V1, V2: TFixedVector): TFixed;
+function CrossProduct(V1, V2: TFixedPoint): TFixed;
+begin
+  Result := FixedMul(V1.X, V2.Y) - FixedMul(V1.Y, V2.X);
+end;
+
+function Dot(const V1, V2: TFixedPoint): TFixed;
 begin
   Result := FixedMul(V1.X, V2.X) + FixedMul(V1.Y, V2.Y);
 end;
 
-function Distance(const V1, V2: TFixedVector): TFixed;
-begin
-  Result := Fixed(Hypot((V2.X - V1.X) * FixedToFloat, (V2.Y - V1.Y) * FixedToFloat));
-end;
-
-function SqrDistance(const V1, V2: TFixedVector): TFixed;
+function Distance(const V1, V2: TFixedPoint): TFixed;
+begin
+  Result :=
+    Fixed(Hypot((V2.X - V1.X) * FixedToFloat, (V2.Y - V1.Y) * FixedToFloat));
+end;
+
+function SqrDistance(const V1, V2: TFixedPoint): TFixed;
 begin
   Result := FixedSqr(V2.X - V1.X) + FixedSqr(V2.Y - V1.Y);
 end;
 
+function GetPointAtAngleFromPoint(const Pt: TFixedPoint;
+  const Dist, Radians: TFloat): TFixedPoint;
+var
+  SinAng, CosAng: TFloat;
+begin
+  GR32_Math.SinCos(Radians, SinAng, CosAng);
+  Result.X := Round(Dist * CosAng * FixedOne) + Pt.X;
+  Result.Y := -Round(Dist * SinAng * FixedOne) + Pt.Y; // Y axis is positive down
+end;
+
+function GetAngleOfPt2FromPt1(Pt1, Pt2: TFixedPoint): Single;
+begin
+  with Pt2 do
+  begin
+    X := X - Pt1.X;
+    Y := Y - Pt1.Y;
+    if X = 0 then
+    begin
+     if Y > 0 then Result := CRad270 else Result := CRad90;
+    end else
+    begin
+      Result := ArcTan2(-Y,X);
+      if Result < 0 then Result := Result + CRad360;
+    end;
+  end;
+end;
+
+function GetUnitVector(const Pt1, Pt2: TFixedPoint): TFloatPoint;
+var
+  Delta: TFloatPoint;
+  Temp: Single;
+begin
+  Delta.X := (Pt2.X - Pt1.X) * FixedToFloat;
+  Delta.Y := (Pt2.Y - Pt1.Y) * FixedToFloat;
+  if (Delta.X = 0) and (Delta.Y = 0) then
+  begin
+    Result := FloatPoint(0,0);
+  end else
+  begin
+    Temp := 1 / GR32_Math.Hypot(Delta.X, Delta.Y);
+    Result.X := Delta.X * Temp;
+    Result.Y := Delta.Y * Temp;
+  end;
+end;
+
+function GetUnitNormal(const Pt1, Pt2: TFixedPoint): TFloatPoint;
+var
+  Delta: TFloatPoint;
+  Temp: Single;
+begin
+  Delta.X := (Pt2.X - Pt1.X) * FixedToFloat;
+  Delta.Y := (Pt2.Y - Pt1.Y) * FixedToFloat;
+
+  if (Delta.X = 0) and (Delta.Y = 0) then
+  begin
+    Result := FloatPoint(0,0);
+  end else
+  begin
+    Temp := 1 / GR32_Math.Hypot(Delta.X, Delta.Y);
+    Delta.X := Delta.X * Temp;
+    Delta.Y := Delta.Y * Temp;
+  end;
+  Result.X :=  Delta.Y; // ie perpendicular to
+  Result.Y := -Delta.X; // the unit vector
+end;
+
+function OffsetPoint(const Pt: TFixedPoint; DeltaX, DeltaY: TFixed): TFixedPoint;
+begin
+  Result.X := Pt.X + DeltaX;
+  Result.Y := Pt.Y + DeltaY;
+end;
+
+function OffsetPoint(const Pt: TFixedPoint; DeltaX, DeltaY: TFloat): TFixedPoint;
+begin
+  Result.X := Pt.X + Fixed(DeltaX);
+  Result.Y := Pt.Y + Fixed(DeltaY);
+end;
+
+function OffsetPoint(const Pt: TFixedPoint; const Delta: TFixedPoint): TFixedPoint;
+begin
+  Result.X := Pt.X + Delta.X;
+  Result.Y := Pt.Y + Delta.Y;
+end;
+
+function OffsetPoint(const Pt: TFixedPoint; const Delta: TFloatPoint): TFixedPoint;
+begin
+  Result.X := Pt.X + Fixed(Delta.X);
+  Result.Y := Pt.Y + Fixed(Delta.Y);
+end;
+
+function OffsetRect(const Rct: TFixedRect; const DeltaX, DeltaY: TFixed): TFixedRect;
+begin
+  Result.TopLeft := OffsetPoint(Rct.TopLeft, DeltaX, DeltaY);
+  Result.BottomRight := OffsetPoint(Rct.BottomRight, DeltaX, DeltaY);
+end;
+
+function OffsetRect(const Rct: TFixedRect; const Delta: TFixedPoint): TFixedRect;
+begin
+  Result.TopLeft := OffsetPoint(Rct.TopLeft, Delta);
+  Result.BottomRight := OffsetPoint(Rct.BottomRight, Delta);
+end;
+
+function OffsetRect(const Rct: TFixedRect; const DeltaX, DeltaY: TFloat): TFixedRect;
+var
+  DX, DY: TFixed;
+begin
+  DX := Fixed(DeltaX);
+  DY := Fixed(DeltaY);
+  Result.TopLeft := OffsetPoint(Rct.TopLeft, DX, DY);
+  Result.BottomRight := OffsetPoint(Rct.BottomRight, DX, DY);
+end;
+
+function OffsetRect(const Rct: TFixedRect; const Delta: TFloatPoint): TFixedRect;
+var
+  DX, DY: TFixed;
+begin
+  DX := Fixed(Delta.X);
+  DY := Fixed(Delta.Y);
+  Result.TopLeft := OffsetPoint(Rct.TopLeft, DX, DY);
+  Result.BottomRight := OffsetPoint(Rct.BottomRight, DX, DY);
+end;
+
+function Shorten(const Pts: TArrayOfFixedPoint;
+  Delta: TFloat; LinePos: TLinePos): TArrayOfFixedPoint;
+var
+  Index, HighI: integer;
+  Dist, DeltaSqr: TFloat;
+  UnitVec: TFloatPoint;
+
+  procedure FixStart;
+  begin
+    Index := 1;
+    while (Index < HighI) and (SqrDistance(Pts[Index],Pts[0]) < DeltaSqr) do Inc(Index);
+    UnitVec := GetUnitVector(Pts[Index], Pts[0]);
+    Dist := Distance(Pts[Index],Pts[0]) - Delta;
+    if Index > 1 then
+    begin
+      Move(Result[Index], Result[1], SizeOf(TFloatPoint) * (HighI - Index + 1));
+      SetLength(Result, HighI - Index + 2);
+      HighI := HighI - Index + 1;
+    end;
+    Result[0] := OffsetPoint(Result[1], UnitVec.X * Dist, UnitVec.Y * Dist);
+  end;
+
+  procedure FixEnd;
+  begin
+    Index := HighI -1;
+    while (Index > 0) and (SqrDistance(Pts[Index],Pts[HighI]) < DeltaSqr) do Dec(Index);
+    UnitVec := GetUnitVector(Pts[Index],Pts[HighI]);
+    Dist := Distance(Pts[Index],Pts[HighI]) - Delta;
+    if Index + 1 < HighI then SetLength(Result, Index + 2);
+    Result[Index + 1] := OffsetPoint(Result[Index], UnitVec.X * Dist, UnitVec.Y * Dist);
+  end;
+
+begin
+  Result := Pts;
+  HighI := High(Pts);
+  DeltaSqr := Delta * Delta;
+  if HighI < 1 then Exit;
+
+  case LinePos of
+    lpStart: FixStart;
+    lpEnd  : FixEnd;
+    lpBoth : begin FixStart; FixEnd; end;
+  end;
+end;
+
+function PointInPolygon(const Pt: TFixedPoint; const Pts: array of TFixedPoint): Boolean;
+var
+  I: Integer;
+  iPt, jPt: PFixedPoint;
+begin
+  Result := False;
+  iPt := @Pts[0];
+  jPt := @Pts[High(Pts)];
+  for I := 0 to High(Pts) do
+  begin
+    Result := Result xor (((Pt.Y >= iPt.Y) xor (Pt.Y >= jPt.Y)) and
+      (Pt.X - iPt.X < MulDiv(jPt.X - iPt.X, Pt.Y - iPt.Y, jPt.Y - iPt.Y)));
+    jPt := iPt;
+    Inc(iPt);
+  end;
+end;
+
+function SegmentIntersect(const P1, P2, P3, P4: TFixedPoint;
+  out IntersectPoint: TFixedPoint): Boolean;
+var
+  m1,b1,m2,b2: TFloat;
+begin
+  Result := False;
+  if (P2.X = P1.X) then
+  begin
+    if (P4.X = P3.X) then Exit; // parallel lines
+    m2 := (P4.Y - P3.Y) / (P4.X - P3.X);
+    b2 := P3.Y - m2 * P3.X;
+    IntersectPoint.X := P1.X;
+    IntersectPoint.Y := Round(m2 * P1.X + b2);
+    Result := (IntersectPoint.Y < P2.Y) = (IntersectPoint.Y > P1.Y);
+  end
+  else if (P4.X = P3.X) then
+  begin
+    m1 := (P2.Y - P1.Y) / (P2.X - P1.X);
+    b1 := P1.Y - m1 * P1.X;
+    IntersectPoint.X := P3.X;
+    IntersectPoint.Y := Round(m1 * P3.X + b1);
+    Result := (IntersectPoint.Y < P3.Y) = (IntersectPoint.Y > P4.Y);
+  end else
+  begin
+    m1 := (P2.Y - P1.Y) / (P2.X - P1.X);
+    b1 := P1.Y - m1 * P1.X;
+    m2 := (P4.Y - P3.Y) / (P4.X - P3.X);
+    b2 := P3.Y - m2 * P3.X;
+    if m1 = m2 then Exit; // parallel lines
+    IntersectPoint.X := Round((b2 - b1) / (m1 - m2));
+    IntersectPoint.Y := Round(m1 * IntersectPoint.X + b1);
+    Result := ((IntersectPoint.X < P2.X) = (IntersectPoint.X > P1.X));
+  end;
+end;
+
+function PerpendicularDistance(const P, P1, P2: TFixedPoint): TFixed;
+begin
+  Result := Fixed(Abs((P.x - P2.x) * (P1.y - P2.y) - (P.y - P2.y) *
+    (P1.x - P2.x)) * FixedToFloat / Hypot((P1.x - P2.x) * FixedToFloat,
+    (P1.y - P2.y) * FixedToFloat));
+end;
+
+
+// Integer overloads
+
+function Average(const V1, V2: TPoint): TPoint;
+begin
+  Result.X := (V1.X + V2.X) div 2;
+  Result.Y := (V1.Y + V2.Y) div 2;
+end;
+
+function CrossProduct(V1, V2: TPoint): Integer;
+begin
+  Result := V1.X * V2.Y - V1.Y * V2.X;
+end;
+
+function Dot(const V1, V2: TPoint): Integer;
+begin
+  Result := V1.X * V2.X + V1.Y * V2.Y;
+end;
+
+function Distance(const V1, V2: TPoint): TFloat;
+begin
+  Result := Hypot(Integer(V2.X - V1.X), Integer(V2.Y - V1.Y));
+end;
+
+function SqrDistance(const V1, V2: TPoint): Integer;
+begin
+  Result := Sqr(V2.X - V1.X) + Sqr(V2.Y - V1.Y);
+end;
+
+function OffsetPoint(const Pt: TPoint; DeltaX, DeltaY: Integer): TPoint;
+begin
+  Result.X := Pt.X + DeltaX;
+  Result.Y := Pt.Y + DeltaY;
+end;
+
+function OffsetPoint(const Pt, Delta: TPoint): TPoint;
+begin
+  Result.X := Pt.X + Delta.X;
+  Result.Y := Pt.Y + Delta.Y;
+end;
+
+function PerpendicularDistance(const P, P1, P2: TPoint): TFloat;
+begin
+  Result := Abs((P.x - P2.x) * (P1.y - P2.y) - (P.y - P2.y) * (P1.x - P2.x)) /
+    Math.Hypot(P1.x - P2.x, P1.y - P2.y);
+end;
+
 end.

GraphicTest/Packages/Graphics32/GR32_Image.pas

@@ -49 +49 @@
 {$ENDIF}
   Graphics, Controls, Forms,
-  Classes, SysUtils, GR32, GR32_Layers, GR32_RangeBars, GR32_LowLevel,
-  GR32_System, GR32_Containers, GR32_RepaintOpt;
+  Classes, SysUtils, GR32, GR32_Layers, GR32_RangeBars, GR32_Containers,
+  GR32_RepaintOpt;
 
 const
@@ -118 +118 @@
     procedure CMMouseEnter(var Message: TLMessage); message LM_MOUSEENTER;
     procedure CMMouseLeave(var Message: TLMessage); message LM_MOUSELEAVE;
-    procedure CMInvalidate(var Message: TLMessage); message CM_INVALIDATE;
 {$ELSE}
     procedure WMEraseBkgnd(var Message: TWmEraseBkgnd); message WM_ERASEBKGND;
@@ -278 +277 @@
     procedure InvalidateCache;
     function  InvalidRectsAvailable: Boolean; override;
-    procedure DblClick; override;
     procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); overload; override;
     procedure MouseMove(Shift: TShiftState; X, Y: Integer); overload; override;
@@ -366 +364 @@
     property OnClick;
     property OnChange;
+    property OnContextPopup;
     property OnDblClick;
     property OnGDIOverlay;
@@ -653 +652 @@
 { TCustomPaintBox32 }
 
-{$IFDEF FPC}
-procedure TCustomPaintBox32.CMInvalidate(var Message: TLMessage);
-begin
-  if CustomRepaint and HandleAllocated then
-    PostMessage(Handle, LM_PAINT, 0, 0)
-  else
-    inherited;
-end;
-{$ELSE}
-
+{$IFNDEF FPC}
 procedure TCustomPaintBox32.CMInvalidate(var Message: TMessage);
 begin
@@ -848 +838 @@
 end;
 
-procedure TCustomPaintBox32.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
+procedure TCustomPaintBox32.MouseDown(Button: TMouseButton; Shift: TShiftState;
+  X, Y: Integer);
 begin
   if (pboAutoFocus in Options) and CanFocus then SetFocus;
@@ -874 +865 @@
 
   if FRepaintOptimizer.Enabled then
-  begin
     FRepaintOptimizer.BeginPaint;
-  end;
 
   if not FBufferValid then
@@ -984 +973 @@
 procedure TCustomPaintBox32.WMGetDlgCode(var Msg: {$IFDEF FPC}TLMessage{$ELSE}TWmGetDlgCode{$ENDIF});
 begin
-  with Msg do if pboWantArrowKeys in Options then
-    Result:= Result or DLGC_WANTARROWS
-  else
-    Result:= Result and not DLGC_WANTARROWS;
+  with Msg do
+    if pboWantArrowKeys in Options then
+      Result:= Result or DLGC_WANTARROWS
+    else
+      Result:= Result and not DLGC_WANTARROWS;
 end;
 
@@ -1050 +1040 @@
 { TCustomImage32 }
 
+constructor TCustomImage32.Create(AOwner: TComponent);
+begin
+  inherited;
+  ControlStyle := [csAcceptsControls, csCaptureMouse, csClickEvents,
+    csDoubleClicks, csReplicatable, csOpaque];
+  FBitmap := TBitmap32.Create;
+  FBitmap.OnResize := BitmapResizeHandler;
+
+  FLayers := TLayerCollection.Create(Self);
+  with TLayerCollectionAccess(FLayers) do
+  begin
+    OnChange := LayerCollectionChangeHandler;
+    OnGDIUpdate := LayerCollectionGDIUpdateHandler;
+    OnGetViewportScale := LayerCollectionGetViewportScaleHandler;
+    OnGetViewportShift := LayerCollectionGetViewportShiftHandler;
+  end;
+
+  FRepaintOptimizer.RegisterLayerCollection(FLayers);
+  RepaintMode := rmFull;
+
+  FPaintStages := TPaintStages.Create;
+  FScaleX := 1;
+  FScaleY := 1;
+  SetXForm(0, 0, 1, 1);
+
+  InitDefaultStages;
+end;
+
+destructor TCustomImage32.Destroy;
+begin
+  BeginUpdate;
+  FPaintStages.Free;
+  FRepaintOptimizer.UnregisterLayerCollection(FLayers);
+  FLayers.Free;
+  FBitmap.Free;
+  inherited;
+end;
+
 procedure TCustomImage32.BeginUpdate;
 begin
@@ -1104 +1132 @@
 end;
 
-function TCustomImage32.CanAutoSize(var NewWidth, NewHeight: Integer): Boolean;
-var
-  W, H: Integer;
-begin
-  InvalidateCache;
-  Result := True;
-  W := Bitmap.Width;
-  H := Bitmap.Height;
-  if ScaleMode = smScale then
-  begin
-    W := Round(W * Scale);
-    H := Round(H * Scale);
-  end;
-  if not (csDesigning in ComponentState) or (W > 0) and (H > 0) then
-  begin
-    if Align in [alNone, alLeft, alRight] then NewWidth := W;
-    if Align in [alNone, alTop, alBottom] then NewHeight := H;
-  end;
-end;
-
-procedure TCustomImage32.Changed;
-begin
-  if FUpdateCount = 0 then
-  begin
-    Invalidate;
-    if Assigned(FOnChange) then FOnChange(Self);
-  end;
-end;
-
-procedure TCustomImage32.Update(const Rect: TRect);
-begin
-  if FRepaintOptimizer.Enabled then
-    FRepaintOptimizer.AreaUpdateHandler(Self, Rect, AREAINFO_RECT);
-end;
-
 procedure TCustomImage32.BitmapResizeHandler(Sender: TObject);
 begin
@@ -1150 +1143 @@
 end;
 
-procedure TCustomImage32.BitmapAreaChangeHandler(Sender: TObject; const Area: TRect; const Info: Cardinal);
+procedure TCustomImage32.BitmapAreaChangeHandler(Sender: TObject;
+  const Area: TRect; const Info: Cardinal);
 var
   T, R: TRect;
@@ -1185 +1179 @@
 end;
 
-procedure TCustomImage32.BitmapDirectAreaChangeHandler(Sender: TObject; const Area: TRect; const Info: Cardinal);
+procedure TCustomImage32.BitmapDirectAreaChangeHandler(Sender: TObject;
+  const Area: TRect; const Info: Cardinal);
 var
   T, R: TRect;
@@ -1224 +1219 @@
 end;
 
-procedure TCustomImage32.LayerCollectionChangeHandler(Sender: TObject);
-begin
-  Changed;
-end;
-
-procedure TCustomImage32.LayerCollectionGDIUpdateHandler(Sender: TObject);
-begin
-  Paint;
-end;
-
-procedure TCustomImage32.LayerCollectionGetViewportScaleHandler(Sender: TObject;
-  out ScaleX, ScaleY: TFloat);
-begin
-  UpdateCache;
-  ScaleX := CachedScaleX;
-  ScaleY := CachedScaleY;
-end;
-
-procedure TCustomImage32.LayerCollectionGetViewportShiftHandler(Sender: TObject;
-  out ShiftX, ShiftY: TFloat);
-begin
-  UpdateCache;
-  ShiftX := CachedShiftX;
-  ShiftY := CachedShiftY;
+function TCustomImage32.CanAutoSize(var NewWidth, NewHeight: Integer): Boolean;
+var
+  W, H: Integer;
+begin
+  InvalidateCache;
+  Result := True;
+  W := Bitmap.Width;
+  H := Bitmap.Height;
+  if ScaleMode = smScale then
+  begin
+    W := Round(W * Scale);
+    H := Round(H * Scale);
+  end;
+  if not (csDesigning in ComponentState) or (W > 0) and (H > 0) then
+  begin
+    if Align in [alNone, alLeft, alRight] then NewWidth := W;
+    if Align in [alNone, alTop, alBottom] then NewHeight := H;
+  end;
+end;
+
+procedure TCustomImage32.Changed;
+begin
+  if FUpdateCount = 0 then
+  begin
+    Invalidate;
+    if Assigned(FOnChange) then FOnChange(Self);
+  end;
 end;
 
@@ -1285 +1283 @@
       Result.Y := (Y - CachedShiftY) * CachedRecScaleY;
   end;
-end;
-
-
-constructor TCustomImage32.Create(AOwner: TComponent);
-begin
-  inherited;
-  ControlStyle := [csAcceptsControls, csCaptureMouse, csClickEvents,
-    csDoubleClicks, csReplicatable, csOpaque];
-  FBitmap := TBitmap32.Create;
-  FBitmap.OnResize := BitmapResizeHandler;
-
-  FLayers := TLayerCollection.Create(Self);
-  with TLayerCollectionAccess(FLayers) do
-  begin
-    OnChange := LayerCollectionChangeHandler;
-    OnGDIUpdate := LayerCollectionGDIUpdateHandler;
-    OnGetViewportScale := LayerCollectionGetViewportScaleHandler;
-    OnGetViewportShift := LayerCollectionGetViewportShiftHandler;
-  end;
-
-  FRepaintOptimizer.RegisterLayerCollection(FLayers);
-  RepaintMode := rmFull;
-
-  FPaintStages := TPaintStages.Create;
-  FScaleX := 1;
-  FScaleY := 1;
-  SetXForm(0, 0, 1, 1);
-
-  InitDefaultStages;
-end;
-
-procedure TCustomImage32.DblClick;
-begin
-  Layers.MouseListener := nil;
-  MouseUp(mbLeft, [], 0, 0);
-  inherited;
-end;
-
-destructor TCustomImage32.Destroy;
-begin
-  BeginUpdate;
-  FPaintStages.Free;
-  FRepaintOptimizer.UnregisterLayerCollection(FLayers);
-  FLayers.Free;
-  FBitmap.Free;
-  inherited;
 end;
 
@@ -1674 +1626 @@
 procedure TCustomImage32.InvalidateCache;
 begin
-  if FRepaintOptimizer.Enabled then FRepaintOptimizer.Reset;
+  if FRepaintOptimizer.Enabled and CacheValid then
+    FRepaintOptimizer.Reset;
   CacheValid := False;
 end;
 
+function TCustomImage32.InvalidRectsAvailable: Boolean;
+begin
+  // avoid calling inherited, we have a totally different behaviour here...
+  DoPrepareInvalidRects;
+  Result := FInvalidRects.Count > 0;
+end;
+
+procedure TCustomImage32.LayerCollectionChangeHandler(Sender: TObject);
+begin
+  Changed;
+end;
+
+procedure TCustomImage32.LayerCollectionGDIUpdateHandler(Sender: TObject);
+begin
+  Paint;
+end;
+
+procedure TCustomImage32.LayerCollectionGetViewportScaleHandler(Sender: TObject;
+  out ScaleX, ScaleY: TFloat);
+begin
+  UpdateCache;
+  ScaleX := CachedScaleX;
+  ScaleY := CachedScaleY;
+end;
+
+procedure TCustomImage32.LayerCollectionGetViewportShiftHandler(Sender: TObject;
+  out ShiftX, ShiftY: TFloat);
+begin
+  UpdateCache;
+  ShiftX := CachedShiftX;
+  ShiftY := CachedShiftY;
+end;
+
 procedure TCustomImage32.Loaded;
 begin
@@ -1691 +1677 @@
 
   if TabStop and CanFocus then SetFocus;
-  
+
   if Layers.MouseEvents then
     Layer := TLayerCollectionAccess(Layers).MouseDown(Button, Shift, X, Y)
@@ -1720 +1706 @@
 var
   Layer: TCustomLayer;
-begin
+  MouseListener: TCustomLayer;
+begin
+  MouseListener := TLayerCollectionAccess(Layers).MouseListener;
+
   if Layers.MouseEvents then
     Layer := TLayerCollectionAccess(Layers).MouseUp(Button, Shift, X, Y)
@@ -1727 +1716 @@
 
   // unlock the capture using same criteria as was used to acquire it
-  if (Button = mbLeft) or (TLayerCollectionAccess(Layers).MouseListener <> nil) then
+  if (Button = mbLeft) or ((MouseListener <> nil) and (TLayerCollectionAccess(Layers).MouseListener = nil)) then
     MouseCapture := False;
 
@@ -1736 +1725 @@
   Shift: TShiftState; X, Y: Integer; Layer: TCustomLayer);
 begin
-  if Assigned(FOnMouseDown) then FOnMouseDown(Self, Button, Shift, X, Y, Layer);
+  if Assigned(FOnMouseDown) then
+    FOnMouseDown(Self, Button, Shift, X, Y, Layer);
 end;
 
@@ -1742 +1732 @@
   Layer: TCustomLayer);
 begin
-  if Assigned(FOnMouseMove) then FOnMouseMove(Self, Shift, X, Y, Layer);
+  if Assigned(FOnMouseMove) then
+    FOnMouseMove(Self, Shift, X, Y, Layer);
 end;
 
@@ -1748 +1739 @@
   X, Y: Integer; Layer: TCustomLayer);
 begin
-  if Assigned(FOnMouseUp) then FOnMouseUp(Self, Button, Shift, X, Y, Layer);
+  if Assigned(FOnMouseUp) then
+    FOnMouseUp(Self, Button, Shift, X, Y, Layer);
 end;
 
@@ -1933 +1925 @@
 end;
 
-procedure TCustomImage32.UpdateCache;
-begin
-  if CacheValid then Exit;
-  CachedBitmapRect := GetBitmapRect;
-
-  if Bitmap.Empty then
-    SetXForm(0, 0, 1, 1)
-  else
-    SetXForm(
-      CachedBitmapRect.Left, CachedBitmapRect.Top,
-      (CachedBitmapRect.Right - CachedBitmapRect.Left) / Bitmap.Width,
-      (CachedBitmapRect.Bottom - CachedBitmapRect.Top) / Bitmap.Height
-    );
-
-  CacheValid := True;
-end;
-
-function TCustomImage32.InvalidRectsAvailable: Boolean;
-begin
-  // avoid calling inherited, we have a totally different behaviour here...
-  DoPrepareInvalidRects;
-  Result := FInvalidRects.Count > 0;
-end;
-
 procedure TCustomImage32.SetRepaintMode(const Value: TRepaintMode);
 begin
@@ -1977 +1945 @@
   end;
 end;
+
+procedure TCustomImage32.Update(const Rect: TRect);
+begin
+  if FRepaintOptimizer.Enabled then
+    FRepaintOptimizer.AreaUpdateHandler(Self, Rect, AREAINFO_RECT);
+end;
+
+procedure TCustomImage32.UpdateCache;
+begin
+  if CacheValid then Exit;
+  CachedBitmapRect := GetBitmapRect;
+
+  if Bitmap.Empty then
+    SetXForm(0, 0, 1, 1)
+  else
+    SetXForm(
+      CachedBitmapRect.Left, CachedBitmapRect.Top,
+      (CachedBitmapRect.Right - CachedBitmapRect.Left) / Bitmap.Width,
+      (CachedBitmapRect.Bottom - CachedBitmapRect.Top) / Bitmap.Height
+    );
+
+  CacheValid := True;
+end;
+
 
 { TIVScrollProperties }
@@ -2404 +2396 @@
   begin
     if W > Sz.Cx + 2 * ScaledOversize then // Viewport is bigger than scaled Bitmap
-      OffsetHorz := (W - Sz.Cx) / 2
+      OffsetHorz := (W - Sz.Cx) * 0.5
     else
       OffsetHorz := -HScroll.Position + ScaledOversize;
 
     if H > Sz.Cy + 2 * ScaledOversize then // Viewport is bigger than scaled Bitmap
-      OffsetVert := (H - Sz.Cy) / 2
+      OffsetVert := (H - Sz.Cy) * 0.5
     else
       OffsetVert := -VScroll.Position + ScaledOversize;

GraphicTest/Packages/Graphics32/GR32_Layers.pas

@@ -63 +63 @@
   TCustomLayer = class;
   TPositionedLayer = class;
+  TRubberbandLayer = class;
   TLayerClass = class of TCustomLayer;
 
@@ -111 +112 @@
     function MouseMove(Shift: TShiftState; X, Y: Integer): TCustomLayer;
     function MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer): TCustomLayer;
+
     property OnChanging: TNotifyEvent read FOnChanging write FOnChanging;
     property OnChange: TNotifyEvent read FOnChange write FOnChange;
@@ -122 +124 @@
     constructor Create(AOwner: TPersistent);
     destructor Destroy; override;
+
     function  Add(ItemClass: TLayerClass): TCustomLayer;
     procedure Assign(Source: TPersistent); override;
@@ -131 +134 @@
     procedure GetViewportScale(out ScaleX, ScaleY: TFloat); virtual;
     procedure GetViewportShift(out ShiftX, ShiftY: TFloat); virtual;
+
     property Count: Integer read GetCount;
     property Owner: TPersistent read FOwner;
@@ -137 +141 @@
     property MouseEvents: Boolean read FMouseEvents write SetMouseEvents;
   end;
+
+{$IFDEF COMPILER2009_UP}
+  TLayerEnum = class
+   private
+     FIndex: Integer;
+     FLayerCollection: TLayerCollection;
+   public
+     constructor Create(ALayerCollection: TLayerCollection);
+
+     function GetCurrent: TCustomLayer;
+     function MoveNext: Boolean;
+
+     property Current: TCustomLayer read GetCurrent;
+   end;
+
+   TLayerCollectionHelper = class Helper for TLayerCollection
+   public
+     function GetEnumerator: TLayerEnum;
+   end;
+{$ENDIF}
 
   TLayerState = (lsMouseLeft, lsMouseRight, lsMouseMiddle);
@@ -151 +175 @@
     FLayerStates: TLayerStates;
     FLayerOptions: Cardinal;
+    FTag: Integer;
+    FClicked: Boolean;
     FOnHitTest: THitTestEvent;
     FOnMouseDown: TMouseEvent;
@@ -156 +182 @@
     FOnMouseUp: TMouseEvent;
     FOnPaint: TPaintLayerEvent;
-    FTag: Integer;
     FOnDestroy: TNotifyEvent;
+    FOnDblClick: TNotifyEvent;
+    FOnClick: TNotifyEvent;
     function  GetIndex: Integer;
     function  GetMouseEvents: Boolean;
@@ -170 +197 @@
     procedure AddNotification(ALayer: TCustomLayer);
     procedure Changing;
+    procedure Click;
+    procedure DblClick;
     function  DoHitTest(X, Y: Integer): Boolean; virtual;
     procedure DoPaint(Buffer: TBitmap32);
@@ -184 +213 @@
     procedure SetLayerCollection(Value: TLayerCollection); virtual;
     procedure SetLayerOptions(Value: Cardinal); virtual;
+
     property Invalid: Boolean read GetInvalid write SetInvalid;
     property ForceUpdate: Boolean read GetForceUpdate write SetForceUpdate;
@@ -189 +219 @@
     constructor Create(ALayerCollection: TLayerCollection); virtual;
     destructor Destroy; override;
+
     procedure BeforeDestruction; override;
     procedure BringToFront;
@@ -198 +229 @@
     procedure SendToBack;
     procedure SetAsMouseListener;
+
     property Cursor: TCursor read FCursor write SetCursor;
     property Index: Integer read GetIndex write SetIndex;
@@ -206 +238 @@
     property Tag: Integer read FTag write FTag;
     property Visible: Boolean read GetVisible write SetVisible;
+
     property OnDestroy: TNotifyEvent read FOnDestroy write FOnDestroy;
     property OnHitTest: THitTestEvent read FOnHitTest write FOnHitTest;
     property OnPaint: TPaintLayerEvent read FOnPaint write FOnPaint;
+    property OnClick: TNotifyEvent read FOnClick write FOnClick;
+    property OnDblClick: TNotifyEvent read FOnDblClick write FOnDblClick;
     property OnMouseDown: TMouseEvent read FOnMouseDown write FOnMouseDown;
     property OnMouseMove: TMouseMoveEvent read FOnMouseMove write FOnMouseMove;
@@ -225 +260 @@
   public
     constructor Create(ALayerCollection: TLayerCollection); override;
+
     function GetAdjustedRect(const R: TFloatRect): TFloatRect; virtual;
     function GetAdjustedLocation: TFloatRect;
+
     property Location: TFloatRect read FLocation write SetLocation;
     property Scaled: Boolean read FScaled write SetScaled;
@@ -245 +282 @@
     constructor Create(ALayerCollection: TLayerCollection); override;
     destructor Destroy; override;
+
     property AlphaHit: Boolean read FAlphaHit write FAlphaHit;
     property Bitmap: TBitmap32 read FBitmap write SetBitmap;
@@ -250 +288 @@
   end;
 
-  TDragState = (dsNone, dsMove, dsSizeL, dsSizeT, dsSizeR, dsSizeB,
+  TRBDragState = (dsNone, dsMove, dsSizeL, dsSizeT, dsSizeR, dsSizeB,
     dsSizeTL, dsSizeTR, dsSizeBL, dsSizeBR);
   TRBHandles = set of (rhCenter, rhSides, rhCorners, rhFrame,
     rhNotLeftSide, rhNotRightSide, rhNotTopSide, rhNotBottomSide,
     rhNotTLCorner, rhNotTRCorner, rhNotBLCorner, rhNotBRCorner);
-  TRBOptions = set of (roProportional, roConstrained);
+  TRBOptions = set of (roProportional, roConstrained, roQuantized);
   TRBResizingEvent = procedure(
     Sender: TObject;
     const OldLocation: TFloatRect;
     var NewLocation: TFloatRect;
-    DragState: TDragState;
+    DragState: TRBDragState;
     Shift: TShiftState) of object;
   TRBConstrainEvent = TRBResizingEvent;
+
+  TRubberbandPassMouse = class(TPersistent)
+  private
+    FOwner: TRubberbandLayer;
+    FEnabled: Boolean;
+    FToChild: Boolean;
+    FLayerUnderCursor: Boolean;
+    FCancelIfPassed: Boolean;
+  protected
+    function GetChildUnderCursor(X, Y: Integer): TPositionedLayer;
+  public
+    constructor Create(AOwner: TRubberbandLayer);
+
+    property Enabled: Boolean read FEnabled write FEnabled default False;
+    property ToChild: Boolean read FToChild write FToChild default False;
+    property ToLayerUnderCursor: Boolean read FLayerUnderCursor write FLayerUnderCursor default False;
+    property CancelIfPassed: Boolean read FCancelIfPassed write FCancelIfPassed default False;
+  end;
 
   TRubberbandLayer = class(TPositionedLayer)
@@ -273 +329 @@
     FHandleFill: TColor32;
     FHandles: TRBHandles;
-    FHandleSize: Integer;
+    FHandleSize: TFloat;
     FMinWidth: TFloat;
     FMaxHeight: TFloat;
@@ -282 +338 @@
     FOnConstrain: TRBConstrainEvent;
     FOptions: TRBOptions;
+    FQuantized: Integer;
+    FPassMouse: TRubberbandPassMouse;
     procedure SetFrameStippleStep(const Value: TFloat);
     procedure SetFrameStippleCounter(const Value: TFloat);
@@ -288 +346 @@
     procedure SetHandleFrame(Value: TColor32);
     procedure SetHandles(Value: TRBHandles);
-    procedure SetHandleSize(Value: Integer);
+    procedure SetHandleSize(Value: TFloat);
     procedure SetOptions(const Value: TRBOptions);
+    procedure SetQuantized(const Value: Integer);
   protected
-    IsDragging: Boolean;
-    DragState: TDragState;
-    OldLocation: TFloatRect;
-    MouseShift: TFloatPoint;
+    FIsDragging: Boolean;
+    FDragState: TRBDragState;
+    FOldLocation: TFloatRect;
+    FMouseShift: TFloatPoint;
     function  DoHitTest(X, Y: Integer): Boolean; override;
-    procedure DoResizing(var OldLocation, NewLocation: TFloatRect; DragState: TDragState; Shift: TShiftState); virtual;
-    procedure DoConstrain(var OldLocation, NewLocation: TFloatRect; DragState: TDragState; Shift: TShiftState); virtual;
+    procedure DoResizing(var OldLocation, NewLocation: TFloatRect; DragState: TRBDragState; Shift: TShiftState); virtual;
+    procedure DoConstrain(var OldLocation, NewLocation: TFloatRect; DragState: TRBDragState; Shift: TShiftState); virtual;
     procedure DoSetLocation(const NewLocation: TFloatRect); override;
-    function  GetDragState(X, Y: Integer): TDragState; virtual;
+    function  GetDragState(X, Y: Integer): TRBDragState; virtual;
     procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
     procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
@@ -306 +365 @@
     procedure Paint(Buffer: TBitmap32); override;
     procedure SetLayerOptions(Value: Cardinal); override;
+    procedure SetDragState(const Value: TRBDragState); overload;
+    procedure SetDragState(const Value: TRBDragState; const X, Y: Integer); overload;
     procedure UpdateChildLayer;
+    procedure DrawHandle(Buffer: TBitmap32; X, Y: TFloat); virtual;
   public
     constructor Create(ALayerCollection: TLayerCollection); override;
+    destructor Destroy; override;
+
     procedure SetFrameStipple(const Value: Array of TColor32);
+    procedure Quantize;
+
     property ChildLayer: TPositionedLayer read FChildLayer write SetChildLayer;
     property Options: TRBOptions read FOptions write SetOptions;
     property Handles: TRBHandles read FHandles write SetHandles;
-    property HandleSize: Integer read FHandleSize write SetHandleSize;
+    property HandleSize: TFloat read FHandleSize write SetHandleSize;
     property HandleFill: TColor32 read FHandleFill write SetHandleFill;
     property HandleFrame: TColor32 read FHandleFrame write SetHandleFrame;
@@ -322 +388 @@
     property MinHeight: TFloat read FMinHeight write FMinHeight;
     property MinWidth: TFloat read FMinWidth write FMinWidth;
+    property Quantized: Integer read FQuantized write SetQuantized default 8;
+    property PassMouseToChild: TRubberbandPassMouse read FPassMouse;
+
     property OnUserChange: TNotifyEvent read FOnUserChange write FOnUserChange;
     property OnConstrain: TRBConstrainEvent read FOnConstrain write FOnConstrain;
@@ -330 +399 @@
 
 uses
-  TypInfo, GR32_Image, GR32_LowLevel, GR32_Resamplers, GR32_RepaintOpt;
+  TypInfo, GR32_Image, GR32_LowLevel, GR32_Resamplers, GR32_RepaintOpt, Types;
 
 { mouse state mapping }
@@ -375 +444 @@
 procedure TLayerCollection.BeginUpdate;
 begin
-  if FUpdateCount = 0 then Changing;
+  if FUpdateCount = 0 then
+    Changing;
   Inc(FUpdateCount);
 end;
@@ -381 +451 @@
 procedure TLayerCollection.Changed;
 begin
-  if Assigned(FOnChange) then FOnChange(Self);
+  if Assigned(FOnChange) then
+    FOnChange(Self);
 end;
 
 procedure TLayerCollection.Changing;
 begin
-  if Assigned(FOnChanging) then FOnChanging(Self);
+  if Assigned(FOnChanging) then
+    FOnChanging(Self);
 end;
 
@@ -415 +487 @@
 begin
   FUpdateCount := 1; // disable update notification
-  if Assigned(FItems) then Clear;
+  if Assigned(FItems) then
+    Clear;
   FItems.Free;
   inherited;
@@ -423 +496 @@
 begin
   Dec(FUpdateCount);
-  if FUpdateCount = 0 then Changed;
+  if FUpdateCount = 0 then
+    Changed;
   Assert(FUpdateCount >= 0, 'Unpaired EndUpdate');
 end;
@@ -434 +508 @@
   begin
     Result := Items[I];
-    if (Result.LayerOptions and OptionsMask) = 0 then Continue; // skip to the next one
+    if (Result.LayerOptions and OptionsMask) = 0 then
+      Continue; // skip to the next one
     if Result.HitTest(X, Y) then Exit;
   end;
@@ -442 +517 @@
 procedure TLayerCollection.GDIUpdate;
 begin
-  if (FUpdateCount = 0) and Assigned(FOnGDIUpdate) then FOnGDIUpdate(Self);
+  if (FUpdateCount = 0) and Assigned(FOnGDIUpdate) then
+    FOnGDIUpdate(Self);
 end;
 
@@ -538 +614 @@
 begin
   Result := MouseListener;
-  if Result = nil then Result := FindLayerAtPos(X, Y, LOB_MOUSE_EVENTS);
-  if Assigned(Result) then Result.MouseMove(Shift, X, Y)
-  else if FOwner is TControl then Screen.Cursor := TControl(FOwner).Cursor;
+  if Result = nil then
+    Result := FindLayerAtPos(X, Y, LOB_MOUSE_EVENTS);
+
+  if Assigned(Result) then
+    Result.MouseMove(Shift, X, Y)
+  else if FOwner is TControl then
+    Screen.Cursor := TControl(FOwner).Cursor;
 end;
 
@@ -546 +626 @@
 begin
   Result := MouseListener;
-  if Result = nil then Result := FindLayerAtPos(X, Y, LOB_MOUSE_EVENTS);
+  if Result = nil then
+    Result := FindLayerAtPos(X, Y, LOB_MOUSE_EVENTS);
 
   if Assigned(Result) then
@@ -562 +643 @@
 procedure TLayerCollection.Notify(Action: TLayerListNotification; Layer: TCustomLayer; Index: Integer);
 begin
-  if Assigned(FOnListNotify) then FOnListNotify(Self, Action, Layer, Index);
+  if Assigned(FOnListNotify) then
+    FOnListNotify(Self, Action, Layer, Index);
 end;
 
@@ -607 +689 @@
 procedure TLayerCollection.DoUpdateArea(const Rect: TRect);
 begin
-  if Assigned(FOnAreaUpdated) then FOnAreaUpdated(Self, Rect, AREAINFO_RECT);
-  Changed;  
+  if Assigned(FOnAreaUpdated) then
+    FOnAreaUpdated(Self, Rect, AREAINFO_RECT);
+  Changed;
 end;
 
 procedure TLayerCollection.DoUpdateLayer(Layer: TCustomLayer);
 begin
-  if Assigned(FOnLayerUpdated) then FOnLayerUpdated(Self, Layer);
+  if Assigned(FOnLayerUpdated) then
+    FOnLayerUpdated(Self, Layer);
   Changed;
 end;
@@ -639 +723 @@
 end;
 
+
+{$IFDEF COMPILER2009_UP}
+{ TLayerEnum }
+
+constructor TLayerEnum.Create(ALayerCollection: TLayerCollection);
+begin
+  inherited Create;
+  FLayerCollection := ALayerCollection;
+  FIndex := -1;
+end;
+
+function TLayerEnum.GetCurrent: TCustomLayer;
+begin
+  Result := FLayerCollection.Items[FIndex];
+end;
+
+function TLayerEnum.MoveNext: Boolean;
+begin
+  Result := FIndex < Pred(FLayerCollection.Count);
+  if Result then
+    Inc(FIndex);
+end;
+
+
+{ TLayerCollectionHelper }
+
+function TLayerCollectionHelper.GetEnumerator: TLayerEnum;
+begin
+  Result := TLayerEnum.Create(Self);
+end;
+{$ENDIF}
+
+
 { TCustomLayer }
 
+constructor TCustomLayer.Create(ALayerCollection: TLayerCollection);
+begin
+  LayerCollection := ALayerCollection;
+  FLayerOptions := LOB_VISIBLE;
+end;
+
+destructor TCustomLayer.Destroy;
+var
+  I: Integer;
+begin
+  if Assigned(FFreeNotifies) then
+  begin
+    for I := FFreeNotifies.Count - 1 downto 0 do
+    begin
+      TCustomLayer(FFreeNotifies[I]).Notification(Self);
+      if FFreeNotifies = nil then Break;
+    end;
+    FFreeNotifies.Free;
+    FFreeNotifies := nil;
+  end;
+  SetLayerCollection(nil);
+  inherited;
+end;
+
 procedure TCustomLayer.AddNotification(ALayer: TCustomLayer);
 begin
-  if not Assigned(FFreeNotifies) then FFreeNotifies := TList.Create;
-  if FFreeNotifies.IndexOf(ALayer) < 0 then FFreeNotifies.Add(ALayer);
+  if not Assigned(FFreeNotifies) then
+    FFreeNotifies := TList.Create;
+  if FFreeNotifies.IndexOf(ALayer) < 0 then
+    FFreeNotifies.Add(ALayer);
 end;
 
 procedure TCustomLayer.BeforeDestruction;
 begin
-  if Assigned(FOnDestroy) then FOnDestroy(Self);
+  if Assigned(FOnDestroy) then
+    FOnDestroy(Self);
   inherited;
 end;
@@ -664 +808 @@
   begin
     Update;
-    if Visible then FLayerCollection.Changed
+    if Visible then
+      FLayerCollection.Changed
     else if (FLayerOptions and LOB_GDI_OVERLAY) <> 0 then
       FLayerCollection.GDIUpdate;
@@ -678 +823 @@
   begin
     Update(Rect);
-    if Visible then FLayerCollection.Changed
+    if Visible then
+      FLayerCollection.Changed
     else if (FLayerOptions and LOB_GDI_OVERLAY) <> 0 then
       FLayerCollection.GDIUpdate;
@@ -694 +840 @@
 end;
 
-constructor TCustomLayer.Create(ALayerCollection: TLayerCollection);
-begin
-  LayerCollection := ALayerCollection;
-  FLayerOptions := LOB_VISIBLE;
-end;
-
-destructor TCustomLayer.Destroy;
-var
-  I: Integer;
-begin
-  if Assigned(FFreeNotifies) then
-  begin
-    for I := FFreeNotifies.Count - 1 downto 0 do
-    begin
-      TCustomLayer(FFreeNotifies[I]).Notification(Self);
-      if FFreeNotifies = nil then Break;
-    end;
-    FFreeNotifies.Free;
-    FFreeNotifies := nil;
-  end;
-  SetLayerCollection(nil);
-  inherited;
+procedure TCustomLayer.Click;
+begin
+  FClicked := False;
+  if Assigned(FOnClick) then
+    FOnClick(Self);
+end;
+
+procedure TCustomLayer.DblClick;
+begin
+  FClicked := False;
+  if Assigned(FOnDblClick) then
+    FOnDblClick(Self);
 end;
 
 function TCustomLayer.DoHitTest(X, Y: Integer): Boolean;
 begin
-  Result := True;
+  Result := Visible;
 end;
 
@@ -726 +862 @@
 begin
   Paint(Buffer);
-  if Assigned(FOnPaint) then FOnPaint(Self, Buffer);
+  if Assigned(FOnPaint) then
+    FOnPaint(Self, Buffer);
 end;
 
@@ -755 +892 @@
 begin
   Result := DoHitTest(X, Y);
-  if Assigned(FOnHitTest) then FOnHitTest(Self, X, Y, Result);
+  if Assigned(FOnHitTest) then
+    FOnHitTest(Self, X, Y, Result);
 end;
 
 procedure TCustomLayer.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
 begin
-  if Assigned(FOnMouseDown) then FOnMouseDown(Self, Button, Shift, X, Y);
+  if (Button = mbLeft) then
+  begin
+    if (ssDouble in Shift) then
+      DblClick
+    else
+      FClicked := True;
+  end;
+  if Assigned(FOnMouseDown) then
+    FOnMouseDown(Self, Button, Shift, X, Y);
 end;
 
@@ -766 +912 @@
 begin
   Screen.Cursor := Cursor;
-  if Assigned(FOnMouseMove) then FOnMouseMove(Self, Shift, X, Y);
+  if Assigned(FOnMouseMove) then
+    FOnMouseMove(Self, Shift, X, Y);
 end;
 
@@ -772 +919 @@
 begin
   Screen.Cursor := crDefault;
-  if Assigned(FOnMouseUp) then FOnMouseUp(Self, Button, Shift, X, Y);
+  if (Button = mbLeft) and FClicked then
+    Click;
+  if Assigned(FOnMouseUp) then
+    FOnMouseUp(Self, Button, Shift, X, Y);
 end;
 
@@ -819 +969 @@
   begin
     FCursor := Value;
-    if FLayerCollection.MouseListener = Self then Screen.Cursor := Value;
+    if FLayerCollection.MouseListener = Self then
+      Screen.Cursor := Value;
   end;
 end;
@@ -857 +1008 @@
     if Assigned(Value) then
       Value.InsertItem(Self);
+    FLayerCollection := Value;
   end;
 end;
@@ -948 +1100 @@
 begin
   with GetAdjustedRect(FLocation) do
-    Result := (X >= Left) and (X < Right) and (Y >= Top) and (Y < Bottom);
+    Result := (X >= Left) and (X < Right) and (Y >= Top) and (Y < Bottom) and
+      inherited DoHitTest(X, Y);
 end;
 
@@ -1076 +1229 @@
   DstRect := MakeRect(GetAdjustedRect(FLocation));
   ClipRect := Buffer.ClipRect;
-  IntersectRect(TempRect, ClipRect, DstRect);
-  if IsRectEmpty(TempRect) then Exit;
+  GR32.IntersectRect(TempRect, ClipRect, DstRect);
+  if GR32.IsRectEmpty(TempRect) then Exit;
 
   SrcRect := MakeRect(0, 0, Bitmap.Width, Bitmap.Height);
@@ -1090 +1243 @@
     if (LayerWidth < 0.5) or (LayerHeight < 0.5) then Exit;
     ImageRect := TCustomImage32(LayerCollection.FOwner).GetBitmapRect;
-    IntersectRect(ClipRect, ClipRect, ImageRect);
+    GR32.IntersectRect(ClipRect, ClipRect, ImageRect);
   end;
   StretchTransfer(Buffer, DstRect, ClipRect, FBitmap, SrcRect,
@@ -1109 +1262 @@
   end;
 end;
+
+
+{ TRubberbandPassMouse }
+
+constructor TRubberbandPassMouse.Create(AOwner: TRubberbandLayer);
+begin
+  FOwner := AOwner;
+  FEnabled := False;
+  FToChild := False;
+  FLayerUnderCursor := False;
+  FCancelIfPassed := False;
+end;
+
+function TRubberbandPassMouse.GetChildUnderCursor(X, Y: Integer): TPositionedLayer;
+var
+  Layer: TCustomLayer;
+  Index: Integer;
+begin
+  Result := nil;
+  for Index := FOwner.LayerCollection.Count - 1 downto 0 do
+  begin
+    Layer := FOwner.LayerCollection.Items[Index];
+    if ((Layer.LayerOptions and LOB_MOUSE_EVENTS) > 0) and
+      (Layer is TPositionedLayer) and Layer.HitTest(X, Y) then
+    begin
+      Result := TPositionedLayer(Layer);
+      Exit;
+    end;
+  end;
+end;
+
 
 { TRubberbandLayer }
@@ -1121 +1305 @@
   FMinWidth := 10;
   FMinHeight := 10;
+  FQuantized := 8;
   FLayerOptions := LOB_VISIBLE or LOB_MOUSE_EVENTS;
   SetFrameStipple([clWhite32, clWhite32, clBlack32, clBlack32]);
+  FPassMouse := TRubberbandPassMouse.Create(Self);
   FFrameStippleStep := 1;
   FFrameStippleCounter := 0;
 end;
 
+destructor TRubberbandLayer.Destroy;
+begin
+  FPassMouse.Free;
+  inherited;
+end;
+
 function TRubberbandLayer.DoHitTest(X, Y: Integer): Boolean;
 begin
-  Result := GetDragState(X, Y) <> dsNone;
+  if (Visible) then
+    Result := (GetDragState(X, Y) <> dsNone)
+  else
+    Result := False;
 end;
 
 procedure TRubberbandLayer.DoResizing(var OldLocation,
-  NewLocation: TFloatRect; DragState: TDragState; Shift: TShiftState);
+  NewLocation: TFloatRect; DragState: TRBDragState; Shift: TShiftState);
 begin
   if Assigned(FOnResizing) then
@@ -1140 +1335 @@
 
 procedure TRubberbandLayer.DoConstrain(var OldLocation,
-  NewLocation: TFloatRect; DragState: TDragState; Shift: TShiftState);
+  NewLocation: TFloatRect; DragState: TRBDragState; Shift: TShiftState);
 begin
   if Assigned(FOnConstrain) then
@@ -1152 +1347 @@
 end;
 
-function TRubberbandLayer.GetDragState(X, Y: Integer): TDragState;
+function TRubberbandLayer.GetDragState(X, Y: Integer): TRBDragState;
 var
   R: TRect;
@@ -1158 +1353 @@
   dl, dt, dr, db, dx, dy: Boolean;
   Sz: Integer;
+const
+  DragZone = 1;
 begin
   Result := dsNone;
-  Sz := FHandleSize + 1;
+  Sz := Ceil(FHandleSize + DragZone);
   dh_center := rhCenter in FHandles;
   dh_sides := rhSides in FHandles;
@@ -1186 +1383 @@
   else if dl and dy and dh_sides and not(rhNotLeftSide in FHandles) then Result := dsSizeL
   else if dt and dx and dh_sides and not(rhNotTopSide in FHandles) then Result := dsSizeT
-  else if dh_center and PtInRect(R, Point(X, Y)) then Result := dsMove;
+  else if dh_center and GR32.PtInRect(R, GR32.Point(X, Y)) then Result := dsMove;
 end;
 
 procedure TRubberbandLayer.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
 var
-  ALoc: TFloatRect;
-begin
-  if IsDragging then Exit;
-  DragState := GetDragState(X, Y);
-  IsDragging := DragState <> dsNone;
-  if IsDragging then
-  begin
-    OldLocation := Location;
-
-    ALoc := GetAdjustedRect(FLocation);
-    case DragState of
-      dsMove: MouseShift := FloatPoint(X - ALoc.Left, Y - ALoc.Top);
+  PositionedLayer: TPositionedLayer;
+begin
+  if FPassMouse.Enabled then
+  begin
+    if FPassMouse.ToLayerUnderCursor then
+      PositionedLayer := FPassMouse.GetChildUnderCursor(X, Y)
     else
-      MouseShift := FloatPoint(0, 0);
-    end;
-  end;
+      PositionedLayer := ChildLayer;
+
+    if FPassMouse.ToChild and Assigned(ChildLayer) then
+    begin
+      ChildLayer.MouseDown(Button, Shift, X, Y);
+      if FPassMouse.CancelIfPassed then
+        Exit;
+    end;
+
+    if (PositionedLayer <> ChildLayer) and Assigned(PositionedLayer) then
+    begin
+      PositionedLayer.MouseDown(Button, Shift, X, Y);
+      if FPassMouse.CancelIfPassed then
+        Exit;
+    end;
+  end;
+
+  if FIsDragging then Exit;
+  SetDragState(GetDragState(X, Y), X, Y);
   inherited;
 end;
@@ -1212 +1419 @@
 procedure TRubberbandLayer.MouseMove(Shift: TShiftState; X, Y: Integer);
 const
-  CURSOR_ID: array [TDragState] of TCursor = (crDefault, crDefault, crSizeWE,
+  CURSOR_ID: array [TRBDragState] of TCursor = (crDefault, crDefault, crSizeWE,
     crSizeNS, crSizeWE, crSizeNS, crSizeNWSE, crSizeNESW, crSizeNESW, crSizeNWSE);
 var
   Mx, My: TFloat;
   L, T, R, B, W, H: TFloat;
+  Quantize: Boolean;
   ALoc, NewLocation: TFloatRect;
 
@@ -1234 +1442 @@
 
 begin
-  if not IsDragging then
-  begin
-    DragState := GetDragState(X, Y);
-    if DragState = dsMove then Screen.Cursor := Cursor
-    else Screen.Cursor := CURSOR_ID[DragState];
+  if not FIsDragging then
+  begin
+    FDragState := GetDragState(X, Y);
+    if FDragState = dsMove then
+      Screen.Cursor := Cursor
+    else
+      Screen.Cursor := CURSOR_ID[FDragState];
   end
   else
   begin
-    Mx := X - MouseShift.X;
-    My := Y - MouseShift.Y;
+    Mx := X - FMouseShift.X;
+    My := Y - FMouseShift.Y;
     if Scaled then
     with Location do
     begin
       ALoc := GetAdjustedRect(FLocation);
-      if IsRectEmpty(ALoc) then Exit;
+      if GR32.IsRectEmpty(ALoc) then Exit;
       Mx := (Mx - ALoc.Left) / (ALoc.Right - ALoc.Left) * (Right - Left) + Left;
       My := (My - ALoc.Top) / (ALoc.Bottom - ALoc.Top) * (Bottom - Top) + Top;
     end;
 
-    with OldLocation do
+    with FOldLocation do
     begin
       L := Left;
@@ -1263 +1473 @@
     end;
 
-    if DragState = dsMove then
+    Quantize := (roQuantized in Options) and not (ssAlt in Shift);
+
+    if FDragState = dsMove then
     begin
       L := Mx;
       T := My;
+      if Quantize then
+      begin
+        L := Round(L / FQuantized) * FQuantized;
+        T := Round(T / FQuantized) * FQuantized;
+      end;
       R := L + W;
       B := T + H;
@@ -1272 +1489 @@
     else
     begin
-      if DragState in [dsSizeL, dsSizeTL, dsSizeBL] then
+      if FDragState in [dsSizeL, dsSizeTL, dsSizeBL] then
+      begin
         IncLT(L, R, Mx - L, MinWidth, MaxWidth);
-
-      if DragState in [dsSizeR, dsSizeTR, dsSizeBR] then
+        if Quantize then
+          L := Round(L / FQuantized) * FQuantized;
+      end;
+
+      if FDragState in [dsSizeR, dsSizeTR, dsSizeBR] then
+      begin
         IncRB(L, R, Mx - R, MinWidth, MaxWidth);
-
-      if DragState in [dsSizeT, dsSizeTL, dsSizeTR] then
+        if Quantize then
+          R := Round(R / FQuantized) * FQuantized;
+      end;
+
+      if FDragState in [dsSizeT, dsSizeTL, dsSizeTR] then
+      begin
         IncLT(T, B, My - T, MinHeight, MaxHeight);
-
-      if DragState in [dsSizeB, dsSizeBL, dsSizeBR] then
+        if Quantize then
+          T := Round(T / FQuantized) * FQuantized;
+      end;
+
+      if FDragState in [dsSizeB, dsSizeBL, dsSizeBR] then
+      begin
         IncRB(T, B, My - B, MinHeight, MaxHeight);
+        if Quantize then
+          B := Round(B / FQuantized) * FQuantized;
+      end;
     end;
 
@@ -1288 +1521 @@
 
     if roConstrained in FOptions then
-      DoConstrain(OldLocation, NewLocation, DragState, Shift);
+      DoConstrain(FOldLocation, NewLocation, FDragState, Shift);
 
     if roProportional in FOptions then
     begin
-      case DragState of
+      case FDragState of
         dsSizeB, dsSizeBR:
-          NewLocation.Right := OldLocation.Left + (OldLocation.Right - OldLocation.Left) * (NewLocation.Bottom - NewLocation.Top) / (OldLocation.Bottom - OldLocation.Top);
+          NewLocation.Right := FOldLocation.Left + (FOldLocation.Right - FOldLocation.Left) * (NewLocation.Bottom - NewLocation.Top) / (FOldLocation.Bottom - FOldLocation.Top);
         dsSizeT, dsSizeTL:
-          NewLocation.Left := OldLocation.Right - (OldLocation.Right - OldLocation.Left) * (NewLocation.Bottom - NewLocation.Top) / (OldLocation.Bottom - OldLocation.Top);
+          NewLocation.Left := FOldLocation.Right - (FOldLocation.Right - FOldLocation.Left) * (NewLocation.Bottom - NewLocation.Top) / (FOldLocation.Bottom - FOldLocation.Top);
         dsSizeR, dsSizeBL:
-          NewLocation.Bottom := OldLocation.Top + (OldLocation.Bottom - OldLocation.Top) * (NewLocation.Right - NewLocation.Left) / (OldLocation.Right - OldLocation.Left);
+          NewLocation.Bottom := FOldLocation.Top + (FOldLocation.Bottom - FOldLocation.Top) * (NewLocation.Right - NewLocation.Left) / (FOldLocation.Right - FOldLocation.Left);
         dsSizeL, dsSizeTR:
-          NewLocation.Top := OldLocation.Bottom - (OldLocation.Bottom - OldLocation.Top) * (NewLocation.Right - NewLocation.Left) / (OldLocation.Right - OldLocation.Left);
+          NewLocation.Top := FOldLocation.Bottom - (FOldLocation.Bottom - FOldLocation.Top) * (NewLocation.Right - NewLocation.Left) / (FOldLocation.Right - FOldLocation.Left);
       end;
     end;
 
-    DoResizing(OldLocation, NewLocation, DragState, Shift);
+    DoResizing(FOldLocation, NewLocation, FDragState, Shift);
 
     if (NewLocation.Left <> Location.Left) or
@@ -1312 +1545 @@
     begin
       Location := NewLocation;
-      if Assigned(FOnUserChange) then FOnUserChange(Self);
+      if Assigned(FOnUserChange) then
+        FOnUserChange(Self);
     end;
   end;
@@ -1318 +1552 @@
 
 procedure TRubberbandLayer.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
-begin
-  IsDragging := False;
+var
+  PositionedLayer: TPositionedLayer;
+begin
+  if FPassMouse.Enabled then
+  begin
+    if FPassMouse.ToLayerUnderCursor then
+      PositionedLayer := FPassMouse.GetChildUnderCursor(X, Y)
+    else
+      PositionedLayer := ChildLayer;
+
+    if FPassMouse.ToChild and Assigned(ChildLayer) then
+    begin
+      ChildLayer.MouseUp(Button, Shift, X, Y);
+      if FPassMouse.CancelIfPassed then
+        Exit;
+    end;
+
+    if (PositionedLayer <> ChildLayer) and Assigned(PositionedLayer) then
+    begin
+      PositionedLayer.MouseUp(Button, Shift, X, Y);
+      if FPassMouse.CancelIfPassed then
+        Exit;
+    end;
+  end;
+
+  FIsDragging := False;
   inherited;
 end;
@@ -1329 +1587 @@
 end;
 
+procedure TRubberbandLayer.DrawHandle(Buffer: TBitmap32; X, Y: TFloat);
+var
+  HandleRect: TRect;
+begin
+  // Coordinate specifies exact center of handle. I.e. center of
+  // pixel if handle is odd number of pixels wide.
+
+  HandleRect.Left := Floor(X - FHandleSize);
+  HandleRect.Right := HandleRect.Left + Ceil(FHandleSize*2);
+  HandleRect.Top := Floor(Y - FHandleSize);
+  HandleRect.Bottom := HandleRect.Top + Ceil(FHandleSize*2);
+
+  Buffer.FrameRectTS(HandleRect, FHandleFrame);
+
+  GR32.InflateRect(HandleRect, -1, -1);
+  Buffer.FillRectTS(HandleRect, FHandleFill);
+end;
+
 procedure TRubberbandLayer.Paint(Buffer: TBitmap32);
-var
-  Cx, Cy: Integer;
+
+var
+  CenterX, CenterY: TFloat;
   R: TRect;
-
-  procedure DrawHandle(X, Y: Integer);
-  begin
-    Buffer.FillRectTS(X - FHandleSize, Y - FHandleSize, X + FHandleSize, Y + FHandleSize, FHandleFill);
-    Buffer.FrameRectTS(X - FHandleSize, Y - FHandleSize, X + FHandleSize, Y + FHandleSize, FHandleFrame);
-  end;
-
 begin
   R := MakeRect(GetAdjustedRect(FLocation));
@@ -1354 +1624 @@
     if rhCorners in FHandles then
     begin
-      if not(rhNotTLCorner in FHandles) then DrawHandle(Left, Top);
-      if not(rhNotTRCorner in FHandles) then DrawHandle(Right, Top);
-      if not(rhNotBLCorner in FHandles) then DrawHandle(Left, Bottom);
-      if not(rhNotBRCorner in FHandles) then DrawHandle(Right, Bottom);
+      if not(rhNotTLCorner in FHandles) then DrawHandle(Buffer, Left+0.5, Top+0.5);
+      if not(rhNotTRCorner in FHandles) then DrawHandle(Buffer, Right-0.5, Top+0.5);
+      if not(rhNotBLCorner in FHandles) then DrawHandle(Buffer, Left+0.5, Bottom-0.5);
+      if not(rhNotBRCorner in FHandles) then DrawHandle(Buffer, Right-0.5, Bottom-0.5);
     end;
     if rhSides in FHandles then
     begin
-      Cx := (Left + Right) div 2;
-      Cy := (Top + Bottom) div 2;
-      if not(rhNotTopSide in FHandles) then DrawHandle(Cx, Top);
-      if not(rhNotLeftSide in FHandles) then DrawHandle(Left, Cy);
-      if not(rhNotRightSide in FHandles) then DrawHandle(Right, Cy);
-      if not(rhNotBottomSide in FHandles) then DrawHandle(Cx, Bottom);
-    end;
-  end;
+      CenterX := (Left + Right) / 2;
+      CenterY := (Top + Bottom) / 2;
+      if not(rhNotTopSide in FHandles) then DrawHandle(Buffer, CenterX, Top+0.5);
+      if not(rhNotLeftSide in FHandles) then DrawHandle(Buffer, Left+0.5, CenterY);
+      if not(rhNotRightSide in FHandles) then DrawHandle(Buffer, Right-0.5, CenterY);
+      if not(rhNotBottomSide in FHandles) then DrawHandle(Buffer, CenterX, Bottom-0.5);
+    end;
+  end;
+end;
+
+procedure TRubberbandLayer.Quantize;
+begin
+  Location := FloatRect(
+    Round(Location.Left / Quantized) * Quantized,
+    Round(Location.Top / Quantized) * Quantized,
+    Round(Location.Right / Quantized) * Quantized,
+    Round(Location.Bottom / Quantized) * Quantized);
 end;
 
@@ -1385 +1664 @@
 end;
 
+procedure TRubberbandLayer.SetDragState(const Value: TRBDragState);
+begin
+  SetDragState(Value, 0, 0);
+end;
+
+procedure TRubberbandLayer.SetDragState(const Value: TRBDragState; const X, Y: Integer);
+var
+  ALoc: TFloatRect;
+begin
+  FDragState := Value;
+  FIsDragging := FDragState <> dsNone;
+
+  if FIsDragging then
+  begin
+    FOldLocation := Location;
+
+    ALoc := GetAdjustedRect(FLocation);
+
+    case FDragState of
+      dsMove: FMouseShift := FloatPoint(X - ALoc.Left, Y - ALoc.Top);
+    else
+      FMouseShift := FloatPoint(0, 0);
+    end;
+  end;
+end;
+
 procedure TRubberbandLayer.SetHandleFill(Value: TColor32);
 begin
@@ -1412 +1717 @@
 end;
 
-procedure TRubberbandLayer.SetHandleSize(Value: Integer);
-begin
-  if Value < 1 then Value := 1;
+procedure TRubberbandLayer.SetHandleSize(Value: TFloat);
+begin
+  if Value < 1 then
+    Value := 1;
   if Value <> FHandleSize then
   begin
@@ -1466 +1772 @@
 end;
 
+procedure TRubberbandLayer.SetQuantized(const Value: Integer);
+begin
+  if Value < 1 then
+    raise Exception.Create('Value must be larger than zero!');
+
+  FQuantized := Value;
+end;
+
 end.

GraphicTest/Packages/Graphics32/GR32_LowLevel.pas

@@ -49 +49 @@
 
 uses
-  Graphics, GR32, GR32_Math, GR32_System, GR32_Bindings;
+  Graphics, GR32, GR32_Math;
 
 { Clamp function restricts value to [0..255] range }
@@ -68 +68 @@
 procedure MoveWord(const Source; var Dest; Count: Integer);
 
+{$IFDEF USESTACKALLOC}
 { Allocates a 'small' block of memory on the stack }
 function StackAlloc(Size: Integer): Pointer; register;
@@ -73 +74 @@
 { Pops memory allocated by StackAlloc }
 procedure StackFree(P: Pointer); register;
+{$ENDIF}
 
 { Exchange two 32-bit values }
@@ -79 +81 @@
 procedure Swap(var A, B: TFixed); overload;{$IFDEF USEINLINING} inline; {$ENDIF}
 procedure Swap(var A, B: TColor32); overload;{$IFDEF USEINLINING} inline; {$ENDIF}
+procedure Swap32(var A, B); overload;{$IFDEF USEINLINING} inline; {$ENDIF}
 
 { Exchange A <-> B only if B < A }
@@ -147 +150 @@
 
 { shift right with sign conservation }
+function SAR_3(Value: Integer): Integer;
 function SAR_4(Value: Integer): Integer;
+function SAR_6(Value: Integer): Integer;
 function SAR_8(Value: Integer): Integer;
 function SAR_9(Value: Integer): Integer;
@@ -162 +167 @@
 implementation
 
+uses
 {$IFDEF FPC}
-uses
-  SysUtils;
-{$ENDIF}
+  SysUtils,
+{$ENDIF}
+  GR32_System, GR32_Bindings;
 
 {$R-}{$Q-}  // switch off overflow and range checking
@@ -172 +178 @@
 {$IFDEF USENATIVECODE}
 begin
- if Value > 255 then Result := 255
-  else if Value < 0 then Result := 0
-  else Result := Value;
-{$ELSE}
+ if Value > 255 then
+   Result := 255
+ else
+ if Value < 0 then
+   Result := 0
+ else
+   Result := Value;
+{$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -202 +213 @@
 
 {$IFNDEF PUREPASCAL}
-procedure FillLongword_ASM(var X; Count: Cardinal; Value: Longword);
+procedure FillLongword_ASM(var X; Count: Cardinal; Value: Longword); {$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -232 +243 @@
 end;
 
-procedure FillLongword_MMX(var X; Count: Cardinal; Value: Longword);
+procedure FillLongword_MMX(var X; Count: Cardinal; Value: Longword); {$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -301 +312 @@
 end;
 
-procedure FillLongword_SSE2(var X; Count: Integer; Value: Longword);
+procedure FillLongword_SSE2(var X; Count: Integer; Value: Longword); {$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -363 +374 @@
 {$IFDEF TARGET_x64}
         // RCX = X;   RDX = Count;   R8 = Value
-        TEST       EDX,EDX    // if Count = 0 then
-        JZ         @Exit      //   Exit
-        MOV        RAX, RCX   // RAX = X
-
-        PUSH       RDI        // store RDI on stack
-        MOV        R9, RDX    // R9 = Count
-        MOV        RDI, RDX   // RDI = Count
-
-        SHR        RDI, 1     // RDI = RDI SHR 1
-        SHL        RDI, 1     // RDI = RDI SHL 1
-        SUB        R9, RDI    // check if extra fill is necessary
-        JE         @QLoopIni
-
-        MOV        [RAX], R8D // eventually perform extra fill
-        ADD        RAX, 4     // Inc(X, 4)
-        DEC        RDX        // Dec(Count)
-        JZ         @ExitPOP   // if (Count = 0) then Exit
-@QLoopIni:
-        MOVD       XMM0, R8D  // XMM0 = R8D
-        PUNPCKLDQ  XMM0, XMM0 // unpack XMM0 register
-        SHR        RDX, 1     // RDX = RDX div 2
-@QLoop:
-        MOVQ       QWORD PTR [RAX], XMM0 // perform fill
-        ADD        RAX, 8     // Inc(X, 8)
-        DEC        RDX        // Dec(X);
-        JNZ        @QLoop
-        EMMS
-@ExitPOP:
-        POP        RDI
+
+        TEST       RDX, RDX        // if Count = 0 then
+        JZ         @Exit           //   Exit
+
+        MOV        R9, RCX         // Point R9 to destination
+
+        CMP        RDX, 32
+        JL         @SmallLoop
+
+        AND        RCX, 3          // get aligned count
+        TEST       RCX, RCX        // check if X is not dividable by 4
+        JNZ        @SmallLoop      // otherwise perform slow small loop
+
+        MOV        RCX, R9
+        SHR        RCX, 2          // bytes to count
+        AND        RCX, 3          // get aligned count
+        ADD        RCX,-4
+        NEG        RCX             // get count to advance
+        JZ         @SetupMain
+        SUB        RDX, RCX        // subtract aligning start from total count
+
+@AligningLoop:
+        MOV        [R9], R8D
+        ADD        R9, 4
+        DEC        RCX
+        JNZ        @AligningLoop
+
+@SetupMain:
+        MOV        RCX, RDX        // RCX = remaining count
+        SHR        RCX, 2
+        SHL        RCX, 2
+        SUB        RDX, RCX        // RDX = remaining count
+        SHR        RCX, 2
+
+        MOVD       XMM0, R8D
+        PUNPCKLDQ  XMM0, XMM0
+        PUNPCKLDQ  XMM0, XMM0
+@SSE2Loop:
+        MOVDQA     [R9], XMM0
+        ADD        R9, 16
+        DEC        RCX
+        JNZ        @SSE2Loop
+
+        TEST       RDX, RDX
+        JZ         @Exit
+@SmallLoop:
+        MOV        [R9], R8D
+        ADD        R9, 4
+        DEC        RDX
+        JNZ        @SmallLoop
 @Exit:
 {$ENDIF}
@@ -407 +439 @@
     P[I] := Value;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -445 +478 @@
   Move(Source, Dest, Count shl 2);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -486 +520 @@
   Move(Source, Dest, Count shl 1);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -557 +592 @@
   A := B;
   B := T;
+end;
+
+procedure Swap32(var A, B);
+var
+  T: Integer;
+begin
+  T := Integer(A);
+  Integer(A) := Integer(B);
+  Integer(B) := T;
 end;
 
@@ -613 +657 @@
     Result := Value;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -651 +696 @@
     Result := C;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -674 +720 @@
     Result := C;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -696 +743 @@
     Result := Value;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -725 +773 @@
     Result := Value;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -743 +792 @@
     Result := Max + (Value - Max) mod (Max + 1)
   else
-    Result := (Value) mod (Max + 1);
-{$ELSE}
+    Result := Value mod (Max + 1);
+{$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -776 +826 @@
   Result := FloatMod(Value, Max);
 {$ELSE}
+  if Max = 0 then
+  begin
+    Result := 0;
+    Exit;
+  end;
+
   Result := Value;
   while Result >= Max do Result := Result - Max;
@@ -788 +844 @@
   Result := Dividend div Divisor;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -826 +883 @@
     Result := Max - Result;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -861 +919 @@
     Inc(Result, Min);
   end;
-  if Odd(DivResult) then Result := Max+Min-Result;
+  if Odd(DivResult) then Result := Max + Min - Result;
 end;
 
@@ -979 +1037 @@
 
 { shift right with sign conservation }
+function SAR_3(Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value div 8;
+{$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
+asm
+{$IFDEF TARGET_x64}
+        MOV       EAX,ECX
+{$ENDIF}
+        SAR       EAX,3
+{$ENDIF}
+end;
+
 function SAR_4(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 16;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -992 +1065 @@
 end;
 
+function SAR_6(Value: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Value div 64;
+{$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
+asm
+{$IFDEF TARGET_x64}
+        MOV       EAX,ECX
+{$ENDIF}
+        SAR       EAX,6
+{$ENDIF}
+end;
+
 function SAR_8(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 256;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1006 +1094 @@
 
 function SAR_9(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 512;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1019 +1108 @@
 
 function SAR_11(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 2048;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1032 +1122 @@
 
 function SAR_12(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 4096;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1045 +1136 @@
 
 function SAR_13(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 8192;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1058 +1150 @@
 
 function SAR_14(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 16384;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1071 +1164 @@
 
 function SAR_15(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 32768;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1084 +1178 @@
 
 function SAR_16(Value: Integer): Integer;
-{$IFDEF USENATIVECODE}
+{$IFDEF PUREPASCAL}
 begin
   Result := Value div 65536;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -1108 +1203 @@
   REn.B := WCEn.R;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 // EAX = WinColor
@@ -1121 +1217 @@
 end;
 
+{$IFDEF USESTACKALLOC}
 {$IFDEF PUREPASCAL}
 function StackAlloc(Size: Integer): Pointer;
@@ -1138 +1235 @@
   x64 implementation by Jameel Halabi
   }
-function StackAlloc(Size: Integer): Pointer; register;
+function StackAlloc(Size: Integer): Pointer; register; {$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -1163 +1260 @@
 {$ENDIF}
 {$IFDEF TARGET_x64}
-        MOV       RAX, RCX
+        {$IFNDEF FPC}
+        .NOFRAME
+        {$ENDIF}
         POP       R8           // return address
         MOV       RDX, RSP     // original SP
         ADD       ECX, 15
         AND       ECX, NOT 15  // round up to keep SP dqword aligned
-        CMP       ECX, 4092
+        CMP       ECX, 4088
         JLE       @@2
 @@1:
-        SUB       RSP, 4092
+        SUB       RSP, 4088
         PUSH      RCX          // make sure we touch guard page, to grow stack
         SUB       ECX, 4096
@@ -1183 +1282 @@
         SUB       RDX, 8
         PUSH      RDX          // save current SP, for sanity check  (sp = [sp])
+        PUSH      R8           // return to caller
 {$ENDIF}
 end;
@@ -1196 +1296 @@
   corrupt the stack. Worst case is that the stack block is not released until
   the calling routine exits. }
-procedure StackFree(P: Pointer); register;
+procedure StackFree(P: Pointer); register; {$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
-        POP       ECX                     { return address }
+        POP       ECX                     // return address
         MOV       EDX, DWORD PTR [ESP]
         SUB       EAX, 8
-        CMP       EDX, ESP                { sanity check #1 (SP = [SP]) }
+        CMP       EDX, ESP                // sanity check #1 (SP = [SP])
         JNE       @Exit
-        CMP       EDX, EAX                { sanity check #2 (P = this stack block) }
+        CMP       EDX, EAX                // sanity check #2 (P = this stack block)
         JNE       @Exit
-        MOV       ESP, DWORD PTR [ESP+4]  { restore previous SP  }
+        MOV       ESP, DWORD PTR [ESP+4]  // restore previous SP
 @Exit:
-        PUSH      ECX                     { return to caller }
-{$ENDIF}
-{$IFDEF TARGET_x64}
-        POP       R8                       { return address }
+        PUSH      ECX                     // return to caller
+{$ENDIF}
+{$IFDEF TARGET_x64}
+        {$IFNDEF FPC}
+        .NOFRAME
+        {$ENDIF}
+        POP       R8                       // return address
         MOV       RDX, QWORD PTR [RSP]
         SUB       RCX, 16
-        CMP       RDX, RSP                 { sanity check #1 (SP = [SP]) }
+        CMP       RDX, RSP                 // sanity check #1 (SP = [SP])
         JNE       @Exit
-        CMP       RDX, RCX                 { sanity check #2 (P = this stack block) }
+        CMP       RDX, RCX                 // sanity check #2 (P = this stack block)
         JNE       @Exit
-        MOV       RSP, QWORD PTR [RSP + 8] { restore previous SP  }
+        MOV       RSP, QWORD PTR [RSP + 8] // restore previous SP
  @Exit:
-        PUSH      R8                       { return to caller }
-{$ENDIF}
-end;
+        PUSH      R8                       // return to caller
+{$ENDIF}
+end;
+{$ENDIF}
 {$ENDIF}
 

GraphicTest/Packages/Graphics32/GR32_Math.pas

@@ -59 +59 @@
 procedure SinCos(const Theta: TFloat; out Sin, Cos: TFloat); overload;
 procedure SinCos(const Theta, Radius: Single; out Sin, Cos: Single); overload;
+procedure SinCos(const Theta, ScaleX, ScaleY: TFloat; out Sin, Cos: Single); overload;
 function Hypot(const X, Y: TFloat): TFloat; overload;
 function Hypot(const X, Y: Integer): Integer; overload;
@@ -86 +87 @@
 function FloatMod(x, y: Double): Double; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
 
+function DivMod(Dividend, Divisor: Integer; var Remainder: Integer): Integer;
+
+
+{$IFDEF FPC}
+{$IFDEF TARGET_X64}
+(*
+  FPC has no similar {$EXCESSPRECISION OFF} directive,
+  but we can easily emulate that by overriding some internal math functions
+*)
+function PI: Single; [internproc: fpc_in_pi_real];
+//function Abs(D: Single): Single; [internproc: fpc_in_abs_real];
+//function Sqr(D: Single): Single; [internproc: fpc_in_sqr_real];
+function Sqrt(D: Single): Single; [internproc: fpc_in_sqrt_real];
+function ArcTan(D: Single): Single; [internproc: fpc_in_arctan_real];
+function Ln(D: Single): Single; [internproc: fpc_in_ln_real];
+function Sin(D: Single): Single; [internproc: fpc_in_sin_real];
+function Cos(D: Single): Single; [internproc: fpc_in_cos_real];
+function Exp(D: Single): Single; [internproc: fpc_in_exp_real];
+function Round(D: Single): Int64; [internproc: fpc_in_round_real];
+function Frac(D: Single): Single; [internproc: fpc_in_frac_real];
+function Int(D: Single): Single; [internproc: fpc_in_int_real];
+function Trunc(D: Single): Int64; [internproc: fpc_in_trunc_real];
+
+function Ceil(X: Single): Integer; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+function Floor(X: Single): Integer; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+{$ENDIF}
+{$ENDIF}
+
+type
+  TCumSumProc = procedure(Values: PSingleArray; Count: Integer);
+
+var
+  CumSum: TCumSumProc;
+
 implementation
 
 uses
-  Math;
+  Math, GR32_System;
 
 {$IFDEF PUREPASCAL}
@@ -96 +131 @@
 {$ENDIF}
 
+
+{$IFDEF FPC}
+{$IFDEF TARGET_X64}
+function Ceil(X: Single): Integer;
+begin
+  Result := Trunc(X);
+  if (X - Result) > 0 then
+    Inc(Result);
+end;
+
+function Floor(X: Single): Integer;
+begin
+  Result := Trunc(X);
+  if (X - Result) < 0 then
+    Dec(Result);
+end;
+{$ENDIF}
+{$ENDIF}
+
+
 { Fixed-point math }
 
@@ -103 +158 @@
   Result := A div FIXEDONE;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -119 +175 @@
   Result := (A + $FFFF) div FIXEDONE;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -137 +194 @@
   Result := (A + $7FFF) div FIXEDONE;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -155 +213 @@
   Result := Round(A * FixedToFloat * B);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -173 +232 @@
   Result := Round(A / B * FixedOne);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -199 +259 @@
   Result := Round(Dividend / Value);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -219 +280 @@
   Result := Round(Value * FixedToFloat * Value);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -237 +299 @@
   Result := Round(Sqrt(Value * FixedOneS));
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -297 +360 @@
   Result := Round(Sqrt(Value * FixedOneS));
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -397 +461 @@
   Result := Round(Y + (X - Y) * FixedToFloat * W);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -427 +492 @@
 {$IFDEF TARGET_x64}
 var
-  Temp: DWord = 0;
+  Temp: TFloat;
 {$ENDIF}
 asm
@@ -455 +520 @@
   Cos := C * Radius;
 {$ELSE}
+{$IFDEF TARGET_x64}
+var
+  Temp: TFloat;
+{$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -477 +546 @@
 end;
 
+procedure SinCos(const Theta, ScaleX, ScaleY: TFloat; out Sin, Cos: Single); overload;
+{$IFDEF NATIVE_SINCOS}
+var
+  S, C: Extended;
+begin
+  Math.SinCos(Theta, S, C);
+  Sin := S * ScaleX;
+  Cos := C * ScaleY;
+{$ELSE}
+{$IFDEF TARGET_x64}
+var
+  Temp: TFloat;
+{$ENDIF}
+asm
+{$IFDEF TARGET_x86}
+        FLD     Theta
+        FSINCOS
+        FMUL    ScaleX
+        FSTP    DWORD PTR [EDX] // cosine
+        FMUL    ScaleY
+        FSTP    DWORD PTR [EAX] // sine
+{$ENDIF}
+{$IFDEF TARGET_x64}
+        MOVD    Temp, Theta
+        FLD     Temp
+        FSINCOS
+        MOVD    Temp, ScaleX
+        FMUL    Temp
+        FSTP    [Cos]
+        MOVD    Temp, ScaleY
+        FMUL    Temp
+        FSTP    [Sin]
+{$ENDIF}
+{$ENDIF}
+end;
+
 function Hypot(const X, Y: TFloat): TFloat;
 {$IFDEF PUREPASCAL}
@@ -482 +587 @@
   Result := Sqrt(Sqr(X) + Sqr(Y));
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -534 +640 @@
   J := (I - $3F800000) div 2 + $3F800000;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -552 +659 @@
 // see http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Approximations_that_depend_on_IEEE_representation
 // additionally one babylonian step added
+{$IFNDEF PUREPASCAL}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
+{$ENDIF}
 const
   CHalf : TFloat = 0.5;
@@ -594 +704 @@
  Result := CQuarter * Result + Value / Result;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 const
   CHalf : TFloat = 0.5;
@@ -616 +727 @@
         DIVSS   XMM0, XMM1
         ADDSS   XMM0, XMM1
-        MOVD    XMM1, CHalf
+        MOVD    XMM1, [RIP + CHalf]
         MULSS   XMM0, XMM1
 {$ENDIF}
@@ -638 +749 @@
   Result := Int64(Multiplicand) * Int64(Multiplier) div Divisor;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -741 +853 @@
     Result := Result shl 1;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -764 +877 @@
     Result := Result shl 1;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -796 +910 @@
   Result := (A and B) + (A xor B) div 2;
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x86}
@@ -821 +936 @@
   Result := (- Value) shr 31 - (Value shr 31);
 {$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
 asm
 {$IFDEF TARGET_x64}
@@ -840 +956 @@
 end;
 
+function DivMod(Dividend, Divisor: Integer; var Remainder: Integer): Integer;
+{$IFDEF PUREPASCAL}
+begin
+  Result := Dividend div Divisor;
+  Remainder := Dividend mod Divisor;
+{$ELSE}
+{$IFDEF FPC} assembler; nostackframe; {$ENDIF}
+asm
+{$IFDEF TARGET_x86}
+        PUSH    EDX
+        CDQ
+        IDIV    DWORD PTR [ESP]
+        ADD     ESP, $04
+        MOV     DWORD PTR [ECX], edx
+{$ENDIF}
+{$IFDEF TARGET_x64}
+        MOV     RAX, RCX
+        MOV     R9, RDX
+        CDQ
+        IDIV    R9
+        MOV     DWORD PTR [R8], EDX
+{$ENDIF}
+{$ENDIF}
+end;
+
+procedure CumSum_Pas(Values: PSingleArray; Count: Integer);
+var
+  I: Integer;
+  V: TFloat;
+begin
+  V := Values[0];
+  for I := 1 to Count - 1 do
+  begin
+    if PInteger(@Values[I])^ <> 0 then
+      V := V + Values[I];
+    Values[I] := V;
+  end;
+end;
+
+{$IFNDEF PUREPASCAL}
+// Aligned SSE2 version -- Credits: Sanyin <prevodilac@hotmail.com>
+procedure CumSum_SSE2(Values: PSingleArray; Count: Integer); {$IFDEF FPC} assembler; nostackframe; {$ENDIF}
+asm
+{$IFDEF TARGET_x86}
+        MOV     ECX,EDX
+        CMP     ECX,2       // if count < 2, exit
+        JL      @END
+        CMP     ECX,32      // if count < 32, avoid SSE2 overhead
+        JL      @SMALL
+
+{--- align memory ---}
+        PUSH    EBX
+        PXOR    XMM4,XMM4
+        MOV     EBX,EAX
+        AND     EBX,15       // get aligned count
+        JZ      @ENDALIGNING // already aligned
+        ADD     EBX,-16
+        NEG     EBX          // get bytes to advance
+        JZ      @ENDALIGNING // already aligned
+
+        MOV     ECX,EBX
+        SAR     ECX,2        // div with 4 to get cnt
+        SUB     EDX,ECX
+
+        ADD     EAX,4
+        DEC     ECX
+        JZ      @SETUPLAST   // one element
+
+@ALIGNINGLOOP:
+        FLD     DWORD PTR [EAX-4]
+        FADD    DWORD PTR [EAX]
+        FSTP    DWORD PTR [EAX]
+        ADD     EAX,4
+        DEC     ECX
+        JNZ     @ALIGNINGLOOP
+
+@SETUPLAST:
+        MOVUPS  XMM4,[EAX-4]
+        PSLLDQ  XMM4,12
+        PSRLDQ  XMM4,12
+
+@ENDALIGNING:
+        POP     EBX
+        PUSH    EBX
+        MOV     ECX,EDX
+        SAR     ECX,2
+@LOOP:
+        MOVAPS  XMM0,[EAX]
+        PXOR    XMM5,XMM5
+        PCMPEQD XMM5,XMM0
+        PMOVMSKB EBX,XMM5
+        CMP     EBX,$0000FFFF
+        JNE     @NORMAL
+        PSHUFD  XMM0,XMM4,0
+        JMP     @SKIP
+
+@NORMAL:
+        ADDPS   XMM0,XMM4
+        PSHUFD  XMM1,XMM0,$e4
+        PSLLDQ  XMM1,4
+        PSHUFD  XMM2,XMM1,$90
+        PSHUFD  XMM3,XMM1,$40
+        ADDPS   XMM2,XMM3
+        ADDPS   XMM1,XMM2
+        ADDPS   XMM0,XMM1
+
+        PSHUFLW XMM4,XMM0,$E4
+        PSRLDQ  XMM4,12
+
+@SKIP:
+        PREFETCHNTA [eax+16*16*2]
+        MOVAPS  [EAX],XMM0
+        ADD     EAX,16
+        SUB     ECX,1
+        JNZ     @LOOP
+        POP     EBX
+        MOV     ECX,EDX
+        SAR     ECX,2
+        SHL     ECX,2
+        SUB     EDX,ECX
+        MOV     ECX,EDX
+        JZ      @END
+
+@LOOP2:
+        FLD     DWORD PTR [EAX-4]
+        FADD    DWORD PTR [EAX]
+        FSTP    DWORD PTR [EAX]
+        ADD     EAX,4
+        DEC     ECX
+        JNZ     @LOOP2
+        JMP     @END
+
+@SMALL:
+        MOV     ECX,EDX
+        ADD     EAX,4
+        DEC     ECX
+@LOOP3:
+        FLD     DWORD PTR [EAX-4]
+        FADD    DWORD PTR [EAX]
+        FSTP    DWORD PTR [EAX]
+        ADD     EAX,4
+        DEC     ECX
+        JNZ     @LOOP3
+{$ENDIF}
+{$IFDEF TARGET_x64}
+        CMP     EDX,2       // if count < 2, exit
+        JL      @END
+
+        MOV     RAX,RCX
+        MOV     ECX,EDX
+
+        CMP     ECX,32      // if count < 32, avoid SSE2 overhead
+        JL      @SMALL
+
+{--- align memory ---}
+        PXOR    XMM4,XMM4
+        MOV     R8D,EAX
+        AND     R8D,15       // get aligned count
+        JZ      @ENDALIGNING // already aligned
+        ADD     R8D,-16
+        NEG     R8D          // get bytes to advance
+        JZ      @ENDALIGNING // already aligned
+
+        MOV     ECX,R8D
+        SAR     ECX,2        // div with 4 to get cnt
+        SUB     EDX,ECX
+
+        ADD     RAX,4
+        DEC     ECX
+        JZ      @SETUPLAST   // one element
+
+@ALIGNINGLOOP:
+        FLD     DWORD PTR [RAX - 4]
+        FADD    DWORD PTR [RAX]
+        FSTP    DWORD PTR [RAX]
+        ADD     RAX,4
+        DEC     ECX
+        JNZ     @ALIGNINGLOOP
+
+@SETUPLAST:
+        MOVUPS  XMM4,[RAX - 4]
+        PSLLDQ  XMM4,12
+        PSRLDQ  XMM4,12
+
+@ENDALIGNING:
+        MOV     ECX,EDX
+        SAR     ECX,2
+@LOOP:
+        MOVAPS  XMM0,[RAX]
+        PXOR    XMM5,XMM5
+        PCMPEQD XMM5,XMM0
+        PMOVMSKB R8D,XMM5
+        CMP     R8D,$0000FFFF
+        JNE     @NORMAL
+        PSHUFD  XMM0,XMM4,0
+        JMP     @SKIP
+
+@NORMAL:
+        ADDPS   XMM0,XMM4
+        PSHUFD  XMM1,XMM0,$e4
+        PSLLDQ  XMM1,4
+        PSHUFD  XMM2,XMM1,$90
+        PSHUFD  XMM3,XMM1,$40
+        ADDPS   XMM2,XMM3
+        ADDPS   XMM1,XMM2
+        ADDPS   XMM0,XMM1
+
+        PSHUFLW XMM4,XMM0,$E4
+        PSRLDQ  XMM4,12
+
+@SKIP:
+        PREFETCHNTA [RAX + 32 * 2]
+        MOVAPS  [RAX],XMM0
+        ADD     RAX,16
+        SUB     ECX,1
+        JNZ     @LOOP
+        MOV     ECX,EDX
+        SAR     ECX,2
+        SHL     ECX,2
+        SUB     EDX,ECX
+        MOV     ECX,EDX
+        JZ      @END
+
+@LOOP2:
+        FLD     DWORD PTR [RAX - 4]
+        FADD    DWORD PTR [RAX]
+        FSTP    DWORD PTR [RAX]
+        ADD     RAX,4
+        DEC     ECX
+        JNZ     @LOOP2
+        JMP     @END
+
+@SMALL:
+        ADD     RAX,4
+        DEC     ECX
+@LOOP3:
+        FLD     DWORD PTR [RAX - 4]
+        FADD    DWORD PTR [RAX]
+        FSTP    DWORD PTR [RAX]
+        ADD     RAX,4
+        DEC     ECX
+        JNZ     @LOOP3
+{$ENDIF}
+@END:
+end;
+{$ENDIF}
+
+
+initialization
+{$IFNDEF PUREPASCAL}
+  if HasInstructionSet(ciSSE2) then
+    CumSum := CumSum_SSE2
+  else
+{$ENDIF}
+    CumSum := CumSum_Pas;
+
 end.

GraphicTest/Packages/Graphics32/GR32_MicroTiles.pas

@@ -62 +62 @@
 {$ENDIF}
   SysUtils, Classes,
-  GR32, GR32_System, GR32_Containers, GR32_Layers, GR32_RepaintOpt, GR32_Bindings;
+  GR32, GR32_System, GR32_Containers, GR32_Layers, GR32_RepaintOpt;
 
 const
@@ -242 +242 @@
 
 uses
-  GR32_LowLevel, GR32_Math, Math;
+  GR32_Bindings, GR32_LowLevel, GR32_Math, Math;
 
 var

GraphicTest/Packages/Graphics32/GR32_OrdinalMaps.pas

@@ -54 +54 @@
     ctWeightedRGB);
 
+{$IFDEF FPC}
+  PInteger = ^Integer;
+{$ENDIF}
+
   TBooleanMap = class(TCustomMap)
   private
-    FBits: TArrayOfByte;
     function GetValue(X, Y: Integer): Boolean;
     procedure SetValue(X, Y: Integer; const Value: Boolean);
-    function GetBits: PByteArray;
   protected
+    FBits: PByteArray;
     procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
   public
+    constructor Create; overload; override;
     destructor Destroy; override;
+
     function Empty: Boolean; override;
     procedure Clear(FillValue: Byte);
     procedure ToggleBit(X, Y: Integer);
+
     property Value[X, Y: Integer]: Boolean read GetValue write SetValue; default;
-    property Bits: PByteArray read GetBits;
+    property Bits: PByteArray read FBits;
   end;
 
   TByteMap = class(TCustomMap)
   private
-    FBits: TArrayOfByte;
     function GetValue(X, Y: Integer): Byte; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     function GetValPtr(X, Y: Integer): PByte; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     procedure SetValue(X, Y: Integer; Value: Byte); {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
-    function GetBits: PByteArray;
+    function GetScanline(Y: Integer): PByteArray;
   protected
+    FBits: PByteArray;
     procedure AssignTo(Dst: TPersistent); override;
     procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
   public
+    constructor Create; overload; override;
     destructor Destroy; override;
+
     procedure Assign(Source: TPersistent); override;
-    function  Empty: Boolean; override;
+    function Empty: Boolean; override;
     procedure Clear(FillValue: Byte);
+
+    procedure Multiply(Value: Byte);
+    procedure Add(Value: Byte);
+    procedure Sub(Value: Byte);
+
     procedure ReadFrom(Source: TCustomBitmap32; Conversion: TConversionType);
     procedure WriteTo(Dest: TCustomBitmap32; Conversion: TConversionType); overload;
     procedure WriteTo(Dest: TCustomBitmap32; const Palette: TPalette32); overload;
-    property Bits: PByteArray read GetBits;
+
+    procedure DrawTo(Dest: TCustomBitmap32; X, Y: Integer; Color: TColor32); overload;
+    procedure DrawTo(Dest: TCustomBitmap32; Rect: TRect; Color: TColor32); overload;
+
+    procedure Downsample(Factor: Byte); overload;
+    procedure Downsample(Dest: TByteMap; Factor: Byte); overload;
+
+    procedure FlipHorz(Dst: TByteMap = nil);
+    procedure FlipVert(Dst: TByteMap = nil);
+    procedure Rotate90(Dst: TByteMap = nil);
+    procedure Rotate180(Dst: TByteMap = nil);
+    procedure Rotate270(Dst: TByteMap = nil);
+
+    property Bits: PByteArray read FBits;
+    property Scanline[Y: Integer]: PByteArray read GetScanline;
     property ValPtr[X, Y: Integer]: PByte read GetValPtr;
     property Value[X, Y: Integer]: Byte read GetValue write SetValue; default;
   end;
 
+  { TWordMap }
+
   TWordMap = class(TCustomMap)
   private
-    FBits: TArrayOfWord;
     function GetValPtr(X, Y: Integer): PWord; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     function GetValue(X, Y: Integer): Word; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     procedure SetValue(X, Y: Integer; const Value: Word); {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
-    function GetBits: PWordArray;
+    function GetScanline(Y: Integer): PWordArray;
   protected
+    FBits: PWordArray;
     procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
   public
+    constructor Create; overload; override;
     destructor Destroy; override;
+
+    procedure Assign(Source: TPersistent); override;
     function Empty: Boolean; override;
     procedure Clear(FillValue: Word);
+
     property ValPtr[X, Y: Integer]: PWord read GetValPtr;
     property Value[X, Y: Integer]: Word read GetValue write SetValue; default;
-    property Bits: PWordArray read GetBits;
-  end;
+    property Bits: PWordArray read FBits;
+    property Scanline[Y: Integer]: PWordArray read GetScanline;
+  end;
+
+  { TIntegerMap }
 
   TIntegerMap = class(TCustomMap)
   private
-    FBits: TArrayOfInteger;
     function GetValPtr(X, Y: Integer): PInteger; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     function GetValue(X, Y: Integer): Integer; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     procedure SetValue(X, Y: Integer; const Value: Integer); {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
-    function GetBits: PIntegerArray;
+    function GetScanline(Y: Integer): PIntegerArray;
   protected
+    FBits: PIntegerArray;
     procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
   public
+    constructor Create; overload; override;
     destructor Destroy; override;
+
+    procedure Assign(Source: TPersistent); override;
     function Empty: Boolean; override;
-    procedure Clear(FillValue: Integer);
+    procedure Clear(FillValue: Integer = 0);
+
     property ValPtr[X, Y: Integer]: PInteger read GetValPtr;
     property Value[X, Y: Integer]: Integer read GetValue write SetValue; default;
-    property Bits: PIntegerArray read GetBits;
-  end;
+    property Bits: PIntegerArray read FBits;
+    property Scanline[Y: Integer]: PIntegerArray read GetScanline;
+  end;
+
+  { TCardinalMap }
+
+  TCardinalMap = class(TCustomMap)
+  private
+    function GetValPtr(X, Y: Cardinal): PCardinal; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+    function GetValue(X, Y: Cardinal): Cardinal; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+    procedure SetValue(X, Y: Cardinal; const Value: Cardinal); {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+    function GetScanline(Y: Integer): PCardinalArray;
+  protected
+    FBits: PCardinalArray;
+    procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
+  public
+    constructor Create; overload; override;
+    destructor Destroy; override;
+
+    procedure Assign(Source: TPersistent); override;
+    function Empty: Boolean; override;
+    procedure Clear(FillValue: Cardinal = 0);
+
+    property ValPtr[X, Y: Cardinal]: PCardinal read GetValPtr;
+    property Value[X, Y: Cardinal]: Cardinal read GetValue write SetValue; default;
+    property Bits: PCardinalArray read FBits;
+    property Scanline[Y: Integer]: PCardinalArray read GetScanline;
+  end;
+
+  { TFloatMap }
 
   TFloatMap = class(TCustomMap)
   private
-    FBits: TArrayOfFloat;
-    function GetValPtr(X, Y: Integer): PFloat; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+    function GetValPtr(X, Y: Integer): GR32.PFloat; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     function GetValue(X, Y: Integer): TFloat; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
     procedure SetValue(X, Y: Integer; const Value: TFloat); {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
-    function GetBits: PFloatArray;
+    function GetScanline(Y: Integer): PFloatArray;
   protected
+    FBits: PFloatArray;
     procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
   public
+    constructor Create; overload; override;
     destructor Destroy; override;
+
+    procedure Assign(Source: TPersistent); override;
     function Empty: Boolean; override;
     procedure Clear; overload;
     procedure Clear(FillValue: TFloat); overload;
+
     property ValPtr[X, Y: Integer]: PFloat read GetValPtr;
     property Value[X, Y: Integer]: TFloat read GetValue write SetValue; default;
-    property Bits: PFloatArray read GetBits;
-  end;
+    property Bits: PFloatArray read FBits;
+    property Scanline[Y: Integer]: PFloatArray read GetScanline;
+  end;
+
+{$IFDEF COMPILER2010}
+
+  { TGenericMap<T> }
+
+  TGenericMap<T> = class(TCustomMap)
+  private
+    function GetValue(X, Y: Integer): T; {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+    procedure SetValue(X, Y: Integer; const Value: T); {$IFDEF INLININGSUPPORTED} inline; {$ENDIF}
+  protected
+    FBits: Pointer;
+    procedure ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer); override;
+  public
+    constructor Create; overload; override;
+    destructor Destroy; override;
+
+    procedure Assign(Source: TPersistent); override;
+    function Empty: Boolean; override;
+    procedure Clear; overload;
+    procedure Clear(FillValue: T); overload;
+
+    property Value[X, Y: Integer]: T read GetValue write SetValue; default;
+    property Bits: Pointer read FBits;
+  end;
+
+{$ENDIF}
 
 implementation
 
 uses
-  GR32_LowLevel;
+  Math, GR32_LowLevel, GR32_Blend, GR32_Resamplers;
+
+function Bytes(Bits: Integer): Integer;
+begin
+  Result := (Bits - 1) shr 3 + 1;
+end;
 
 { TBooleanMap }
 
-function Bytes(Bits: Integer): Integer;
-begin
-  Result := (Bits - 1) shr 3 + 1;
+constructor TBooleanMap.Create;
+begin
+  FreeMem(FBits);
+  inherited Create;
 end;
 
@@ -164 +269 @@
   NewHeight: Integer);
 begin
-  SetLength(FBits, Bytes(NewWidth * NewHeight));
+  ReallocMem(FBits, Bytes(NewWidth * NewHeight));
   Width := NewWidth;
   Height := NewHeight;
@@ -171 +276 @@
 procedure TBooleanMap.Clear(FillValue: Byte);
 begin
-  FillChar(FBits[0], Bytes(Width * Height), FillValue);
+  FillChar(FBits^, Bytes(Width * Height), FillValue);
 end;
 
@@ -185 +290 @@
 end;
 
-function TBooleanMap.GetBits: PByteArray;
-begin
-  Result := @FBits[0];
-end;
-
 function TBooleanMap.GetValue(X, Y: Integer): Boolean;
 begin
   X := X + Y * Width;
-  Result := FBits[X shr 3] and (1 shl (X and 7)) <> 0; //Boolean(FBits[X shr 3] and (1 shl (X and 7)));
+  Result := FBits^[X shr 3] and (1 shl (X and 7)) <> 0; //Boolean(FBits^[X shr 3] and (1 shl (X and 7)));
 end;
 
@@ -200 +300 @@
   X := Y * Width + X;
   if Value then
-    FBits[X shr 3] := FBits[X shr 3] or (1 shl (X and 7))
+    FBits^[X shr 3] := FBits^[X shr 3] or (1 shl (X and 7))
   else
-    FBits[X shr 3] := FBits[X shr 3] and ((1 shl (X and 7)) xor $FF);
+    FBits^[X shr 3] := FBits^[X shr 3] and ((1 shl (X and 7)) xor $FF);
 end;
 
@@ -208 +308 @@
 begin
   X := Y * Width + X;
-  FBits[X shr 3] := FBits[X shr 3] xor (1 shl (X and 7));
+  FBits^[X shr 3] := FBits^[X shr 3] xor (1 shl (X and 7));
 end;
 
 { TByteMap }
+
+constructor TByteMap.Create;
+begin
+  FBits := nil;
+  inherited Create;
+end;
+
+destructor TByteMap.Destroy;
+begin
+  FreeMem(FBits);
+  inherited;
+end;
+
+procedure TByteMap.Downsample(Factor: Byte);
+begin
+  // downsample inplace
+  case Factor of
+    2:
+      DownsampleByteMap2x(Self, Self);
+    3:
+      DownsampleByteMap3x(Self, Self);
+    4:
+      DownsampleByteMap4x(Self, Self);
+    6:
+      begin
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap2x(Self, Self);
+      end;
+    8:
+      begin
+        DownsampleByteMap4x(Self, Self);
+        DownsampleByteMap2x(Self, Self);
+      end;
+    9:
+      begin
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap3x(Self, Self);
+      end;
+    12:
+      begin
+        DownsampleByteMap4x(Self, Self);
+        DownsampleByteMap3x(Self, Self);
+      end;
+    16:
+      begin
+        DownsampleByteMap4x(Self, Self);
+        DownsampleByteMap4x(Self, Self);
+      end;
+    18:
+      begin
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap2x(Self, Self);
+      end;
+    24:
+      begin
+        DownsampleByteMap4x(Self, Self);
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap2x(Self, Self);
+      end;
+    27:
+      begin
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap3x(Self, Self);
+        DownsampleByteMap3x(Self, Self);
+      end;
+    32:
+      begin
+        DownsampleByteMap4x(Self, Self);
+        DownsampleByteMap4x(Self, Self);
+        DownsampleByteMap2x(Self, Self);
+      end;
+  end;
+end;
+
+procedure TByteMap.Downsample(Dest: TByteMap; Factor: Byte);
+
+  procedure DownsampleAndMove;
+  var
+    Temp: TByteMap;
+    Y: Integer;
+  begin
+    // clone destination and downsample inplace
+    Temp := TByteMap.Create;
+    Temp.Assign(Self);
+    Temp.Downsample(Factor);
+
+    // copy downsampled result
+    Dest.SetSize(Width div Factor, Height div Factor);
+    for Y := 0 to Dest.Height - 1 do
+      Move(Temp.Scanline[Y]^, Dest.Scanline[Y]^, Dest.Width);
+  end;
+
+begin
+  // downsample directly
+  if (Dest = Self) or not (Factor in [2, 3, 4]) then
+  begin
+    DownsampleAndMove;
+    Exit;
+  end;
+
+  case Factor of
+    2:
+      begin
+        Dest.SetSize(Width div 2, Height div 2);
+        DownsampleByteMap2x(Self, Dest);
+      end;
+    3:
+      begin
+        // downsample directly
+        Dest.SetSize(Width div 3, Height div 3);
+        DownsampleByteMap3x(Self, Dest);
+      end;
+    4:
+      begin
+        // downsample directly
+        Dest.SetSize(Width div 4, Height div 4);
+        DownsampleByteMap4x(Self, Dest);
+      end;
+  end;
+end;
 
 procedure TByteMap.Assign(Source: TPersistent);
@@ -240 +461 @@
 procedure TByteMap.ChangeSize(var Width, Height: Integer; NewWidth, NewHeight: Integer);
 begin
-  SetLength(FBits, NewWidth * NewHeight);
+  ReallocMem(FBits, NewWidth * NewHeight);
   Width := NewWidth;
   Height := NewHeight;
@@ -247 +468 @@
 procedure TByteMap.Clear(FillValue: Byte);
 begin
-  FillChar(Bits[0], Width * Height, FillValue);
+  FillChar(Bits^, Width * Height, FillValue);
   Changed;
-end;
-
-destructor TByteMap.Destroy;
-begin
-  FBits := nil;
-  inherited;
 end;
 
@@ -263 +478 @@
 end;
 
-function TByteMap.GetBits: PByteArray;
-begin
-  Result := @FBits[0];
+procedure TByteMap.FlipHorz(Dst: TByteMap);
+var
+  i, j: Integer;
+  P1, P2: PByte;
+  tmp: Byte;
+  W, W2: Integer;
+begin
+  W := Width;
+  if (Dst = nil) or (Dst = Self) then
+  begin
+    { In-place flipping }
+    P1 := PByte(Bits);
+    P2 := P1;
+    Inc(P2, Width - 1);
+    W2 := Width shr 1;
+    for J := 0 to Height - 1 do
+    begin
+      for I := 0 to W2 - 1 do
+      begin
+        tmp := P1^;
+        P1^ := P2^;
+        P2^ := tmp;
+        Inc(P1);
+        Dec(P2);
+      end;
+      Inc(P1, W - W2);
+      Inc(P2, W + W2);
+    end;
+    Changed;
+  end
+  else
+  begin
+    { Flip to Dst }
+    Dst.BeginUpdate;
+    Dst.SetSize(W, Height);
+    P1 := PByte(Bits);
+    P2 := PByte(Dst.Bits);
+    Inc(P2, W - 1);
+    for J := 0 to Height - 1 do
+    begin
+      for I := 0 to W - 1 do
+      begin
+        P2^ := P1^;
+        Inc(P1);
+        Dec(P2);
+      end;
+      Inc(P2, W shl 1);
+    end;
+    Dst.EndUpdate;
+    Dst.Changed;
+  end;
+end;
+
+procedure TByteMap.FlipVert(Dst: TByteMap);
+var
+  J, J2: Integer;
+  Buffer: PByteArray;
+  P1, P2: PByte;
+begin
+  if (Dst = nil) or (Dst = Self) then
+  begin
+    { in-place }
+    J2 := Height - 1;
+    GetMem(Buffer, Width);
+    for J := 0 to Height div 2 - 1 do
+    begin
+      P1 := PByte(ScanLine[J]);
+      P2 := PByte(ScanLine[J2]);
+      Move(P1^, Buffer^, Width);
+      Move(P2^, P1^, Width);
+      Move(Buffer^, P2^, Width);
+      Dec(J2);
+    end;
+    FreeMem(Buffer);
+    Changed;
+  end
+  else
+  begin
+    Dst.SetSize(Width, Height);
+    J2 := Height - 1;
+    for J := 0 to Height - 1 do
+    begin
+      Move(ScanLine[J]^, Dst.ScanLine[J2]^, Width);
+      Dec(J2);
+    end;
+    Dst.Changed;
+  end;
+end;
+
+function TByteMap.GetScanline(Y: Integer): PByteArray;
+begin
+  Result := @FBits^[Y * Width];
 end;
 
 function TByteMap.GetValPtr(X, Y: Integer): PByte;
 begin
-  Result := @FBits[X + Y * Width];
+  Result := @FBits^[X + Y * Width];
 end;
 
 function TByteMap.GetValue(X, Y: Integer): Byte;
 begin
-  Result := FBits[X + Y * Width];
+  Result := FBits^[X + Y * Width];
+end;
+
+procedure TByteMap.Multiply(Value: Byte);
+var
+  Index: Integer;
+begin
+  for Index := 0 to FWidth * FHeight - 1 do
+    FBits^[Index] := ((FBits^[Index] * Value + $80) shr 8);
+end;
+
+procedure TByteMap.Add(Value: Byte);
+var
+  Index: Integer;
+begin
+  for Index := 0 to FWidth * FHeight - 1 do
+    FBits^[Index] := Min(FBits^[Index] + Value, 255);
+end;
+
+procedure TByteMap.Sub(Value: Byte);
+var
+  Index: Integer;
+begin
+  for Index := 0 to FWidth * FHeight - 1 do
+    FBits^[Index] := Max(FBits^[Index] + Value, 0);
 end;
 
@@ -295 +623 @@
     SrcC := Source.PixelPtr[0, 0];
     SrcB := Pointer(SrcC);
-    DstB := @FBits[0];
+    DstB := @FBits^;
     case Conversion of
 
@@ -371 +699 @@
 end;
 
+procedure TByteMap.Rotate180(Dst: TByteMap);
+var
+  Src: PByteArray;
+  S, D: PByte;
+  X, Y: Integer;
+  T: Byte;
+begin
+  if (Dst = nil) or (Dst = Self) then
+  begin
+    for Y := 0 to FHeight - 1 do
+    begin
+      Src := Scanline[Y];
+      for X := 0 to (FWidth div 2) - 1 do
+      begin
+        T := Src^[X];
+        Src^[X] := Src^[Width - 1 - X];
+        Src^[Width - 1 - X] := T;
+      end;
+    end;
+  end
+  else
+  begin
+    S := PByte(FBits);
+    D := PByte(@Dst.Bits[FHeight * FWidth - 1]);
+    for X := 0 to FHeight * FWidth - 1 do
+    begin
+      D^ := S^;
+      Dec(D);
+      Inc(S);
+    end;
+  end;
+end;
+
+procedure TByteMap.Rotate270(Dst: TByteMap);
+var
+  Src: PByteArray;
+  Current: PByte;
+  X, Y, W, H: Integer;
+begin
+  if (Dst = nil) or (Dst = Self) then
+  begin
+    W := FWidth;
+    H := FHeight;
+
+     // inplace replace
+    GetMem(Src, W * H);
+
+    // copy bits
+    Move(Bits^, Src^, W * H);
+
+    SetSize(H, W);
+
+    Current := PByte(Src);
+    for Y := 0 to H - 1 do
+      for X := 0 to W - 1 do
+      begin
+        Bits^[(W - 1 - X) * H + Y] := Current^;
+        Inc(Current);
+      end;
+
+    // dispose old data pointer
+    FreeMem(Src);
+  end
+  else
+  begin
+    // exchange dimensions
+    Dst.SetSize(Height, Width);
+
+    for Y := 0 to FHeight - 1 do
+    begin
+      Src := Scanline[Y];
+      for X := 0 to FWidth - 1 do
+        Dst.Bits^[X * FHeight + FHeight - 1 - Y] := Src^[X];
+    end;
+  end;
+end;
+
+procedure TByteMap.Rotate90(Dst: TByteMap);
+var
+  Src: PByteArray;
+  Current: PByte;
+  X, Y, W, H: Integer;
+begin
+  if (Dst = nil) or (Dst = Self) then
+  begin
+    W := FWidth;
+    H := FHeight;
+
+     // inplace replace
+    GetMem(Src, W * H);
+
+    // copy bits
+    Move(Bits^, Src^, W * H);
+
+    SetSize(H, W);
+
+    Current := PByte(Src);
+    for Y := 0 to H - 1 do
+      for X := 0 to W - 1 do
+      begin
+        Bits^[X * H + (H - 1 - Y)] := Current^;
+        Inc(Current);
+      end;
+
+    // dispose old data pointer
+    FreeMem(Src);
+  end
+  else
+  begin
+    // exchange dimensions
+    Dst.SetSize(Height, Width);
+
+    for Y := 0 to FHeight - 1 do
+    begin
+      Src := Scanline[Y];
+      for X := 0 to FWidth - 1 do
+        Dst.Bits^[(FWidth - 1 - X) * FHeight + Y] := Src^[X];
+    end;
+  end;
+end;
+
 procedure TByteMap.SetValue(X, Y: Integer; Value: Byte);
 begin
-  FBits[X + Y * Width] := Value;
+  FBits^[X + Y * Width] := Value;
 end;
 
@@ -394 +843 @@
     DstC := Dest.PixelPtr[0, 0];
     DstB := Pointer(DstC);
-    SrcB := @FBits[0];
+    SrcB := @FBits^;
     case Conversion of
 
@@ -472 +921 @@
     N := W * H - 1;
     DstC := Dest.PixelPtr[0, 0];
-    SrcB := @FBits[0];
+    SrcB := @FBits^;
 
     for I := 0 to N do
@@ -485 +934 @@
   end;
 end;
-  
+
+procedure TByteMap.DrawTo(Dest: TCustomBitmap32; X, Y: Integer; Color: TColor32);
+var
+  ClipRect: TRect;
+  IX, IY: Integer;
+  RGB: Cardinal;
+  NewColor: TColor32;
+  ScnLn: PColor32Array;
+  ByteLine: PByteArray;
+  Alpha: Byte;
+begin
+  with ClipRect do
+  begin
+    Left := X;
+    if Left < 0 then
+      Left := 0;
+    Top := Y;
+    if Top < 0 then
+      Top := 0;
+    Right := X + Self.Width;
+    if Right > Self.Width then
+      Right := Self.Width;
+    Bottom := Y + Self.Height;
+    if Bottom > Self.Height then
+      Bottom := Self.Height;
+
+    // split RGB and alpha
+    RGB := Color and $FFFFFF;
+    Alpha := Color shr 24;
+
+    // blend scanlines
+    for IY := Top to Bottom - 1 do
+    begin
+      ScnLn := Dest.ScanLine[IY];
+      ByteLine := Self.ScanLine[IY - Y];
+      for IX := Left to Right - 1 do
+      begin
+        NewColor := (((ByteLine^[IX - X] * Alpha) shl 16) and $FF000000) or RGB;
+        MergeMem(NewColor, ScnLn^[IX]);
+      end;
+    end;
+    EMMS;
+  end;
+end;
+
+procedure TByteMap.DrawTo(Dest: TCustomBitmap32; Rect: TRect; Color: TColor32);
+var
+  ClipRect: TRect;
+  IX, IY: Integer;
+  RGB: Cardinal;
+  NewColor: TColor32;
+  ScnLn: PColor32Array;
+  ByteLine: PByteArray;
+  Alpha: Byte;
+begin
+  with ClipRect do
+  begin
+    Left := Rect.Left;
+    if Left < 0 then
+      Left := 0;
+    Top := Rect.Top;
+    if Top < 0 then
+      Top := 0;
+    Right := Math.Min(Rect.Left + Self.Width, Rect.Right);
+    Bottom := Math.Min(Rect.Top + Self.Height, Rect.Bottom);
+
+    // split RGB and alpha
+    RGB := Color and $FFFFFF;
+    Alpha := Color shr 24;
+
+    // blend scanlines
+    for IY := Top to Bottom - 1 do
+    begin
+      ScnLn := Dest.ScanLine[IY];
+      ByteLine := Self.ScanLine[IY - Rect.Top];
+      for IX := Left to Right - 1 do
+      begin
+        NewColor := (((ByteLine^[IX - Rect.Left] * Alpha) shl 16) and $FF000000) or RGB;
+        MergeMem(NewColor, ScnLn^[IX]);
+      end;
+    end;
+    EMMS;
+  end;
+end;
+
+
 { TWordMap }
+
+constructor TWordMap.Create;
+begin
+  FBits := nil;
+  inherited Create;
+end;
+
+destructor TWordMap.Destroy;
+begin
+  FreeMem(FBits);
+  inherited;
+end;
 
 procedure TWordMap.ChangeSize(var Width, Height: Integer; NewWidth,
   NewHeight: Integer);
 begin
-  SetLength(FBits, NewWidth * NewHeight);
+  ReallocMem(FBits, NewWidth * NewHeight * SizeOf(Word));
   Width := NewWidth;
   Height := NewHeight;
@@ -498 +1044 @@
 procedure TWordMap.Clear(FillValue: Word);
 begin
-  FillWord(FBits[0], Width * Height, FillValue);
+  FillWord(FBits^, Width * Height, FillValue);
   Changed;
 end;
 
-destructor TWordMap.Destroy;
+procedure TWordMap.Assign(Source: TPersistent);
+begin
+  BeginUpdate;
+    try
+      if Source is TWordMap then
+      begin
+        inherited SetSize(TWordMap(Source).Width, TWordMap(Source).Height);
+        Move(TWordMap(Source).Bits[0], Bits[0], Width * Height * SizeOf(Word));
+      end
+      //else if Source is TBitmap32 then
+      //  ReadFrom(TBitmap32(Source), ctWeightedRGB)
+      else
+        inherited;
+    finally
+      EndUpdate;
+      Changed;
+    end;
+end;
+
+function TWordMap.Empty: Boolean;
+begin
+  Result := not Assigned(FBits);
+end;
+
+function TWordMap.GetScanline(Y: Integer): PWordArray;
+begin
+  Result := @FBits^[Y * Width];
+end;
+
+function TWordMap.GetValPtr(X, Y: Integer): PWord;
+begin
+  Result := @FBits^[X + Y * Width];
+end;
+
+function TWordMap.GetValue(X, Y: Integer): Word;
+begin
+  Result := FBits^[X + Y * Width];
+end;
+
+procedure TWordMap.SetValue(X, Y: Integer; const Value: Word);
+begin
+  FBits^[X + Y * Width] := Value;
+end;
+
+
+{ TIntegerMap }
+
+constructor TIntegerMap.Create;
 begin
   FBits := nil;
+  inherited Create;
+end;
+
+destructor TIntegerMap.Destroy;
+begin
+  FreeMem(FBits);
   inherited;
 end;
-
-function TWordMap.Empty: Boolean;
-begin
-  Result := not Assigned(FBits);
-end;
-
-function TWordMap.GetBits: PWordArray;
-begin
-  Result := @FBits[0];
-end;
-
-function TWordMap.GetValPtr(X, Y: Integer): PWord;
-begin
-  Result := @FBits[X + Y * Width];
-end;
-
-function TWordMap.GetValue(X, Y: Integer): Word;
-begin
-  Result := FBits[X + Y * Width];
-end;
-
-procedure TWordMap.SetValue(X, Y: Integer; const Value: Word);
-begin
-  FBits[X + Y * Width] := Value;
-end;
-
-{ TIntegerMap }
 
 procedure TIntegerMap.ChangeSize(var Width, Height: Integer; NewWidth,
   NewHeight: Integer);
 begin
-  SetLength(FBits, NewWidth * NewHeight);
+  ReallocMem(FBits, NewWidth * NewHeight * SizeOf(Integer));
   Width := NewWidth;
   Height := NewHeight;
@@ -545 +1117 @@
 procedure TIntegerMap.Clear(FillValue: Integer);
 begin
-  FillLongword(FBits[0], Width * Height, FillValue);
+  FillLongword(FBits^, Width * Height, FillValue);
   Changed;
 end;
 
-destructor TIntegerMap.Destroy;
+procedure TIntegerMap.Assign(Source: TPersistent);
+begin
+  BeginUpdate;
+  try
+    if Source is TIntegerMap then
+    begin
+      inherited SetSize(TIntegerMap(Source).Width, TIntegerMap(Source).Height);
+      Move(TIntegerMap(Source).Bits[0], Bits[0], Width * Height * SizeOf(Integer));
+    end
+    //else if Source is TBitmap32 then
+    //  ReadFrom(TBitmap32(Source), ctWeightedRGB)
+    else
+      inherited;
+  finally
+    EndUpdate;
+    Changed;
+  end;
+end;
+
+function TIntegerMap.Empty: Boolean;
+begin
+  Result := not Assigned(FBits);
+end;
+
+function TIntegerMap.GetScanline(Y: Integer): PIntegerArray;
+begin
+  Result := @FBits^[Y * Width];
+end;
+
+function TIntegerMap.GetValPtr(X, Y: Integer): PInteger;
+begin
+  Result := @FBits^[X + Y * Width];
+end;
+
+function TIntegerMap.GetValue(X, Y: Integer): Integer;
+begin
+  Result := FBits^[X + Y * Width];
+end;
+
+procedure TIntegerMap.SetValue(X, Y: Integer; const Value: Integer);
+begin
+  FBits^[X + Y * Width] := Value;
+end;
+
+
+{ TCardinalMap }
+
+constructor TCardinalMap.Create;
 begin
   FBits := nil;
+  inherited Create;
+end;
+
+destructor TCardinalMap.Destroy;
+begin
+  FreeMem(FBits);
   inherited;
 end;
 
-function TIntegerMap.Empty: Boolean;
+procedure TCardinalMap.Assign(Source: TPersistent);
+begin
+  BeginUpdate;
+  try
+    if Source is TCardinalMap then
+    begin
+      inherited SetSize(TCardinalMap(Source).Width, TCardinalMap(Source).Height);
+      Move(TCardinalMap(Source).Bits[0], Bits[0], Width * Height * SizeOf(Cardinal));
+    end
+    //else if Source is TBitmap32 then
+    //  ReadFrom(TBitmap32(Source), ctWeightedRGB)
+    else
+      inherited;
+  finally
+    EndUpdate;
+    Changed;
+  end;
+end;
+
+procedure TCardinalMap.ChangeSize(var Width, Height: Integer; NewWidth,
+  NewHeight: Integer);
+begin
+  ReallocMem(FBits, NewWidth * NewHeight * SizeOf(Cardinal));
+  Width := NewWidth;
+  Height := NewHeight;
+end;
+
+procedure TCardinalMap.Clear(FillValue: Cardinal);
+begin
+  FillLongword(FBits^, Width * Height, FillValue);
+  Changed;
+end;
+
+function TCardinalMap.Empty: Boolean;
 begin
   Result := not Assigned(FBits);
 end;
 
-function TIntegerMap.GetBits: PIntegerArray;
-begin
-  Result := @FBits[0];
-end;
-
-function TIntegerMap.GetValPtr(X, Y: Integer): PInteger;
-begin
-  Result := @FBits[X + Y * Width];
-end;
-
-function TIntegerMap.GetValue(X, Y: Integer): Integer;
-begin
-  Result := FBits[X + Y * Width];
-end;
-
-procedure TIntegerMap.SetValue(X, Y: Integer; const Value: Integer);
-begin
-  FBits[X + Y * Width] := Value;
-end;
+function TCardinalMap.GetScanline(Y: Integer): PCardinalArray;
+begin
+  Result := @FBits^[Y * Width];
+end;
+
+function TCardinalMap.GetValPtr(X, Y: Cardinal): PCardinal;
+begin
+  Result := @FBits^[X + Y * Cardinal(Width)];
+end;
+
+function TCardinalMap.GetValue(X, Y: Cardinal): Cardinal;
+begin
+  Result := FBits^[X + Y * Cardinal(Width)];
+end;
+
+procedure TCardinalMap.SetValue(X, Y: Cardinal; const Value: Cardinal);
+begin
+  FBits^[X + Y * Cardinal(Width)] := Value;
+end;
+
 
 { TFloatMap }
+
+constructor TFloatMap.Create;
+begin
+  FBits := nil;
+  inherited Create;
+end;
+
+destructor TFloatMap.Destroy;
+begin
+  FreeMem(FBits);
+  inherited;
+end;
+
+procedure TFloatMap.Assign(Source: TPersistent);
+begin
+  BeginUpdate;
+  try
+    if Source is TFloatMap then
+    begin
+      inherited SetSize(TFloatMap(Source).Width, TFloatMap(Source).Height);
+      Move(TFloatMap(Source).Bits[0], Bits[0], Width * Height * SizeOf(TFloat));
+    end
+    //else if Source is TBitmap32 then
+    //  ReadFrom(TBitmap32(Source), ctWeightedRGB)
+    else
+      inherited;
+  finally
+    EndUpdate;
+    Changed;
+  end;
+end;
 
 procedure TFloatMap.ChangeSize(var Width, Height: Integer; NewWidth,
   NewHeight: Integer);
 begin
-  SetLength(FBits, NewWidth * NewHeight);
+  ReallocMem(FBits, NewWidth * NewHeight * SizeOf(TFloat));
   Width := NewWidth;
   Height := NewHeight;
@@ -592 +1282 @@
 procedure TFloatMap.Clear;
 begin
-  FillChar(FBits[0], Width * Height * SizeOf(TFloat), 0);
+  FillChar(FBits^, Width * Height * SizeOf(TFloat), 0);
   Changed;
 end;
@@ -601 +1291 @@
 begin
   for Index := 0 to Width * Height - 1 do
-    FBits[Index] := FillValue;
+    FBits^[Index] := FillValue;
   Changed;
 end;
 
-destructor TFloatMap.Destroy;
+function TFloatMap.Empty: Boolean;
+begin
+  Result := not Assigned(FBits);
+end;
+
+function TFloatMap.GetScanline(Y: Integer): PFloatArray;
+begin
+  Result := @FBits^[Y * Width];
+end;
+
+function TFloatMap.GetValPtr(X, Y: Integer): GR32.PFloat;
+begin
+  Result := @FBits^[X + Y * Width];
+end;
+
+function TFloatMap.GetValue(X, Y: Integer): TFloat;
+begin
+  Result := FBits^[X + Y * Width];
+end;
+
+procedure TFloatMap.SetValue(X, Y: Integer; const Value: TFloat);
+begin
+  FBits^[X + Y * Width] := Value;
+end;
+
+
+{$IFDEF COMPILER2010}
+
+{ TGenericMap<T> }
+
+constructor TGenericMap<T>.Create;
 begin
   FBits := nil;
+  inherited Create;
+end;
+
+destructor TGenericMap<T>.Destroy;
+begin
+  FreeMem(FBits);
   inherited;
 end;
 
-function TFloatMap.Empty: Boolean;
+procedure TGenericMap<T>.Assign(Source: TPersistent);
+begin
+  BeginUpdate;
+  try
+(*
+    if Source is TFloatMap then
+    begin
+      inherited SetSize(TFloatMap(Source).Width, TFloatMap(Source).Height);
+      Move(TFloatMap(Source).Bits[0], Bits[0], Width * Height * SizeOf(TFloat));
+    end
+    //else if Source is TBitmap32 then
+    //  ReadFrom(TBitmap32(Source), ctWeightedRGB)
+    else
+      inherited;
+*)
+  finally
+    EndUpdate;
+    Changed;
+  end;
+end;
+
+procedure TGenericMap<T>.ChangeSize(var Width, Height: Integer; NewWidth,
+  NewHeight: Integer);
+begin
+  ReallocMem(FBits, NewWidth * NewHeight * SizeOf(T));
+  Width := NewWidth;
+  Height := NewHeight;
+end;
+
+procedure TGenericMap<T>.Clear(FillValue: T);
+var
+  Index: Integer;
+begin
+  for Index := 0 to Width * Height - 1 do
+    Move(FillValue, PByte(FBits)[Index], SizeOf(T));
+  Changed;
+end;
+
+procedure TGenericMap<T>.Clear;
+begin
+  FillChar(FBits^, Width * Height * SizeOf(T), 0);
+  Changed;
+end;
+
+function TGenericMap<T>.Empty: Boolean;
 begin
   Result := not Assigned(FBits);
 end;
 
-function TFloatMap.GetBits: PFloatArray;
-begin
-  Result := @FBits[0];
-end;
-
-function TFloatMap.GetValPtr(X, Y: Integer): PFloat;
-begin
-  Result := @FBits[X + Y * Width];
-end;
-
-function TFloatMap.GetValue(X, Y: Integer): TFloat;
-begin
-  Result := FBits[X + Y * Width];
-end;
-
-procedure TFloatMap.SetValue(X, Y: Integer; const Value: TFloat);
-begin
-  FBits[X + Y * Width] := Value;
-end;
+function TGenericMap<T>.GetValue(X, Y: Integer): T;
+begin
+  Move(PByte(FBits)[(X + Y * Width) * SizeOf(T)], Result, SizeOf(T));
+end;
+
+procedure TGenericMap<T>.SetValue(X, Y: Integer; const Value: T);
+begin
+  Move(Value, PByte(FBits)[(X + Y * Width) * SizeOf(T)], SizeOf(T));
+end;
+
+{$ENDIF}
 
 end.

GraphicTest/Packages/Graphics32/GR32_Polygons.pas

@@ -21 +21 @@
  * license.
  *
- * The Original Code is Graphics32
+ * The Original Code is Vectorial Polygon Rasterizer for Graphics32
  *
  * The Initial Developer of the Original Code is
- * Alex A. Denisov
+ * Mattias Andersson <mattias@centaurix.com>
  *
- * Portions created by the Initial Developer are Copyright (C) 2000-2009
+ * Portions created by the Initial Developer are Copyright (C) 2008-2012
  * the Initial Developer. All Rights Reserved.
  *
  * Contributor(s):
- *   Andre Beckedorf <Andre@metaException.de>
- *   Mattias Andersson <mattias@centaurix.com>
- *   Peter Larson <peter@larson.net>
  *
  * ***** END LICENSE BLOCK ***** *)
@@ -40 +37 @@
 {$I GR32.inc}
 
-{$IFDEF PUREPASCAL}
-{$DEFINE USENATIVECODE}
-{$ENDIF}
-{$IFDEF USEINLINING}
-{$DEFINE USENATIVECODE}
-{$ENDIF}
-
 uses
-{$IFDEF FPC}
-{$ELSE}
-  Windows,
-{$ENDIF}
-  Classes, SysUtils, GR32, GR32_LowLevel, GR32_Blend, GR32_Transforms,
-  GR32_Resamplers, GR32_Math;
-
-{ Polylines }
-
-procedure PolylineTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Closed: Boolean = False; Transformation: TTransformation = nil);
-procedure PolylineAS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Closed: Boolean = False; Transformation: TTransformation = nil);
-procedure PolylineXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Closed: Boolean = False; Transformation: TTransformation = nil);
-procedure PolylineXSP(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Closed: Boolean = False; Transformation: TTransformation = nil);
-
-procedure PolyPolylineTS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32; Closed: Boolean = False; Transformation: TTransformation = nil);
-procedure PolyPolylineAS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32; Closed: Boolean = False; Transformation: TTransformation = nil);
-procedure PolyPolylineXS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32; Closed: Boolean = False; Transformation: TTransformation = nil);
-procedure PolyPolylineXSP(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Closed: Boolean = False; Transformation: TTransformation = nil);
-
-{ Polygons }
+  Types, GR32, GR32_Containers, GR32_VPR, GR32_Transforms, GR32_Resamplers;
 
 type
-  TPolyFillMode = (pfAlternate, pfWinding);
-  TAntialiasMode = (am32times, am16times, am8times, am4times, am2times, amNone);
-
-  TFillLineEvent = procedure(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32) of object;
+  { Polygon join style - used by GR32_VectorUtils.Grow(). }
+  { nb: jsRoundEx rounds both convex and concave joins unlike jsRound which
+    only rounds convex joins. The depth of convex join rounding is controlled
+    by Grow's MiterLimit parameter }
+  TJoinStyle = (jsMiter, jsBevel, jsRound, jsRoundEx);
+
+  { Polygon end style }
+  TEndStyle = (esButt, esSquare, esRound);
+
+  { Polygon fill mode }
+  TPolyFillMode = (pfAlternate, pfWinding, pfEvenOdd = 0, pfNonZero);
+
+  { TCustomPolygonRenderer }
+  TCustomPolygonRenderer = class(TThreadPersistent)
+  public
+    procedure PolyPolygonFS(const Points: TArrayOfArrayOfFloatPoint;
+      const ClipRect: TFloatRect; Transformation: TTransformation); overload; virtual;
+    procedure PolyPolygonFS(const Points: TArrayOfArrayOfFloatPoint;
+      const ClipRect: TFloatRect); overload; virtual;
+    procedure PolygonFS(const Points: TArrayOfFloatPoint;
+      const ClipRect: TFloatRect; Transformation: TTransformation); overload; virtual;
+    procedure PolygonFS(const Points: TArrayOfFloatPoint;
+      const ClipRect: TFloatRect); overload; virtual;
+
+    // procedure PolyPolygonXS(const Points: TArrayOfArrayOfFixedPoint; const ClipRect: TFixedRect; Transformation: TTransformation); virtual; overload;
+    // procedure PolyPolygonXS(const Points: TArrayOfArrayOfFixedPoint; const ClipRect: TFixedRect); virtual; overload;
+  end;
+  TCustomPolygonRendererClass = class of TCustomPolygonRenderer;
+
+  TCustomPolygonFiller = class;
+
+  { TPolygonRenderer32 }
+  TPolygonRenderer32 = class(TCustomPolygonRenderer)
+  private
+    FBitmap: TBitmap32;
+    FFillMode: TPolyFillMode;
+    FColor: TColor32;
+    FFiller: TCustomPolygonFiller;
+    procedure SetColor(const Value: TColor32);
+    procedure SetFillMode(const Value: TPolyFillMode);
+    procedure SetFiller(const Value: TCustomPolygonFiller);
+  protected
+    procedure SetBitmap(const Value: TBitmap32); virtual;
+  public
+    constructor Create(Bitmap: TBitmap32; Fillmode: TPolyFillMode = pfWinding); reintroduce; overload;
+    procedure PolygonFS(const Points: TArrayOfFloatPoint); overload; virtual;
+    procedure PolyPolygonFS(const Points: TArrayOfArrayOfFloatPoint); overload; virtual;
+
+    property Bitmap: TBitmap32 read FBitmap write SetBitmap;
+    property FillMode: TPolyFillMode read FFillMode write SetFillMode;
+    property Color: TColor32 read FColor write SetColor;
+    property Filler: TCustomPolygonFiller read FFiller write SetFiller;
+  end;
+  TPolygonRenderer32Class = class of TPolygonRenderer32;
+
+  { TPolygonRenderer32VPR }
+  { Polygon renderer based on VPR. Computes exact coverages for optimal anti-aliasing. }
+  TFillProc = procedure(Coverage: PSingleArray; AlphaValues: PColor32Array; Count: Integer; Color: TColor32);
+
+  TPolygonRenderer32VPR = class(TPolygonRenderer32)
+  private
+    FFillProc: TFillProc;
+    procedure UpdateFillProcs;
+  protected
+    procedure RenderSpan(const Span: TValueSpan; DstY: Integer); virtual;
+    procedure FillSpan(const Span: TValueSpan; DstY: Integer); virtual;
+    function GetRenderSpan: TRenderSpanEvent; virtual;
+  public
+    procedure PolyPolygonFS(const Points: TArrayOfArrayOfFloatPoint;
+      const ClipRect: TFloatRect); override;
+  end;
+
+  { TPolygonRenderer32LCD }
+  TPolygonRenderer32LCD = class(TPolygonRenderer32VPR)
+  protected
+    procedure RenderSpan(const Span: TValueSpan; DstY: Integer); override;
+  public
+    procedure PolyPolygonFS(const Points: TArrayOfArrayOfFloatPoint;
+      const ClipRect: TFloatRect); override;
+  end;
+
+  { TPolygonRenderer32LCD2 }
+  TPolygonRenderer32LCD2 = class(TPolygonRenderer32LCD)
+  public
+    procedure RenderSpan(const Span: TValueSpan; DstY: Integer); override;
+  end;
+
+  { TCustomPolygonFiller }
+
+  TFillLineEvent = procedure(Dst: PColor32; DstX, DstY, Length: Integer;
+    AlphaValues: PColor32; CombineMode: TCombineMode) of object;
 
   TCustomPolygonFiller = class
@@ -87 +137 @@
     function GetFillLine: TFillLineEvent; virtual; abstract;
   public
+    procedure BeginRendering; virtual;
+    procedure EndRendering; virtual;
+
     property FillLine: TFillLineEvent read GetFillLine;
   end;
 
-const
-  DefaultAAMode = am8times; // Use 54 levels of transparency for antialiasing.
-
-procedure PolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Mode: TPolyFillMode = pfAlternate; Transformation: TTransformation = nil); overload;
-procedure PolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode = pfAlternate; Transformation: TTransformation = nil); overload;
-procedure PolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Filler: TCustomPolygonFiller; Mode: TPolyFillMode = pfAlternate; Transformation: TTransformation = nil); overload;
-
-procedure PolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Mode: TPolyFillMode = pfAlternate;
-  const AAMode: TAntialiasMode = DefaultAAMode; Transformation: TTransformation = nil); overload;
-procedure PolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode = pfAlternate;
-  const AAMode: TAntialiasMode = DefaultAAMode; Transformation: TTransformation = nil); overload;
-procedure PolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Filler: TCustomPolygonFiller; Mode: TPolyFillMode = pfAlternate;
-  const AAMode: TAntialiasMode = DefaultAAMode; Transformation: TTransformation = nil); overload;
-
-procedure PolyPolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32; Mode: TPolyFillMode = pfAlternate; Transformation: TTransformation = nil); overload;
-procedure PolyPolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode = pfAlternate; Transformation: TTransformation = nil); overload;
-procedure PolyPolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Filler: TCustomPolygonFiller; Mode: TPolyFillMode = pfAlternate; Transformation: TTransformation = nil); overload;
-
-procedure PolyPolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode = pfAlternate;
-  const AAMode: TAntialiasMode = DefaultAAMode; Transformation: TTransformation = nil); overload;
-procedure PolyPolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32; Mode: TPolyFillMode = pfAlternate;
-  const AAMode: TAntialiasMode = DefaultAAMode; Transformation: TTransformation = nil); overload;
-procedure PolyPolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfArrayOfFixedPoint;
-  Filler: TCustomPolygonFiller; Mode: TPolyFillMode = pfAlternate;
-  const AAMode: TAntialiasMode = DefaultAAMode; Transformation: TTransformation = nil); overload;
-
-function PolygonBounds(const Points: TArrayOfFixedPoint; Transformation: TTransformation = nil): TFixedRect;
-function PolyPolygonBounds(const Points: TArrayOfArrayOfFixedPoint; Transformation: TTransformation = nil): TFixedRect;
-
-function PtInPolygon(const Pt: TFixedPoint; const Points: TArrayOfFixedPoint): Boolean;
-
-{ TPolygon32 }
-{ TODO : Bezier Curves, and QSpline curves for TrueType font rendering }
-{ TODO : Check if QSpline is compatible with Type1 fonts }
-type
-  TPolygon32 = class(TThreadPersistent)
+  { TCallbackPolygonFiller }
+  TCallbackPolygonFiller = class(TCustomPolygonFiller)
   private
-    FAntialiased: Boolean;
-    FClosed: Boolean;
-    FFillMode: TPolyFillMode;
-    FNormals: TArrayOfArrayOfFixedPoint;
-    FPoints: TArrayOfArrayOfFixedPoint;
-    FAntialiasMode: TAntialiasMode;
+    FFillLineEvent: TFillLineEvent;
   protected
-    procedure BuildNormals;
-    procedure CopyPropertiesTo(Dst: TPolygon32); virtual;
-    procedure AssignTo(Dst: TPersistent); override;
+    function GetFillLine: TFillLineEvent; override;
   public
-    constructor Create; override;
-    destructor Destroy; override;
-    procedure Add(const P: TFixedPoint);
-    procedure AddPoints(var First: TFixedPoint; Count: Integer);
-    function  ContainsPoint(const P: TFixedPoint): Boolean;
-    procedure Clear;
-    function  Grow(const Delta: TFixed; EdgeSharpness: Single = 0): TPolygon32;
-
-    procedure Draw(Bitmap: TCustomBitmap32; OutlineColor, FillColor: TColor32; Transformation: TTransformation = nil); overload;
-    procedure Draw(Bitmap: TCustomBitmap32; OutlineColor: TColor32; FillCallback: TFillLineEvent; Transformation: TTransformation = nil); overload;
-    procedure Draw(Bitmap: TCustomBitmap32; OutlineColor: TColor32; Filler: TCustomPolygonFiller; Transformation: TTransformation = nil); overload;
-
-    procedure DrawEdge(Bitmap: TCustomBitmap32; Color: TColor32; Transformation: TTransformation = nil);
-
-    procedure DrawFill(Bitmap: TCustomBitmap32; Color: TColor32; Transformation: TTransformation = nil); overload;
-    procedure DrawFill(Bitmap: TCustomBitmap32; FillCallback: TFillLineEvent; Transformation: TTransformation = nil); overload;
-    procedure DrawFill(Bitmap: TCustomBitmap32; Filler: TCustomPolygonFiller; Transformation: TTransformation = nil); overload;
-
-    procedure NewLine;
-    procedure Offset(const Dx, Dy: TFixed);
-    function  Outline: TPolygon32;
-    procedure Transform(Transformation: TTransformation);
-    function GetBoundingRect: TFixedRect;
-
-    property Antialiased: Boolean read FAntialiased write FAntialiased;
-    property AntialiasMode: TAntialiasMode read FAntialiasMode write FAntialiasMode;
-    property Closed: Boolean read FClosed write FClosed;
-    property FillMode: TPolyFillMode read FFillMode write FFillMode;
-
-    property Normals: TArrayOfArrayOfFixedPoint read FNormals write FNormals;
-    property Points: TArrayOfArrayOfFixedPoint read FPoints write FPoints;
+    property FillLineEvent: TFillLineEvent read FFillLineEvent write FFillLineEvent;
+  end;
+
+  { TInvertPolygonFiller }
+  TInvertPolygonFiller = class(TCustomPolygonFiller)
+  protected
+    function GetFillLine: TFillLineEvent; override;
+    procedure FillLineBlend(Dst: PColor32; DstX, DstY, Length: Integer;
+      AlphaValues: PColor32; CombineMode: TCombineMode);
+  end;
+
+  { TClearPolygonFiller }
+  TClearPolygonFiller = class(TCustomPolygonFiller)
+  private
+    FColor: TColor32;
+  protected
+    function GetFillLine: TFillLineEvent; override;
+    procedure FillLineClear(Dst: PColor32; DstX, DstY,
+      Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
+  public
+    constructor Create(Color: TColor32 = $00808080); reintroduce; virtual;
+
+    property Color: TColor32 read FColor write FColor;
   end;
 
@@ -190 +183 @@
   protected
     function GetFillLine: TFillLineEvent; override;
-    procedure FillLineOpaque(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32);
-    procedure FillLineBlend(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32);
-    procedure FillLineBlendMasterAlpha(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32);
-    procedure FillLineCustomCombine(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32);
+    procedure FillLineOpaque(Dst: PColor32; DstX, DstY,
+      Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
+    procedure FillLineBlend(Dst: PColor32; DstX, DstY,
+      Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
+    procedure FillLineBlendMasterAlpha(Dst: PColor32; DstX, DstY,
+      Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
+    procedure FillLineCustomCombine(Dst: PColor32; DstX, DstY,
+      Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
   public
     property Pattern: TCustomBitmap32 read FPattern write FPattern;
@@ -207 +204 @@
     procedure SetSampler(const Value: TCustomSampler);
   protected
+    procedure SamplerChanged; virtual;
     function GetFillLine: TFillLineEvent; override;
-    procedure SampleLineOpaque(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32);
-
+    procedure SampleLineOpaque(Dst: PColor32; DstX, DstY, Length: Integer;
+      AlphaValues: PColor32; CombineMode: TCombineMode);
+  public
+    constructor Create(Sampler: TCustomSampler = nil); reintroduce; virtual;
+    procedure BeginRendering; override;
+    procedure EndRendering; override;
     property Sampler: TCustomSampler read FSampler write SetSampler;
   end;
-    
+
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  ClipRect: TRect; Filler: TCustomPolygonFiller; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Filler: TCustomPolygonFiller; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+
+
+procedure PolyPolylineFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; Closed: Boolean = False; StrokeWidth: TFloat = 1.0;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFloat = 4.0; Transformation: TTransformation = nil); overload;
+procedure PolyPolylineFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False; StrokeWidth: TFloat = 1.0;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFloat = 4.0; Transformation: TTransformation = nil); overload;
+
+procedure PolylineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; Closed: Boolean = False; StrokeWidth: TFloat = 1.0;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFloat = 4.0; Transformation: TTransformation = nil); overload;
+procedure PolylineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False; StrokeWidth: TFloat = 1.0;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFloat = 4.0; Transformation: TTransformation = nil); overload;
+
+//Filled only Dashes ...
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; Color: TColor32;
+  Closed: Boolean = False; Width: TFloat = 1.0); overload;
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; FillColor, StrokeColor: TColor32;
+  Closed: Boolean; Width: TFloat; StrokeWidth: TFloat = 2.0); overload;
+//Filled and stroked Dashes ...
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; Filler: TCustomPolygonFiller;
+  Closed: Boolean = False; Width: TFloat = 1.0); overload;
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; Filler: TCustomPolygonFiller; StrokeColor: TColor32;
+  Closed: Boolean; Width: TFloat; StrokeWidth: TFloat = 2.0); overload;
+
+procedure PolyPolygonXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolyPolygonXS_LCD(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonXS_LCD(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil);
+procedure PolyPolygonXS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil); overload;
+procedure PolygonXS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode = pfAlternate;
+  Transformation: TTransformation = nil);
+
+procedure PolyPolylineXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; Closed: Boolean = False; StrokeWidth: TFixed = $10000;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFixed = $40000; Transformation: TTransformation = nil); overload;
+procedure PolyPolylineXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False; StrokeWidth: TFixed = $10000;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFixed = $40000; Transformation: TTransformation = nil); overload;
+
+procedure PolylineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; Closed: Boolean = False; StrokeWidth: TFixed = $10000;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFixed = $40000; Transformation: TTransformation = nil); overload;
+procedure PolylineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False; StrokeWidth: TFixed = $10000;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFixed = $40000; Transformation: TTransformation = nil); overload;
+
+//Filled only Dashes ...
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; Color: TColor32;
+  Closed: Boolean = False; Width: TFixed = $10000); overload;
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; FillColor, StrokeColor: TColor32;
+  Closed: Boolean; Width: TFixed; StrokeWidth: TFixed = $20000); overload;
+//Filled and stroked Dashes ...
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; Filler: TCustomPolygonFiller;
+  Closed: Boolean = False; Width: TFixed = $10000); overload;
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; Filler: TCustomPolygonFiller; StrokeColor: TColor32;
+  Closed: Boolean; Width: TFixed; StrokeWidth: TFixed = $20000); overload;
+
+// fill entire bitmap with a given polygon filler
+procedure FillBitmap(Bitmap: TBitmap32; Filler: TCustomPolygonFiller);
+
+{ Registration routines }
+procedure RegisterPolygonRenderer(PolygonRendererClass: TCustomPolygonRendererClass);
+
+var
+  PolygonRendererList: TClassList;
+  DefaultPolygonRendererClass: TPolygonRenderer32Class = TPolygonRenderer32VPR;
+
 implementation
 
-uses Math;
+uses
+  Math, SysUtils, GR32_Math, GR32_LowLevel, GR32_Blend, GR32_Gamma,
+  GR32_VectorUtils;
+
+resourcestring
+  RCStrNoSamplerSpecified = 'No sampler specified!';
 
 type
-  TCustomBitmap32Access = class(TCustomBitmap32);
-  TShiftFunc = function(Value: Integer): Integer;  // needed for antialiasing to speed things up
-// These are for edge scan info. Note, that the most significant bit of the
-// edge in a scan line is used for winding (edge direction) info.
-
-  TEdgePoint = Integer;
-
-  PEdgePoints = ^TEdgePoints;
-  TEdgePoints = array [0..MaxListSize-1] of TEdgePoint;
-
-  PScanLine = ^TScanLine;
-  TScanLine = record
-    Count: Integer;
-    EdgePoints: PEdgePoints;
-    EdgePointsLength: Integer;
-  end;
-
-  TScanLines = array of TScanLine;
-
-const
-  AA_LINES: Array[TAntialiasMode] of Integer = (32, 16, 8, 4, 2, 1);
-  AA_SHIFT: Array[TAntialiasMode] of Integer = (5, 4, 3, 2, 1, 0);
-  AA_MULTI: Array[TAntialiasMode] of Integer = (65, 273, 1167, 5460, 32662, 0);
-
-{ POLYLINES }
-
-procedure PolylineTS(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfFixedPoint;
-  Color: TColor32;
-  Closed: Boolean;
+  TBitmap32Access = class(TBitmap32);
+
+procedure RegisterPolygonRenderer(PolygonRendererClass: TCustomPolygonRendererClass);
+begin
+  if not Assigned(PolygonRendererList) then PolygonRendererList := TClassList.Create;
+  PolygonRendererList.Add(PolygonRendererClass);
+end;
+
+// routines for color filling:
+
+procedure MakeAlphaNonZeroUP(Coverage: PSingleArray; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  M, V: Cardinal;
+  Last: TFloat;
+  C: TColor32Entry absolute Color;
+begin
+  M := C.A * $101;
+  Last := Infinity;
+  for I := 0 to Count - 1 do
+  begin
+    if PInteger(@Last)^ <> PInteger(@Coverage[I])^ then
+    begin
+      Last := Coverage[I];
+      V := Abs(Round(Last * $10000));
+      if V > $10000 then V := $10000;
+      V := V * M shr 24;
+{$IFDEF USEGR32GAMMA}
+      V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+      C.A := V;
+    end;
+    AlphaValues[I] := Color;
+  end;
+end;
+
+(*
+procedure MakeAlphaNonZeroUP(Coverage: PSingleArray; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  M, V, C: Cardinal;
+begin
+  M := Color shr 24 * $101;
+  C := Color and $00ffffff;
+  for I := 0 to Count - 1 do
+  begin
+    V := Abs(Round(Coverage[I] * $10000));
+    if V > $10000 then V := $10000;
+{$IFDEF USEGR32GAMMA}
+    V := GAMMA_ENCODING_TABLE[V * M shr 24];
+    AlphaValues[I] := (V shl 24) or C;
+{$ELSE}
+    AlphaValues[I] := (V * M and $ff000000) or C;
+{$ENDIF}
+  end;
+end;
+*)
+
+procedure MakeAlphaEvenOddUP(Coverage: PSingleArray; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  M, V: Cardinal;
+  Last: TFloat;
+  C: TColor32Entry absolute Color;
+begin
+  M := C.A * $101;
+  Last := Infinity;
+  for I := 0 to Count - 1 do
+  begin
+    if PInteger(@Last)^ <> PInteger(@Coverage[I])^ then
+    begin
+      Last := Coverage[I];
+      V := Abs(Round(Coverage[I] * $10000));
+      V := V and $01ffff;
+      if V >= $10000 then
+        V := V xor $1ffff;
+      V := V * M shr 24;
+{$IFDEF USEGR32GAMMA}
+      V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+      C.A := V;
+    end;
+    AlphaValues[I] := Color;
+  end;
+end;
+
+procedure MakeAlphaNonZeroP(Value: Single; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  M, V: Cardinal;
+  C: TColor32Entry absolute Color;
+begin
+  M := C.A * $101;
+  V := Abs(Round(Value * $10000));
+  if V > $10000 then V := $10000;
+  V := V * M shr 24;
+{$IFDEF USEGR32GAMMA}
+  V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+  C.A := V;
+  FillLongWord(AlphaValues[0], Count, Color);
+end;
+
+procedure MakeAlphaEvenOddP(Value: Single; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  M, V: Cardinal;
+  C: TColor32Entry absolute Color;
+begin
+  M := C.A * $101;
+  V := Abs(Round(Value * $10000));
+  V := V and $01ffff;
+  if V > $10000 then V := V xor $1ffff;
+  V := V * M shr 24;
+{$IFDEF USEGR32GAMMA}
+  V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+  C.A := V;
+  FillLongWord(AlphaValues[0], Count, Color);
+end;
+
+
+// polygon filler routines (extract alpha only):
+
+procedure MakeAlphaNonZeroUPF(Coverage: PSingleArray; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  V: Integer;
+begin
+  for I := 0 to Count - 1 do
+  begin
+    V := Clamp(Round(Abs(Coverage[I]) * 256));
+{$IFDEF USEGR32GAMMA}
+    V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+    AlphaValues[I] := V;
+  end;
+end;
+
+procedure MakeAlphaEvenOddUPF(Coverage: PSingleArray; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  V: Integer;
+begin
+  for I := 0 to Count - 1 do
+  begin
+    V := Round(Abs(Coverage[I]) * 256);
+    V := V and $000001ff;
+    if V >= $100 then V := V xor $1ff;
+{$IFDEF USEGR32GAMMA}
+    V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+    AlphaValues[I] := V;
+  end;
+end;
+
+procedure MakeAlphaNonZeroPF(Value: Single; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  V: Integer;
+begin
+  V := Clamp(Round(Abs(Value) * 256));
+{$IFDEF USEGR32GAMMA}
+    V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+  FillLongWord(AlphaValues[0], Count, V);
+end;
+
+procedure MakeAlphaEvenOddPF(Value: Single; AlphaValues: PColor32Array;
+  Count: Integer; Color: TColor32);
+var
+  V: Integer;
+begin
+  V := Round(Abs(Value) * 256);
+  V := V and $000001ff;
+  if V >= $100 then V := V xor $1ff;
+{$IFDEF USEGR32GAMMA}
+    V := GAMMA_ENCODING_TABLE[V];
+{$ENDIF}
+  FillLongWord(AlphaValues[0], Count, V);
+end;
+
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Color := Color;
+    Renderer.FillMode := FillMode;
+    Renderer.PolyPolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Color := Color;
+    Renderer.FillMode := FillMode;
+    Renderer.PolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  if not Assigned(Filler) then Exit;
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Filler := Filler;
+    Renderer.FillMode := FillMode;
+    Renderer.PolyPolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  if not Assigned(Filler) then Exit;
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Filler := Filler;
+    Renderer.FillMode := FillMode;
+    Renderer.PolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD;
+begin
+  Renderer := TPolygonRenderer32LCD.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD;
+begin
+  Renderer := TPolygonRenderer32LCD.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolyPolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD2;
+begin
+  Renderer := TPolygonRenderer32LCD2.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD2;
+begin
+  Renderer := TPolygonRenderer32LCD2.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolyPolygonFS(Points, FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode;
   Transformation: TTransformation);
 var
-  I, Count: Integer;
-  DoAlpha: Boolean;
-begin
-  Count := Length(Points);
-
-  if (Count = 1) and Closed then
-    if Assigned(Transformation) then
-      with Transformation.Transform(Points[0]) do
-        Bitmap.SetPixelTS(FixedRound(X), FixedRound(Y), Color)
+  Renderer: TPolygonRenderer32VPR;
+  IntersectedClipRect: TRect;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Color := Color;
+    Renderer.FillMode := FillMode;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolyPolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode;
+  Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+  IntersectedClipRect: TRect;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Color := Color;
+    Renderer.FillMode := FillMode;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  ClipRect: TRect; Filler: TCustomPolygonFiller; FillMode: TPolyFillMode;
+  Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+  IntersectedClipRect: TRect;
+begin
+  if not Assigned(Filler) then Exit;
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Filler := Filler;
+    Renderer.FillMode := FillMode;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolyPolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Filler: TCustomPolygonFiller; FillMode: TPolyFillMode;
+  Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+  IntersectedClipRect: TRect;
+begin
+  if not Assigned(Filler) then Exit;
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Filler := Filler;
+    Renderer.FillMode := FillMode;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS_LCD(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode;
+  Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD;
+  IntersectedClipRect: TRect;
+begin
+  Renderer := TPolygonRenderer32LCD.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS_LCD(Bitmap: TBitmap32;
+  const Points: TArrayOfArrayOfFloatPoint; ClipRect: TRect; Color: TColor32;
+  FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD;
+  IntersectedClipRect: TRect;
+begin
+  Renderer := TPolygonRenderer32LCD.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolyPolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonFS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  ClipRect: TRect; Color: TColor32; FillMode: TPolyFillMode;
+  Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD2;
+  IntersectedClipRect: TRect;
+begin
+  Renderer := TPolygonRenderer32LCD2.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonFS_LCD2(Bitmap: TBitmap32;
+  const Points: TArrayOfArrayOfFloatPoint; ClipRect: TRect; Color: TColor32;
+  FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD2;
+  IntersectedClipRect: TRect;
+begin
+  Renderer := TPolygonRenderer32LCD2.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    GR32.IntersectRect(IntersectedClipRect, Bitmap.ClipRect, ClipRect);
+    Renderer.PolyPolygonFS(Points, FloatRect(IntersectedClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolylineFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Color: TColor32; Closed: Boolean; StrokeWidth: TFloat;
+  JoinStyle: TJoinStyle; EndStyle: TEndStyle;
+  MiterLimit: TFloat; Transformation: TTransformation);
+var
+  Dst: TArrayOfArrayOfFloatPoint;
+begin
+  Dst := BuildPolyPolyLine(Points, Closed, StrokeWidth, JoinStyle, EndStyle, MiterLimit);
+  PolyPolygonFS(Bitmap, Dst, Color, pfWinding, Transformation);
+end;
+
+procedure PolyPolylineFS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False; StrokeWidth: TFloat = 1.0;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFloat = 4.0; Transformation: TTransformation = nil);
+var
+  Dst: TArrayOfArrayOfFloatPoint;
+begin
+  Dst := BuildPolyPolyLine(Points, Closed, StrokeWidth, JoinStyle, EndStyle, MiterLimit);
+  PolyPolygonFS(Bitmap, Dst, Filler, pfWinding, Transformation);
+end;
+
+procedure PolylineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Color: TColor32; Closed: Boolean; StrokeWidth: TFloat;
+  JoinStyle: TJoinStyle; EndStyle: TEndStyle;
+  MiterLimit: TFloat; Transformation: TTransformation);
+begin
+  PolyPolylineFS(Bitmap, PolyPolygon(Points), Color, Closed, StrokeWidth,
+    JoinStyle, EndStyle, MiterLimit, Transformation);
+end;
+
+procedure PolylineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False; StrokeWidth: TFloat = 1.0;
+  JoinStyle: TJoinStyle = jsMiter; EndStyle: TEndStyle = esButt;
+  MiterLimit: TFloat = 4.0; Transformation: TTransformation = nil);
+begin
+  PolyPolylineFS(Bitmap, PolyPolygon(Points), Filler, Closed, StrokeWidth,
+    JoinStyle, EndStyle, MiterLimit, Transformation);
+end;
+
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; Color: TColor32;
+  Closed: Boolean = False; Width: TFloat = 1.0);
+var
+  MultiPoly: TArrayOfArrayOfFloatPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  PolyPolylineFS(Bitmap, MultiPoly, Color, False, Width);
+end;
+
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; FillColor, StrokeColor: TColor32;
+  Closed: Boolean; Width: TFloat; StrokeWidth: TFloat = 2.0);
+var
+  MultiPoly: TArrayOfArrayOfFloatPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  MultiPoly := BuildPolyPolyLine(MultiPoly, False, Width);
+  PolyPolygonFS(Bitmap, MultiPoly, FillColor);
+  PolyPolylineFS(Bitmap, MultiPoly, StrokeColor, True, StrokeWidth);
+end;
+
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; Filler: TCustomPolygonFiller;
+  Closed: Boolean = False; Width: TFloat = 1.0);
+var
+  MultiPoly: TArrayOfArrayOfFloatPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  PolyPolylineFS(Bitmap, MultiPoly, Filler, False, Width);
+end;
+
+procedure DashLineFS(Bitmap: TBitmap32; const Points: TArrayOfFloatPoint;
+  const Dashes: TArrayOfFloat; Filler: TCustomPolygonFiller; StrokeColor: TColor32;
+  Closed: Boolean; Width: TFloat; StrokeWidth: TFloat = 2.0);
+var
+  MultiPoly: TArrayOfArrayOfFloatPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  MultiPoly := BuildPolyPolyLine(MultiPoly, False, Width);
+  PolyPolygonFS(Bitmap, MultiPoly, Filler);
+  PolyPolylineFS(Bitmap, MultiPoly, StrokeColor, True, StrokeWidth);
+end;
+
+
+procedure PolyPolygonXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Color := Color;
+    Renderer.FillMode := FillMode;
+    Renderer.PolyPolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Color := Color;
+    Renderer.FillMode := FillMode;
+    Renderer.PolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Filler := Filler;
+    Renderer.FillMode := FillMode;
+    Renderer.PolyPolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32VPR;
+begin
+  Renderer := TPolygonRenderer32VPR.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.Filler := Filler;
+    Renderer.FillMode := FillMode;
+    Renderer.PolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonXS_LCD(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD;
+begin
+  Renderer := TPolygonRenderer32LCD.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonXS_LCD(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD;
+begin
+  Renderer := TPolygonRenderer32LCD.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolyPolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolygonXS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD2;
+begin
+  Renderer := TPolygonRenderer32LCD2.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolygonXS_LCD2(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; FillMode: TPolyFillMode; Transformation: TTransformation);
+var
+  Renderer: TPolygonRenderer32LCD2;
+begin
+  Renderer := TPolygonRenderer32LCD2.Create;
+  try
+    Renderer.Bitmap := Bitmap;
+    Renderer.FillMode := FillMode;
+    Renderer.Color := Color;
+    Renderer.PolyPolygonFS(FixedPointToFloatPoint(Points),
+      FloatRect(Bitmap.ClipRect), Transformation);
+  finally
+    Renderer.Free;
+  end;
+end;
+
+procedure PolyPolylineXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Color: TColor32; Closed: Boolean; StrokeWidth: TFixed;
+  JoinStyle: TJoinStyle; EndStyle: TEndStyle;
+  MiterLimit: TFixed; Transformation: TTransformation);
+var
+  Dst: TArrayOfArrayOfFixedPoint;
+begin
+  Dst := BuildPolyPolyLine(Points, Closed, StrokeWidth, JoinStyle, EndStyle,
+    MiterLimit);
+  PolyPolygonXS(Bitmap, Dst, Color, pfWinding, Transformation);
+end;
+
+procedure PolyPolylineXS(Bitmap: TBitmap32; const Points: TArrayOfArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False;
+  StrokeWidth: TFixed = $10000; JoinStyle: TJoinStyle = jsMiter;
+  EndStyle: TEndStyle = esButt; MiterLimit: TFixed = $40000;
+  Transformation: TTransformation = nil);
+var
+  Dst: TArrayOfArrayOfFixedPoint;
+begin
+  Dst := BuildPolyPolyLine(Points, Closed, StrokeWidth, JoinStyle, EndStyle,
+    MiterLimit);
+  PolyPolygonXS(Bitmap, Dst, Filler, pfWinding, Transformation);
+end;
+
+procedure PolylineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Color: TColor32; Closed: Boolean; StrokeWidth: TFixed;
+  JoinStyle: TJoinStyle; EndStyle: TEndStyle;
+  MiterLimit: TFixed; Transformation: TTransformation);
+begin
+  PolyPolylineXS(Bitmap, PolyPolygon(Points), Color,
+    Closed, StrokeWidth, JoinStyle, EndStyle,
+    MiterLimit, Transformation);
+end;
+
+procedure PolylineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  Filler: TCustomPolygonFiller; Closed: Boolean = False;
+  StrokeWidth: TFixed = $10000; JoinStyle: TJoinStyle = jsMiter;
+  EndStyle: TEndStyle = esButt; MiterLimit: TFixed = $40000;
+  Transformation: TTransformation = nil);
+begin
+  PolyPolylineXS(Bitmap, PolyPolygon(Points), Filler, Closed, StrokeWidth,
+    JoinStyle, EndStyle, MiterLimit, Transformation);
+end;
+
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; Color: TColor32;
+  Closed: Boolean = False; Width: TFixed = $10000);
+var
+  MultiPoly: TArrayOfArrayOfFixedPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  PolyPolylineXS(Bitmap, MultiPoly, Color, False, Width);
+end;
+
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; FillColor, StrokeColor: TColor32;
+  Closed: Boolean; Width: TFixed; StrokeWidth: TFixed = $20000);
+var
+  MultiPoly: TArrayOfArrayOfFixedPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  PolyPolylineXS(Bitmap, MultiPoly, FillColor, False, Width);
+  MultiPoly := BuildPolyPolyLine(MultiPoly, False, Width);
+  PolyPolylineXS(Bitmap, MultiPoly, StrokeColor, True, strokeWidth);
+end;
+
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; Filler: TCustomPolygonFiller;
+  Closed: Boolean = False; Width: TFixed = $10000);
+var
+  MultiPoly: TArrayOfArrayOfFixedPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  PolyPolylineXS(Bitmap, MultiPoly, Filler, False, Width);
+end;
+
+procedure DashLineXS(Bitmap: TBitmap32; const Points: TArrayOfFixedPoint;
+  const Dashes: TArrayOfFixed; Filler: TCustomPolygonFiller; StrokeColor: TColor32;
+  Closed: Boolean; Width: TFixed; StrokeWidth: TFixed = $20000);
+var
+  MultiPoly: TArrayOfArrayOfFixedPoint;
+begin
+  MultiPoly := GR32_VectorUtils.BuildDashedLine(Points, Dashes, 0, Closed);
+  PolyPolylineXS(Bitmap, MultiPoly, Filler, False, Width);
+  MultiPoly := BuildPolyPolyLine(MultiPoly, False, Width);
+  PolyPolylineXS(Bitmap, MultiPoly, StrokeColor, True, StrokeWidth);
+end;
+
+procedure FillBitmap(Bitmap: TBitmap32; Filler: TCustomPolygonFiller);
+var
+  AlphaValues: PColor32;
+  Y: Integer;
+begin
+  {$IFDEF USESTACKALLOC}
+  AlphaValues := StackAlloc(Bitmap.Width * SizeOf(TColor32));
+  {$ELSE}
+  GetMem(AlphaValues, Bitmap.Width * SizeOf(TColor32));
+  {$ENDIF}
+  FillLongword(AlphaValues^, Bitmap.Width, $FF);
+  Filler.BeginRendering;
+  for Y := 0 to Bitmap.Height - 1 do
+    Filler.FillLine(PColor32(Bitmap.ScanLine[y]), 0, y, Bitmap.Width,
+      AlphaValues, Bitmap.CombineMode);
+  Filler.EndRendering;
+  {$IFDEF USESTACKALLOC}
+  StackFree(AlphaValues);
+  {$ELSE}
+  FreeMem(AlphaValues);
+  {$ENDIF}
+end;
+
+
+{ LCD sub-pixel rendering (see http://www.grc.com/cttech.htm) }
+
+type
+  PRGBTriple = ^TRGBTriple;
+  TRGBTriple = packed record
+    B, G, R: Byte;
+  end;
+
+  PRGBTripleArray = ^TRGBTripleArray;
+  TRGBTripleArray = array [0..0] of TRGBTriple;
+
+  TMakeAlphaProcLCD = procedure(Coverage: PSingleArray; AlphaValues: SysUtils.PByteArray;
+    Count: Integer; Color: TColor32);
+
+procedure MakeAlphaNonZeroLCD(Coverage: PSingleArray; AlphaValues: SysUtils.PByteArray;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  M, V: Cardinal;
+  Last: TFloat;
+  C: TColor32Entry absolute Color;
+begin
+  M := C.A * 86;  // 86 = 258 / 3
+
+  Last := Infinity;
+  V := 0;
+  AlphaValues[0] := 0;
+  AlphaValues[1] := 0;
+  for I := 0 to Count - 1 do
+  begin
+    if PInteger(@Last)^ <> PInteger(@Coverage[I])^ then
+    begin
+      Last := Coverage[I];
+      V := Abs(Round(Last * $10000));
+      if V > $10000 then V := $10000;
+      V := V * M shr 24;
+    end;
+    Inc(AlphaValues[I], V);
+{$IFDEF USEGR32GAMMA}
+    AlphaValues[I] := GAMMA_ENCODING_TABLE[AlphaValues[I]];
+{$ENDIF}
+    Inc(AlphaValues[I + 1], V);
+    AlphaValues[I + 2] := V;
+  end;
+  AlphaValues[Count + 2] := 0;
+  AlphaValues[Count + 3] := 0;
+end;
+
+procedure MakeAlphaEvenOddLCD(Coverage: PSingleArray; AlphaValues: SysUtils.PByteArray;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+  M, V: Cardinal;
+  Last: TFloat;
+begin
+  M := Color shr 24 * 86;  // 86 = 258 / 3
+
+  Last := Infinity;
+  V := 0;
+  AlphaValues[0] := 0;
+  AlphaValues[1] := 0;
+  for I := 0 to Count - 1 do
+  begin
+    if PInteger(@Last)^ <> PInteger(@Coverage[I])^ then
+    begin
+      Last := Coverage[I];
+      V := Abs(Round(Coverage[I] * $10000));
+      V := V and $01ffff;
+      if V >= $10000 then V := V xor $1ffff;
+      V := V * M shr 24;
+    end;
+    Inc(AlphaValues[I], V);
+{$IFDEF USEGR32GAMMA}
+    AlphaValues[I] := GAMMA_ENCODING_TABLE[AlphaValues[I]];
+{$ENDIF}
+    Inc(AlphaValues[I + 1], V);
+    AlphaValues[I + 2] := V;
+  end;
+  AlphaValues[Count + 2] := 0;
+  AlphaValues[Count + 3] := 0;
+end;
+
+procedure MakeAlphaNonZeroLCD2(Coverage: PSingleArray; AlphaValues: SysUtils.PByteArray;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+begin
+  MakeAlphaNonZeroLCD(Coverage, AlphaValues, Count, Color);
+  AlphaValues[Count + 2] := (AlphaValues[Count] + AlphaValues[Count + 1]) div 3;
+  AlphaValues[Count + 3] := AlphaValues[Count + 1] div 3;
+  for I := Count + 1 downto 2 do
+  begin
+    AlphaValues[I] := (AlphaValues[I] + AlphaValues[I - 1] + AlphaValues[I - 2]) div 3;
+  end;
+  AlphaValues[1] := (AlphaValues[0] + AlphaValues[1]) div 3;
+  AlphaValues[0] := AlphaValues[0] div 3;
+end;
+
+procedure MakeAlphaEvenOddLCD2(Coverage: PSingleArray; AlphaValues: SysUtils.PByteArray;
+  Count: Integer; Color: TColor32);
+var
+  I: Integer;
+begin
+  MakeAlphaEvenOddLCD(Coverage, AlphaValues, Count, Color);
+  AlphaValues[Count + 2] := (AlphaValues[Count] + AlphaValues[Count + 1]) div 3;
+  AlphaValues[Count + 3] := AlphaValues[Count + 1] div 3;
+  for I := Count + 1 downto 2 do
+  begin
+    AlphaValues[I] := (AlphaValues[I] + AlphaValues[I - 1] + AlphaValues[I - 2]) div 3;
+  end;
+  AlphaValues[1] := (AlphaValues[0] + AlphaValues[1]) div 3;
+  AlphaValues[0] := AlphaValues[0] div 3;
+end;
+
+procedure CombineLineLCD(Weights: PRGBTripleArray; Dst: PColor32Array; Color: TColor32; Count: Integer);
+var
+  I: Integer;
+  {$IFDEF TEST_BLENDMEMRGB128SSE4}
+  Weights64: UInt64;
+  {$ENDIF}
+begin
+  I := 0;
+  while Count <> 0 do
+    {$IFDEF TEST_BLENDMEMRGB128SSE4}
+    if (Count shr 1) = 0 then
+    {$ENDIF}
+    begin
+      if PColor32(@Weights[I])^ = $FFFFFFFF then
+        Dst[I] := Color
+      else
+        BlendMemRGB(Color, Dst[I], PColor32(@Weights[I])^);
+      Dec(Count);
+      Inc(I);
+    end
+    {$IFDEF TEST_BLENDMEMRGB128SSE4}
     else
-      with Points[0] do
-        Bitmap.SetPixelTS(FixedRound(X), FixedRound(Y), Color);
-
-  if Count < 2 then Exit;
-  DoAlpha := Color and $FF000000 <> $FF000000;
-  Bitmap.BeginUpdate;
-  Bitmap.PenColor := Color;
-
-  if Assigned(Transformation) then
-  begin
-    with Transformation.Transform(Points[0]) do Bitmap.MoveTo(FixedRound(X), FixedRound(Y));
-    if DoAlpha then
-      for I := 1 to Count - 1 do
-        with Transformation.Transform(Points[I]) do
-          Bitmap.LineToTS(FixedRound(X), FixedRound(Y))
-    else
-      for I := 1 to Count - 1 do
-        with Transformation.Transform(Points[I]) do
-          Bitmap.LineToS(FixedRound(X), FixedRound(Y));
-
-    if Closed then with Transformation.Transform(Points[0]) do
-      if DoAlpha then
-        Bitmap.LineToTS(FixedRound(X), FixedRound(Y))
-      else
-        Bitmap.LineToS(FixedRound(X), FixedRound(Y));
-  end
-  else
-  begin
-    with Points[0] do Bitmap.MoveTo(FixedRound(X), FixedRound(Y));
-    if DoAlpha then
-      for I := 1 to Count - 1 do
-        with Points[I] do
-          Bitmap.LineToTS(FixedRound(X), FixedRound(Y))
-    else
-      for I := 1 to Count - 1 do
-        with Points[I] do
-          Bitmap.LineToS(FixedRound(X), FixedRound(Y));
-
-    if Closed then with Points[0] do
-      if DoAlpha then
-        Bitmap.LineToTS(FixedRound(X), FixedRound(Y))
-      else
-        Bitmap.LineToS(FixedRound(X), FixedRound(Y));
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure PolylineAS(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfFixedPoint;
-  Color: TColor32;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I, Count: Integer;
-begin
-  Count := Length(Points);
-  if (Count = 1) and Closed then
-    if Assigned(Transformation) then
-      with Transformation.Transform(Points[0]) do
-        Bitmap.SetPixelTS(FixedRound(X), FixedRound(Y), Color)
-    else
-      with Points[0] do
-        Bitmap.SetPixelTS(FixedRound(X), FixedRound(Y), Color);
-
-  if Count < 2 then Exit;
-  Bitmap.BeginUpdate;
-  Bitmap.PenColor := Color;
-
-  if Assigned(Transformation) then
-  begin
-    with Transformation.Transform(Points[0]) do Bitmap.MoveTo(FixedRound(X), FixedRound(Y));
-    for I := 1 to Count - 1 do
-      with Transformation.Transform(Points[I]) do
-        Bitmap.LineToAS(FixedRound(X), FixedRound(Y));
-    if Closed then with Transformation.Transform(Points[0]) do Bitmap.LineToAS(FixedRound(X), FixedRound(Y));
-  end
-  else
-  begin
-    with Points[0] do Bitmap.MoveTo(FixedRound(X), FixedRound(Y));
-    for I := 1 to Count - 1 do
-      with Points[I] do
-        Bitmap.LineToAS(FixedRound(X), FixedRound(Y));
-    if Closed then with Points[0] do Bitmap.LineToAS(FixedRound(X), FixedRound(Y));
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure PolylineXS(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfFixedPoint;
-  Color: TColor32;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I, Count: Integer;
-begin
-  Count := Length(Points);
-  if (Count = 1) and Closed then
-    if Assigned(Transformation) then
-      with Transformation.Transform(Points[0]) do Bitmap.PixelXS[X, Y] := Color
-    else
-      with Points[0] do Bitmap.PixelXS[X, Y] := Color;
-
-  if Count < 2 then Exit;
-  Bitmap.BeginUpdate;
-  Bitmap.PenColor := Color;
-
-  if Assigned(Transformation) then
-  begin
-    with Transformation.Transform(Points[0]) do Bitmap.MoveToX(X, Y);
-    for I := 1 to Count - 1 do with Transformation.Transform(Points[I]) do Bitmap.LineToXS(X, Y);
-    if Closed then with Transformation.Transform(Points[0]) do Bitmap.LineToXS(X, Y);
-  end
-  else
-  begin
-    with Points[0] do Bitmap.MoveToX(X, Y);
-    for I := 1 to Count - 1 do with Points[I] do Bitmap.LineToXS(X, Y);
-    if Closed then with Points[0] do Bitmap.LineToXS(X, Y);
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure PolylineXSP(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfFixedPoint;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I, Count: Integer;
-begin
-  Count := Length(Points);
-  if Count < 2 then Exit;
-  Bitmap.BeginUpdate;
-  if Assigned(Transformation) then
-  begin
-    with Transformation.Transform(Points[0]) do Bitmap.MoveToX(X, Y);
-    for I := 1 to Count - 1 do with Transformation.Transform(Points[I]) do Bitmap.LineToXSP(X, Y);
-    if Closed then with Transformation.Transform(Points[0]) do Bitmap.LineToXSP(X, Y);
-  end
-  else
-  begin
-    with Points[0] do Bitmap.MoveToX(X, Y);
-    for I := 1 to Count - 1 do with Points[I] do Bitmap.LineToXSP(X, Y);
-    if Closed then with Points[0] do Bitmap.LineToXSP(X, Y);
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure PolyPolylineTS(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I: Integer;
-begin
-  for I := 0 to High(Points) do PolylineTS(Bitmap, Points[I], Color, Closed, Transformation);
-end;
-
-procedure PolyPolylineAS(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I: Integer;
-begin
-  for I := 0 to High(Points) do PolylineAS(Bitmap, Points[I], Color, Closed, Transformation);
-end;
-
-procedure PolyPolylineXS(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint;
-  Color: TColor32;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I: Integer;
-begin
-  for I := 0 to High(Points) do PolylineXS(Bitmap, Points[I], Color, Closed, Transformation);
-end;
-
-procedure PolyPolylineXSP(
-  Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint;
-  Closed: Boolean;
-  Transformation: TTransformation);
-var
-  I: Integer;
-begin
-  for I := 0 to High(Points) do PolylineXSP(Bitmap, Points[I], Closed, Transformation);
-end;
-
-
-{ General routines for drawing polygons }
-
-procedure ScanLinesCreate(var ScanLines: TScanLines; Length: Integer);
-begin
-  SetLength(ScanLines, Length);
-end;
-
-procedure ScanLinesDestroy(var ScanLines: TScanLines);
-var
-  I: Integer;
-begin
-  for I := 0 to High(ScanLines) do
-    FreeMem(ScanLines[I].EdgePoints);
-
-  SetLength(ScanLines, 0);
-end;
-
-
-{ Routines for sorting edge points in scanlines }
-
-const
-  SortThreshold = 10;
-  ReallocationThreshold = 64;
-
-procedure InsertionSort(LPtr, RPtr: PInteger);
-var
-  IPtr, JPtr: PInteger;
-  Temp: PInteger;
-  P, C, T: Integer;
-begin
-  IPtr := LPtr;
-  Inc(IPtr);
-  repeat
-    C := IPtr^;
-    P := C and $7FFFFFFF;
-    JPtr := IPtr;
-
-{$IFDEF HAS_NATIVEINT}
-    if NativeUInt(JPtr) > NativeUInt(LPtr) then
-{$ELSE}
-    if Cardinal(JPtr) > Cardinal(LPtr) then
-{$ENDIF}
-    repeat
-      Temp := JPtr;
-      Dec(Temp);
-      T := Temp^;
-      if T and $7FFFFFFF > P then
+    begin
+      Weights64 := (UInt64(PColor32(@Weights[I + 1])^) shl 32) or
+        PColor32(@Weights[I])^;
+      if Weights64 = $FFFFFFFFFFFFFFFF then
       begin
-        JPtr^ := T;
-        JPtr := Temp;
+        Dst[I] := Color;
+        Dst[I + 1] := Color;
       end
       else
-        Break;
-{$IFDEF HAS_NATIVEINT}
-    until NativeUInt(JPtr) <= NativeUInt(LPtr);
-{$ELSE}
-    until Cardinal(JPtr) <= Cardinal(LPtr);
-{$ENDIF}
-
-    JPtr^ := C;
-    Inc(IPtr);
-{$IFDEF HAS_NATIVEINT}
-  until NativeUInt(IPtr) > NativeUInt(RPtr);
-{$ELSE}
-  until Cardinal(IPtr) > Cardinal(RPtr);
-{$ENDIF}
-end;
-
-procedure QuickSort(LPtr, RPtr: PInteger);
-var
-{$IFDEF HAS_NATIVEINT}
-  P: NativeUInt;
-{$ELSE}
-  P: Cardinal;
-{$ENDIF}
-  TempVal: Integer;
-  IPtr, JPtr: PInteger;
-  Temp: Integer;
-const
-  OddMask = SizeOf(Integer) and not(SizeOf(Integer) - 1);
-begin
-  {$IFDEF HAS_NATIVEINT}
-  if NativeUInt(RPtr) - NativeUInt(LPtr) > SortThreshold shl 2 then
-  {$ELSE}
-  if Cardinal(RPtr) - Cardinal(LPtr) > SortThreshold shl 2 then
-  {$ENDIF}
-  repeat
-    {$IFDEF HAS_NATIVEINT}
-    P := NativeUInt(RPtr) - NativeUInt(LPtr);
-    if (P and OddMask > 0) then Dec(P, SizeOf(Integer));
-    TempVal := PInteger(NativeUInt(LPtr) + P shr 1)^ and $7FFFFFFF;
-    {$ELSE}
-    P := Cardinal(RPtr) - Cardinal(LPtr);
-    if (P and OddMask > 0) then Dec(P, SizeOf(Integer));
-    TempVal := PInteger(Cardinal(LPtr) + P shr 1)^ and $7FFFFFFF;
-    {$ENDIF}
-
-    IPtr := LPtr;
-    JPtr := RPtr;
-    repeat
-      while (IPtr^ and $7FFFFFFF) < TempVal do Inc(IPtr);
-      while (JPtr^ and $7FFFFFFF) > TempVal do Dec(JPtr);
-      {$IFDEF HAS_NATIVEINT}
-      if NativeUInt(IPtr) <= NativeUInt(JPtr) then
-      {$ELSE}
-      if Cardinal(IPtr) <= Cardinal(JPtr) then
-      {$ENDIF}
-      begin
-        Temp := IPtr^;
-        IPtr^ := JPtr^;
-        JPtr^ := Temp;
-//        Swap(IPtr^, JPtr^);
-        Inc(IPtr);
-        Dec(JPtr);
-      end;
-    {$IFDEF HAS_NATIVEINT}
-    until NativeUInt(IPtr) > NativeUInt(JPtr);
-    if NativeUInt(LPtr) < NativeUInt(JPtr) then
-    {$ELSE}
-    until Integer(IPtr) > Integer(JPtr);
-    if Cardinal(LPtr) < Cardinal(JPtr) then
-    {$ENDIF}
-      QuickSort(LPtr, JPtr);
-    LPtr := IPtr;
-  {$IFDEF HAS_NATIVEINT}
-  until NativeUInt(IPtr) >= NativeUInt(RPtr)
-  {$ELSE}
-  until Cardinal(IPtr) >= Cardinal(RPtr)
-  {$ENDIF}
-  else
-    InsertionSort(LPtr, RPtr);
-end;
-
-procedure SortLine(const ALine: TScanLine);
-var
-  L, T: Integer;
-begin
-  L := ALine.Count;
-  Assert(not Odd(L));
-  if L = 2 then
-  begin
-    if (ALine.EdgePoints[0] and $7FFFFFFF) > (ALine.EdgePoints[1] and $7FFFFFFF) then
-    begin
-      T := ALine.EdgePoints[0];
-      ALine.EdgePoints[0] := ALine.EdgePoints[1];
-      ALine.EdgePoints[1] := T;
-    end;
-  end
-  else if L > SortThreshold then
-    QuickSort(@ALine.EdgePoints[0], @ALine.EdgePoints[L - 1])
-  else if L > 2 then
-    InsertionSort(@ALine.EdgePoints[0], @ALine.EdgePoints[L - 1]);
-end;
-
-procedure SortLines(const ScanLines: TScanLines);
-var
-  I: Integer;
-begin
-  for I := 0 to High(ScanLines) do SortLine(ScanLines[I]);
-end;
-
-
-{ Routines for rendering polygon edges to scanlines }
-
-procedure AddEdgePoint(X: Integer; const Y: Integer; const ClipRect: TFixedRect; const ScanLines: TScanLines; const Direction: Integer);
-var
-  L: Integer;
-  ScanLine: PScanLine;
-begin
-  if (Y < ClipRect.Top) or (Y > ClipRect.Bottom) then Exit;
-
-  if X < ClipRect.Left then
-    X := ClipRect.Left
-  else if X > ClipRect.Right then
-    X := ClipRect.Right;
-
-  // positive direction (+1) is down
-  if Direction < 0 then
-    X := Integer(Longword(X) or $80000000); // set the highest bit if the winding is up
-
-  ScanLine := @ScanLines[Y - ClipRect.Top];
-
-  L := ScanLine.Count;
-  Inc(ScanLine.Count);
-  if ScanLine.Count > ScanLine.EdgePointsLength then
-  begin
-    ScanLine.EdgePointsLength := L + ReallocationThreshold;
-    ReallocMem(ScanLine.EdgePoints, ScanLine.EdgePointsLength * SizeOf(TEdgePoint));
-  end;
-  ScanLine.EdgePoints[L] := X;  
-end;
-
-function DrawEdge(const P1, P2: TFixedPoint; const ClipRect: TFixedRect; const ScanLines: TScanLines): Integer;
-var
-  X, Y: Integer;
-  I, K: Integer;
-  Dx, Dy, Sx, Sy: Integer;
-  Delta: Integer;
-begin
-  // this function 'renders' a line into the edge point (ScanLines) buffer
-  // and returns the line direction (1 - down, -1 - up, 0 - horizontal)
-  Result := 0;
-  if P2.Y = P1.Y then Exit;
-  Dx := P2.X - P1.X;
-  Dy := P2.Y - P1.Y;
-
-  if Dy > 0 then Sy := 1
-  else
-  begin
-    Sy := -1;
-    Dy := -Dy;
-  end;
-
-  Result := Sy;
-
-  if Dx > 0 then Sx := 1
-  else
-  begin
-    Sx := -1;
-    Dx := -Dx;
-  end;
-
-  Delta := (Dx mod Dy) shr 1;
-  X := P1.X; Y := P1.Y;
-
-  for I := 0 to Dy - 1 do
-  begin
-    AddEdgePoint(X, Y, ClipRect, ScanLines, Result);
-    Inc(Y, Sy);
-    Inc(Delta, Dx);
-
-    // try it two times and if anything else left, use div and mod
-    if Delta > Dy then
-    begin
-      Inc(X, Sx);
-      Dec(Delta, Dy);
-
-      if Delta > Dy then  // segment is tilted more than 45 degrees?
-      begin
-        Inc(X, Sx);
-        Dec(Delta, Dy);
-
-        if Delta > Dy then // are we still here?
-        begin
-          K := (Delta + Dy - 1) div Dy;
-          Inc(X, Sx * K);
-          Dec(Delta, Dy * K);
-        end;
-      end;
-    end;
-  end;
-end;
-
-
-procedure RoundShift1(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation); forward; {$IFDEF USEINLINING} inline; {$ENDIF}
-procedure RoundShift2(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation); forward; {$IFDEF USEINLINING} inline; {$ENDIF}
-procedure RoundShift4(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation); forward; {$IFDEF USEINLINING} inline; {$ENDIF}
-procedure RoundShift8(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation); forward; {$IFDEF USEINLINING} inline; {$ENDIF}
-procedure RoundShift16(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation); forward; {$IFDEF USEINLINING} inline; {$ENDIF}
-procedure RoundShift32(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation); forward; {$IFDEF USEINLINING} inline; {$ENDIF}
-
-type
-  TTransformProc = procedure(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-  TTransformationAccess = class(TTransformation);
-
-procedure Transform1(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-begin
-  TTransformationAccess(T).TransformFixed(SrcPoint.X, SrcPoint.Y, DstPoint.X, DstPoint.Y);
-  RoundShift1(DstPoint, DstPoint, nil);
-end;
-
-procedure RoundShift1(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-{$IFDEF USENATIVECODE}
-begin
-  DstPoint.X := (SrcPoint.X + $7F) div 256;
-  DstPoint.Y := (SrcPoint.Y + $7FFF) div 65536;
-{$ELSE}
-asm
-{$IFDEF TARGET_x64}
-    MOV EAX, [SrcPoint]
-    ADD EAX, $0000007F
-    SAR EAX, 8 // sub-sampled
-    MOV [DstPoint], EAX
-    MOV EDX, [SrcPoint + $4]
-    ADD EDX, $00007FFF
-    SAR EDX, 16
-    MOV [DstPoint + $4], EDX
-{$ENDIF}
-{$IFDEF TARGET_x86}
-    MOV ECX, [SrcPoint.X]
-    ADD ECX, $0000007F
-    SAR ECX, 8 // sub-sampled
-    MOV [DstPoint.X], ECX
-    MOV EDX, [SrcPoint.Y]
-    ADD EDX, $00007FFF
-    SAR EDX, 16
-    MOV [DstPoint.Y], EDX
-{$ENDIF}
-{$ENDIF}
-end;
-
-procedure Transform2(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-begin
-  TTransformationAccess(T).TransformFixed(SrcPoint.X, SrcPoint.Y, DstPoint.X, DstPoint.Y);
-  RoundShift2(DstPoint, DstPoint, nil);
-end;
-
-procedure RoundShift2(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-{$IFDEF USENATIVECODE}
-begin
-  DstPoint.X := (SrcPoint.X + $3FFF) div 32768;
-  DstPoint.Y := (SrcPoint.Y + $3FFF) div 32768;
-{$ELSE}
-asm
-{$IFDEF TARGET_x64}
-    MOV EAX, [SrcPoint]
-    ADD EAX, $00003FFF
-    SAR EAX, 15
-    MOV [DstPoint], EAX
-    MOV EDX, [SrcPoint + $4]
-    ADD EDX, $00003FFF
-    SAR EDX, 15
-    MOV [DstPoint + $4], EDX
-{$ENDIF}
-{$IFDEF TARGET_x86}
-    MOV ECX, [SrcPoint.X]
-    ADD ECX, $00003FFF
-    SAR ECX, 15
-    MOV [DstPoint.X], ECX
-    MOV EDX, [SrcPoint.Y]
-    ADD EDX, $00003FFF
-    SAR EDX, 15
-    MOV [DstPoint.Y], EDX
-{$ENDIF}
-{$ENDIF}
-end;
-
-procedure Transform4(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-begin
-  TTransformationAccess(T).TransformFixed(SrcPoint.X, SrcPoint.Y, DstPoint.X, DstPoint.Y);
-  RoundShift4(DstPoint, DstPoint, nil);
-end;
-
-procedure RoundShift4(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-{$IFDEF USENATIVECODE}
-begin
-  DstPoint.X := (SrcPoint.X + $1FFF) div 16384;
-  DstPoint.Y := (SrcPoint.Y + $1FFF) div 16384;
-{$ELSE}
-asm
-{$IFDEF TARGET_x64}
-    MOV EAX, [SrcPoint]
-    ADD EAX, $00001FFF
-    SAR EAX, 14
-    MOV [DstPoint], EAX
-    MOV EDX, [SrcPoint + $4]
-    ADD EDX, $00001FFF
-    SAR EDX, 14
-    MOV [DstPoint + $4], EDX
-{$ENDIF}
-{$IFDEF TARGET_x86}
-    MOV ECX, [SrcPoint.X]
-    ADD ECX, $00001FFF
-    SAR ECX, 14
-    MOV [DstPoint.X], ECX
-    MOV EDX, [SrcPoint.Y]
-    ADD EDX, $00001FFF
-    SAR EDX, 14
-    MOV [DstPoint.Y], EDX
-{$ENDIF}
-{$ENDIF}
-end;
-
-procedure Transform8(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-begin
-  TTransformationAccess(T).TransformFixed(SrcPoint.X, SrcPoint.Y, DstPoint.X, DstPoint.Y);
-  RoundShift8(DstPoint, DstPoint, nil);
-end;
-
-procedure RoundShift8(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-{$IFDEF USENATIVECODE}
-begin
-  DstPoint.X := (SrcPoint.X + $FFF) div 8192;
-  DstPoint.Y := (SrcPoint.Y + $FFF) div 8192;
-{$ELSE}
-asm
-{$IFDEF TARGET_x64}
-    MOV EAX, [SrcPoint]
-    ADD EAX, $00000FFF
-    SAR EAX, 13
-    MOV [DstPoint], EAX
-    MOV EDX, [SrcPoint + $4]
-    ADD EDX, $00000FFF
-    SAR EDX, 13
-    MOV [DstPoint + $4], EDX
-{$ENDIF}
-{$IFDEF TARGET_x86}
-    MOV ECX, [SrcPoint.X]
-    ADD ECX, $00000FFF
-    SAR ECX, 13
-    MOV [DstPoint.X], ECX
-    MOV EDX, [SrcPoint.Y]
-    ADD EDX, $00000FFF
-    SAR EDX, 13
-    MOV [DstPoint.Y], EDX
-{$ENDIF}
-{$ENDIF}
-end;
-
-procedure Transform16(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-begin
-  TTransformationAccess(T).TransformFixed(SrcPoint.X, SrcPoint.Y, DstPoint.X, DstPoint.Y);
-  RoundShift16(DstPoint, DstPoint, nil);
-end;
-
-procedure RoundShift16(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-{$IFDEF USENATIVECODE}
-begin
-  DstPoint.X := (SrcPoint.X + $7FF) div 4096;
-  DstPoint.Y := (SrcPoint.Y + $7FF) div 4096;
-{$ELSE}
-asm
-{$IFDEF TARGET_x64}
-    MOV EAX, [SrcPoint]
-    ADD EAX, $000007FF
-    SAR EAX, 12
-    MOV [DstPoint], EAX
-    MOV EDX, [SrcPoint + $4]
-    ADD EDX, $000007FF
-    SAR EDX, 12
-    MOV [DstPoint + $4], EDX
-{$ENDIF}
-{$IFDEF TARGET_x86}
-    MOV ECX, [SrcPoint.X]
-    ADD ECX, $000007FF
-    SAR ECX, 12
-    MOV [DstPoint.X], ECX
-    MOV EDX, [SrcPoint.Y]
-    ADD EDX, $000007FF
-    SAR EDX, 12
-    MOV [DstPoint.Y], EDX
-{$ENDIF}
-{$ENDIF}
-end;
-
-procedure Transform32(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-begin
-  TTransformationAccess(T).TransformFixed(SrcPoint.X, SrcPoint.Y, DstPoint.X, DstPoint.Y);
-  RoundShift32(DstPoint, DstPoint, nil);
-end;
-
-procedure RoundShift32(var DstPoint: TFixedPoint; const SrcPoint: TFixedPoint; const T: TTransformation);
-{$IFDEF USENATIVECODE}
-begin
-  DstPoint.X := (SrcPoint.X + $3FF) div 2048;
-  DstPoint.Y := (SrcPoint.Y + $3FF) div 2048;
-{$ELSE}
-asm
-{$IFDEF TARGET_x64}
-    MOV EAX, [SrcPoint]
-    ADD EAX, $000003FF
-    SAR EAX, 11
-    MOV [DstPoint], EAX
-    MOV EDX, [SrcPoint + $4]
-    ADD EDX, $000003FF
-    SAR EDX, 11
-    MOV [DstPoint + $4], EDX
-{$ENDIF}
-{$IFDEF TARGET_x86}
-    MOV ECX, [SrcPoint.X]
-    ADD ECX, $000003FF
-    SAR ECX, 11
-    MOV [DstPoint.X], ECX
-    MOV EDX, [SrcPoint.Y]
-    ADD EDX, $000003FF
-    SAR EDX, 11
-    MOV [DstPoint.Y], EDX
-{$ENDIF}
-{$ENDIF}
-end;
-
-const
-  RoundShiftProcs: array[TAntialiasMode] of TTransformProc = (RoundShift32, RoundShift16, RoundShift8, RoundShift4, RoundShift2, RoundShift1);
-  TransformProcs:  array[TAntialiasMode] of TTransformProc = (Transform32, Transform16, Transform8, Transform4, Transform2, Transform1);
-
-procedure AddPolygon(const Points: TArrayOfFixedPoint; const ClipRect: TFixedRect;
-  var ScanLines: TScanLines; AAMode: TAntialiasMode; Transformation: TTransformation);
-var
-  P1, P2: TFixedPoint;
-  I: Integer;
-  PPtr: PFixedPoint;
-  Transform: TTransformProc;
-  Direction, PrevDirection: Integer; // up = 1 or down = -1
-begin
-  if Length(Points) < 3 then Exit;
-
-  if Assigned(Transformation) then
-    Transform := TransformProcs[AAMode]
-  else
-    Transform := RoundShiftProcs[AAMode];
-
-  Transform(P1, Points[0], Transformation);
-
-  // find the last Y different from Y1 and get direction
-  PrevDirection := 0;
-  I := High(Points);
-  PPtr := @Points[I];
-
-  while (I > 0) and (PrevDirection = 0) do
-  begin
-    Dec(I);
-    Transform(P2, PPtr^, Transformation); { TODO : optimize minor inefficiency... }
-    PrevDirection := P1.Y - P2.Y;
-    Dec(PPtr);
-  end;
-
-  if PrevDirection > 0 then
-    PrevDirection := 1
-  else if PrevDirection < 0 then
-    PrevDirection := -1
-  else
-    PrevDirection := 0;
-
-  PPtr := @Points[1];
-  for I := 1 to High(Points) do
-  begin
-    Transform(P2, PPtr^, Transformation);
-
-    if P1.Y <> P2.Y then
-    begin
-      Direction := DrawEdge(P1, P2, ClipRect, ScanLines);
-      if Direction <> PrevDirection then
-      begin
-        AddEdgePoint(P1.X, P1.Y, ClipRect, ScanLines, -Direction);
-        PrevDirection := Direction;
-      end;
-    end;
-
-    P1 := P2;
-    Inc(PPtr);
-  end;
-
-  Transform(P2, Points[0], Transformation);
-
-  if P1.Y <> P2.Y then
-  begin
-    Direction := DrawEdge(P1, P2, ClipRect, ScanLines);
-    if Direction <> PrevDirection then AddEdgePoint(P1.X, P1.Y, ClipRect, ScanLines, -Direction);
-  end;
-end;
-
-
-{ FillLines routines }
-{ These routines rasterize the sorted edge points in the scanlines to
-  the bitmap buffer }
-
-procedure ColorFillLines(Bitmap: TCustomBitmap32; BaseY: Integer;
-  const ScanLines: TScanLines; Color: TColor32; Mode: TPolyFillMode);
-var
-  I, J, L: Integer;
-  Top, Left, Right, OldRight, LP, RP, Cx: Integer;
-  Winding, NextWinding: Integer;
-  HorzLine: procedure(X1, Y, X2: Integer; Value: TColor32) of Object;
-begin
-  if Color and $FF000000 <> $FF000000 then
-    HorzLine := Bitmap.HorzLineT
-  else
-    HorzLine := Bitmap.HorzLine;
-
-  Cx := Bitmap.ClipRect.Right - 1;
-  Top := BaseY - 1;
-
-  if Mode = pfAlternate then
-    for J := 0 to High(ScanLines) do
-    begin
-      Inc(Top);
-      L := ScanLines[J].Count; // assuming length is even
-      if L = 0 then Continue;
-      I := 0;
-      OldRight := -1;
-
-      while I < L do
-      begin
-        Left := ScanLines[J].EdgePoints[I] and $7FFFFFFF;
-        Inc(I);
-        Right := ScanLines[J].EdgePoints[I] and $7FFFFFFF - 1;
-        if Right > Left then
-        begin
-          if (Left and $FF) < $80 then Left := Left shr 8
-          else Left := Left shr 8 + 1;
-
-          if (Right and $FF) < $80 then Right := Right shr 8
-          else Right := Right shr 8 + 1;
-
-          if Right >= Cx then Right := Cx;
-
-          if Left <= OldRight then Left := OldRight + 1;
-          OldRight := Right;
-          if Right >= Left then HorzLine(Left, Top, Right, Color);
-        end;
-        Inc(I);
-      end
+        BlendMemRGB128(Color, Dst[I], Weights64);
+      Dec(Count, 2);
+      Inc(I, 2);
     end
-  else // Mode = pfWinding
-    for J := 0 to High(ScanLines) do
-    begin
-      Inc(Top);
-      L := ScanLines[J].Count; // assuming length is even
-      if L = 0 then Continue;
-      I := 0;
-
-      Winding := 0;
-      Left := ScanLines[J].EdgePoints[0];
-      if (Left and $80000000) <> 0 then Inc(Winding) else Dec(Winding);
-      Left := Left and $7FFFFFFF;
-      Inc(I);
-
-      while I < L do
-      begin
-        Right := ScanLines[J].EdgePoints[I];
-        if (Right and $80000000) <> 0 then NextWinding := 1 else NextWinding := -1;
-        Right := Right and $7FFFFFFF;
-        Inc(I);
-
-        if Winding <> 0 then
-        begin
-          if (Left and $FF) < $80 then LP := Left shr 8
-          else LP := Left shr 8 + 1;
-          if (Right and $FF) < $80 then RP := Right shr 8
-          else RP := Right shr 8 + 1;
-
-          if RP >= Cx then RP := Cx;
-
-          if RP >= LP then HorzLine(LP, Top, RP, Color);
-        end;
-
-        Inc(Winding, NextWinding);
-        Left := Right;
-      end;
-    end;
-end;
-
-procedure ColorFillLines2(Bitmap: TCustomBitmap32; BaseY: Integer;
-  const ScanLines: TScanLines; Color: TColor32; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode = DefaultAAMode);
-var
-  I, J, L, N: Integer;
-  MinY, MaxY, Y, Top, Bottom: Integer;
-  MinX, MaxX, X, Dx: Integer;
-  Left, Right: Integer;
-  Buffer: array of Integer;
-  ColorBuffer: array of TColor32;
-  BufferSize: Integer;
-  C, A: TColor32;
-  ScanLine: PIntegerArray;
-  Winding, NextWinding: Integer;
-  AAShift, AALines, AAMultiplier: Integer;
-  BlendLineEx: TBlendLineEx;
-begin
-  A := Color shr 24;
-
-  AAShift := AA_SHIFT[AAMode];
-  AALines := AA_LINES[AAMode] - 1; // we do the -1 here for optimization.
-  AAMultiplier := AA_MULTI[AAMode];
-
-  BlendLineEx := BLEND_LINE_EX[Bitmap.CombineMode]^;
-
-  // find the range of Y screen coordinates
-  MinY := BaseY shr AAShift;
-  MaxY := (BaseY + Length(ScanLines) + AALines) shr AAShift;
-
-  Y := MinY;
-  while Y < MaxY do
-  begin
-    Top := Y shl AAShift - BaseY;
-    Bottom := Top + AALines;
-    if Top < 0 then Top := 0;
-    if Bottom >= Length(ScanLines) then Bottom := High(ScanLines);
-
-    // find left and right edges of the screen scanline
-    MinX := $7F000000; MaxX := -$7F000000;
-    for J := Top to Bottom do
-    begin
-      L := ScanLines[J].Count - 1;
-      if L > 0 then
-      begin
-        Left := (ScanLines[J].EdgePoints[0] and $7FFFFFFF);
-        Right := (ScanLines[J].EdgePoints[L] and $7FFFFFFF + AALines);
-        if Left < MinX then MinX := Left;
-        if Right > MaxX then MaxX := Right;
-      end
-    end;
-
-    if MaxX >= MinX then
-    begin
-      MinX := MinX shr AAShift;
-      MaxX := MaxX shr AAShift;
-      // allocate buffer for a single scanline
-      BufferSize := MaxX - MinX + 2;
-      if Length(Buffer) < BufferSize then
-      begin
-        SetLength(Buffer, BufferSize + 64);
-        SetLength(ColorBuffer, BufferSize + 64);
-      end;
-      FillLongword(Buffer[0], BufferSize, 0);
-
-      // ...and fill it
-      if Mode = pfAlternate then
-        for J := Top to Bottom do
-        begin
-          I := 0;
-          L := ScanLines[J].Count;
-          ScanLine := @ScanLines[J].EdgePoints[0];
-          while I < L do
-          begin
-            // Left edge
-            X := ScanLine[I] and $7FFFFFFF;
-            Dx := X and AALines;
-            X := X shr AAShift - MinX;
-            Inc(Buffer[X], Dx xor AALines);
-            Inc(Buffer[X + 1], Dx);
-            Inc(I);
-
-            // Right edge
-            X := ScanLine[I] and $7FFFFFFF;
-            Dx := X and AALines;
-            X := X shr AAShift - MinX;
-            Dec(Buffer[X], Dx xor AALines);
-            Dec(Buffer[X + 1], Dx);
-            Inc(I);
-          end
-        end
-      else // mode = pfWinding
-        for J := Top to Bottom do
-        begin
-          I := 0;
-          L := ScanLines[J].Count;
-          ScanLine := @ScanLines[J].EdgePoints[0];
-          Winding := 0;
-          while I < L do
-          begin
-            X := ScanLine[I];
-            Inc(I);
-            if (X and $80000000) <> 0 then NextWinding := 1 else NextWinding := -1;
-            X := X and $7FFFFFFF;
-            if Winding = 0 then
-            begin
-              Dx := X and AALines;
-              X := X shr AAShift - MinX;
-              Inc(Buffer[X], Dx xor AALines);
-              Inc(Buffer[X + 1], Dx);
-            end;
-            Inc(Winding, NextWinding);
-            if Winding = 0 then
-            begin
-              Dx := X and AALines;
-              X := X shr AAShift - MinX;
-              Dec(Buffer[X], Dx xor AALines);
-              Dec(Buffer[X + 1], Dx);
-            end;
-          end;
-        end;
-
-      // integrate the buffer
-      N := 0;
-      C := Color and $00FFFFFF;
-      for I := 0 to BufferSize - 1 do
-      begin
-        Inc(N, Buffer[I]);
-        ColorBuffer[I] := TColor32(N * AAMultiplier and $FF00) shl 16 or C;
-      end;
-
-      // draw it to the screen
-      BlendLineEx(@ColorBuffer[0], Pointer(Bitmap.PixelPtr[MinX, Y]),
-        Min(BufferSize, Bitmap.Width - MinX), A);
-      EMMS;
-    end;
-
-    Inc(Y);
-  end;
-end;
-
-procedure CustomFillLines(Bitmap: TCustomBitmap32; BaseY: Integer;
-  const ScanLines: TScanLines; FillLineCallback: TFillLineEvent; Mode: TPolyFillMode);
-var
-  I, J, L: Integer;
-  Top, Left, Right, OldRight, LP, RP, Cx: Integer;
-  Winding, NextWinding: Integer;
-begin
-  Top := BaseY - 1;
-  Cx := Bitmap.ClipRect.Right - 1;
-
-  if Mode = pfAlternate then
-    for J := 0 to High(ScanLines) do
-    begin
-      Inc(Top);
-      L := ScanLines[J].Count; // assuming length is even
-      if L = 0 then Continue;
-      I := 0;
-      OldRight := -1;
-
-      while I < L do
-      begin
-        Left := ScanLines[J].EdgePoints[I] and $7FFFFFFF;
-        Inc(I);
-        Right := ScanLines[J].EdgePoints[I] and $7FFFFFFF - 1;
-        if Right > Left then
-        begin
-          if (Left and $FF) < $80 then Left := Left shr 8
-          else Left := Left shr 8 + 1;
-          if (Right and $FF) < $80 then Right := Right shr 8
-          else Right := Right shr 8 + 1;
-
-          if Right >= Cx then Right := Cx;
-
-          if Left <= OldRight then Left := OldRight + 1;
-          OldRight := Right;
-          if Right >= Left then
-            FillLineCallback(Bitmap.PixelPtr[Left, Top], Left, Top, Right - Left, nil);
-        end;
-        Inc(I);
-      end
-    end
-  else // Mode = pfWinding
-    for J := 0 to High(ScanLines) do
-    begin
-      Inc(Top);
-      L := ScanLines[J].Count; // assuming length is even
-      if L = 0 then Continue;
-      I := 0;
-
-      Winding := 0;
-      Left := ScanLines[J].EdgePoints[0];
-      if (Left and $80000000) <> 0 then Inc(Winding) else Dec(Winding);
-      Left := Left and $7FFFFFFF;
-      Inc(I);
-      while I < L do
-      begin
-        Right := ScanLines[J].EdgePoints[I];
-        if (Right and $80000000) <> 0 then NextWinding := 1 else NextWinding := -1;
-        Right := Right and $7FFFFFFF;
-        Inc(I);
-
-        if Winding <> 0 then
-        begin
-          if (Left and $FF) < $80 then LP := Left shr 8
-          else LP := Left shr 8 + 1;
-          if (Right and $FF) < $80 then RP := Right shr 8
-          else RP := Right shr 8 + 1;
-
-          if RP >= Cx then RP := Cx;
-
-          if RP >= LP then
-            FillLineCallback(Bitmap.PixelPtr[LP, Top], LP, Top, RP - LP, nil);
-        end;
-
-        Inc(Winding, NextWinding);
-        Left := Right;
-      end;
-    end;
+    {$ENDIF};
   EMMS;
 end;
 
-procedure CustomFillLines2(Bitmap: TCustomBitmap32; BaseY: Integer;
-  const ScanLines: TScanLines; FillLineCallback: TFillLineEvent; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode = DefaultAAMode);
-var
-  I, J, L, N: Integer;
-  MinY, MaxY, Y, Top, Bottom: Integer;
-  MinX, MaxX, X, Dx: Integer;
-  Left, Right: Integer;
-  Buffer: array of Integer;
-  AlphaBuffer: array of TColor32;
-  BufferSize: Integer;
-  ScanLine: PIntegerArray;
-  Winding, NextWinding: Integer;
-  AAShift, AALines, AAMultiplier: Integer;
-begin
-  AAShift := AA_SHIFT[AAMode];
-  AALines := AA_LINES[AAMode] - 1; // we do the -1 here for optimization.
-  AAMultiplier := AA_MULTI[AAMode];
-
-  // find the range of Y screen coordinates
-  MinY := BaseY shr AAShift;
-  MaxY := (BaseY + Length(ScanLines) + AALines) shr AAShift;
-
-  Y := MinY;
-  while Y < MaxY do
-  begin
-    Top := Y shl AAShift - BaseY;
-    Bottom := Top + AALines;
-    if Top < 0 then Top := 0;
-    if Bottom >= Length(ScanLines) then Bottom := High(ScanLines);
-
-    // find left and right edges of the screen scanline
-    MinX := $7F000000; MaxX := -$7F000000;
-    for J := Top to Bottom do
-    begin
-      L := ScanLines[J].Count - 1;
-      if L > 0 then
-      begin
-        Left := (ScanLines[J].EdgePoints[0] and $7FFFFFFF);
-        Right := (ScanLines[J].EdgePoints[L] and $7FFFFFFF + AALines);
-        if Left < MinX then MinX := Left;
-        if Right > MaxX then MaxX := Right;
-      end
-    end;
-
-    if MaxX >= MinX then
-    begin
-      MinX := MinX shr AAShift;
-      MaxX := MaxX shr AAShift;
-      // allocate buffer for a single scanline
-      BufferSize := MaxX - MinX + 2;
-      if Length(Buffer) < BufferSize then
-      begin
-        SetLength(Buffer, BufferSize + 64);
-        SetLength(AlphaBuffer, BufferSize + 64);
-      end;
-      FillLongword(Buffer[0], BufferSize, 0);
-
-      // ...and fill it
-      if Mode = pfAlternate then
-        for J := Top to Bottom do
-        begin
-          I := 0;
-          L := ScanLines[J].Count;
-          ScanLine := @ScanLines[J].EdgePoints[0];
-          while I < L do
-          begin
-            // Left edge
-            X := ScanLine[I] and $7FFFFFFF;
-            Dx := X and AALines;
-            X := X shr AAShift - MinX;
-            Inc(Buffer[X], Dx xor AALines);
-            Inc(Buffer[X + 1], Dx);
-            Inc(I);
-
-            // Right edge
-            X := ScanLine[I] and $7FFFFFFF;
-            Dx := X and AALines;
-            X := X shr AAShift - MinX;
-            Dec(Buffer[X], Dx xor AALines);
-            Dec(Buffer[X + 1], Dx);
-            Inc(I);
-          end
-        end
-      else // mode = pfWinding
-        for J := Top to Bottom do
-        begin
-          I := 0;
-          L := ScanLines[J].Count;
-          ScanLine := @ScanLines[J].EdgePoints[0];
-          Winding := 0;
-          while I < L do
-          begin
-            X := ScanLine[I];
-            Inc(I);
-            if (X and $80000000) <> 0 then NextWinding := 1 else NextWinding := -1;
-            X := X and $7FFFFFFF;
-            if Winding = 0 then
-            begin
-              Dx := X and AALines;
-              X := X shr AAShift - MinX;
-              Inc(Buffer[X], Dx xor AALines);
-              Inc(Buffer[X + 1], Dx);
-            end;
-            Inc(Winding, NextWinding);
-            if Winding = 0 then
-            begin
-              Dx := X and AALines;
-              X := X shr AAShift - MinX;
-              Dec(Buffer[X], Dx xor AALines);
-              Dec(Buffer[X + 1], Dx);
-            end;
-          end;
-        end;
-
-      // integrate the buffer
-      N := 0;
-      for I := 0 to BufferSize - 1 do
-      begin
-        Inc(N, Buffer[I]);
-        AlphaBuffer[I] := (N * AAMultiplier) shr 8;
-      end;
-
-      // draw it to the screen
-      FillLineCallback(Pointer(Bitmap.PixelPtr[MinX, Y]), MinX, Y, BufferSize, @AlphaBuffer[0]);
-      EMMS;
-    end;
-
-    Inc(Y);
-  end;
-end;
-
-
-{ Helper routines for drawing Polygons and PolyPolygons }
-
-procedure RenderPolyPolygon(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; Color: TColor32;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode; Transformation: TTransformation);
-var
-  ChangedRect, DstRect: TFixedRect;
-  P: TFixedPoint;
-  AAShift: Integer;
-  I: Integer;
-  ScanLines: TScanLines;
-begin
-  if not Bitmap.MeasuringMode then
-  begin
-    ChangedRect := PolyPolygonBounds(Points, Transformation);
-
-    with DstRect do
-    if AAMode <> amNone then
-    begin
-      AAShift := AA_SHIFT[AAMode];
-      Left := Bitmap.ClipRect.Left shl AAShift;
-      Right := Bitmap.ClipRect.Right shl AAShift - 1;
-      Top := Bitmap.ClipRect.Top shl AAShift;
-      Bottom := Bitmap.ClipRect.Bottom shl AAShift - 1;
-
-      P.X := ChangedRect.Top;
-      P.Y := ChangedRect.Bottom;
-      RoundShiftProcs[AAMode](P, P, nil);
-      Top := Constrain(P.X, Top, Bottom);
-      Bottom := Constrain(P.Y, Top, Bottom);
-    end
-    else
-    begin
-      Left := Bitmap.ClipRect.Left shl 8;
-      Right := Bitmap.ClipRect.Right shl 8 - 1;
-      Top := Constrain(SAR_16(ChangedRect.Top + $00007FFF),
-        Bitmap.ClipRect.Top, Bitmap.ClipRect.Bottom - 1);
-      Bottom := Constrain(SAR_16(ChangedRect.Bottom + $00007FFF),
-        Bitmap.ClipRect.Top, Bitmap.ClipRect.Bottom - 1);
-    end;
-
-    if DstRect.Top >= DstRect.Bottom then Exit;
-
-    ScanLinesCreate(ScanLines, DstRect.Bottom - DstRect.Top + 1);
-    for I := 0 to High(Points) do
-      AddPolygon(Points[I], DstRect, ScanLines, AAMode, Transformation);
-
-    SortLines(ScanLines);
-    Bitmap.BeginUpdate;
-    try
-      if AAMode <> amNone then
-        if Assigned(FillLineCallback) then
-          CustomFillLines2(Bitmap, DstRect.Top, ScanLines, FillLineCallback, Mode, AAMode)
-        else
-          ColorFillLines2(Bitmap, DstRect.Top, ScanLines, Color, Mode, AAMode)
-      else
-        if Assigned(FillLineCallback) then
-          CustomFillLines(Bitmap, DstRect.Top, ScanLines, FillLineCallback, Mode)
-        else
-          ColorFillLines(Bitmap, DstRect.Top, ScanLines, Color, Mode);
-    finally
-      Bitmap.EndUpdate;
-      ScanLinesDestroy(ScanLines);
-    end;
-    Bitmap.Changed(MakeRect(ChangedRect, rrOutside));
-  end
-  else
-    Bitmap.Changed(MakeRect(PolyPolygonBounds(Points, Transformation), rrOutside));
-end;
-
-procedure RenderPolygon(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfFixedPoint; Color: TColor32;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode; Transformation: TTransformation);
-var
-  H: TArrayOfArrayOfFixedPoint;
-begin
-  SetLength(H, 1);
-  H[0] := Points;
-  RenderPolyPolygon(Bitmap, H, Color, FillLineCallback, Mode, AAMode, Transformation);
-  H[0] := nil;
-end;
-
-
-{ Polygons }
-
-procedure PolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Mode: TPolyFillMode; Transformation: TTransformation);
-begin
-  RenderPolygon(Bitmap, Points, Color, nil, Mode, amNone, Transformation);
-end;
-
-procedure PolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode;
-  Transformation: TTransformation);
-begin
-  RenderPolygon(Bitmap, Points, 0, FillLineCallback, Mode, amNone, Transformation);
-end;
-
-procedure PolygonTS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Filler: TCustomPolygonFiller; Mode: TPolyFillMode;
-  Transformation: TTransformation);
-begin
-  RenderPolygon(Bitmap, Points, 0, Filler.FillLine, Mode, amNone, Transformation);
-end;
-
-procedure PolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Color: TColor32; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode; Transformation: TTransformation);
-begin
-  RenderPolygon(Bitmap, Points, Color, nil, Mode, AAMode, Transformation);
-end;
-
-procedure PolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  FillLineCallback: TFillLineEvent; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode; Transformation: TTransformation);
-begin
-  RenderPolygon(Bitmap, Points, 0, FillLineCallback, Mode, AAMode, Transformation);
-end;
-
-procedure PolygonXS(Bitmap: TCustomBitmap32; const Points: TArrayOfFixedPoint;
-  Filler: TCustomPolygonFiller; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode; Transformation: TTransformation);
-begin
-  RenderPolygon(Bitmap, Points, 0, Filler.FillLine, Mode, AAMode, Transformation);
-end;
-
-
-{ PolyPolygons }
-
-procedure PolyPolygonTS(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; Color: TColor32; Mode: TPolyFillMode;
-  Transformation: TTransformation);
-begin
-  RenderPolyPolygon(Bitmap, Points, Color, nil, Mode, amNone, Transformation);
-end;
-
-procedure PolyPolygonTS(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; FillLineCallback: TFillLineEvent;
-  Mode: TPolyFillMode; Transformation: TTransformation);
-begin
-  RenderPolyPolygon(Bitmap, Points, 0, FillLineCallback, Mode, amNone, Transformation);
-end;
-
-procedure PolyPolygonTS(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; Filler: TCustomPolygonFiller;
-  Mode: TPolyFillMode; Transformation: TTransformation);
-begin
-  RenderPolyPolygon(Bitmap, Points, 0, Filler.FillLine, Mode, amNone, Transformation);
-end;
-
-procedure PolyPolygonXS(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; Color: TColor32; Mode: TPolyFillMode;
-  const AAMode: TAntialiasMode; Transformation: TTransformation);
-begin
-  RenderPolyPolygon(Bitmap, Points, Color, nil, Mode, AAMode, Transformation);
-end;
-
-procedure PolyPolygonXS(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; FillLineCallback: TFillLineEvent;
-  Mode: TPolyFillMode; const AAMode: TAntialiasMode;
-  Transformation: TTransformation);
-begin
-  RenderPolyPolygon(Bitmap, Points, 0, FillLineCallback, Mode, AAMode, Transformation);
-end;
-
-procedure PolyPolygonXS(Bitmap: TCustomBitmap32;
-  const Points: TArrayOfArrayOfFixedPoint; Filler: TCustomPolygonFiller;
-  Mode: TPolyFillMode; const AAMode: TAntialiasMode;
-  Transformation: TTransformation);
-begin
-  RenderPolyPolygon(Bitmap, Points, 0, Filler.FillLine, Mode, AAMode, Transformation);
-end;
-
-
-{ Helper routines }
-
-function PolygonBounds(const Points: TArrayOfFixedPoint;
-  Transformation: TTransformation): TFixedRect;
-var
-  I: Integer;
-begin
-  with Result do
-  begin
-    Left := $7FFFFFFF;
-    Right := -$7FFFFFFF;
-    Top := $7FFFFFFF;
-    Bottom := -$7FFFFFFF;
-
-    if Assigned(Transformation) then
-    begin
-      for I := 0 to High(Points) do
-      with Transformation.Transform(Points[I]) do
-      begin
-        if X < Left   then Left := X;
-        if X > Right  then Right := X;
-        if Y < Top    then Top := Y;
-        if Y > Bottom then Bottom := Y;
-      end
-    end
-    else
-      for I := 0 to High(Points) do
-      with Points[I] do
-      begin
-        if X < Left   then Left := X;
-        if X > Right  then Right := X;
-        if Y < Top    then Top := Y;
-        if Y > Bottom then Bottom := Y;
-      end;
-  end;
-end;
-
-function PolyPolygonBounds(const Points: TArrayOfArrayOfFixedPoint;
-  Transformation: TTransformation): TFixedRect;
-var
-  I, J: Integer;
-begin
-  with Result do
-  begin
-    Left := $7FFFFFFF;
-    Right := -$7FFFFFFF;
-    Top := $7FFFFFFF;
-    Bottom := -$7FFFFFFF;
-
-    if Assigned(Transformation) then
-      for I := 0 to High(Points) do
-        for J := 0 to High(Points[I]) do
-        with Transformation.Transform(Points[I, J]) do
-        begin
-          if X < Left   then Left := X;
-          if X > Right  then Right := X;
-          if Y < Top    then Top := Y;
-          if Y > Bottom then Bottom := Y;
-        end
-    else
-      for I := 0 to High(Points) do
-        for J := 0 to High(Points[I]) do
-        with Points[I, J] do
-        begin
-          if X < Left   then Left := X;
-          if X > Right  then Right := X;
-          if Y < Top    then Top := Y;
-          if Y > Bottom then Bottom := Y;
-        end;
-  end;
-end;
-
-function PtInPolygon(const Pt: TFixedPoint; const Points: TArrayOfFixedPoint): Boolean;
-var
-  I: Integer;
-  iPt, jPt: PFixedPoint;
-begin
-  Result := False;
-  iPt := @Points[0];
-  jPt := @Points[High(Points)];
-  for I := 0 to High(Points) do
-  begin
-    Result := Result xor (((Pt.Y >= iPt.Y) xor (Pt.Y >= jPt.Y)) and
-      (Pt.X - iPt.X < MulDiv(jPt.X - iPt.X, Pt.Y - iPt.Y, jPt.Y - iPt.Y)));
-    jPt := iPt;
-    Inc(iPt);
-  end;
-end;
-
-{ TPolygon32 }
-
-procedure TPolygon32.Add(const P: TFixedPoint);
-var
-  H, L: Integer;
-begin
-  H := High(Points);
-  L := Length(Points[H]);
-  SetLength(Points[H], L + 1);
-  Points[H][L] := P;
-  Normals := nil;
-end;
-
-procedure TPolygon32.AddPoints(var First: TFixedPoint; Count: Integer);
-var
-  H, L, I: Integer;
-begin
-  H := High(Points);
-  L := Length(Points[H]);
-  SetLength(Points[H], L + Count);
-  for I := 0 to Count - 1 do
-    Points[H, L + I] := PFixedPointArray(@First)[I];
-  Normals := nil;
-end;
-
-procedure TPolygon32.CopyPropertiesTo(Dst: TPolygon32);
-begin
-  Dst.Antialiased := Antialiased;
-  Dst.AntialiasMode := AntialiasMode;
-  Dst.Closed := Closed;
-  Dst.FillMode := FillMode;
-end;
-
-procedure TPolygon32.AssignTo(Dst: TPersistent);
-var
-  DstPolygon: TPolygon32;
-  Index: Integer;
-begin
-  if Dst is TPolygon32 then
-  begin
-    DstPolygon := TPolygon32(Dst);
-    CopyPropertiesTo(DstPolygon);
-    SetLength(DstPolygon.FNormals, Length(Normals));
-    for Index := 0 to Length(Normals) - 1 do
-    begin
-      DstPolygon.Normals[Index] := Copy(Normals[Index]);
-    end;
-
-    SetLength(DstPolygon.FPoints, Length(Points));
-    for Index := 0 to Length(Points) - 1 do
-    begin
-      DstPolygon.Points[Index] := Copy(Points[Index]);
-    end;
-  end
-  else
-    inherited;
-end;
-
-function TPolygon32.GetBoundingRect: TFixedRect;
-begin
-  Result := PolyPolygonBounds(Points);
-end;
-
-procedure TPolygon32.BuildNormals;
-var
-  I, J, Count, NextI: Integer;
-  dx, dy, f: Single;
-begin
-  if Length(Normals) <> 0 then Exit;
-  SetLength(FNormals, Length(Points));
-
-  for J := 0 to High(Points) do
-  begin
-    Count := Length(Points[J]);
-    SetLength(Normals[J], Count);
-
-    if Count = 0 then Continue;
-    if Count = 1 then
-    begin
-      FillChar(Normals[J][0], SizeOf(TFixedPoint), 0);
-      Continue;
-    end;
-
-    I := 0;
-    NextI := 1;
-    dx := 0;
-    dy := 0;
-
-    while I < Count do
-    begin
-      if Closed and (NextI >= Count) then NextI := 0;
-      if NextI < Count then
-      begin
-        dx := (Points[J][NextI].X - Points[J][I].X) / $10000;
-        dy := (Points[J][NextI].Y - Points[J][I].Y) / $10000;
-      end;
-      if (dx <> 0) or (dy <> 0) then
-      begin
-        f := 1 / GR32_Math.Hypot(dx, dy);
-        dx := dx * f;
-        dy := dy * f;
-      end;
-      with Normals[J][I] do
-      begin
-        X := Fixed(dy);
-        Y := Fixed(-dx);
-      end;
-      Inc(I);
-      Inc(NextI);
-    end;
-  end;
-end;
-
-procedure TPolygon32.Clear;
-begin
-  Points := nil;
-  Normals := nil;
-  NewLine;
-end;
-
-function TPolygon32.ContainsPoint(const P: TFixedPoint): Boolean;
-var
-  I: Integer;
-begin
-  Result := False;
-  for I := 0 to High(FPoints) do
-    if PtInPolygon(P, FPoints[I]) then
-    begin
-      Result := True;
-      Exit;
-    end;
-end;
-
-constructor TPolygon32.Create;
-begin
-  inherited;
-  FClosed := True;
-  FAntialiasMode := DefaultAAMode;
-  NewLine; // initiate a new contour
-end;
-
-destructor TPolygon32.Destroy;
-begin
-  Clear;
-  inherited;
-end;
-
-procedure TPolygon32.Draw(Bitmap: TCustomBitmap32; OutlineColor, FillColor: TColor32; Transformation: TTransformation);
-begin
-  Bitmap.BeginUpdate;
-
-  if Antialiased then
-  begin
-    if (FillColor and $FF000000) <> 0 then
-      PolyPolygonXS(Bitmap, Points, FillColor, FillMode, AntialiasMode, Transformation);
-    if (OutlineColor and $FF000000) <> 0 then
-      PolyPolylineXS(Bitmap, Points, OutlineColor, Closed, Transformation);
-  end
-  else
-  begin
-    if (FillColor and $FF000000) <> 0 then
-      PolyPolygonTS(Bitmap, Points, FillColor, FillMode, Transformation);
-    if (OutlineColor and $FF000000) <> 0 then
-      PolyPolylineTS(Bitmap, Points, OutlineColor, Closed, Transformation);
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure TPolygon32.Draw(Bitmap: TCustomBitmap32; OutlineColor: TColor32;
-  FillCallback: TFillLineEvent; Transformation: TTransformation);
-begin
-  Bitmap.BeginUpdate;
-
-  if Antialiased then
-  begin
-{$IFDEF FPC}
-    RenderPolyPolygon(Bitmap, Points, 0, FillCallback, FillMode, AntialiasMode, Transformation);
-{$ELSE}
-    PolyPolygonXS(Bitmap, Points, FillCallback, FillMode, AntialiasMode, Transformation);
-{$ENDIF}
-    if (OutlineColor and $FF000000) <> 0 then
-      PolyPolylineXS(Bitmap, Points, OutlineColor, Closed, Transformation);
-  end
-  else
-  begin
-{$IFDEF FPC}
-    RenderPolyPolygon(Bitmap, Points, 0, FillCallback, FillMode, amNone, Transformation);
-{$ELSE}
-    PolyPolygonTS(Bitmap, Points, FillCallback, FillMode, Transformation);
-{$ENDIF}
-    if (OutlineColor and $FF000000) <> 0 then
-      PolyPolylineTS(Bitmap, Points, OutlineColor, Closed, Transformation);
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure TPolygon32.Draw(Bitmap: TCustomBitmap32; OutlineColor: TColor32;
-  Filler: TCustomPolygonFiller; Transformation: TTransformation);
-begin
-{$IFDEF FPC}
-  Bitmap.BeginUpdate;
-
-  if Antialiased then
-  begin
-    RenderPolyPolygon(Bitmap, Points, 0, Filler.FillLine, FillMode, AntialiasMode, Transformation);
-    if (OutlineColor and $FF000000) <> 0 then
-      PolyPolylineXS(Bitmap, Points, OutlineColor, Closed, Transformation);
-  end
-  else
-  begin
-    RenderPolyPolygon(Bitmap, Points, 0, Filler.FillLine, FillMode, amNone, Transformation);
-    if (OutlineColor and $FF000000) <> 0 then
-      PolyPolylineTS(Bitmap, Points, OutlineColor, Closed, Transformation);
-  end;
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-
-{$ELSE}
-  Draw(Bitmap, OutlineColor, Filler.FillLine, Transformation);
-{$ENDIF}
-end;
-
-procedure TPolygon32.DrawEdge(Bitmap: TCustomBitmap32; Color: TColor32; Transformation: TTransformation);
-begin
-  Bitmap.BeginUpdate;
-
-  if Antialiased then
-    PolyPolylineXS(Bitmap, Points, Color, Closed, Transformation)
-  else
-    PolyPolylineTS(Bitmap, Points, Color, Closed, Transformation);
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure TPolygon32.DrawFill(Bitmap: TCustomBitmap32; Color: TColor32; Transformation: TTransformation);
-begin
-  Bitmap.BeginUpdate;
-
-  if Antialiased then
-    PolyPolygonXS(Bitmap, Points, Color, FillMode, AntialiasMode, Transformation)
-  else
-    PolyPolygonTS(Bitmap, Points, Color, FillMode, Transformation);
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure TPolygon32.DrawFill(Bitmap: TCustomBitmap32; FillCallback: TFillLineEvent;
-  Transformation: TTransformation);
-begin
-  Bitmap.BeginUpdate;
-
-{$IFDEF FPC}
-  if Antialiased then
-    RenderPolyPolygon(Bitmap, Points, 0, FillCallback, FillMode, AntialiasMode, Transformation)
-  else
-    RenderPolyPolygon(Bitmap, Points, 0, FillCallback, FillMode, amNone, Transformation);
-{$ELSE}
-  if Antialiased then
-    PolyPolygonXS(Bitmap, Points, FillCallback, FillMode, AntialiasMode, Transformation)
-  else
-    PolyPolygonTS(Bitmap, Points, FillCallback, FillMode, Transformation);
-{$ENDIF}
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-end;
-
-procedure TPolygon32.DrawFill(Bitmap: TCustomBitmap32; Filler: TCustomPolygonFiller;
-  Transformation: TTransformation);
-begin
-{$IFDEF FPC}
-  Bitmap.BeginUpdate;
-  if Antialiased then
-    RenderPolyPolygon(Bitmap, Points, 0, Filler.FillLine, FillMode, AntialiasMode, Transformation)
-  else
-    RenderPolyPolygon(Bitmap, Points, 0, Filler.FillLine, FillMode, amNone, Transformation);
-
-  Bitmap.EndUpdate;
-  Bitmap.Changed;
-{$ELSE}
-  DrawFill(Bitmap, Filler.FillLine, Transformation);
-{$ENDIF}
-end;
-
-function TPolygon32.Grow(const Delta: TFixed; EdgeSharpness: Single = 0): TPolygon32;
-var
-  J, I, PrevI: Integer;
-  PX, PY, AX, AY, BX, BY, CX, CY, R, D, E: Integer;
-
-  procedure AddPoint(LongDeltaX, LongDeltaY: Integer);
-  var
-    N, L: Integer;
-  begin
-    with Result do
-    begin
-      N := High(Points);
-      L := Length(Points[N]);
-      SetLength(Points[N], L + 1);
-    end;
-    with Result.Points[N][L] do
-    begin
-      X := PX + LongDeltaX;
-      Y := PY + LongDeltaY;
-    end;
-  end;
-
-begin
-  BuildNormals;
-
-  if EdgeSharpness > 0.99 then
-    EdgeSharpness := 0.99
-  else if EdgeSharpness < 0 then
-    EdgeSharpness := 0;
-
-  D := Delta;
-  E := Round(D * (1 - EdgeSharpness));
-
-  Result := TPolygon32.Create;
-  CopyPropertiesTo(Result);
-
-  if Delta = 0 then
-  begin
-    // simply copy the data
-    SetLength(Result.FPoints, Length(Points));
-    for J := 0 to High(Points) do
-      Result.Points[J] := Copy(Points[J], 0, Length(Points[J]));
-    Exit;
-  end;
-
-  Result.Points := nil;
-
-  for J := 0 to High(Points) do
-  begin
-    if Length(Points[J]) < 2 then Continue;
-
-    Result.NewLine;
-
-    for I := 0 to High(Points[J]) do
-    begin
-      with Points[J][I] do
-      begin
-        PX := X;
-        PY := Y;
-      end;
-
-      with Normals[J][I] do
-      begin
-        BX := MulDiv(X, D, $10000);
-        BY := MulDiv(Y, D, $10000);
-      end;
-
-      if (I > 0) or Closed then
-      begin
-        PrevI := I - 1;
-        if PrevI < 0 then PrevI := High(Points[J]);
-        with Normals[J][PrevI] do
-        begin
-          AX := MulDiv(X, D, $10000);
-          AY := MulDiv(Y, D, $10000);
-        end;
-
-        if (I = High(Points[J])) and (not Closed) then AddPoint(AX, AY)
-        else
-        begin
-          CX := AX + BX;
-          CY := AY + BY;
-          R := MulDiv(AX, CX, D) + MulDiv(AY, CY, D);
-          if R > E then AddPoint(MulDiv(CX, D, R), MulDiv(CY, D, R))
-          else
-          begin
-            AddPoint(AX, AY);
-            AddPoint(BX, BY);
-          end;
-        end;
-      end
-      else AddPoint(BX, BY);
-    end;
-  end;
-end;
-
-procedure TPolygon32.NewLine;
-begin
-  SetLength(FPoints, Length(Points) + 1);
-  Normals := nil;
-end;
-
-procedure TPolygon32.Offset(const Dx, Dy: TFixed);
-var
-  J, I: Integer;
-begin
-  for J := 0 to High(Points) do
-    for I := 0 to High(Points[J]) do
-      with Points[J][I] do
-      begin
-        Inc(X, Dx);
-        Inc(Y, Dy);
-      end;
-end;
-
-function TPolygon32.Outline: TPolygon32;
-var
-  J, I, L, H: Integer;
-begin
-  BuildNormals;
-
-  Result := TPolygon32.Create;
-  CopyPropertiesTo(Result);
-
-  Result.Points := nil;
-
-  for J := 0 to High(Points) do
-  begin
-    if Length(Points[J]) < 2 then Continue;
-
-    if Closed then
-    begin
-      Result.NewLine;
-      for I := 0 to High(Points[J]) do Result.Add(Points[J][I]);
-      Result.NewLine;
-      for I := High(Points[J]) downto 0 do Result.Add(Points[J][I]);
-    end
-    else // not closed
-    begin
-      // unrolled...
-      SetLength(Result.FPoints, Length(Result.FPoints) + 1);
-      Result.FNormals:= nil;
-
-      L:= Length(Points[J]);
-      H:= High(Result.FPoints);
-      SetLength(Result.FPoints[H], L * 2);
-      for I := 0 to High(Points[J]) do
-        Result.FPoints[H][I]:= (Points[J][I]);
-      for I := High(Points[J]) downto 0 do
-        Result.FPoints[H][2 * L - (I + 1)]:= (Points[J][I]);
-    end;
-  end;
-end;
-
-procedure TPolygon32.Transform(Transformation: TTransformation);
-begin
-  Points := TransformPoints(Points, Transformation);
-end;
+{ TCustomPolygonFiller }
+
+procedure TCustomPolygonFiller.BeginRendering;
+begin
+  // implemented by descendants
+end;
+
+procedure TCustomPolygonFiller.EndRendering;
+begin
+  // implemented by descendants
+end;
+
+{ TCallbackPolygonFiller }
+
+function TCallbackPolygonFiller.GetFillLine: TFillLineEvent;
+begin
+  Result := FFillLineEvent;
+end;
+
+
+{ TInvertPolygonFiller }
+
+procedure TInvertPolygonFiller.FillLineBlend(Dst: PColor32; DstX, DstY,
+  Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
+var
+  X: Integer;
+  BlendMemEx: TBlendMemEx;
+begin
+  BlendMemEx := BLEND_MEM_EX[CombineMode]^;
+  for X := DstX to DstX + Length - 1 do
+  begin
+    BlendMemEx(InvertColor(Dst^), Dst^, AlphaValues^);
+    EMMS;
+    Inc(Dst);
+    Inc(AlphaValues);
+  end;
+end;
+
+function TInvertPolygonFiller.GetFillLine: TFillLineEvent;
+begin
+  Result := FillLineBlend;
+end;
+
+
+{ TClearPolygonFiller }
+
+constructor TClearPolygonFiller.Create(Color: TColor32 = $00808080);
+begin
+  inherited Create;
+  FColor := Color;
+end;
+
+procedure TClearPolygonFiller.FillLineClear(Dst: PColor32; DstX, DstY,
+  Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
+begin
+  FillLongword(Dst^, Length, FColor);
+end;
+
+function TClearPolygonFiller.GetFillLine: TFillLineEvent;
+begin
+  Result := FillLineClear;
+end;
+
 
 { TBitmapPolygonFiller }
 
 procedure TBitmapPolygonFiller.FillLineOpaque(Dst: PColor32; DstX, DstY,
-  Length: Integer; AlphaValues: PColor32);
+  Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
 var
   PatternX, PatternY, X: Integer;
@@ -2223 +1445 @@
 end;
 
-procedure TBitmapPolygonFiller.FillLineBlend(Dst: PColor32; DstX, DstY, Length: Integer; AlphaValues: PColor32);
+procedure TBitmapPolygonFiller.FillLineBlend(Dst: PColor32; DstX, DstY,
+  Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
 var
   PatternX, PatternY, X: Integer;
@@ -2268 +1491 @@
 end;
 
-procedure TBitmapPolygonFiller.FillLineBlendMasterAlpha(Dst: PColor32; DstX, DstY,
-  Length: Integer; AlphaValues: PColor32);
+procedure TBitmapPolygonFiller.FillLineBlendMasterAlpha(Dst: PColor32;
+  DstX, DstY, Length: Integer; AlphaValues: PColor32;
+  CombineMode: TCombineMode);
 var
   PatternX, PatternY, X: Integer;
@@ -2309 +1533 @@
 end;
 
-procedure TBitmapPolygonFiller.FillLineCustomCombine(Dst: PColor32; DstX, DstY,
-  Length: Integer; AlphaValues: PColor32);
+procedure TBitmapPolygonFiller.FillLineCustomCombine(Dst: PColor32;
+  DstX, DstY, Length: Integer; AlphaValues: PColor32;
+  CombineMode: TCombineMode);
 var
   PatternX, PatternY, X: Integer;
@@ -2372 +1597 @@
 { TSamplerFiller }
 
+constructor TSamplerFiller.Create(Sampler: TCustomSampler = nil);
+begin
+  inherited Create;
+  FSampler := Sampler;
+  SamplerChanged;
+end;
+
+procedure TSamplerFiller.EndRendering;
+begin
+  if Assigned(FSampler) then
+    FSampler.FinalizeSampling
+  else
+    raise Exception.Create(RCStrNoSamplerSpecified);
+end;
+
 procedure TSamplerFiller.SampleLineOpaque(Dst: PColor32; DstX, DstY,
-  Length: Integer; AlphaValues: PColor32);
+  Length: Integer; AlphaValues: PColor32; CombineMode: TCombineMode);
 var
   X: Integer;
   BlendMemEx: TBlendMemEx;
 begin
-  BlendMemEx := BLEND_MEM_EX[cmBlend]^;
+  BlendMemEx := BLEND_MEM_EX[CombineMode]^;
   for X := DstX to DstX + Length - 1 do
   begin
@@ -2388 +1628 @@
 end;
 
+procedure TSamplerFiller.SamplerChanged;
+begin
+  if Assigned(FSampler) then
+    FGetSample := FSampler.GetSampleInt;
+end;
+
+procedure TSamplerFiller.BeginRendering;
+begin
+  if Assigned(FSampler) then
+    FSampler.PrepareSampling
+  else
+    raise Exception.Create(RCStrNoSamplerSpecified);
+end;
+
 function TSamplerFiller.GetFillLine: TFillLineEvent;
 begin
@@ -2395 +1649 @@
 procedure TSamplerFiller.SetSampler(const Value: TCustomSampler);
 begin
-  FSampler := Value;
-  FGetSample := FSampler.GetSampleInt;
-end;
+  if FSampler <> Value then
+  begin
+    FSampler := Value;
+    SamplerChanged;
+  end;
+end;
+
+
+{ TCustomPolygonRenderer }
+
+procedure TCustomPolygonRenderer.PolygonFS(
+  const Points: TArrayOfFloatPoint; const ClipRect: TFloatRect;
+  Transformation: TTransformation);
+begin
+  PolyPolygonFS(PolyPolygon(Points), ClipRect, Transformation);
+end;
+
+procedure TCustomPolygonRenderer.PolygonFS(
+  const Points: TArrayOfFloatPoint; const ClipRect: TFloatRect);
+begin
+  PolyPolygonFS(PolyPolygon(Points), ClipRect);
+end;
+
+procedure TCustomPolygonRenderer.PolyPolygonFS(
+  const Points: TArrayOfArrayOfFloatPoint; const ClipRect: TFloatRect);
+begin
+  // implemented by descendants
+end;
+
+procedure TCustomPolygonRenderer.PolyPolygonFS(
+  const Points: TArrayOfArrayOfFloatPoint; const ClipRect: TFloatRect;
+  Transformation: TTransformation);
+var
+  APoints: TArrayOfArrayOfFloatPoint;
+begin
+  if Assigned(Transformation) then
+    APoints := TransformPolyPolygon(Points, Transformation)
+  else
+    APoints := Points;
+  PolyPolygonFS(APoints, ClipRect);
+end;
+
+{ TPolygonRenderer32 }
+
+constructor TPolygonRenderer32.Create(Bitmap: TBitmap32;
+  Fillmode: TPolyFillMode);
+begin
+  inherited Create;
+  FBitmap := Bitmap;
+  FFillMode := Fillmode;
+end;
+
+procedure TPolygonRenderer32.PolygonFS(const Points: TArrayOfFloatPoint);
+begin
+  PolyPolygonFS(PolyPolygon(Points), FloatRect(FBitmap.ClipRect));
+end;
+
+procedure TPolygonRenderer32.PolyPolygonFS(const Points: TArrayOfArrayOfFloatPoint);
+begin
+  PolyPolygonFS(Points, FloatRect(FBitmap.ClipRect));
+end;
+
+procedure TPolygonRenderer32.SetBitmap(const Value: TBitmap32);
+begin
+  if FBitmap <> Value then
+  begin
+    FBitmap := Value;
+    Changed;
+  end;
+end;
+
+procedure TPolygonRenderer32.SetColor(const Value: TColor32);
+begin
+  if FColor <> Value then
+  begin
+    FColor := Value;
+    Changed;
+  end;
+end;
+
+procedure TPolygonRenderer32.SetFiller(const Value: TCustomPolygonFiller);
+begin
+  if FFiller <> Value then
+  begin
+    FFiller := Value;
+    Changed;
+  end;
+end;
+
+procedure TPolygonRenderer32.SetFillMode(const Value: TPolyFillMode);
+begin
+  if FFillMode <> Value then
+  begin
+    FFillMode := Value;
+    Changed;
+  end;
+end;
+
+{ TPolygonRenderer32VPR }
+
+{$IFDEF USESTACKALLOC}
+{$W+}
+{$ENDIF}
+procedure TPolygonRenderer32VPR.FillSpan(const Span: TValueSpan; DstY: Integer);
+var
+  AlphaValues: PColor32Array;
+  Count: Integer;
+begin
+  Count := Span.X2 - Span.X1 + 1;
+  {$IFDEF USESTACKALLOC}
+  AlphaValues := StackAlloc(Count * SizeOf(TColor32));
+  {$ELSE}
+  GetMem(AlphaValues, Count * SizeOf(TColor32));
+  {$ENDIF}
+  FFillProc(Span.Values, AlphaValues, Count, FColor);
+  FFiller.FillLine(@Bitmap.ScanLine[DstY][Span.X1], Span.X1, DstY, Count,
+    PColor32(AlphaValues), Bitmap.CombineMode);
+  EMMS;
+  {$IFDEF USESTACKALLOC}
+  StackFree(AlphaValues);
+  {$ELSE}
+  FreeMem(AlphaValues);
+  {$ENDIF}
+end;
+{$IFDEF USESTACKALLOC}
+{$W-}
+{$ENDIF}
+
+function TPolygonRenderer32VPR.GetRenderSpan: TRenderSpanEvent;
+begin
+  if Assigned(FFiller) then
+    Result := FillSpan
+  else
+    Result := RenderSpan;
+end;
+
+procedure TPolygonRenderer32VPR.PolyPolygonFS(
+  const Points: TArrayOfArrayOfFloatPoint; const ClipRect: TFloatRect);
+{$IFDEF CHANGENOTIFICATIONS}
+var
+  I: Integer;
+{$ENDIF}
+begin
+  UpdateFillProcs;
+  if Assigned(FFiller) then
+  begin
+    FFiller.BeginRendering;
+    RenderPolyPolygon(Points, ClipRect, GetRenderSpan());
+    FFiller.EndRendering;
+  end
+  else
+    RenderPolyPolygon(Points, ClipRect, GetRenderSpan());
+
+{$IFDEF CHANGENOTIFICATIONS}
+  if TBitmap32Access(Bitmap).UpdateCount = 0 then
+    for I := 0 to High(Points) do
+      if Length(Points[I]) > 0 then
+        Bitmap.Changed(MakeRect(PolygonBounds(Points[I])));
+{$ENDIF}
+end;
+
+{$W+}
+procedure TPolygonRenderer32VPR.RenderSpan(const Span: TValueSpan;
+  DstY: Integer);
+var
+  AlphaValues: PColor32Array;
+  Count: Integer;
+begin
+  Count := Span.X2 - Span.X1 + 1;
+  {$IFDEF USESTACKALLOC}
+  AlphaValues := StackAlloc(Count * SizeOf(TColor32));
+  {$ELSE}
+  GetMem(AlphaValues, Count * SizeOf(TColor32));
+  {$ENDIF}
+  FFillProc(Span.Values, AlphaValues, Count, FColor);
+  if Bitmap.CombineMode = cmMerge then
+    MergeLine(@AlphaValues[0], @Bitmap.ScanLine[DstY][Span.X1], Count)
+  else
+    BlendLine(@AlphaValues[0], @Bitmap.ScanLine[DstY][Span.X1], Count);
+  EMMS;
+  {$IFDEF USESTACKALLOC}
+  StackFree(AlphaValues);
+  {$ELSE}
+  FreeMem(AlphaValues);
+  {$ENDIF}
+end;
+{$W-}
+
+procedure TPolygonRenderer32VPR.UpdateFillProcs;
+const
+  FillProcs: array [Boolean, TPolyFillMode] of TFillProc = (
+    (MakeAlphaEvenOddUP, MakeAlphaNonZeroUP),
+    (MakeAlphaEvenOddUPF, MakeAlphaNonZeroUPF)
+  );
+begin
+  FFillProc := FillProcs[Assigned(FFiller), FillMode];
+end;
+
+{ TPolygonRenderer32LCD }
+
+procedure TPolygonRenderer32LCD.PolyPolygonFS(
+  const Points: TArrayOfArrayOfFloatPoint; const ClipRect: TFloatRect);
+var
+  R: TFloatRect;
+  APoints: TArrayOfArrayOfFloatPoint;
+{$IFDEF CHANGENOTIFICATIONS}
+  I: Integer;
+{$ENDIF}
+begin
+  APoints := ScalePolyPolygon(Points, 3, 1);
+  R.Top := ClipRect.Top;
+  R.Bottom := ClipRect.Bottom;
+  R.Left := ClipRect.Left * 3;
+  R.Right := ClipRect.Right * 3;
+  RenderPolyPolygon(APoints, R, RenderSpan);
+{$IFDEF CHANGENOTIFICATIONS}
+  if TBitmap32Access(Bitmap).UpdateCount = 0 then
+    for I := 0 to High(Points) do
+      if length(Points[I]) > 0 then
+        Bitmap.Changed(MakeRect(PolygonBounds(Points[I])));
+{$ENDIF}
+end;
+
+{$W+}
+procedure TPolygonRenderer32LCD.RenderSpan(const Span: TValueSpan;
+  DstY: Integer);
+const
+  PADDING = 5;
+var
+  AlphaValues: SysUtils.PByteArray;
+  Count: Integer;
+  X1, Offset: Integer;
+const
+  MakeAlpha: array [TPolyFillMode] of TMakeAlphaProcLCD = (MakeAlphaEvenOddLCD, MakeAlphaNonZeroLCD);
+begin
+  Count := Span.X2 - Span.X1 + 1;
+  X1 := DivMod(Span.X1, 3, Offset);
+
+  // Left Padding + Right Padding + Filter Width = 2 + 2 + 2 = 6
+  {$IFDEF USESTACKALLOC}
+  AlphaValues := StackAlloc((Count + 6 + PADDING) * SizeOf(Byte));
+  {$ELSE}
+  GetMem(AlphaValues, (Count + 6 + PADDING) * SizeOf(Byte));
+  {$ENDIF}
+  AlphaValues[0] := 0;
+  AlphaValues[1] := 0;
+  if (X1 > 0) then
+  begin
+    Dec(X1);
+    Inc(Offset, 3);
+    AlphaValues[2] := 0;
+    AlphaValues[3] := 0;
+    AlphaValues[4] := 0;
+  end;
+
+  MakeAlpha[FFillMode](Span.Values, PByteArray(@AlphaValues[PADDING]), Count, FColor);
+  CombineLineLCD(@AlphaValues[PADDING - Offset], PColor32Array(@Bitmap.ScanLine[DstY][X1]), FColor, (Count + Offset + 2) div 3);
+
+  {$IFDEF USESTACKALLOC}
+  StackFree(AlphaValues);
+  {$ELSE}
+  FreeMem(AlphaValues);
+  {$ENDIF}
+end;
+{$W-}
+
+
+{ TPolygonRenderer32LCD2 }
+
+{$W+}
+procedure TPolygonRenderer32LCD2.RenderSpan(const Span: TValueSpan;
+  DstY: Integer);
+const
+  PADDING = 5;
+var
+  AlphaValues: SysUtils.PByteArray;
+  Count: Integer;
+  X1, Offset: Integer;
+const
+  MakeAlpha: array [TPolyFillMode] of TMakeAlphaProcLCD = (MakeAlphaEvenOddLCD2, MakeAlphaNonZeroLCD2);
+begin
+  Count := Span.X2 - Span.X1 + 1;
+  X1 := DivMod(Span.X1, 3, Offset);
+
+  // Left Padding + Right Padding + Filter Width = 2 + 2 + 2 = 6
+  {$IFDEF USESTACKALLOC}
+  AlphaValues := StackAlloc((Count + 6 + PADDING) * SizeOf(Byte));
+  {$ELSE}
+  GetMem(AlphaValues, (Count + 6 + PADDING) * SizeOf(Byte));
+  {$ENDIF}
+  AlphaValues[0] := 0;
+  AlphaValues[1] := 0;
+  if (X1 > 0) then
+  begin
+    Dec(X1);
+    Inc(Offset, 3);
+    AlphaValues[2] := 0;
+    AlphaValues[3] := 0;
+    AlphaValues[4] := 0;
+  end;
+
+  Dec(Offset, 1);
+  MakeAlpha[FFillMode](Span.Values, PByteArray(@AlphaValues[PADDING]), Count, FColor);
+  Inc(Count);
+  CombineLineLCD(@AlphaValues[PADDING - Offset], PColor32Array(@Bitmap.ScanLine[DstY][X1]), FColor, (Count + Offset + 2) div 3);
+
+  {$IFDEF USESTACKALLOC}
+  StackFree(AlphaValues);
+  {$ELSE}
+  FreeMem(AlphaValues);
+  {$ENDIF}
+end;
+{$W-}
+
+initialization
+  RegisterPolygonRenderer(TPolygonRenderer32VPR);
+  RegisterPolygonRenderer(TPolygonRenderer32LCD);
+  RegisterPolygonRenderer(TPolygonRenderer32LCD2);
+
+finalization
+  PolygonRendererList.Free;
 
 end.

GraphicTest/Packages/Graphics32/GR32_RangeBars.pas

@@ -74 +74 @@
     FOnUserChange: TNotifyEvent;
     procedure SetButtonSize(Value: Integer);
-    procedure SetBorderStyle(Value: TBorderStyle); {$IFDEF FPC} override; {$ENDIF}
     procedure SetHandleColor(Value: TColor);
     procedure SetHighLightColor(Value: TColor);
@@ -101 +100 @@
 {$ENDIF}
   protected
-    GenChange: Boolean;
-    DragZone: TRBZone;
-    HotZone: TRBZone;
-    Timer: TTimer;
-    TimerMode: Integer;
-    StoredX, StoredY: Integer;
-    PosBeforeDrag: Single;
+    FGenChange: Boolean;
+    FDragZone: TRBZone;
+    FHotZone: TRBZone;
+    FTimer: TTimer;
+    FTimerMode: Integer;
+    FStored: TPoint;
+    FPosBeforeDrag: Single;
     procedure DoChange; virtual;
     procedure DoDrawButton(R: TRect; Direction: TRBDirection; Pushed, Enabled, Hot: Boolean); virtual;
@@ -124 +123 @@
     procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
     procedure Paint; override;
+    procedure SetBorderStyle(Value: TBorderStyle); {$IFDEF FPC} override; {$ENDIF}
     procedure StartDragTracking;
     procedure StartHotTracking;
@@ -632 +632 @@
 begin
   MouseLeft;
+  inherited;
 end;
 
@@ -642 +643 @@
   ParentColor := False;
   Color := clScrollBar;
-  Timer := TTimer.Create(Self);
-  Timer.OnTimer := TimerHandler;
+  FTimer := TTimer.Create(Self);
+  FTimer.OnTimer := TimerHandler;
   FShowArrows := True;
   FBorderStyle := bsSingle;
@@ -657 +658 @@
 begin
   if Assigned(FOnChange) then FOnChange(Self);
-  if GenChange and Assigned(FOnUserChange) then FOnUserChange(Self);
+  if FGenChange and Assigned(FOnUserChange) then FOnUserChange(Self);
 end;
 
@@ -1021 +1022 @@
   inherited;
   if Button <> mbLeft then Exit;
-  DragZone := GetZone(X, Y);
+  FDragZone := GetZone(X, Y);
   Invalidate;
-  StoredX := X;
-  StoredY := Y;
+  FStored.X := X;
+  FStored.Y := Y;
   StartDragTracking;
 end;
@@ -1038 +1039 @@
 begin
   inherited;
-  if (DragZone = zNone) and DrawEnabled then
+  if (FDragZone = zNone) and DrawEnabled then
   begin
     NewHotZone := GetZone(X, Y);
-    if NewHotZone <> HotZone then
-    begin
-      HotZone := NewHotZone;
-      if HotZone <> zNone then StartHotTracking;
+    if NewHotZone <> FHotZone then
+    begin
+      FHotZone := NewHotZone;
+      if FHotZone <> zNone then StartHotTracking;
       Invalidate;
     end;
@@ -1053 +1054 @@
 begin
   inherited;
-  DragZone := zNone;
+  FDragZone := zNone;
   Invalidate;
   StopDragTracking;
@@ -1078 +1079 @@
     BtnRect := R;
     with BtnRect do if Horz then Right := Left + BSize else Bottom := Top + BSize;
-    DoDrawButton(BtnRect, CPrevDirs[Horz], DragZone = zBtnPrev, ShowEnabled, HotZone = zBtnPrev);
+    DoDrawButton(BtnRect, CPrevDirs[Horz], FDragZone = zBtnPrev, ShowEnabled, FHotZone = zBtnPrev);
 
     { right / bottom button }
     BtnRect := R;
     with BtnRect do if Horz then Left := Right - BSize else Top := Bottom - BSize;
-    DoDrawButton(BtnRect, CNextDirs[Horz], DragZone = zBtnNext, ShowEnabled, HotZone = zBtnNext);
+    DoDrawButton(BtnRect, CNextDirs[Horz], FDragZone = zBtnNext, ShowEnabled, FHotZone = zBtnNext);
   end;
 
@@ -1091 +1092 @@
   ShowHandle := not GR32.IsRectEmpty(HandleRect);
 
-  DoDrawTrack(GetZoneRect(zTrackPrev), CPrevDirs[Horz], DragZone = zTrackPrev, ShowEnabled, HotZone = zTrackPrev);
-  DoDrawTrack(GetZoneRect(zTrackNext), CNextDirs[Horz], DragZone = zTrackNext, ShowEnabled, HotZone = zTrackNext);
-  if ShowHandle then DoDrawHandle(HandleRect, Horz, DragZone = zHandle, HotZone = zHandle);
+  DoDrawTrack(GetZoneRect(zTrackPrev), CPrevDirs[Horz], FDragZone = zTrackPrev, ShowEnabled, FHotZone = zTrackPrev);
+  DoDrawTrack(GetZoneRect(zTrackNext), CNextDirs[Horz], FDragZone = zTrackNext, ShowEnabled, FHotZone = zTrackNext);
+  if ShowHandle then DoDrawHandle(HandleRect, Horz, FDragZone = zHandle, FHotZone = zHandle);
 end;
 
@@ -1219 +1220 @@
 procedure TArrowBar.StartDragTracking;
 begin
-  Timer.Interval := FIRST_DELAY;
-  TimerMode := tmScroll;
+  FTimer.Interval := FIRST_DELAY;
+  FTimerMode := tmScroll;
   TimerHandler(Self);
-  TimerMode := tmScrollFirst;
-  Timer.Enabled := True;
+  FTimerMode := tmScrollFirst;
+  FTimer.Enabled := True;
 end;
 
 procedure TArrowBar.StartHotTracking;
 begin
-  Timer.Interval := HOTTRACK_INTERVAL;
-  TimerMode := tmHotTrack;
-  Timer.Enabled := True;
+  FTimer.Interval := HOTTRACK_INTERVAL;
+  FTimerMode := tmHotTrack;
+  FTimer.Enabled := True;
 end;
 
@@ -1240 +1241 @@
 procedure TArrowBar.StopHotTracking;
 begin
-  Timer.Enabled := False;
-  HotZone := zNone;
+  FTimer.Enabled := False;
+  FHotZone := zNone;
   Invalidate;
 end;
@@ -1249 +1250 @@
   Pt: TPoint;
 begin
-  case TimerMode of
+  case FTimerMode of
     tmScrollFirst:
       begin
-        Timer.Interval := SCROLL_INTERVAL;
-        TimerMode := tmScroll;
+        FTimer.Interval := SCROLL_INTERVAL;
+        FTimerMode := tmScroll;
       end;
     tmHotTrack:
@@ -1431 +1432 @@
   Shift: TShiftState; X, Y: Integer);
 begin
-  if Range <= EffectiveWindow then DragZone := zNone
+  if Range <= EffectiveWindow then FDragZone := zNone
   else
   begin
     inherited;
-    if DragZone = zHandle then
+    if FDragZone = zHandle then
     begin
       StopDragTracking;
-      PosBeforeDrag := Position;
+      FPosBeforeDrag := Position;
     end;
   end;
@@ -1450 +1451 @@
 begin
   inherited;
-  if DragZone = zHandle then
+  if FDragZone = zHandle then
   begin
     WinSz := EffectiveWindow;
 
     if Range <= WinSz then Exit;
-    if Kind = sbHorizontal then Delta := X - StoredX else Delta := Y - StoredY;
+    if Kind = sbHorizontal then Delta := X - FStored.X else Delta := Y - FStored.Y;
 
     if Kind = sbHorizontal then ClientSz := ClientWidth  else ClientSz := ClientHeight;
@@ -1465 +1466 @@
     else Delta := Delta * Range / ClientSz;
 
-    GenChange := True;
-    Position := PosBeforeDrag + Delta;
-    GenChange := False;
+    FGenChange := True;
+    Position := FPosBeforeDrag + Delta;
+    FGenChange := False;
   end;
 end;
@@ -1561 +1562 @@
 begin
   inherited;
-  GenChange := True;
+  FGenChange := True;
   OldPosition := Position;
 
-  case DragZone of
+  case FDragZone of
     zBtnPrev:
       begin
@@ -1591 +1592 @@
       end;
   end;
-  GenChange := False;
+  FGenChange := False;
 end;
 
@@ -1677 +1678 @@
 begin
   inherited;
-  if DragZone = zHandle then
+  if FDragZone = zHandle then
   begin
     StopDragTracking;
-    PosBeforeDrag := Position;
+    FPosBeforeDrag := Position;
   end;
 end;
@@ -1691 +1692 @@
 begin
   inherited;
-  if DragZone = zHandle then
-  begin
-    if Kind = sbHorizontal then Delta := X - StoredX else Delta := Y - StoredY;
+  if FDragZone = zHandle then
+  begin
+    if Kind = sbHorizontal then Delta := X - FStored.X else Delta := Y - FStored.Y;
     R := GetTrackBoundary;
 
@@ -1701 +1702 @@
     Delta := Delta * (Max - Min) / (ClientSz - GetHandleSize);
 
-    GenChange := True;
-    Position := Round(PosBeforeDrag + Delta);
-    GenChange := False;
+    FGenChange := True;
+    Position := Round(FPosBeforeDrag + Delta);
+    FGenChange := False;
   end;
 end;
@@ -1779 +1780 @@
 begin
   inherited;
-  GenChange := True;
+  FGenChange := True;
   OldPosition := Position;
 
-  case DragZone of
+  case FDragZone of
     zBtnPrev:
       begin
@@ -1809 +1810 @@
       end;
   end;
-  GenChange := False;
+  FGenChange := False;
 end;
 

GraphicTest/Packages/Graphics32/GR32_Rasterizers.pas

@@ -47 +47 @@
   Windows,
 {$ENDIF}
-  Classes, GR32, GR32_Blend, GR32_OrdinalMaps;
+  Classes, GR32, GR32_Blend;
 
 type
@@ -184 +184 @@
 
 uses
-  GR32_Resamplers, GR32_Containers, GR32_System, Math, GR32_Math, SysUtils;
+  Math, SysUtils, GR32_Math, GR32_System, GR32_LowLevel, GR32_Resamplers,
+  GR32_Containers, GR32_OrdinalMaps;
 
 type
-  TThreadPersistentAccess = class(TThreadPersistent);
+  TCustomBitmap32Access = class(TCustomBitmap32);
 
   TLineRasterizerData = record
@@ -292 +293 @@
   R: TRect;
 begin
-  UpdateCount := TThreadPersistentAccess(Dst).UpdateCount;
+  UpdateCount := TCustomBitmap32Access(Dst).UpdateCount;
   if Assigned(FSampler) then
   begin
@@ -302 +303 @@
       DoRasterize(Dst, R);
     finally
-      while TThreadPersistentAccess(Dst).UpdateCount > UpdateCount do
-        TThreadPersistentAccess(Dst).EndUpdate;
+      while TCustomBitmap32Access(Dst).UpdateCount > UpdateCount do
+        TCustomBitmap32Access(Dst).EndUpdate;
       FSampler.FinalizeSampling;
     end;
@@ -430 +431 @@
   Size := NextPowerOf2(Max(W, H));
 
-  SetLength(ForwardBuffer, Size);
+  SetLength(ForwardBuffer, Size + 1);
 
   I := 2;
-  while I < Size do
+  while I <= Size do
   begin
     ForwardBuffer[I] := ForwardBuffer[I shr 1] + 1;
@@ -452 +453 @@
     P2.X := L + P1.X;
     P2.Y := T + P1.Y;
+
     AssignColor(Dst.Bits[P2.X + P2.Y * RowSize], GetSample(P2.X, P2.Y));
 
@@ -482 +484 @@
   FUpdateRows := True;
 end;
+
+{$DEFINE UseInternalFill}
 
 procedure TProgressiveRasterizer.DoRasterize(Dst: TCustomBitmap32;
@@ -491 +495 @@
   Step: Integer;
   GetSample: TGetSampleInt;
-begin
-    GetSample := FSampler.GetSampleInt;
-    OnChanged := Dst.OnAreaChanged;
-    DoUpdate := (TThreadPersistentAccess(Dst).UpdateCount = 0) and Assigned(OnChanged);
-    W := DstRect.Right - DstRect.Left;
-    H := DstRect.Bottom - DstRect.Top;
-    J := DstRect.Top;
-    Step := 1 shl FSteps;
-    while J < DstRect.Bottom do
-    begin
-      I := DstRect.Left;
-      B := Min(J + Step, DstRect.Bottom);
-      while I < DstRect.Right - Step do
-      begin
-        Dst.FillRect(I, J, I + Step, B, GetSample(I, J));
-        Inc(I, Step);
-      end;
-      Dst.FillRect(I, J, DstRect.Right, B, GetSample(I, J));
-      if DoUpdate and FUpdateRows then
-        OnChanged(Dst, Rect(DstRect.Left, J, DstRect.Right, B), AREAINFO_RECT);
-      Inc(J, Step);
-    end;
-    if DoUpdate and (not FUpdateRows) then OnChanged(Dst, DstRect, AREAINFO_RECT);
-
-    Shift := FSteps;
-    while Step > 1 do
-    begin
-      Dec(Shift);
-      Step := Step div 2;
-      Wk := W div Step - 1;
-      Hk := H div Step;
-      for J := 0 to Hk do
-      begin
-        Y := DstRect.Top + J shl Shift;
-        B := Min(Y + Step, DstRect.Bottom);
-        if Odd(J) then
-          for I := 0 to Wk do
+
+{$IFDEF UseInternalFill}
+  Bits: PColor32Array;
+
+procedure IntFillRect(X1, Y1, X2, Y2: Integer; C: TColor32);
+var
+  Y: Integer;
+  P: PColor32Array;
+begin
+  for Y := Y1 to Y2 - 1 do
+  begin
+    P := Pointer(@Bits[Y * W]);
+    FillLongword(P[X1], X2 - X1, C);
+  end;
+end;
+{$ENDIF}
+
+begin
+  GetSample := FSampler.GetSampleInt;
+  OnChanged := Dst.OnAreaChanged;
+{$IFDEF UseInternalFill}
+  Bits := Dst.Bits;
+{$ENDIF}
+  DoUpdate := (TCustomBitmap32Access(Dst).UpdateCount = 0) and Assigned(OnChanged);
+  W := DstRect.Right - DstRect.Left;
+  H := DstRect.Bottom - DstRect.Top;
+  J := DstRect.Top;
+  Step := 1 shl FSteps;
+  while J < DstRect.Bottom do
+  begin
+    I := DstRect.Left;
+    B := Min(J + Step, DstRect.Bottom);
+    while I < DstRect.Right - Step do
+    begin
+      {$IFDEF UseInternalFill}
+      IntFillRect(I, J, I + Step, B, GetSample(I, J));
+      {$ELSE}
+      Dst.FillRect(I, J, I + Step, B, GetSample(I, J));
+      {$ENDIF}
+      Inc(I, Step);
+    end;
+    {$IFDEF UseInternalFill}
+    IntFillRect(I, J, DstRect.Right, B, GetSample(I, J));
+    if DoUpdate and FUpdateRows then
+      OnChanged(Dst, Rect(DstRect.Left, J, DstRect.Right, B), AREAINFO_RECT);
+    {$ELSE}
+    Dst.FillRect(I, J, DstRect.Right, B, GetSample(I, J));
+    {$ENDIF}
+    Inc(J, Step);
+  end;
+  if DoUpdate and (not FUpdateRows) then OnChanged(Dst, DstRect, AREAINFO_RECT);
+
+  Shift := FSteps;
+  while Step > 1 do
+  begin
+    Dec(Shift);
+    Step := Step div 2;
+    Wk := W div Step - 1;
+    Hk := H div Step;
+    for J := 0 to Hk do
+    begin
+      Y := DstRect.Top + J shl Shift;
+      B := Min(Y + Step, DstRect.Bottom);
+      if Odd(J) then
+        for I := 0 to Wk do
+        begin
+          X := DstRect.Left + I shl Shift;
+          {$IFDEF UseInternalFill}
+          IntFillRect(X, Y, X + Step, B, GetSample(X, Y));
+          {$ELSE}
+          Dst.FillRect(X, Y, X + Step, B, GetSample(X, Y));
+          {$ENDIF}
+        end
+      else
+        for I := 0 to Wk do
+          if Odd(I) then
           begin
             X := DstRect.Left + I shl Shift;
+            {$IFDEF UseInternalFill}
+            IntFillRect(X, Y, X + Step, B, GetSample(X, Y));
+            {$ELSE}
             Dst.FillRect(X, Y, X + Step, B, GetSample(X, Y));
-          end
-        else
-          for I := 0 to Wk do
-            if Odd(I) then
-            begin
-              X := DstRect.Left + I shl Shift;
-              Dst.FillRect(X, Y, X + Step, B, GetSample(X, Y));
-            end;
-        X := DstRect.Left + Wk shl Shift;
-        Dst.FillRect(X, Y, DstRect.Right, B, GetSample(X, Y));
-        if FUpdateRows and DoUpdate then
-          OnChanged(Dst, Rect(DstRect.Left, Y, DstRect.Right, B), AREAINFO_RECT);
-      end;
-      if DoUpdate and (not FUpdateRows) then OnChanged(Dst, DstRect, AREAINFO_RECT);
-    end;
+            {$ENDIF}
+          end;
+      X := DstRect.Left + Wk shl Shift;
+      {$IFDEF UseInternalFill}
+      IntFillRect(X, Y, DstRect.Right, B, GetSample(X, Y));
+      if FUpdateRows and DoUpdate then
+        OnChanged(Dst, Rect(DstRect.Left, Y, DstRect.Right, B), AREAINFO_RECT);
+      {$ELSE}
+      Dst.FillRect(X, Y, DstRect.Right, B, GetSample(X, Y));
+      {$ENDIF}
+    end;
+    if DoUpdate and (not FUpdateRows) then OnChanged(Dst, DstRect, AREAINFO_RECT);
+  end;
 end;
 

GraphicTest/Packages/Graphics32/GR32_Reg.pas

@@ -60 +60 @@
   GR32_Layers,
   GR32_RangeBars,
+  GR32_ColorPicker,
+  GR32_ColorSwatch,
   GR32_Resamplers;
 
@@ -66 +68 @@
 begin
   RegisterComponents('Graphics32', [TPaintBox32, TImage32, TBitmap32List,
-    TRangeBar, TGaugeBar, TImgView32{$IFDEF Windows}, TSyntheticImage32{$ENDIF}]);
+    TRangeBar, TGaugeBar, TImgView32{$IFDEF Windows}, TSyntheticImage32{$ENDIF},
+    TColorPickerComponent, TColorPickerRGBA, TColorPickerHS, TColorPickerHSV,
+    TColorPickerGTK, {$IFDEF COMPILER2010_UP} TColor32Dialog,{$ENDIF}
+    TColorSwatch]);
   RegisterPropertyEditor(TypeInfo(TColor32), nil, '', TColor32Property);
   RegisterPropertyEditor(TypeInfo(TBitmap32), nil, '', TBitmap32Property);
@@ -83 +88 @@
 
 end.
+

GraphicTest/Packages/Graphics32/GR32_RepaintOpt.pas

@@ -42 +42 @@
   LCLIntf,
 {$ELSE}
-  Windows,
+  Types, Windows,
 {$ENDIF}
-  Classes, SysUtils, GR32, GR32_LowLevel, GR32_Containers, GR32_Layers;
+  Classes, SysUtils, GR32, GR32_Containers, GR32_Layers;
 
 type

GraphicTest/Packages/Graphics32/GR32_Resamplers.pas

@@ -50 +50 @@
 {$ENDIF}
   Classes, SysUtils, GR32, GR32_Transforms, GR32_Containers,
-  GR32_OrdinalMaps, GR32_Blend, GR32_System, GR32_Bindings;
+  GR32_OrdinalMaps, GR32_Blend;
 
 procedure BlockTransfer(
@@ -343 +343 @@
     procedure SetKernel(const Value: TCustomKernel);
     function GetKernelClassName: string;
-    procedure SetKernelClassName(Value: string);
+    procedure SetKernelClassName(const Value: string);
     procedure SetKernelMode(const Value: TKernelMode);
     procedure SetTableSize(Value: Integer);
@@ -578 +578 @@
 procedure IncBuffer(var Buffer: TBufferEntry; Color: TColor32); {$IFDEF USEINLINING} inline; {$ENDIF}
 procedure MultiplyBuffer(var Buffer: TBufferEntry; W: Integer); {$IFDEF USEINLINING} inline; {$ENDIF}
-function BufferToColor32(Buffer: TBufferEntry; Shift: Integer): TColor32; {$IFDEF USEINLINING} inline; {$ENDIF}
+function BufferToColor32(const Buffer: TBufferEntry; Shift: Integer): TColor32; {$IFDEF USEINLINING} inline; {$ENDIF}
 procedure ShrBuffer(var Buffer: TBufferEntry; Shift: Integer); {$IFDEF USEINLINING} inline; {$ENDIF}
+
+{ Downsample byte map }
+procedure DownsampleByteMap2x(Source, Dest: TByteMap);
+procedure DownsampleByteMap3x(Source, Dest: TByteMap);
+procedure DownsampleByteMap4x(Source, Dest: TByteMap);
 
 { Registration routines }
@@ -605 +610 @@
 
 uses
-  GR32_LowLevel, GR32_Rasterizers, GR32_Math, Math;
+  GR32_System, GR32_Bindings, GR32_LowLevel, GR32_Rasterizers, GR32_Math,
+  GR32_Gamma, Math;
 
 resourcestring
@@ -611 +617 @@
 
 const
-  CAlbrecht2    : array [0..1] of Double = (5.383553946707251E-1, 4.616446053292749E-1);
-  CAlbrecht3    : array [0..2] of Double = (3.46100822018625E-1,  4.97340635096738E-1,
-                                            1.56558542884637E-1);
-  CAlbrecht4    : array [0..3] of Double = (2.26982412792069E-1,  4.57254070828427E-1,
-                                            2.73199027957384E-1,  4.25644884221201E-2);
-  CAlbrecht5    : array [0..4] of Double = (1.48942606015830E-1,  3.86001173639176E-1,
-                                            3.40977403214053E-1,  1.139879604246E-1,
-                                            1.00908567063414E-2);
-  CAlbrecht6    : array [0..5] of Double = (9.71676200107429E-2,  3.08845222524055E-1,
-                                            3.62623371437917E-1,  1.88953325525116E-1,
-                                            4.02095714148751E-2,  2.20088908729420E-3);
-  CAlbrecht7    : array [0..6] of Double = (6.39644241143904E-2,  2.39938645993528E-1,
-                                            3.50159563238205E-1,  2.47741118970808E-1,
-                                            8.54382560558580E-2,  1.23202033692932E-2,
-                                            4.37788257917735E-4);
-  CAlbrecht8    : array [0..7] of Double = (4.21072107042137E-2,  1.82076226633776E-1,
-                                            3.17713781059942E-1,  2.84438001373442E-1,
-                                            1.36762237777383E-1,  3.34038053504025E-2,
-                                            3.41677216705768E-3,  8.19649337831348E-5);
-  CAlbrecht9    : array [0..8] of Double = (2.76143731612611E-2,  1.35382228758844E-1,
-                                            2.75287234472237E-1,  2.98843335317801E-1,
-                                            1.85319330279284E-1,  6.48884482549063E-2,
-                                            1.17641910285655E-2,  8.85987580106899E-4,
-                                            1.48711469943406E-5);
-  CAlbrecht10   : array [0..9] of Double = (1.79908225352538E-2,  9.87959586065210E-2,
-                                            2.29883817001211E-1,  2.94113019095183E-1,
-                                            2.24338977814325E-1,  1.03248806248099E-1,
-                                            2.75674109448523E-2,  3.83958622947123E-3,
-                                            2.18971708430106E-4,  2.62981665347889E-6);
-  CAlbrecht11  : array [0..10] of Double = (1.18717127796602E-2,  7.19533651951142E-2,
-                                            1.87887160922585E-1,  2.75808174097291E-1,
-                                            2.48904243244464E-1,  1.41729867200712E-1,
-                                            5.02002976228256E-2,  1.04589649084984E-2,
-                                            1.13615112741660E-3,  4.96285981703436E-5,
-                                            4.34303262685720E-7);
+  CAlbrecht2 : array [0..1] of Double = (5.383553946707251E-1,
+    4.616446053292749E-1);
+  CAlbrecht3 : array [0..2] of Double = (3.46100822018625E-1,
+    4.97340635096738E-1, 1.56558542884637E-1);
+  CAlbrecht4 : array [0..3] of Double = (2.26982412792069E-1,
+    4.57254070828427E-1, 2.73199027957384E-1, 4.25644884221201E-2);
+  CAlbrecht5 : array [0..4] of Double = (1.48942606015830E-1,
+    3.86001173639176E-1, 3.40977403214053E-1, 1.139879604246E-1,
+    1.00908567063414E-2);
+  CAlbrecht6 : array [0..5] of Double = (9.71676200107429E-2,
+    3.08845222524055E-1, 3.62623371437917E-1, 1.88953325525116E-1,
+    4.02095714148751E-2, 2.20088908729420E-3);
+  CAlbrecht7 : array [0..6] of Double = (6.39644241143904E-2,
+    2.39938645993528E-1, 3.50159563238205E-1, 2.47741118970808E-1,
+    8.54382560558580E-2, 1.23202033692932E-2, 4.37788257917735E-4);
+  CAlbrecht8 : array [0..7] of Double = (4.21072107042137E-2,
+    1.82076226633776E-1, 3.17713781059942E-1, 2.84438001373442E-1,
+    1.36762237777383E-1, 3.34038053504025E-2, 3.41677216705768E-3,
+    8.19649337831348E-5);
+  CAlbrecht9 : array [0..8] of Double = (2.76143731612611E-2,
+    1.35382228758844E-1, 2.75287234472237E-1, 2.98843335317801E-1,
+    1.85319330279284E-1, 6.48884482549063E-2, 1.17641910285655E-2,
+    8.85987580106899E-4, 1.48711469943406E-5);
+  CAlbrecht10: array [0..9] of Double = (1.79908225352538E-2,
+    9.87959586065210E-2, 2.29883817001211E-1, 2.94113019095183E-1,
+    2.24338977814325E-1, 1.03248806248099E-1, 2.75674109448523E-2,
+    3.83958622947123E-3, 2.18971708430106E-4, 2.62981665347889E-6);
+  CAlbrecht11: array [0..10] of Double = (1.18717127796602E-2,
+    7.19533651951142E-2, 1.87887160922585E-1, 2.75808174097291E-1,
+    2.48904243244464E-1, 1.41729867200712E-1, 5.02002976228256E-2,
+    1.04589649084984E-2, 1.13615112741660E-3, 4.96285981703436E-5,
+    4.34303262685720E-7);
+
 type
   TTransformationAccess = class(TTransformation);
@@ -660 +664 @@
   TMappingTable = array of TCluster;
 
-
-type
   TKernelSamplerClass = class of TKernelSampler;
 
@@ -741 +743 @@
 end;
 
-function BufferToColor32(Buffer: TBufferEntry; Shift: Integer): TColor32;
+function BufferToColor32(const Buffer: TBufferEntry; Shift: Integer): TColor32;
 begin
   with TColor32Entry(Result) do
@@ -1719 +1721 @@
           C := Src.Bits[X + ClusterY[Y].Pos * Src.Width];
           ClustYW := ClusterY[Y].Weight;
-          Inc(Ca, C shr 24 * ClustYW);
-          Inc(Cr, (C and $00FF0000) shr 16 * ClustYW);
-          Inc(Cg, (C and $0000FF00) shr 8 * ClustYW);
-          Inc(Cb, (C and $000000FF) * ClustYW);
+          Inc(Ca, Integer(C shr 24) * ClustYW);
+          Inc(Cr, Integer(C and $00FF0000) shr 16 * ClustYW);
+          Inc(Cg, Integer(C and $0000FF00) shr 8 * ClustYW);
+          Inc(Cb, Integer(C and $000000FF) * ClustYW);
         end;
         with HorzBuffer[X - MapXLoPos] do
@@ -1812 +1814 @@
     Inc(NativeUInt(RowSrc), OffSrc);
     {$ELSE}
-    Inc(Cardinal(RowSrc), OffSrc);
+    Inc(PByte(RowSrc), OffSrc);
     {$ENDIF}
   end;
@@ -2294 +2296 @@
         Inc(NativeUInt(RowSrc), OffSrc * dy);
         {$ELSE}
-        Inc(Cardinal(RowSrc), OffSrc * dy);
+        Inc(PByte(RowSrc), OffSrc * dy);
         {$ENDIF}
       end;
@@ -2491 +2493 @@
 
 
+{ TByteMap downsample functions }
+
+procedure DownsampleByteMap2x(Source, Dest: TByteMap);
+var
+  X, Y: Integer;
+  ScnLn: array [0 .. 2] of PByteArray;
+begin
+  for Y := 0 to (Source.Height div 2) - 1 do
+  begin
+    ScnLn[0] := Dest.ScanLine[Y];
+    ScnLn[1] := Source.ScanLine[Y * 2];
+    ScnLn[2] := Source.ScanLine[Y * 2 + 1];
+    for X := 0 to (Source.Width div 2) - 1 do
+      ScnLn[0, X] := (
+        ScnLn[1, 2 * X] + ScnLn[1, 2 * X + 1] +
+        ScnLn[2, 2 * X] + ScnLn[2, 2 * X + 1]) div 4;
+  end;
+end;
+
+procedure DownsampleByteMap3x(Source, Dest: TByteMap);
+var
+  X, Y: Integer;
+  x3: Integer;
+  ScnLn: array [0 .. 3] of PByteArray;
+begin
+  for Y := 0 to (Source.Height div 3) - 1 do
+  begin
+    ScnLn[0] := Dest.ScanLine[Y];
+    ScnLn[1] := Source.ScanLine[3 * Y];
+    ScnLn[2] := Source.ScanLine[3 * Y + 1];
+    ScnLn[3] := Source.ScanLine[3 * Y + 2];
+    for X := 0 to (Source.Width div 3) - 1 do
+    begin
+      x3 := 3 * X;
+      ScnLn[0, X] := (
+        ScnLn[1, x3] + ScnLn[1, x3 + 1] + ScnLn[1, x3 + 2] +
+        ScnLn[2, x3] + ScnLn[2, x3 + 1] + ScnLn[2, x3 + 2] +
+        ScnLn[3, x3] + ScnLn[3, x3 + 1] + ScnLn[3, x3 + 2]) div 9;
+    end;
+  end;
+end;
+
+procedure DownsampleByteMap4x(Source, Dest: TByteMap);
+var
+  X, Y: Integer;
+  x4: Integer;
+  ScnLn: array [0 .. 4] of PByteArray;
+begin
+  for Y := 0 to (Source.Height div 4) - 1 do
+  begin
+    ScnLn[0] := Dest.ScanLine[Y];
+    ScnLn[1] := Source.ScanLine[Y * 4];
+    ScnLn[2] := Source.ScanLine[Y * 4 + 1];
+    ScnLn[3] := Source.ScanLine[Y * 4 + 2];
+    ScnLn[4] := Source.ScanLine[Y * 4 + 3];
+    for X := 0 to (Source.Width div 4) - 1 do
+    begin
+      x4 := 4 * X;
+      ScnLn[0, X] := (
+        ScnLn[1, x4] + ScnLn[1, x4 + 1] + ScnLn[1, x4 + 2] + ScnLn[1, x4 + 3] +
+        ScnLn[2, x4] + ScnLn[2, x4 + 1] + ScnLn[2, x4 + 2] + ScnLn[2, x4 + 3] +
+        ScnLn[3, x4] + ScnLn[3, x4 + 1] + ScnLn[3, x4 + 2] + ScnLn[3, x4 + 3] +
+        ScnLn[4, x4] + ScnLn[4, x4 + 1] + ScnLn[4, x4 + 2] + ScnLn[4, x4 + 3]) div 16;
+    end;
+  end;
+end;
+
 
 { TCustomKernel }
@@ -2935 +3004 @@
 end;
 
-procedure TKernelResampler.SetKernelClassName(Value: string);
+procedure TKernelResampler.SetKernelClassName(const Value: string);
 var
   KernelClass: TCustomKernelClass;
@@ -3173 +3242 @@
                 end else
                 begin
-                  Inc(HorzEntry.R, Div255(Alpha * SrcP.R) * W);
-                  Inc(HorzEntry.G, Div255(Alpha * SrcP.G) * W);
-                  Inc(HorzEntry.B, Div255(Alpha * SrcP.B) * W);
+                  Inc(HorzEntry.R, Integer(Div255(Alpha * SrcP.R)) * W);
+                  Inc(HorzEntry.G, Integer(Div255(Alpha * SrcP.G)) * W);
+                  Inc(HorzEntry.B, Integer(Div255(Alpha * SrcP.B)) * W);
                 end;
               end;
@@ -3196 +3265 @@
           begin
             // Sample premultiplied values
-            OuterPremultColorR := Div255(Alpha * TColor32Entry(FOuterColor).R);
-            OuterPremultColorG := Div255(Alpha * TColor32Entry(FOuterColor).G);
-            OuterPremultColorB := Div255(Alpha * TColor32Entry(FOuterColor).B);
+            OuterPremultColorR := Integer(Div255(Alpha * TColor32Entry(FOuterColor).R));
+            OuterPremultColorG := Integer(Div255(Alpha * TColor32Entry(FOuterColor).G));
+            OuterPremultColorB := Integer(Div255(Alpha * TColor32Entry(FOuterColor).B));
 
             for I := -KWidth to KWidth do
@@ -3364 +3433 @@
   if FKernelMode in [kmTableNearest, kmTableLinear] then
   begin
-    FWeightTable := TIntegerMap.Create;
-    FWeightTable.SetSize(W * 2 + 1, FTableSize + 1);
+    FWeightTable := TIntegerMap.Create(W * 2 + 1, FTableSize + 1);
     for I := 0 to FTableSize do
     begin
@@ -3382 +3450 @@
 end;
 
+
 { TCustomBitmap32NearestResampler }
 
@@ -3518 +3587 @@
       end;
 
-      WX := GAMMA_TABLE[((X shr 8) and $FF) xor $FF];
+      WX := GAMMA_ENCODING_TABLE[((X shr 8) and $FF) xor $FF];
       Result := CombineReg(CombineReg(C1, C2, WX),
                            CombineReg(C3, C4, WX),
-                           GAMMA_TABLE[((Y shr 8) and $FF) xor $FF]);
+                           GAMMA_ENCODING_TABLE[((Y shr 8) and $FF) xor $FF]);
       EMMS;  
     end  
@@ -3558 +3627 @@
   DstH := DstRect.Bottom - DstRect.Top;
   if (DstW > SrcW) and (DstH > SrcH) and (SrcW > 1) and (SrcH > 1) then
-    StretchHorzStretchVertLinear(Dst, DstRect, DstClip, Src, SrcRect, CombineOp, CombineCallBack)
+    StretchHorzStretchVertLinear(Dst, DstRect, DstClip, Src, SrcRect, CombineOp,
+      CombineCallBack)
   else
-    GR32_Resamplers.Resample(Dst, DstRect, DstClip, Src, SrcRect, FLinearKernel, CombineOp, CombineCallBack);
+    GR32_Resamplers.Resample(Dst, DstRect, DstClip, Src, SrcRect, FLinearKernel,
+      CombineOp, CombineCallBack);
 end;
 
@@ -3568 +3639 @@
   CombineOp: TDrawMode; CombineCallBack: TPixelCombineEvent);
 begin
-  DraftResample(Dst, DstRect, DstClip, Src, SrcRect, FLinearKernel, CombineOp, CombineCallBack)
+  DraftResample(Dst, DstRect, DstClip, Src, SrcRect, FLinearKernel, CombineOp,
+    CombineCallBack)
 end;
 
@@ -3577 +3649 @@
   U, V: TFixed;
 begin
-  FTransformationReverseTransformFixed(X * FixedOne + FixedHalf, Y * FixedOne + FixedHalf, U, V);
+  FTransformationReverseTransformFixed(X * FixedOne + FixedHalf,
+    Y * FixedOne + FixedHalf, U, V);
   Result := FGetSampleFixed(U - FixedHalf, V - FixedHalf);
 end;
@@ -4139 +4212 @@
 end;
 
-{CPU target and feature Function templates}
+{CPU target and feature function templates}
 
 const

GraphicTest/Packages/Graphics32/GR32_System.pas

@@ -70 +70 @@
     function ReadNanoseconds: string;
     function ReadMilliseconds: string;
-    function ReadSeconds: String;
+    function ReadSeconds: string;
+
     function ReadValue: Int64;
   end;
@@ -127 +128 @@
 
 function TPerfTimer.ReadNanoseconds: string;
-var
-  t : timeval;
-begin
-  fpgettimeofday(@t,nil);
-   // Build a 64 bit microsecond tick from the seconds and microsecond longints
-  Result := IntToStr( ( (Int64(t.tv_sec) * 1000000) + t.tv_usec ) div 1000 );
+begin
+  Result := IntToStr(ReadValue);
 end;
 
 function TPerfTimer.ReadMilliseconds: string;
-var
-  t : timeval;
-begin
-  fpgettimeofday(@t,nil);
-   // Build a 64 bit microsecond tick from the seconds and microsecond longints
-  Result := IntToStr( ( (Int64(t.tv_sec) * 1000000) + t.tv_usec ) * 1000 );
+begin
+  Result := IntToStr(ReadValue div 1000);
 end;
 
 function TPerfTimer.ReadSeconds: string;
-var
-  t : timeval;
-begin
-  fpgettimeofday(@t,nil);
-   // Build a 64 bit microsecond tick from the seconds and microsecond longints
-  Result := IntToStr( ( (Int64(t.tv_sec) * 1000000) + t.tv_usec ) );
+begin
+  Result := IntToStr(ReadValue div 1000000);
 end;
 
 function TPerfTimer.ReadValue: Int64;
-var t : timeval;
-begin
-  fpgettimeofday(@t,nil);
-   // Build a 64 bit microsecond tick from the seconds and microsecond longints
-  Result := (Int64(t.tv_sec) * 1000000) + t.tv_usec;
-  Result := Result div 1000;
+begin
+  Result := GetTickCount - FStart;
 end;
 
 procedure TPerfTimer.Start;
-var
-  t : timeval;
-begin
-  fpgettimeofday(@t,nil);
-   // Build a 64 bit microsecond tick from the seconds and microsecond longints
-  FStart := (Int64(t.tv_sec) * 1000000) + t.tv_usec;
+begin
+  FStart := GetTickCount;
 end;
 {$ENDIF}
@@ -242 +223 @@
 {$IFNDEF PUREPASCAL}
 const
-  CPUISChecks: Array[TCPUInstructionSet] of Cardinal =
+  CPUISChecks: array [TCPUInstructionSet] of Cardinal =
     ($800000,  $400000, $2000000, $4000000, $80000000, $40000000);
     {ciMMX  ,  ciEMMX,  ciSSE   , ciSSE2  , ci3DNow ,  ci3DNowExt}
@@ -248 +229 @@
 function CPUID_Available: Boolean;
 asm
+{$IFDEF TARGET_x86}
+        MOV       EDX,False
+        PUSHFD
+        POP       EAX
+        MOV       ECX,EAX
+        XOR       EAX,$00200000
+        PUSH      EAX
+        POPFD
+        PUSHFD
+        POP       EAX
+        XOR       ECX,EAX
+        JZ        @1
+        MOV       EDX,True
+@1:     PUSH      EAX
+        POPFD
+        MOV       EAX,EDX
+{$ENDIF}
 {$IFDEF TARGET_x64}
         MOV       EDX,False
@@ -264 +262 @@
         POPFQ
         MOV       EAX,EDX
-{$ELSE}
-        MOV       EDX,False
-        PUSHFD
-        POP       EAX
-        MOV       ECX,EAX
-        XOR       EAX,$00200000
-        PUSH      EAX
-        POPFD
-        PUSHFD
-        POP       EAX
-        XOR       ECX,EAX
-        JZ        @1
-        MOV       EDX,True
-@1:     PUSH      EAX
-        POPFD
-        MOV       EAX,EDX
 {$ENDIF}
 end;
@@ -285 +267 @@
 function CPU_Signature: Integer;
 asm
-{$IFDEF TARGET_x64}
-        PUSH      RBX
-        MOV       EAX,1
-        CPUID
-        POP       RBX
-{$ELSE}
+{$IFDEF TARGET_x86}
         PUSH      EBX
         MOV       EAX,1
@@ -300 +277 @@
         POP       EBX
 {$ENDIF}
-end;
-
-function CPU_Features: Integer;
-asm
 {$IFDEF TARGET_x64}
         PUSH      RBX
@@ -309 +282 @@
         CPUID
         POP       RBX
-        MOV       EAX,EDX
-{$ELSE}
+{$ENDIF}
+end;
+
+function CPU_Features: Integer;
+asm
+{$IFDEF TARGET_x86}
         PUSH      EBX
         MOV       EAX,1
@@ -321 +298 @@
         MOV       EAX,EDX
 {$ENDIF}
+{$IFDEF TARGET_x64}
+        PUSH      RBX
+        MOV       EAX,1
+        CPUID
+        POP       RBX
+        MOV       EAX,EDX
+{$ENDIF}
 end;
 
 function CPU_ExtensionsAvailable: Boolean;
 asm
-{$IFDEF TARGET_x64}
-        PUSH      RBX
-        MOV       @Result, True
-        MOV       EAX, $80000000
-        CPUID
-        CMP       EAX, $80000000
-        JBE       @NOEXTENSION
-        JMP       @EXIT
-        @NOEXTENSION:
-        MOV       @Result, False
-        @EXIT:
-        POP       RBX
-{$ELSE}
+{$IFDEF TARGET_x86}
         PUSH      EBX
         MOV       @Result, True
@@ -354 +326 @@
         POP       EBX
 {$ENDIF}
+{$IFDEF TARGET_x64}
+        PUSH      RBX
+        MOV       @Result, True
+        MOV       EAX, $80000000
+        CPUID
+        CMP       EAX, $80000000
+        JBE       @NOEXTENSION
+        JMP       @EXIT
+        @NOEXTENSION:
+        MOV       @Result, False
+        @EXIT:
+        POP       RBX
+{$ENDIF}
 end;
 
 function CPU_ExtFeatures: Integer;
 asm
-{$IFDEF TARGET_x64}
-        PUSH      RBX
-        MOV       EAX, $80000001
-        CPUID
-        POP       RBX
-        MOV       EAX,EDX
-{$ELSE}
+{$IFDEF TARGET_x86}
         PUSH      EBX
         MOV       EAX, $80000001
@@ -373 +352 @@
         {$ENDIF}
         POP       EBX
+        MOV       EAX,EDX
+{$ENDIF}
+{$IFDEF TARGET_x64}
+        PUSH      RBX
+        MOV       EAX, $80000001
+        CPUID
+        POP       RBX
         MOV       EAX,EDX
 {$ENDIF}

GraphicTest/Packages/Graphics32/GR32_Transforms.pas

@@ -48 +48 @@
   Windows,
 {$ENDIF}
-  SysUtils, Classes, GR32, GR32_Blend, GR32_VectorMaps, GR32_Rasterizers;
+  SysUtils, Classes, Types, GR32, GR32_VectorMaps, GR32_Rasterizers;
 
 type
@@ -55 +55 @@
 
 type
-  TFloatMatrix = array[0..2, 0..2] of TFloat;     // 3x3 TFloat precision
-  TFixedMatrix = array[0..2, 0..2] of TFixed;     // 3x3 fixed precision
+  TFloatMatrix = array [0..2, 0..2] of TFloat;     // 3x3 TFloat precision
+  TFixedMatrix = array [0..2, 0..2] of TFixed;     // 3x3 fixed precision
 
 const
@@ -65 +65 @@
 
 type
-  TVector3f = array[0..2] of TFloat;
-  TVector3i = array[0..2] of Integer;
+  TVector3f = array [0..2] of TFloat;
+  TVector3i = array [0..2] of Integer;
 
 // Matrix conversion routines
@@ -94 +94 @@
     procedure TransformFloat(SrcX, SrcY: TFloat; out DstX, DstY: TFloat); virtual;
   public
+    constructor Create; virtual;
     procedure Changed; override;
     function HasTransformedBounds: Boolean; virtual;
@@ -106 +107 @@
     property SrcRect: TFloatRect read FSrcRect write SetSrcRect;
   end;
-
-  TAffineTransformation = class(TTransformation)
+  TTransformationClass = class of TTransformation;
+
+  TNestedTransformation = class(TTransformation)
+  private
+    FItems: TList;
+    FOwner: TPersistent;
+    function GetCount: Integer;
+    function GetItem(Index: Integer): TTransformation;
+    procedure SetItem(Index: Integer; const Value: TTransformation);
   protected
-    FInverseMatrix: TFloatMatrix;
+    procedure PrepareTransform; override;
+    procedure ReverseTransformFixed(DstX, DstY: TFixed; out SrcX, SrcY: TFixed); override;
+    procedure ReverseTransformFloat(DstX, DstY: TFloat; out SrcX, SrcY: TFloat); override;
+    procedure TransformFixed(SrcX, SrcY: TFixed; out DstX, DstY: TFixed); override;
+    procedure TransformFloat(SrcX, SrcY: TFloat; out DstX, DstY: TFloat); override;
+  public
+    constructor Create; override;
+    destructor Destroy; override;
+    function Add(ItemClass: TTransformationClass): TTransformation;
+    procedure Clear;
+    procedure Delete(Index: Integer);
+    function Insert(Index: Integer; ItemClass: TTransformationClass): TTransformation;
+
+    property Owner: TPersistent read FOwner;
+    property Count: Integer read GetCount;
+    property Items[Index: Integer]: TTransformation read GetItem write SetItem; default;
+  end;
+
+  T3x3Transformation = class(TTransformation)
+  protected
+    FMatrix, FInverseMatrix: TFloatMatrix;
     FFixedMatrix, FInverseFixedMatrix: TFixedMatrix;
     procedure PrepareTransform; override;
+    procedure ReverseTransformFixed(DstX, DstY: TFixed; out SrcX, SrcY: TFixed); override;
     procedure ReverseTransformFloat(DstX, DstY: TFloat; out SrcX, SrcY: TFloat); override;
-    procedure ReverseTransformFixed(DstX, DstY: TFixed; out SrcX, SrcY: TFixed); override;
+    procedure TransformFixed(SrcX, SrcY: TFixed; out DstX, DstY: TFixed); override;
     procedure TransformFloat(SrcX, SrcY: TFloat; out DstX, DstY: TFloat); override;
-    procedure TransformFixed(SrcX, SrcY: TFixed; out DstX, DstY: TFixed); override;
   public
-    Matrix: TFloatMatrix;
-    constructor Create; virtual;
+    property Matrix: TFloatMatrix read FMatrix;
+  end;
+
+  TAffineTransformation = class(T3x3Transformation)
+  private
+    FStack: ^TFloatMatrix;
+    FStackLevel: Integer;
+  public
+    constructor Create; override;
+
     function GetTransformedBounds(const ASrcRect: TFloatRect): TFloatRect; override;
-    procedure Clear;
+    procedure Push;
+    procedure Pop;
+    procedure Clear; overload;
+    procedure Clear(BaseMatrix: TFloatMatrix); overload;
     procedure Rotate(Alpha: TFloat); overload; // degrees
     procedure Rotate(Cx, Cy, Alpha: TFloat); overload; // degrees
@@ -129 +168 @@
   end;
 
-  TProjectiveTransformation = class(TTransformation)
+  TProjectiveTransformation = class(T3x3Transformation)
   private
-    Wx0, Wx1, Wx2, Wx3: TFloat;
-    Wy0, Wy1, Wy2, Wy3: TFloat;
-    procedure SetX0(Value: TFloat);
-    procedure SetX1(Value: TFloat);
-    procedure SetX2(Value: TFloat);
-    procedure SetX3(Value: TFloat);
-    procedure SetY0(Value: TFloat);
-    procedure SetY1(Value: TFloat);
-    procedure SetY2(Value: TFloat);
-    procedure SetY3(Value: TFloat);
+    FQuadX: array [0..3] of TFloat;
+    FQuadY: array [0..3] of TFloat;
+    procedure SetX(Index: Integer; const Value: TFloat); {$IFDEF UseInlining} inline; {$ENDIF}
+    procedure SetY(Index: Integer; const Value: TFloat); {$IFDEF UseInlining} inline; {$ENDIF}
+    function GetX(Index: Integer): TFloat; {$IFDEF UseInlining} inline; {$ENDIF}
+    function GetY(Index: Integer): TFloat; {$IFDEF UseInlining} inline; {$ENDIF}
   protected
-    FMatrix, FInverseMatrix: TFloatMatrix;
-    FFixedMatrix, FInverseFixedMatrix: TFixedMatrix;
     procedure PrepareTransform; override;
+    procedure ReverseTransformFixed(DstX, DstY: TFixed; out SrcX, SrcY: TFixed); override;
     procedure ReverseTransformFloat(DstX, DstY: TFloat; out SrcX, SrcY: TFloat); override;
-    procedure ReverseTransformFixed(DstX, DstY: TFixed; out SrcX, SrcY: TFixed); override;
+    procedure TransformFixed(SrcX, SrcY: TFixed; out DstX, DstY: TFixed); override;
     procedure TransformFloat(SrcX, SrcY: TFloat; out DstX, DstY: TFloat); override;
-    procedure TransformFixed(SrcX, SrcY: TFixed; out DstX, DstY: TFixed); override;
   public
-    function  GetTransformedBounds(const ASrcRect: TFloatRect): TFloatRect; override;
+    function GetTransformedBounds(const ASrcRect: TFloatRect): TFloatRect; override;
+    property X[Index: Integer]: TFloat read GetX write SetX;
+    property Y[index: Integer]: TFloat read GetX write SetY;
   published
-    property X0: TFloat read Wx0 write SetX0;
-    property X1: TFloat read Wx1 write SetX1;
-    property X2: TFloat read Wx2 write SetX2;
-    property X3: TFloat read Wx3 write SetX3;
-    property Y0: TFloat read Wy0 write SetY0;
-    property Y1: TFloat read Wy1 write SetY1;
-    property Y2: TFloat read Wy2 write SetY2;
-    property Y3: TFloat read Wy3 write SetY3;
+    property X0: TFloat index 0 read GetX write SetX;
+    property X1: TFloat index 1 read GetX write SetX;
+    property X2: TFloat index 2 read GetX write SetX;
+    property X3: TFloat index 3 read GetX write SetX;
+    property Y0: TFloat index 0 read GetY write SetY;
+    property Y1: TFloat index 1 read GetY write SetY;
+    property Y2: TFloat index 2 read GetY write SetY;
+    property Y3: TFloat index 3 read GetY write SetY;
   end;
 
@@ -171 +206 @@
     procedure ReverseTransformFloat(DstX, DstY: TFloat; out SrcX, SrcY: TFloat); override;
   public
-    constructor Create; virtual;
+    constructor Create; override;
     function GetTransformedBounds(const ASrcRect: TFloatRect): TFloatRect; override;
   published
@@ -186 +221 @@
     procedure PrepareTransform; override;
     procedure ReverseTransformFloat(DstX, DstY: TFloat; out SrcX, SrcY: TFloat); override;
+    procedure TransformFloat(DstX, DstY: TFloat; out SrcX, SrcY: TFloat); override;
   public
-    constructor Create; virtual;
+    constructor Create; override;
   published
     property BloatPower: TFloat read FBloatPower write SetBloatPower;
@@ -277 +313 @@
     procedure ReverseTransformFixed(DstX, DstY: TFixed; out SrcX, SrcY: TFixed); override;
   public
-    constructor Create; virtual;
+    constructor Create; override;
     destructor Destroy; override;
     function HasTransformedBounds: Boolean; override;
@@ -316 +352 @@
 
 uses
-  Math, GR32_LowLevel, GR32_Math, GR32_System, GR32_Bindings, GR32_Resamplers;
+  Math, GR32_Blend, GR32_LowLevel, GR32_Math, GR32_Bindings,
+  GR32_Resamplers;
 
 resourcestring
   RCStrSrcRectIsEmpty = 'SrcRect is empty!';
   RCStrMappingRectIsEmpty = 'MappingRect is empty!';
+  RStrStackEmpty = 'Stack empty';
 
 type
@@ -516 +554 @@
   Transformer: TTransformer;
 begin
-  IntersectRect(DstRect, DstClip, Dst.ClipRect);
+  GR32.IntersectRect(DstRect, DstClip, Dst.ClipRect);
 
   if (DstRect.Right < DstRect.Left) or (DstRect.Bottom < DstRect.Top) then Exit;
@@ -538 +576 @@
   I: Integer;
 begin
-  IntersectRect(ARect, ARect, ABitmap.BoundsRect);
+  GR32.IntersectRect(ARect, ARect, ABitmap.BoundsRect);
   with ARect, ABitmap do
   if (Right > Left) and (Bottom > Top) and
@@ -573 +611 @@
 end;
 
+constructor TTransformation.Create;
+begin
+  // virtual constructor to be overriden in derived classes
+end;
+
 function TTransformation.GetTransformedBounds(const ASrcRect: TFloatRect): TFloatRect;
 begin
@@ -619 +662 @@
   out SrcX, SrcY: TFloat);
 begin
-  // ReverseTransformFloat is the top precisionlevel, all decendants must override at least this level!
+  // ReverseTransformFloat is the top precisionlevel, all descendants must override at least this level!
   raise ETransformNotImplemented.CreateFmt(RCStrReverseTransformationNotImplemented, [Self.Classname]);
 end;
@@ -641 +684 @@
 function TTransformation.Transform(const P: TFloatPoint): TFloatPoint;
 begin
-  If not TransformValid then PrepareTransform;
+  if not TransformValid then PrepareTransform;
   TransformFloat(P.X, P.Y, Result.X, Result.Y);
 end;
@@ -647 +690 @@
 function TTransformation.Transform(const P: TFixedPoint): TFixedPoint;
 begin
-  If not TransformValid then PrepareTransform;
+  if not TransformValid then PrepareTransform;
   TransformFixed(P.X, P.Y, Result.X, Result.Y);
 end;
@@ -653 +696 @@
 function TTransformation.Transform(const P: TPoint): TPoint;
 begin
-  If not TransformValid then PrepareTransform;
+  if not TransformValid then PrepareTransform;
   TransformInt(P.X, P.Y, Result.X, Result.Y);
 end;
@@ -669 +712 @@
 procedure TTransformation.TransformFloat(SrcX, SrcY: TFloat; out DstX, DstY: TFloat);
 begin
-  // TransformFloat is the top precisionlevel, all decendants must override at least this level!
+  // TransformFloat is the top precisionlevel, all descendants must override at least this level!
   raise ETransformNotImplemented.CreateFmt(RCStrForwardTransformationNotImplemented, [Self.Classname]);
 end;
@@ -682 +725 @@
 end;
 
+
+{ TNestedTransformation }
+
+constructor TNestedTransformation.Create;
+begin
+  FItems := TList.Create;
+end;
+
+destructor TNestedTransformation.Destroy;
+begin
+  if Assigned(FItems) then Clear;
+  FItems.Free;
+  inherited;
+end;
+
+function TNestedTransformation.Add(
+  ItemClass: TTransformationClass): TTransformation;
+begin
+  Result := ItemClass.Create;
+  {$IFDEF NEXTGEN}
+  Result.__ObjAddRef;
+  {$ENDIF}
+  FItems.Add(Result);
+end;
+
+procedure TNestedTransformation.Clear;
+begin
+  BeginUpdate;
+  try
+    while FItems.Count > 0 do
+      Delete(FItems.Count - 1);
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TNestedTransformation.Delete(Index: Integer);
+begin
+  TTransformation(FItems[Index]).Free;
+  FItems.Delete(Index);
+end;
+
+function TNestedTransformation.GetCount: Integer;
+begin
+  Result := FItems.Count;
+end;
+
+function TNestedTransformation.GetItem(Index: Integer): TTransformation;
+begin
+  Result := FItems[Index];
+end;
+
+function TNestedTransformation.Insert(Index: Integer;
+  ItemClass: TTransformationClass): TTransformation;
+begin
+  BeginUpdate;
+  try
+    Result := Add(ItemClass);
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TNestedTransformation.PrepareTransform;
+var
+  Index: Integer;
+begin
+  for Index := 0 to Count - 1 do
+    TTransformation(FItems[Index]).PrepareTransform;
+end;
+
+procedure TNestedTransformation.ReverseTransformFixed(DstX, DstY: TFixed;
+  out SrcX, SrcY: TFixed);
+var
+  Index: Integer;
+begin
+  for Index := 0 to Count - 1 do
+  begin
+    TTransformation(FItems[Index]).ReverseTransformFixed(DstX, DstY, SrcX,
+      SrcY);
+    DstX := SrcX;
+    DstY := SrcY;
+  end;
+end;
+
+procedure TNestedTransformation.ReverseTransformFloat(DstX, DstY: TFloat;
+  out SrcX, SrcY: TFloat);
+var
+  Index: Integer;
+begin
+  for Index := 0 to Count - 1 do
+  begin
+    TTransformation(FItems[Index]).ReverseTransformFloat(DstX, DstY, SrcX,
+      SrcY);
+    DstX := SrcX;
+    DstY := SrcY;
+  end;
+end;
+
+procedure TNestedTransformation.SetItem(Index: Integer;
+  const Value: TTransformation);
+begin
+  TCollectionItem(FItems[Index]).Assign(Value);
+end;
+
+procedure TNestedTransformation.TransformFixed(SrcX, SrcY: TFixed; out DstX,
+  DstY: TFixed);
+var
+  Index: Integer;
+begin
+  for Index := 0 to Count - 1 do
+  begin
+    TTransformation(FItems[Index]).TransformFixed(SrcX, SrcY, DstX, DstY);
+    SrcX := DstX;
+    SrcY := DstY;
+  end;
+end;
+
+procedure TNestedTransformation.TransformFloat(SrcX, SrcY: TFloat; out DstX,
+  DstY: TFloat);
+var
+  Index: Integer;
+begin
+  for Index := 0 to Count - 1 do
+  begin
+    TTransformation(FItems[Index]).TransformFloat(SrcX, SrcY, DstX, DstY);
+    SrcX := DstX;
+    SrcY := DstY;
+  end;
+end;
+
+
+{ T3x3Transformation }
+
+procedure T3x3Transformation.PrepareTransform;
+begin
+  FInverseMatrix := Matrix;
+  Invert(FInverseMatrix);
+
+  // calculate a fixed point (65536) factors
+  FInverseFixedMatrix := FixedMatrix(FInverseMatrix);
+  FFixedMatrix := FixedMatrix(Matrix);
+
+  TransformValid := True;
+end;
+
+procedure T3x3Transformation.ReverseTransformFixed(DstX, DstY: TFixed; out SrcX,
+  SrcY: TFixed);
+begin
+  SrcX := FixedMul(DstX, FInverseFixedMatrix[0, 0]) +
+    FixedMul(DstY, FInverseFixedMatrix[1, 0]) + FInverseFixedMatrix[2, 0];
+  SrcY := FixedMul(DstX, FInverseFixedMatrix[0, 1]) +
+    FixedMul(DstY, FInverseFixedMatrix[1, 1]) + FInverseFixedMatrix[2, 1];
+end;
+
+procedure T3x3Transformation.ReverseTransformFloat(DstX, DstY: TFloat; out SrcX,
+  SrcY: TFloat);
+begin
+  SrcX := DstX * FInverseMatrix[0, 0] + DstY * FInverseMatrix[1, 0] +
+    FInverseMatrix[2, 0];
+  SrcY := DstX * FInverseMatrix[0, 1] + DstY * FInverseMatrix[1, 1] +
+    FInverseMatrix[2, 1];
+end;
+
+procedure T3x3Transformation.TransformFixed(SrcX, SrcY: TFixed; out DstX,
+  DstY: TFixed);
+begin
+  DstX := FixedMul(SrcX, FFixedMatrix[0, 0]) +
+    FixedMul(SrcY, FFixedMatrix[1, 0]) + FFixedMatrix[2, 0];
+  DstY := FixedMul(SrcX, FFixedMatrix[0, 1]) +
+    FixedMul(SrcY, FFixedMatrix[1, 1]) + FFixedMatrix[2, 1];
+end;
+
+procedure T3x3Transformation.TransformFloat(SrcX, SrcY: TFloat; out DstX,
+  DstY: TFloat);
+begin
+  DstX := SrcX * Matrix[0, 0] + SrcY * Matrix[1, 0] + Matrix[2, 0];
+  DstY := SrcX * Matrix[0, 1] + SrcY * Matrix[1, 1] + Matrix[2, 1];
+end;
+
+
 { TAffineTransformation }
 
+constructor TAffineTransformation.Create;
+begin
+  FStackLevel := 0;
+  FStack := nil;
+  Clear;
+end;
+
 procedure TAffineTransformation.Clear;
 begin
-  Matrix := IdentityMatrix;
-  Changed;
-end;
-
-constructor TAffineTransformation.Create;
-begin
-  Clear;
+  FMatrix := IdentityMatrix;
+  Changed;
+end;
+
+procedure TAffineTransformation.Clear(BaseMatrix: TFloatMatrix);
+begin
+  FMatrix := BaseMatrix;
+  Changed;
 end;
 
@@ -713 +945 @@
 end;
 
-procedure TAffineTransformation.PrepareTransform;
-begin
-  FInverseMatrix := Matrix;
-  Invert(FInverseMatrix);
-
-  // calculate a fixed point (65536) factors
-  FInverseFixedMatrix := FixedMatrix(FInverseMatrix);
-  FFixedMatrix := FixedMatrix(Matrix);
-
-  TransformValid := True;
+procedure TAffineTransformation.Push;
+begin
+  Inc(FStackLevel);
+  ReallocMem(FStack, FStackLevel * SizeOf(TFloatMatrix));
+  Move(FMatrix, FStack^[FStackLevel - 1], SizeOf(TFloatMatrix));
+end;
+
+procedure TAffineTransformation.Pop;
+begin
+  if FStackLevel <= 0 then
+    raise Exception.Create(RStrStackEmpty);
+
+  Move(FStack^[FStackLevel - 1], FMatrix, SizeOf(TFloatMatrix));
+  Dec(FStackLevel);
+  Changed;
 end;
 
@@ -735 +972 @@
   M[0, 0] := C;   M[1, 0] := S;
   M[0, 1] := -S;  M[1, 1] := C;
-  Matrix := Mult(M, Matrix);
+  FMatrix := Mult(M, Matrix);
   Changed;
 end;
@@ -750 +987 @@
   M[0, 0] := C;   M[1, 0] := S;
   M[0, 1] := -S;  M[1, 1] := C;
-  Matrix := Mult(M, Matrix);
+  FMatrix := Mult(M, Matrix);
   if (Cx <> 0) or (Cy <> 0) then Translate(Cx, Cy);
   Changed;
@@ -762 +999 @@
   M[0, 0] := Sx;
   M[1, 1] := Sy;
-  Matrix := Mult(M, Matrix);
+  FMatrix := Mult(M, Matrix);
   Changed;
 end;
@@ -773 +1010 @@
   M[0, 0] := Value;
   M[1, 1] := Value;
-  Matrix := Mult(M, Matrix);
+  FMatrix := Mult(M, Matrix);
   Changed;
 end;
@@ -784 +1021 @@
   M[1, 0] := Fx;
   M[0, 1] := Fy;
-  Matrix := Mult(M, Matrix);
-  Changed;  
-end;
-
-procedure TAffineTransformation.ReverseTransformFloat(
-  DstX, DstY: TFloat;
-  out SrcX, SrcY: TFloat);
-begin
-  SrcX := DstX * FInverseMatrix[0,0] + DstY * FInverseMatrix[1,0] + FInverseMatrix[2,0];
-  SrcY := DstX * FInverseMatrix[0,1] + DstY * FInverseMatrix[1,1] + FInverseMatrix[2,1];
-end;
-
-procedure TAffineTransformation.ReverseTransformFixed(
-  DstX, DstY: TFixed;
-  out SrcX, SrcY: TFixed);
-begin
-  SrcX := FixedMul(DstX, FInverseFixedMatrix[0,0]) + FixedMul(DstY, FInverseFixedMatrix[1,0]) + FInverseFixedMatrix[2,0];
-  SrcY := FixedMul(DstX, FInverseFixedMatrix[0,1]) + FixedMul(DstY, FInverseFixedMatrix[1,1]) + FInverseFixedMatrix[2,1];
-end;
-
-procedure TAffineTransformation.TransformFloat(
-  SrcX, SrcY: TFloat;
-  out DstX, DstY: TFloat);
-begin
-  DstX := SrcX * Matrix[0,0] + SrcY * Matrix[1,0] + Matrix[2,0];
-  DstY := SrcX * Matrix[0,1] + SrcY * Matrix[1,1] + Matrix[2,1];
-end;
-
-procedure TAffineTransformation.TransformFixed(
-  SrcX, SrcY: TFixed;
-  out DstX, DstY: TFixed);
-begin
-  DstX := FixedMul(SrcX, FFixedMatrix[0,0]) + FixedMul(SrcY, FFixedMatrix[1,0]) + FFixedMatrix[2,0];
-  DstY := FixedMul(SrcX, FFixedMatrix[0,1]) + FixedMul(SrcY, FFixedMatrix[1,1]) + FFixedMatrix[2,1];
+  FMatrix := Mult(M, Matrix);
+  Changed;
 end;
 
@@ -825 +1030 @@
 begin
   M := IdentityMatrix;
-  M[2,0] := Dx;
-  M[2,1] := Dy;
-  Matrix := Mult(M, Matrix);
-  Changed;  
+  M[2, 0] := Dx;
+  M[2, 1] := Dy;
+  FMatrix := Mult(M, Matrix);
+
+  Changed;
 end;
 
@@ -836 +1042 @@
 function TProjectiveTransformation.GetTransformedBounds(const ASrcRect: TFloatRect): TFloatRect;
 begin
-  Result.Left   := Min(Min(Wx0, Wx1), Min(Wx2, Wx3));
-  Result.Right  := Max(Max(Wx0, Wx1), Max(Wx2, Wx3));
-  Result.Top    := Min(Min(Wy0, Wy1), Min(Wy2, Wy3));
-  Result.Bottom := Max(Max(Wy0, Wy1), Max(Wy2, Wy3));
+  Result.Left   := Min(Min(FQuadX[0], FQuadX[1]), Min(FQuadX[2], FQuadX[3]));
+  Result.Right  := Max(Max(FQuadX[0], FQuadX[1]), Max(FQuadX[2], FQuadX[3]));
+  Result.Top    := Min(Min(FQuadY[0], FQuadY[1]), Min(FQuadY[2], FQuadY[3]));
+  Result.Bottom := Max(Max(FQuadY[0], FQuadY[1]), Max(FQuadY[2], FQuadY[3]));
+end;
+
+function TProjectiveTransformation.GetX(Index: Integer): TFloat;
+begin
+  Result := FQuadX[Index];
+end;
+
+function TProjectiveTransformation.GetY(Index: Integer): TFloat;
+begin
+  Result := FQuadY[Index];
 end;
 
@@ -848 +1064 @@
   R: TFloatMatrix;
 begin
-  px  := Wx0 - Wx1 + Wx2 - Wx3;
-  py  := Wy0 - Wy1 + Wy2 - Wy3;
+  px  := FQuadX[0] - FQuadX[1] + FQuadX[2] - FQuadX[3];
+  py  := FQuadY[0] - FQuadY[1] + FQuadY[2] - FQuadY[3];
 
   if (px = 0) and (py = 0) then
   begin
     // affine mapping
-    FMatrix[0,0] := Wx1 - Wx0;
-    FMatrix[1,0] := Wx2 - Wx1;
-    FMatrix[2,0] := Wx0;
-
-    FMatrix[0,1] := Wy1 - Wy0;
-    FMatrix[1,1] := Wy2 - Wy1;
-    FMatrix[2,1] := Wy0;
-
-    FMatrix[0,2] := 0;
-    FMatrix[1,2] := 0;
-    FMatrix[2,2] := 1;
+    FMatrix[0, 0] := FQuadX[1] - FQuadX[0];
+    FMatrix[1, 0] := FQuadX[2] - FQuadX[1];
+    FMatrix[2, 0] := FQuadX[0];
+
+    FMatrix[0, 1] := FQuadY[1] - FQuadY[0];
+    FMatrix[1, 1] := FQuadY[2] - FQuadY[1];
+    FMatrix[2, 1] := FQuadY[0];
+
+    FMatrix[0, 2] := 0;
+    FMatrix[1, 2] := 0;
+    FMatrix[2, 2] := 1;
   end
   else
   begin
     // projective mapping
-    dx1 := Wx1 - Wx2;
-    dx2 := Wx3 - Wx2;
-    dy1 := Wy1 - Wy2;
-    dy2 := Wy3 - Wy2;
+    dx1 := FQuadX[1] - FQuadX[2];
+    dx2 := FQuadX[3] - FQuadX[2];
+    dy1 := FQuadY[1] - FQuadY[2];
+    dy2 := FQuadY[3] - FQuadY[2];
     k := dx1 * dy2 - dx2 * dy1;
     if k <> 0 then
@@ -880 +1096 @@
       h := (dx1 * py - dy1 * px) * k;
 
-      FMatrix[0,0] := Wx1 - Wx0 + g * Wx1;
-      FMatrix[1,0] := Wx3 - Wx0 + h * Wx3;
-      FMatrix[2,0] := Wx0;
-
-      FMatrix[0,1] := Wy1 - Wy0 + g * Wy1;
-      FMatrix[1,1] := Wy3 - Wy0 + h * Wy3;
-      FMatrix[2,1] := Wy0;
-
-      FMatrix[0,2] := g;
-      FMatrix[1,2] := h;
-      FMatrix[2,2] := 1;
+      FMatrix[0, 0] := FQuadX[1] - FQuadX[0] + g * FQuadX[1];
+      FMatrix[1, 0] := FQuadX[3] - FQuadX[0] + h * FQuadX[3];
+      FMatrix[2, 0] := FQuadX[0];
+
+      FMatrix[0, 1] := FQuadY[1] - FQuadY[0] + g * FQuadY[1];
+      FMatrix[1, 1] := FQuadY[3] - FQuadY[0] + h * FQuadY[3];
+      FMatrix[2, 1] := FQuadY[0];
+
+      FMatrix[0, 2] := g;
+      FMatrix[1, 2] := h;
+      FMatrix[2, 2] := 1;
     end
     else
@@ -900 +1116 @@
   // denormalize texture space (u, v)
   R := IdentityMatrix;
-  R[0,0] := 1 / (SrcRect.Right - SrcRect.Left);
-  R[1,1] := 1 / (SrcRect.Bottom - SrcRect.Top);
+  R[0, 0] := 1 / (SrcRect.Right - SrcRect.Left);
+  R[1, 1] := 1 / (SrcRect.Bottom - SrcRect.Top);
   FMatrix := Mult(FMatrix, R);
 
   R := IdentityMatrix;
-  R[2,0] := -SrcRect.Left;
-  R[2,1] := -SrcRect.Top;
+  R[2, 0] := -SrcRect.Left;
+  R[2, 1] := -SrcRect.Top;
   FMatrix := Mult(FMatrix, R);
 
-  FInverseMatrix := FMatrix;
-  Invert(FInverseMatrix);
-
-  FInverseFixedMatrix := FixedMatrix(FInverseMatrix);
-  FFixedMatrix := FixedMatrix(FMatrix);
-
-  TransformValid := True;
-end;
-
-procedure TProjectiveTransformation.SetX0(Value: TFloat);
-begin
-  Wx0 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetX1(Value: TFloat);
-begin
-  Wx1 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetX2(Value: TFloat);
-begin
-  Wx2 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetX3(Value: TFloat);
-begin
-  Wx3 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetY0(Value: TFloat);
-begin
-  Wy0 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetY1(Value: TFloat);
-begin
-  Wy1 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetY2(Value: TFloat);
-begin
-  Wy2 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.SetY3(Value: TFloat);
-begin
-  Wy3 := Value;
-  Changed;
-end;
-
-procedure TProjectiveTransformation.ReverseTransformFloat(
-  DstX, DstY: TFloat;
-  out SrcX, SrcY: TFloat);
-var
-  X, Y, Z: TFloat;
-begin
-  EMMS;
-  X := DstX; Y := DstY;
-  Z := FInverseMatrix[0,2] * X + FInverseMatrix[1,2] * Y + FInverseMatrix[2,2];
-
-  if Z = 0 then Exit
-  else if Z = 1 then
-  begin
-    SrcX := FInverseMatrix[0,0] * X + FInverseMatrix[1,0] * Y + FInverseMatrix[2,0];
-    SrcY := FInverseMatrix[0,1] * X + FInverseMatrix[1,1] * Y + FInverseMatrix[2,1];
-  end
-  else
-  begin
-    Z := 1 / Z;
-    SrcX := (FInverseMatrix[0,0] * X + FInverseMatrix[1,0] * Y + FInverseMatrix[2,0]) * Z;
-    SrcY := (FInverseMatrix[0,1] * X + FInverseMatrix[1,1] * Y + FInverseMatrix[2,1]) * Z;
-  end;
+  inherited;
+end;
+
+procedure TProjectiveTransformation.SetX(Index: Integer; const Value: TFloat);
+begin
+  FQuadX[Index] := Value;
+  Changed;
+end;
+
+procedure TProjectiveTransformation.SetY(Index: Integer; const Value: TFloat);
+begin
+  FQuadY[Index] := Value;
+  Changed;
 end;
 
@@ -996 +1146 @@
   Zf: TFloat;
 begin
-  Z := FixedMul(FInverseFixedMatrix[0,2], DstX) +
-       FixedMul(FInverseFixedMatrix[1,2], DstY) +
-       FInverseFixedMatrix[2,2];
+  Z := FixedMul(FInverseFixedMatrix[0, 2], DstX) +
+    FixedMul(FInverseFixedMatrix[1, 2], DstY) + FInverseFixedMatrix[2, 2];
 
   if Z = 0 then Exit;
 
-  SrcX := FixedMul(FInverseFixedMatrix[0,0], DstX) +
-          FixedMul(FInverseFixedMatrix[1,0], DstY) +
-          FInverseFixedMatrix[2,0];
-
-  SrcY := FixedMul(FInverseFixedMatrix[0,1], DstX) +
-          FixedMul(FInverseFixedMatrix[1,1], DstY) +
-          FInverseFixedMatrix[2,1];
+  {$IFDEF UseInlining}
+  SrcX := FixedMul(DstX, FInverseFixedMatrix[0, 0]) +
+    FixedMul(DstY, FInverseFixedMatrix[1, 0]) + FInverseFixedMatrix[2, 0];
+  SrcY := FixedMul(DstX, FInverseFixedMatrix[0,1]) +
+    FixedMul(DstY, FInverseFixedMatrix[1, 1]) + FInverseFixedMatrix[2, 1];
+  {$ELSE}
+  inherited;
+  {$ENDIF}
 
   if Z <> FixedOne then
@@ -1019 +1169 @@
 end;
 
+procedure TProjectiveTransformation.ReverseTransformFloat(
+  DstX, DstY: TFloat;
+  out SrcX, SrcY: TFloat);
+var
+  Z: TFloat;
+begin
+  EMMS;
+  Z := FInverseMatrix[0, 2] * DstX + FInverseMatrix[1, 2] * DstY +
+    FInverseMatrix[2, 2];
+
+  if Z = 0 then Exit;
+
+  {$IFDEF UseInlining}
+  SrcX := DstX * FInverseMatrix[0, 0] + DstY * FInverseMatrix[1, 0] +
+    FInverseMatrix[2, 0];
+  SrcY := DstX * FInverseMatrix[0, 1] + DstY * FInverseMatrix[1, 1] +
+    FInverseMatrix[2, 1];
+  {$ELSE}
+  inherited;
+  {$ENDIF}
+
+  if Z <> 1 then
+  begin
+    Z := 1 / Z;
+    SrcX := SrcX * Z;
+    SrcY := SrcY * Z;
+  end;
+end;
 
 procedure TProjectiveTransformation.TransformFixed(SrcX, SrcY: TFixed;
@@ -1026 +1204 @@
   Zf: TFloat;
 begin
-  Z := FixedMul(FFixedMatrix[0,2], SrcX) +
-       FixedMul(FFixedMatrix[1,2], SrcY) +
-       FFixedMatrix[2,2];
+  Z := FixedMul(FFixedMatrix[0, 2], SrcX) +
+    FixedMul(FFixedMatrix[1, 2], SrcY) + FFixedMatrix[2, 2];
 
   if Z = 0 then Exit;
 
-  DstX := FixedMul(FFixedMatrix[0,0], SrcX) +
-          FixedMul(FFixedMatrix[1,0], SrcY) +
-          FFixedMatrix[2,0];
-
-  DstY := FixedMul(FFixedMatrix[0,1], SrcX) +
-          FixedMul(FFixedMatrix[1,1], SrcY) +
-          FFixedMatrix[2,1];
+  {$IFDEF UseInlining}
+  DstX := FixedMul(SrcX, FFixedMatrix[0, 0]) +
+    FixedMul(SrcY, FFixedMatrix[1, 0]) + FFixedMatrix[2, 0];
+  DstY := FixedMul(SrcX, FFixedMatrix[0, 1]) +
+    FixedMul(SrcY, FFixedMatrix[1, 1]) + FFixedMatrix[2, 1];
+  {$ELSE}
+  inherited;
+  {$ENDIF}
 
   if Z <> FixedOne then
@@ -1052 +1230 @@
   out DstX, DstY: TFloat);
 var
-  X, Y, Z: TFloat;
+  Z: TFloat;
 begin
   EMMS;
-  X := SrcX; Y := SrcY;
-  Z := FMatrix[0,2] * X + FMatrix[1,2] * Y + FMatrix[2,2];
-
-  if Z = 0 then Exit
-  else if Z = 1 then
-  begin
-    DstX := FMatrix[0,0] * X + FMatrix[1,0] * Y + FMatrix[2,0];
-    DstY := FMatrix[0,1] * X + FMatrix[1,1] * Y + FMatrix[2,1];
-  end
-  else
+  Z := FMatrix[0, 2] * SrcX + FMatrix[1, 2] * SrcY + FMatrix[2, 2];
+
+  if Z = 0 then Exit;
+
+  {$IFDEF UseInlining}
+  DstX := SrcX * Matrix[0, 0] + SrcY * Matrix[1, 0] + Matrix[2, 0];
+  DstY := SrcX * Matrix[0, 1] + SrcY * Matrix[1, 1] + Matrix[2, 1];
+  {$ELSE}
+  inherited;
+  {$ENDIF}
+
+  if Z <> 1 then
   begin
     Z := 1 / Z;
-    DstX := (FMatrix[0,0] * X + FMatrix[1,0] * Y + FMatrix[2,0]) * Z;
-    DstY := (FMatrix[0,1] * X + FMatrix[1,1] * Y + FMatrix[2,1]) * Z;
-  end;
-end;
+    DstX := DstX * Z;
+    DstY := DstY * Z;
+  end;
+end;
+
 
 { TTwirlTransformation }
@@ -1148 +1329 @@
   GR32_Math.SinCos(FPiH * DstY, SinY, CosY);
   GR32_Math.SinCos(FPiW * DstX, SinX, CosX);
+  t := FBP * SinY * SinX;
+  SrcX := DstX + t * CosX;
+  SrcY := DstY + t * CosY;
+end;
+
+procedure TBloatTransformation.TransformFloat(DstX, DstY: TFloat;
+  out SrcX, SrcY: TFloat);
+var
+  SinY, CosY, SinX, CosX, t: Single;
+begin
+  GR32_Math.SinCos(-FPiH * DstY, SinY, CosY);
+  GR32_Math.SinCos(-FPiW * DstX, SinX, CosX);
   t := FBP * SinY * SinX;
   SrcX := DstX + t * CosX;
@@ -1580 +1773 @@
   MapPtr: PFixedPointArray;
 begin
-  IntersectRect(DstRect, VectorMap.BoundsRect, DstRect);
-  if IsRectEmpty(DstRect) then Exit;
+  GR32.IntersectRect(DstRect, VectorMap.BoundsRect, DstRect);
+  if GR32.IsRectEmpty(DstRect) then Exit;
 
   if not TTransformationAccess(Transformation).TransformValid then

GraphicTest/Packages/Graphics32/GR32_VectorMaps.pas

@@ -118 +118 @@
 
 uses
-  GR32_Lowlevel, GR32_Blend, GR32_Transforms, GR32_Math, SysUtils;
+  GR32_Lowlevel, GR32_Math, SysUtils;
 
 resourcestring
@@ -249 +249 @@
     {$IFDEF HAS_NATIVEINT}
     Result := CombineVectorsReg(CombineVectorsReg(PFixedPoint(P)^,
-      PFixedPoint(NativeUInt(P) + H)^, WX), CombineVectorsReg(
-      PFixedPoint(NativeUInt(P) + W)^, PFixedPoint(NativeUInt(P) + W + H)^, WX),
-      WY);
+      PFixedPoint(NativeUInt(P) + NativeUInt(H))^, WX), CombineVectorsReg(
+      PFixedPoint(NativeUInt(P) + NativeUInt(W))^,
+      PFixedPoint(NativeUInt(P) + NativeUInt(W + H))^, WX), WY);
     {$ELSE}
     Result := CombineVectorsReg(CombineVectorsReg(PFixedPoint(P)^,
-      PFixedPoint(Cardinal(P) + H)^, WX), CombineVectorsReg(
-      PFixedPoint(Cardinal(P) + W)^, PFixedPoint(Cardinal(P) + W + H)^, WX),
-      WY);
+      PFixedPoint(Cardinal(P) + Cardinal(H))^, WX), CombineVectorsReg(
+      PFixedPoint(Cardinal(P) + Cardinal(W))^,
+      PFixedPoint(Cardinal(P) + Cardinal(W) + Cardinal(H))^, WX), WY);
     {$ENDIF}
   end else
@@ -322 +322 @@
     Reset(MeshFile, 1);
     BlockRead(MeshFile, Header, SizeOf(TPSLiquifyMeshHeader));
-    if Lowercase(String(Header.Ident)) <> Lowercase(MeshIdent) then
+    if LowerCase(string(Header.Ident)) <> LowerCase(MeshIdent) then
       Exception.Create(RCStrBadFormat);
     with Header do
@@ -433 +433 @@
   var
     I: Integer;
+{$IFDEF COMPILERRX1}
+    f: single;
+{$ENDIF}
   begin
     for I := 0 to Length(FVectors) - 1 do
@@ -438 +441 @@
       //Not a mistake! Converting physical mem. directly to avoid temporary floating point buffer
       //Do no change to PFloat.. the type is relative to the msh format.
+
+//Workaround for Delphi 10.1 Internal Error C6949 ...
+{$IFDEF COMPILERRX1}
+      f := FVectors[I].X * FixedToFloat;
+      FVectors[I].X := PInteger(@f)^;
+      f := FVectors[I].Y * FixedToFloat;
+      FVectors[I].Y := PInteger(@f)^;
+{$ELSE}
       PSingle(@FVectors[I].X)^ := FVectors[I].X * FixedToFloat;
       PSingle(@FVectors[I].Y)^ := FVectors[I].Y * FixedToFloat;
+{$ENDIF}
     end;
   end;
@@ -589 +601 @@
       Inc(VectorPtr);
       Inc(Top);
-    until Top = Width * Height;
-
-    TopDone: Top := Top div Width;
+    until Top = Self.Width * Self.Height;
+
+    TopDone: Top := Top div Self.Width;
 
     //Find Bottom
-    Bottom := Width * Height - 1;
+    Bottom := Self.Width * Self.Height - 1;
     VectorPtr := @Vectors[Bottom];
     repeat
@@ -602 +614 @@
     until Bottom < 0;
 
-    BottomDone: Bottom := Bottom div Width - 1;
+    BottomDone: Bottom := Bottom div Self.Width - 1;
 
     //Find Left
@@ -613 +625 @@
       until J >= Bottom;
       Inc(Left)
-    until Left >= Width;
+    until Left >= Self.Width;
 
     LeftDone:
 
     //Find Right
-    Right := Width - 1;
+    Right := Self.Width - 1;
     repeat
       J := Bottom;
@@ -628 +640 @@
     until Right <= Left;
 
-
   end;
   RightDone:
   if IsRectEmpty(Result) then
-    Result := Rect(0,0,0,0);
+    Result := Rect(0, 0, 0, 0);
 end;
 

GraphicTest/Packages/Graphics32/GR32_XPThemes.pas

@@ -229 +229 @@
 constructor TThemeNexus.Create;
 begin
-  FWindowHandle := Classes.AllocateHWnd(WndProc);
+  FWindowHandle := {$IFDEF FPC}Classes.{$ENDIF}AllocateHWnd(WndProc);
   OpenVisualStyles;
 end;
@@ -236 +236 @@
 begin
   CloseVisualStyles;
-  Classes.DeallocateHWnd(FWindowHandle);
+  {$IFDEF FPC}Classes.{$ENDIF}DeallocateHWnd(FWindowHandle);
   inherited;
 end;

GraphicTest/Packages/Graphics32/Packages/GR32_D2005.dpk

@@ -40 +40 @@
   GR32_OrdinalMaps in '..\GR32_OrdinalMaps.pas',
   GR32_VectorMaps in '..\GR32_VectorMaps.pas',
-  GR32_DrawingEx in '..\GR32_DrawingEx.pas',
   GR32_Filters in '..\GR32_Filters.pas',
   GR32_Layers in '..\GR32_Layers.pas',

GraphicTest/Packages/Graphics32/Packages/GR32_D7.dpk

@@ -24 +24 @@
 {$IMAGEBASE $400000}
 {$DESCRIPTION 'Graphics32'}
+{$RUNONLY}
 {$IMPLICITBUILD ON}
 
@@ -41 +42 @@
   GR32_OrdinalMaps in '..\GR32_OrdinalMaps.pas',
   GR32_VectorMaps in '..\GR32_VectorMaps.pas',
-  GR32_DrawingEx in '..\GR32_DrawingEx.pas',
   GR32_Filters in '..\GR32_Filters.pas',
   GR32_Layers in '..\GR32_Layers.pas',
@@ -55 +55 @@
   GR32_Backends_Generic in '..\GR32_Backends_Generic.pas',
   GR32_Backends_VCL in '..\GR32_Backends_VCL.pas',
-  GR32_XPThemes in '..\GR32_XPThemes.pas';
+  GR32_XPThemes in '..\GR32_XPThemes.pas',
+  GR32_VPR in '..\GR32_VPR.pas',
+  GR32_Paths in '..\GR32_Paths.pas',
+  GR32_VectorUtils in '..\GR32_VectorUtils.pas',
+  GR32_Geometry in '..\GR32_Geometry.pas',
+  GR32_Text_VCL in '..\GR32_Text_VCL.pas',
+  GR32_Brushes in '..\GR32_Brushes.pas';
 
 end.

GraphicTest/Packages/Graphics32/Packages/GR32_DSGN_D5.dpk

@@ -1 +1 @@
 package GR32_DSGN_D5;
 
-
-
 {$R *.RES}
-
 {$R '..\GR32_Reg.dcr'}
-
 {$ALIGN ON}
 {$ASSERTIONS ON}

GraphicTest/Packages/Graphics32/Packages/GR32_DSGN_D6.dpk

@@ -1 +1 @@
 package GR32_DSGN_D6;
 
-
-
 {$R *.res}
-
 {$R '..\GR32_Reg.dcr'}
-
 {$ALIGN 8}
-
 {$ASSERTIONS ON}
-
 {$BOOLEVAL OFF}
-
 {$DEBUGINFO ON}
-
 {$EXTENDEDSYNTAX ON}
-
 {$IMPORTEDDATA ON}
-
 {$IOCHECKS ON}
-
 {$LOCALSYMBOLS ON}
-
 {$LONGSTRINGS ON}
-
 {$OPENSTRINGS ON}
-
 {$OPTIMIZATION ON}
-
 {$OVERFLOWCHECKS OFF}
-
 {$RANGECHECKS OFF}
-
 {$REFERENCEINFO ON}
-
 {$SAFEDIVIDE OFF}
-
 {$STACKFRAMES OFF}
-
 {$TYPEDADDRESS OFF}
-
 {$VARSTRINGCHECKS ON}
-
 {$WRITEABLECONST OFF}
-
 {$MINENUMSIZE 1}
-
 {$IMAGEBASE $400000}
-
 {$DESCRIPTION 'Graphics32 Design Time Package'}
-
 {$IMPLICITBUILD ON}
 
-
-
 requires
-
   designide,
-
   vcl,
-
   GR32_D6,
-
   rtl;
-
-
 
 contains
@@ -73 +39 @@
   GR32_Dsgn_Misc in '..\GR32_Dsgn_Misc.pas';
 
-
-
-
 end.
 

GraphicTest/Packages/Graphics32/Packages/GR32_DSGN_D7.dpk

@@ -37 +37 @@
   GR32_Reg in '..\GR32_Reg.pas',
   GR32_Dsgn_Color in '..\GR32_Dsgn_Color.pas',
-  GR32_Dsgn_Misc in '..\GR32_Dsgn_Misc.pas';
+  GR32_Dsgn_Misc in '..\GR32_Dsgn_Misc.pas',
+  GR32_ColorGradients in '..\GR32_ColorGradients.pas',
+  GR32_ColorPicker in '..\GR32_ColorPicker.pas',
+  GR32_ColorSwatch in '..\GR32_ColorSwatch.pas';
 
 end.

GraphicTest/Packages/Graphics32/Packages/GR32_DSGN_RS2007.dpk

@@ -26 +26 @@
 {$DESCRIPTION 'Graphics32 Design Time Package'}
 {$DESIGNONLY}
-{$IMPLICITBUILD OFF}
+{$IMPLICITBUILD ON}
 
 requires

GraphicTest/Packages/Graphics32/Packages/GR32_L.pas

@@ -3 +3 @@
  }
 
-unit GR32_L; 
+unit GR32_L;
 
+{$warn 5023 off : no warning about unused units}
 interface
 
 uses
-  GR32, GR32_Math, GR32_LowLevel, GR32_System, GR32_Containers, GR32_Blend,
+  GR32, GR32_Math, GR32_LowLevel, GR32_System, GR32_Containers, GR32_Blend, 
   GR32_Transforms, GR32_OrdinalMaps, GR32_VectorMaps, GR32_DrawingEx, 
   GR32_Filters, GR32_Layers, GR32_Image, GR32_ExtImage, GR32_RangeBars, 

GraphicTest/Packages/Graphics32/Packages/GR32_RS2006.dpk

@@ -31 +31 @@
 
 contains
-  GR32 in '..\GR32.pas',
-  GR32_Bindings in '..\GR32_Bindings.pas',
-  GR32_Math in '..\GR32_Math.pas',
-  GR32_LowLevel in '..\GR32_LowLevel.pas',
-  GR32_System in '..\GR32_System.pas',
-  GR32_Containers in '..\GR32_Containers.pas',
-  GR32_Blend in '..\GR32_Blend.pas',
-  GR32_Transforms in '..\GR32_Transforms.pas',
-  GR32_OrdinalMaps in '..\GR32_OrdinalMaps.pas',
-  GR32_VectorMaps in '..\GR32_VectorMaps.pas',
-  GR32_DrawingEx in '..\GR32_DrawingEx.pas',
-  GR32_Filters in '..\GR32_Filters.pas',
-  GR32_Layers in '..\GR32_Layers.pas',
-  GR32_Image in '..\GR32_Image.pas',
-  GR32_ExtImage in '..\GR32_ExtImage.pas',
-  GR32_RangeBars in '..\GR32_RangeBars.pas',
-  GR32_Polygons in '..\GR32_Polygons.pas',
-  GR32_RepaintOpt in '..\GR32_RepaintOpt.pas',
-  GR32_MicroTiles in '..\GR32_MicroTiles.pas',
-  GR32_Rasterizers in '..\GR32_Rasterizers.pas',
-  GR32_Resamplers in '..\GR32_Resamplers.pas',
-  GR32_Backends in '..\GR32_Backends.pas',
-  GR32_Backends_Generic in '..\GR32_Backends_Generic.pas',
-  GR32_Backends_VCL in '..\GR32_Backends_VCL.pas',
-  GR32_XPThemes in '..\GR32_XPThemes.pas';
+  GR32 in '..\..\GR32.pas',
+  GR32_Backends in '..\..\GR32_Backends.pas',
+  GR32_Backends_Generic in '..\..\GR32_Backends_Generic.pas',
+  GR32_Backends_VCL in '..\..\GR32_Backends_VCL.pas',
+  GR32_Bindings in '..\..\GR32_Bindings.pas',
+  GR32_Blend in '..\..\GR32_Blend.pas',
+  GR32_BlendASM in '..\..\GR32_BlendASM.pas',
+  GR32_BlendMMX in '..\..\GR32_BlendMMX.pas',
+  GR32_BlendSSE2 in '..\..\GR32_BlendSSE2.pas',
+  GR32_Brushes in '..\..\GR32_Brushes.pas',
+  GR32_ColorGradients in '..\..\GR32_ColorGradients.pas',
+  GR32_ColorPicker in '..\..\GR32_ColorPicker.pas',
+  GR32_ColorSwatch in '..\..\GR32_ColorSwatch.pas',
+  GR32_Containers in '..\..\GR32_Containers.pas',
+  GR32_ExtImage in '..\..\GR32_ExtImage.pas',
+  GR32_Filters in '..\..\GR32_Filters.pas',
+  GR32_Gamma in '..\..\GR32_Gamma.pas',
+  GR32_Geometry in '..\..\GR32_Geometry.pas',
+  GR32_Image in '..\..\GR32_Image.pas',
+  GR32_Layers in '..\..\GR32_Layers.pas',
+  GR32_LowLevel in '..\..\GR32_LowLevel.pas',
+  GR32_Math in '..\..\GR32_Math.pas',
+  GR32_MicroTiles in '..\..\GR32_MicroTiles.pas',
+  GR32_OrdinalMaps in '..\..\GR32_OrdinalMaps.pas',
+  GR32_Paths in '..\..\GR32_Paths.pas',
+  GR32_Polygons in '..\..\GR32_Polygons.pas',
+  GR32_PolygonsAggLite in '..\..\GR32_PolygonsAggLite.pas',
+  GR32_RangeBars in '..\..\GR32_RangeBars.pas',
+  GR32_Rasterizers in '..\..\GR32_Rasterizers.pas',
+  GR32_RepaintOpt in '..\..\GR32_RepaintOpt.pas',
+  GR32_Resamplers in '..\..\GR32_Resamplers.pas',
+  GR32_System in '..\..\GR32_System.pas',
+  GR32_Transforms in '..\..\GR32_Transforms.pas',
+  GR32_VectorMaps in '..\..\GR32_VectorMaps.pas',
+  GR32_VectorUtils in '..\..\GR32_VectorUtils.pas',
+  GR32_VPR in '..\..\GR32_VPR.pas',
+  GR32_Text_VCL in '..\..\GR32_Text_VCL.pas',
+  GR32_XPThemes in '..\..\GR32_XPThemes.pas';
 
 end.

GraphicTest/Packages/Graphics32/Packages/GR32_RS2007.dpk

@@ -25 +25 @@
 {$DESCRIPTION 'Graphics32'}
 {$RUNONLY}
-{$IMPLICITBUILD OFF}
+{$IMPLICITBUILD ON}
 
 requires
@@ -31 +31 @@
 
 contains
-  GR32 in '..\GR32.pas',
-  GR32_Bindings in '..\GR32_Bindings.pas',
-  GR32_Math in '..\GR32_Math.pas',
-  GR32_Backends in '..\GR32_Backends.pas',
-  GR32_Backends_Generic in '..\GR32_Backends_Generic.pas',
-  GR32_Backends_VCL in '..\GR32_Backends_VCL.pas',
-  GR32_LowLevel in '..\GR32_LowLevel.pas',
-  GR32_System in '..\GR32_System.pas',
-  GR32_Containers in '..\GR32_Containers.pas',
-  GR32_Blend in '..\GR32_Blend.pas',
-  GR32_Transforms in '..\GR32_Transforms.pas',
-  GR32_OrdinalMaps in '..\GR32_OrdinalMaps.pas',
-  GR32_VectorMaps in '..\GR32_VectorMaps.pas',
-  GR32_DrawingEx in '..\GR32_DrawingEx.pas',
-  GR32_Filters in '..\GR32_Filters.pas',
-  GR32_Layers in '..\GR32_Layers.pas',
-  GR32_Image in '..\GR32_Image.pas',
-  GR32_ExtImage in '..\GR32_ExtImage.pas',
-  GR32_RangeBars in '..\GR32_RangeBars.pas',
-  GR32_Polygons in '..\GR32_Polygons.pas',
-  GR32_RepaintOpt in '..\GR32_RepaintOpt.pas',
-  GR32_MicroTiles in '..\GR32_MicroTiles.pas',
-  GR32_Rasterizers in '..\GR32_Rasterizers.pas',
-  GR32_Resamplers in '..\GR32_Resamplers.pas',
-  GR32_XPThemes in '..\GR32_XPThemes.pas';
+  GR32 in '..\..\GR32.pas',
+  GR32_Backends in '..\..\GR32_Backends.pas',
+  GR32_Backends_Generic in '..\..\GR32_Backends_Generic.pas',
+  GR32_Backends_VCL in '..\..\GR32_Backends_VCL.pas',
+  GR32_Bindings in '..\..\GR32_Bindings.pas',
+  GR32_Blend in '..\..\GR32_Blend.pas',
+  GR32_BlendASM in '..\..\GR32_BlendASM.pas',
+  GR32_BlendMMX in '..\..\GR32_BlendMMX.pas',
+  GR32_BlendSSE2 in '..\..\GR32_BlendSSE2.pas',
+  GR32_Brushes in '..\..\GR32_Brushes.pas',
+  GR32_ColorGradients in '..\..\GR32_ColorGradients.pas',
+  GR32_ColorPicker in '..\..\GR32_ColorPicker.pas',
+  GR32_ColorSwatch in '..\..\GR32_ColorSwatch.pas',
+  GR32_Containers in '..\..\GR32_Containers.pas',
+  GR32_ExtImage in '..\..\GR32_ExtImage.pas',
+  GR32_Filters in '..\..\GR32_Filters.pas',
+  GR32_Gamma in '..\..\GR32_Gamma.pas',
+  GR32_Geometry in '..\..\GR32_Geometry.pas',
+  GR32_Image in '..\..\GR32_Image.pas',
+  GR32_Layers in '..\..\GR32_Layers.pas',
+  GR32_LowLevel in '..\..\GR32_LowLevel.pas',
+  GR32_Math in '..\..\GR32_Math.pas',
+  GR32_MicroTiles in '..\..\GR32_MicroTiles.pas',
+  GR32_OrdinalMaps in '..\..\GR32_OrdinalMaps.pas',
+  GR32_Paths in '..\..\GR32_Paths.pas',
+  GR32_Polygons in '..\..\GR32_Polygons.pas',
+  GR32_PolygonsAggLite in '..\..\GR32_PolygonsAggLite.pas',
+  GR32_RangeBars in '..\..\GR32_RangeBars.pas',
+  GR32_Rasterizers in '..\..\GR32_Rasterizers.pas',
+  GR32_RepaintOpt in '..\..\GR32_RepaintOpt.pas',
+  GR32_Resamplers in '..\..\GR32_Resamplers.pas',
+  GR32_System in '..\..\GR32_System.pas',
+  GR32_Transforms in '..\..\GR32_Transforms.pas',
+  GR32_VectorMaps in '..\..\GR32_VectorMaps.pas',
+  GR32_VectorUtils in '..\..\GR32_VectorUtils.pas',
+  GR32_VPR in '..\..\GR32_VPR.pas',
+  GR32_Text_VCL in '..\..\GR32_Text_VCL.pas',
+  GR32_XPThemes in '..\..\GR32_XPThemes.pas';
 
 end.

GraphicTest/Packages/Graphics32/Packages/GR32_RS2009.dpk

@@ -25 +25 @@
 {$DESCRIPTION 'Graphics32'}
 {$RUNONLY}
-{$IMPLICITBUILD OFF}
+{$IMPLICITBUILD ON}
 
 requires
@@ -31 +31 @@
 
 contains
-  GR32 in '..\GR32.pas',
-  GR32_Bindings in '..\GR32_Bindings.pas',  
-  GR32_Math in '..\GR32_Math.pas',
-  GR32_Backends in '..\GR32_Backends.pas',
-  GR32_Backends_Generic in '..\GR32_Backends_Generic.pas',
-  GR32_Backends_VCL in '..\GR32_Backends_VCL.pas',
-  GR32_LowLevel in '..\GR32_LowLevel.pas',
-  GR32_System in '..\GR32_System.pas',
-  GR32_Containers in '..\GR32_Containers.pas',
-  GR32_Blend in '..\GR32_Blend.pas',
-  GR32_Transforms in '..\GR32_Transforms.pas',
-  GR32_OrdinalMaps in '..\GR32_OrdinalMaps.pas',
-  GR32_VectorMaps in '..\GR32_VectorMaps.pas',
-  GR32_DrawingEx in '..\GR32_DrawingEx.pas',
-  GR32_Filters in '..\GR32_Filters.pas',
-  GR32_Layers in '..\GR32_Layers.pas',
-  GR32_Image in '..\GR32_Image.pas',
-  GR32_ExtImage in '..\GR32_ExtImage.pas',
-  GR32_RangeBars in '..\GR32_RangeBars.pas',
-  GR32_Polygons in '..\GR32_Polygons.pas',
-  GR32_RepaintOpt in '..\GR32_RepaintOpt.pas',
-  GR32_MicroTiles in '..\GR32_MicroTiles.pas',
-  GR32_Rasterizers in '..\GR32_Rasterizers.pas',
-  GR32_Resamplers in '..\GR32_Resamplers.pas',
-  GR32_XPThemes in '..\GR32_XPThemes.pas';
+  GR32 in '..\..\GR32.pas',
+  GR32_Backends in '..\..\GR32_Backends.pas',
+  GR32_Backends_Generic in '..\..\GR32_Backends_Generic.pas',
+  GR32_Backends_VCL in '..\..\GR32_Backends_VCL.pas',
+  GR32_Bindings in '..\..\GR32_Bindings.pas',
+  GR32_Blend in '..\..\GR32_Blend.pas',
+  GR32_BlendASM in '..\..\GR32_BlendASM.pas',
+  GR32_BlendMMX in '..\..\GR32_BlendMMX.pas',
+  GR32_BlendSSE2 in '..\..\GR32_BlendSSE2.pas',
+  GR32_Brushes in '..\..\GR32_Brushes.pas',
+  GR32_ColorGradients in '..\..\GR32_ColorGradients.pas',
+  GR32_ColorPicker in '..\..\GR32_ColorPicker.pas',
+  GR32_ColorSwatch in '..\..\GR32_ColorSwatch.pas',
+  GR32_Containers in '..\..\GR32_Containers.pas',
+  GR32_ExtImage in '..\..\GR32_ExtImage.pas',
+  GR32_Filters in '..\..\GR32_Filters.pas',
+  GR32_Gamma in '..\..\GR32_Gamma.pas',
+  GR32_Geometry in '..\..\GR32_Geometry.pas',
+  GR32_Image in '..\..\GR32_Image.pas',
+  GR32_Layers in '..\..\GR32_Layers.pas',
+  GR32_LowLevel in '..\..\GR32_LowLevel.pas',
+  GR32_Math in '..\..\GR32_Math.pas',
+  GR32_MicroTiles in '..\..\GR32_MicroTiles.pas',
+  GR32_OrdinalMaps in '..\..\GR32_OrdinalMaps.pas',
+  GR32_Paths in '..\..\GR32_Paths.pas',
+  GR32_Polygons in '..\..\GR32_Polygons.pas',
+  GR32_PolygonsAggLite in '..\..\GR32_PolygonsAggLite.pas',
+  GR32_RangeBars in '..\..\GR32_RangeBars.pas',
+  GR32_Rasterizers in '..\..\GR32_Rasterizers.pas',
+  GR32_RepaintOpt in '..\..\GR32_RepaintOpt.pas',
+  GR32_Resamplers in '..\..\GR32_Resamplers.pas',
+  GR32_System in '..\..\GR32_System.pas',
+  GR32_Transforms in '..\..\GR32_Transforms.pas',
+  GR32_VectorMaps in '..\..\GR32_VectorMaps.pas',
+  GR32_VectorUtils in '..\..\GR32_VectorUtils.pas',
+  GR32_VPR in '..\..\GR32_VPR.pas',
+  GR32_Text_VCL in '..\..\GR32_Text_VCL.pas',
+  GR32_XPThemes in '..\..\GR32_XPThemes.pas';
 
 end.