Changeset 494 for GraphicTest/Packages/bgrabitmap/bgragradientscanner.pas

Timestamp:

Dec 22, 2016, 8:49:19 PM (7 years ago)

Author:

chronos

Message:

• Modified: Updated BGRABitmap package.

File:

• GraphicTest/Packages/bgrabitmap/bgragradientscanner.pas (modified) (42 diffs)

GraphicTest/Packages/bgrabitmap/bgragradientscanner.pas

@@ -16 +16 @@
   private
     FColor1,FColor2: TBGRAPixel;
+    ec1,ec2: TExpandedPixel;
   public
     constructor Create(Color1,Color2: TBGRAPixel);
     function GetColorAt(position: integer): TBGRAPixel; override;
     function GetColorAtF(position: single): TBGRAPixel; override;
+    function GetExpandedColorAt(position: integer): TExpandedPixel; override;
+    function GetExpandedColorAtF(position: single): TExpandedPixel; override;
     function GetAverageColor: TBGRAPixel; override;
     function GetMonochrome: boolean; override;
@@ -35 +38 @@
     function GetColorAtF(position: single): TBGRAPixel; override;
     function GetAverageColor: TBGRAPixel; override;
+    function GetExpandedColorAt(position: integer): TExpandedPixel; override;
+    function GetExpandedColorAtF(position: single): TExpandedPixel; override;
+    function GetAverageExpandedColor: TExpandedPixel; override;
     function GetMonochrome: boolean; override;
   end;
@@ -46 +52 @@
   private
     FColor1,FColor2: TBGRAPixel;
+    ec1,ec2: TExpandedPixel;
     hsla1,hsla2: THSLAPixel;
     hue1,hue2: longword;
     FOptions: THueGradientOptions;
     procedure Init(c1,c2: THSLAPixel; AOptions: THueGradientOptions);
+    function GetColorNoBoundCheck(position: integer): THSLAPixel;
   public
     constructor Create(Color1,Color2: TBGRAPixel; options: THueGradientOptions); overload;
@@ -57 +65 @@
     function GetColorAtF(position: single): TBGRAPixel; override;
     function GetAverageColor: TBGRAPixel; override;
+    function GetExpandedColorAt(position: integer): TExpandedPixel; override;
+    function GetExpandedColorAtF(position: single): TExpandedPixel; override;
+    function GetAverageExpandedColor: TExpandedPixel; override;
     function GetMonochrome: boolean; override;
   end;
+
+  TGradientInterpolationFunction = function(t: single): single of object;
 
   { TBGRAMultiGradient }
@@ -69 +82 @@
     FEColors: array of TExpandedPixel;
     FCycle: Boolean;
+    FInterpolationFunction: TGradientInterpolationFunction;
     procedure Init(Colors: array of TBGRAPixel; Positions0To1: array of single; AGammaCorrection, ACycle: boolean);
   public
     GammaCorrection: boolean;
+    function CosineInterpolation(t: single): single;
+    function HalfCosineInterpolation(t: single): single;
     constructor Create(Colors: array of TBGRAPixel; Positions0To1: array of single; AGammaCorrection: boolean; ACycle: boolean = false);
     function GetColorAt(position: integer): TBGRAPixel; override;
+    function GetExpandedColorAt(position: integer): TExpandedPixel; override;
     function GetAverageColor: TBGRAPixel; override;
     function GetMonochrome: boolean; override;
+    property InterpolationFunction: TGradientInterpolationFunction read FInterpolationFunction write FInterpolationFunction;
   end;
 
@@ -88 +106 @@
     len,aFactor,aFactorF: single;
     mergedColor: TBGRAPixel;
+    mergedExpandedColor: TExpandedPixel;
     FGradient: TBGRACustomGradient;
     FGradientOwner: boolean;
     FHorizColor: TBGRAPixel;
+    FHorizExpandedColor: TExpandedPixel;
     FVertical: boolean;
     FDotProduct,FDotProductPerp: Single;
@@ -96 +116 @@
     procedure InitScanInline(x,y: integer);
     function ScanNextInline: TBGRAPixel; inline;
+    function ScanNextExpandedInline: TExpandedPixel; inline;
   public
     constructor Create(c1, c2: TBGRAPixel; gtype: TGradientType; o1, o2: TPointF;
@@ -103 +124 @@
     procedure ScanMoveTo(X, Y: Integer); override;
     function ScanNextPixel: TBGRAPixel; override;
+    function ScanNextExpandedPixel: TExpandedPixel; override;
     function ScanAt(X, Y: Single): TBGRAPixel; override;
+    function ScanAtExpanded(X, Y: Single): TExpandedPixel; override;
     procedure ScanPutPixels(pdest: PBGRAPixel; count: integer; mode: TDrawMode); override;
     function IsScanPutPixelsDefined: boolean; override;
@@ -140 +163 @@
     function ScanAt(X,Y: Single): TBGRAPixel; override;
     function ScanNextPixel: TBGRAPixel; override;
+    function ScanNextExpandedPixel: TExpandedPixel; override;
   end;
 
@@ -151 +175 @@
     FScanNext : TScanNextPixelFunction;
     FScanAt : TScanAtFunction;
+    FMemMask: packed array of TBGRAPixel;
   public
     constructor Create(AMask: TBGRACustomBitmap; AOffset: TPoint; ASolidColor: TBGRAPixel);
@@ -172 +197 @@
     FMaskScanAt,FTextureScanAt : TScanAtFunction;
     FGlobalOpacity: Byte;
+    FMemMask, FMemTex: packed array of TBGRAPixel;
   public
     constructor Create(AMask: TBGRACustomBitmap; AOffset: TPoint; ATexture: IBGRAScanner; AGlobalOpacity: Byte = 255);
@@ -190 +216 @@
       FScanNext : TScanNextPixelFunction;
       FScanAt : TScanAtFunction;
+      FMemTex: packed array of TBGRAPixel;
   public
     constructor Create(ATexture: IBGRAScanner; AGlobalOpacity: Byte = 255);
@@ -202 +229 @@
 implementation
 
-uses BGRABlend;
+uses BGRABlend, Math;
 
 { TBGRAConstantScanner }
@@ -247 +274 @@
   FColor1 := HSLAToBGRA(c1);
   FColor2 := HSLAToBGRA(c2);
+  ec1 := GammaExpansion(FColor1);
+  ec2 := GammaExpansion(FColor2);
   FOptions:= AOptions;
   if (hgoLightnessCorrection in AOptions) then
@@ -276 +305 @@
 end;
 
+function TBGRAHueGradient.GetColorNoBoundCheck(position: integer): THSLAPixel;
+var b,b2: LongWord;
+begin
+  b      := position shr 2;
+  b2     := 16384-b;
+  result.hue := ((hue1 * b2 + hue2 * b + 8191) shr 14) and $ffff;
+  result.saturation := (hsla1.saturation * b2 + hsla2.saturation * b + 8191) shr 14;
+  result.lightness := (hsla1.lightness * b2 + hsla2.lightness * b + 8191) shr 14;
+  result.alpha := (hsla1.alpha * b2 + hsla2.alpha * b + 8191) shr 14;
+  if hgoLightnessCorrection in FOptions then
+  begin
+    if not (hgoHueCorrection in FOptions) then
+      result.hue := HtoG(result.hue);
+  end else
+  begin
+    if hgoHueCorrection in FOptions then
+      result.hue := GtoH(result.hue);
+  end;
+end;
+
 constructor TBGRAHueGradient.Create(Color1, Color2: TBGRAPixel;options: THueGradientOptions);
 begin
@@ -293 +342 @@
 
 function TBGRAHueGradient.GetColorAt(position: integer): TBGRAPixel;
-var b,b2: cardinal;
-    interm: THSLAPixel;
+var interm: THSLAPixel;
 begin
   if hgoRepeat in FOptions then
@@ -317 +365 @@
     end;
   end;
-  b      := position shr 2;
-  b2     := 16384-b;
-  interm.hue := ((hue1 * b2 + hue2 * b + 8191) shr 14) and $ffff;
-  interm.saturation := (hsla1.saturation * b2 + hsla2.saturation * b + 8191) shr 14;
-  interm.lightness := (hsla1.lightness * b2 + hsla2.lightness * b + 8191) shr 14;
-  interm.alpha := (hsla1.alpha * b2 + hsla2.alpha * b + 8191) shr 14;
+  interm := GetColorNoBoundCheck(position);
   if hgoLightnessCorrection in FOptions then
-  begin
-    if not (hgoHueCorrection in FOptions) then
-      interm.hue := HtoG(interm.hue);
-    result := GSBAToBGRA(interm);
-  end else
-  begin
-    if hgoHueCorrection in FOptions then
-      interm.hue := GtoH(interm.hue);
+    result := GSBAToBGRA(interm)
+  else
     result := HSLAToBGRA(interm);
-  end;
 end;
 
 function TBGRAHueGradient.GetColorAtF(position: single): TBGRAPixel;
-var b,b2: cardinal;
-    interm: THSLAPixel;
+var interm: THSLAPixel;
 begin
   if hgoRepeat in FOptions then
@@ -361 +396 @@
     end;
   end;
-  b      := round(position*16384);
-  b2     := 16384-b;
-  interm.hue := ((hue1 * b2 + hue2 * b + 8191) shr 14) and $ffff;
-  interm.saturation := (hsla1.saturation * b2 + hsla2.saturation * b + 8191) shr 14;
-  interm.lightness := (hsla1.lightness * b2 + hsla2.lightness * b + 8191) shr 14;
-  interm.alpha := (hsla1.alpha * b2 + hsla2.alpha * b + 8191) shr 14;
+  interm := GetColorNoBoundCheck(round(position*65536));
   if hgoLightnessCorrection in FOptions then
-  begin
-    if not (hgoHueCorrection in FOptions) then
-      interm.hue := HtoG(interm.hue);
-    result := GSBAToBGRA(interm);
-  end else
-  begin
-    if hgoHueCorrection in FOptions then
-      interm.hue := GtoH(interm.hue);
+    result := GSBAToBGRA(interm)
+  else
     result := HSLAToBGRA(interm);
-  end;
 end;
 
@@ -383 +406 @@
 begin
   Result:= GetColorAt(32768);
+end;
+
+function TBGRAHueGradient.GetExpandedColorAt(position: integer): TExpandedPixel;
+var interm: THSLAPixel;
+begin
+  if hgoRepeat in FOptions then
+  begin
+    position := position and $ffff;
+    if position = 0 then
+    begin
+      result := ec1;
+      exit;
+    end;
+  end else
+  begin
+    if position <= 0 then
+    begin
+      result := ec1;
+      exit
+    end else
+    if position >= 65536 then
+    begin
+      result := ec2;
+      exit
+    end;
+  end;
+  interm := GetColorNoBoundCheck(position);
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToExpanded(interm)
+  else
+    result := HSLAToExpanded(interm);
+end;
+
+function TBGRAHueGradient.GetExpandedColorAtF(position: single): TExpandedPixel;
+var interm: THSLAPixel;
+begin
+  if hgoRepeat in FOptions then
+  begin
+    position := frac(position);
+    if position = 0 then
+    begin
+      result := ec1;
+      exit;
+    end;
+  end else
+  begin
+    if position <= 0 then
+    begin
+      result := ec1;
+      exit;
+    end else
+    if position >= 1 then
+    begin
+      result := ec2;
+      exit
+    end;
+  end;
+  interm := GetColorNoBoundCheck(round(position*65536));
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToExpanded(interm)
+  else
+    result := HSLAToExpanded(interm);
+end;
+
+function TBGRAHueGradient.GetAverageExpandedColor: TExpandedPixel;
+begin
+  Result:= GetExpandedColorAt(32768);
 end;
 
@@ -417 +507 @@
 end;
 
+function TBGRAMultiGradient.CosineInterpolation(t: single): single;
+begin
+  result := (1-cos(t*Pi))*0.5;
+end;
+
+function TBGRAMultiGradient.HalfCosineInterpolation(t: single): single;
+begin
+  result := (1-cos(t*Pi))*0.25 + t*0.5;
+end;
+
 constructor TBGRAMultiGradient.Create(Colors: array of TBGRAPixel;
   Positions0To1: array of single; AGammaCorrection: boolean; ACycle: boolean);
@@ -424 +524 @@
 
 function TBGRAMultiGradient.GetColorAt(position: integer): TBGRAPixel;
-var i: integer;
+var i: NativeInt;
     ec: TExpandedPixel;
+    curPos,posDiff: NativeInt;
 begin
   if FCycle then
@@ -435 +536 @@
   begin
     i := 0;
-    while (i < high(FPositions)) and (position > FPositions[i+1]) do
+    while (i < high(FPositions)-1) and (position >= FPositions[i+1]) do
       inc(i);
 
-    if Position = FPositions[i+1] then
-      result := FColors[i+1]
+    if Position = FPositions[i] then
+      result := FColors[i]
     else
-    if GammaCorrection then
-    begin
-      ec.red := FEColors[i].red + (position-FPositions[i])*(FEColors[i+1].red-FEColors[i].red) div (FPositions[i+1]-FPositions[i]);
-      ec.green := FEColors[i].green + (position-FPositions[i])*(FEColors[i+1].green-FEColors[i].green) div (FPositions[i+1]-FPositions[i]);
-      ec.blue := FEColors[i].blue + (position-FPositions[i])*(FEColors[i+1].blue-FEColors[i].blue) div (FPositions[i+1]-FPositions[i]);
-      ec.alpha := FEColors[i].alpha + (position-FPositions[i])*(FEColors[i+1].alpha-FEColors[i].alpha) div (FPositions[i+1]-FPositions[i]);
-      result := GammaCompression(ec);
-    end else
-    begin
-      result.red := FColors[i].red + (position-FPositions[i])*(FColors[i+1].red-FColors[i].red) div (FPositions[i+1]-FPositions[i]);
-      result.green := FColors[i].green + (position-FPositions[i])*(FColors[i+1].green-FColors[i].green) div (FPositions[i+1]-FPositions[i]);
-      result.blue := FColors[i].blue + (position-FPositions[i])*(FColors[i+1].blue-FColors[i].blue) div (FPositions[i+1]-FPositions[i]);
-      result.alpha := FColors[i].alpha + (position-FPositions[i])*(FColors[i+1].alpha-FColors[i].alpha) div (FPositions[i+1]-FPositions[i]);
+    begin
+      curPos := position-FPositions[i];
+      posDiff := FPositions[i+1]-FPositions[i];
+      if FInterpolationFunction <> nil then
+      begin
+        curPos := round(FInterpolationFunction(curPos/posDiff)*65536);
+        posDiff := 65536;
+      end;
+      if GammaCorrection then
+      begin
+        if FEColors[i+1].red < FEColors[i].red then
+          ec.red := FEColors[i].red - NativeUInt(curPos)*NativeUInt(FEColors[i].red-FEColors[i+1].red) div NativeUInt(posDiff) else
+          ec.red := FEColors[i].red + NativeUInt(curPos)*NativeUInt(FEColors[i+1].red-FEColors[i].red) div NativeUInt(posDiff);
+        if FEColors[i+1].green < FEColors[i].green then
+          ec.green := FEColors[i].green - NativeUInt(curPos)*NativeUInt(FEColors[i].green-FEColors[i+1].green) div NativeUInt(posDiff) else
+          ec.green := FEColors[i].green + NativeUInt(curPos)*NativeUInt(FEColors[i+1].green-FEColors[i].green) div NativeUInt(posDiff);
+        if FEColors[i+1].blue < FEColors[i].blue then
+          ec.blue := FEColors[i].blue - NativeUInt(curPos)*NativeUInt(FEColors[i].blue-FEColors[i+1].blue) div NativeUInt(posDiff) else
+          ec.blue := FEColors[i].blue + NativeUInt(curPos)*NativeUInt(FEColors[i+1].blue-FEColors[i].blue) div NativeUInt(posDiff);
+        if FEColors[i+1].alpha < FEColors[i].alpha then
+          ec.alpha := FEColors[i].alpha - NativeUInt(curPos)*NativeUInt(FEColors[i].alpha-FEColors[i+1].alpha) div NativeUInt(posDiff) else
+          ec.alpha := FEColors[i].alpha + NativeUInt(curPos)*NativeUInt(FEColors[i+1].alpha-FEColors[i].alpha) div NativeUInt(posDiff);
+        result := GammaCompression(ec);
+      end else
+      begin
+        result.red := FColors[i].red + (curPos)*(FColors[i+1].red-FColors[i].red) div (posDiff);
+        result.green := FColors[i].green + (curPos)*(FColors[i+1].green-FColors[i].green) div (posDiff);
+        result.blue := FColors[i].blue + (curPos)*(FColors[i+1].blue-FColors[i].blue) div (posDiff);
+        result.alpha := FColors[i].alpha + (curPos)*(FColors[i+1].alpha-FColors[i].alpha) div (posDiff);
+      end;
+    end;
+  end;
+end;
+
+function TBGRAMultiGradient.GetExpandedColorAt(position: integer
+  ): TExpandedPixel;
+var i: NativeInt;
+    curPos,posDiff: NativeInt;
+    rw,gw,bw: NativeUInt;
+begin
+  if FCycle then
+    position := (position-FPositions[0]) mod (FPositions[high(FPositions)] - FPositions[0]) + FPositions[0];
+  if position <= FPositions[0] then
+    result := FEColors[0] else
+  if position >= FPositions[high(FPositions)] then
+    result := FEColors[high(FColors)] else
+  begin
+    i := 0;
+    while (i < high(FPositions)-1) and (position >= FPositions[i+1]) do
+      inc(i);
+
+    if Position = FPositions[i] then
+      result := FEColors[i]
+    else
+    begin
+      curPos := position-FPositions[i];
+      posDiff := FPositions[i+1]-FPositions[i];
+      if FInterpolationFunction <> nil then
+      begin
+        curPos := round(FInterpolationFunction(curPos/posDiff)*65536);
+        posDiff := 65536;
+      end;
+      if GammaCorrection then
+      begin
+        if FEColors[i+1].red < FEColors[i].red then
+          result.red := FEColors[i].red - NativeUInt(curPos)*NativeUInt(FEColors[i].red-FEColors[i+1].red) div NativeUInt(posDiff) else
+          result.red := FEColors[i].red + NativeUInt(curPos)*NativeUInt(FEColors[i+1].red-FEColors[i].red) div NativeUInt(posDiff);
+        if FEColors[i+1].green < FEColors[i].green then
+          result.green := FEColors[i].green - NativeUInt(curPos)*NativeUInt(FEColors[i].green-FEColors[i+1].green) div NativeUInt(posDiff) else
+          result.green := FEColors[i].green + NativeUInt(curPos)*NativeUInt(FEColors[i+1].green-FEColors[i].green) div NativeUInt(posDiff);
+        if FEColors[i+1].blue < FEColors[i].blue then
+          result.blue := FEColors[i].blue - NativeUInt(curPos)*NativeUInt(FEColors[i].blue-FEColors[i+1].blue) div NativeUInt(posDiff) else
+          result.blue := FEColors[i].blue + NativeUInt(curPos)*NativeUInt(FEColors[i+1].blue-FEColors[i].blue) div NativeUInt(posDiff);
+        if FEColors[i+1].alpha < FEColors[i].alpha then
+          result.alpha := FEColors[i].alpha - NativeUInt(curPos)*NativeUInt(FEColors[i].alpha-FEColors[i+1].alpha) div NativeUInt(posDiff) else
+          result.alpha := FEColors[i].alpha + NativeUInt(curPos)*NativeUInt(FEColors[i+1].alpha-FEColors[i].alpha) div NativeUInt(posDiff);
+      end else
+      begin
+        rw := NativeInt(FColors[i].red shl 8) + (((curPos) shl 8)*(FColors[i+1].red-FColors[i].red)) div (posDiff);
+        gw := NativeInt(FColors[i].green shl 8) + (((curPos) shl 8)*(FColors[i+1].green-FColors[i].green)) div (posDiff);
+        bw := NativeInt(FColors[i].blue shl 8) + (((curPos) shl 8)*(FColors[i+1].blue-FColors[i].blue)) div (posDiff);
+
+        if rw >= $ff00 then result.red := $ffff
+        else result.red := (GammaExpansionTab[rw shr 8]*NativeUInt(255 - (rw and 255)) + GammaExpansionTab[(rw shr 8)+1]*NativeUInt(rw and 255)) shr 8;
+        if gw >= $ff00 then result.green := $ffff
+        else result.green := (GammaExpansionTab[gw shr 8]*NativeUInt(255 - (gw and 255)) + GammaExpansionTab[(gw shr 8)+1]*NativeUInt(gw and 255)) shr 8;
+        if bw >= $ff00 then result.blue := $ffff
+        else result.blue := (GammaExpansionTab[bw shr 8]*NativeUInt(255 - (bw and 255)) + GammaExpansionTab[(bw shr 8)+1]*NativeUInt(bw and 255)) shr 8;
+        result.alpha := NativeInt(FColors[i].alpha shl 8) + (((curPos) shl 8)*(FColors[i+1].alpha-FColors[i].alpha)) div (posDiff);
+        result.alpha := result.alpha + (result.alpha shr 8);
+      end;
     end;
   end;
@@ -544 +723 @@
 end;
 
+function TBGRASimpleGradientWithGammaCorrection.GetExpandedColorAt(
+  position: integer): TExpandedPixel;
+var b,b2: cardinal;
+begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 65536 then
+    result := ec2 else
+  begin
+    b      := position;
+    b2     := 65536-b;
+    result.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+    result.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+    result.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+    result.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+  end;
+end;
+
+function TBGRASimpleGradientWithGammaCorrection.GetExpandedColorAtF(
+  position: single): TExpandedPixel;
+var b,b2: cardinal;
+begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 1 then
+    result := ec2 else
+  begin
+    b      := round(position*65536);
+    b2     := 65536-b;
+    result.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+    result.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+    result.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+    result.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+  end;
+end;
+
+function TBGRASimpleGradientWithGammaCorrection.GetAverageExpandedColor: TExpandedPixel;
+begin
+  result := MergeBGRA(ec1,ec2);
+end;
+
 function TBGRASimpleGradientWithGammaCorrection.GetMonochrome: boolean;
 begin
@@ -556 +776 @@
   FColor1 := Color1;
   FColor2 := Color2;
+  ec1 := GammaExpansion(Color1);
+  ec2 := GammaExpansion(Color2);
 end;
 
@@ -577 +799 @@
 
 function TBGRASimpleGradientWithoutGammaCorrection.GetColorAtF(position: single): TBGRAPixel;
-var b,b2: cardinal;
 begin
   if position <= 0 then
@@ -583 +804 @@
   if position >= 1 then
     result := FColor2 else
-  begin
-    b      := round(position*1024);
+    result := GetColorAt(round(position*65536));
+end;
+
+function TBGRASimpleGradientWithoutGammaCorrection.GetExpandedColorAt(
+  position: integer): TExpandedPixel;
+var b,b2: cardinal;
+    rw,gw,bw: word;
+begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 65536 then
+    result := ec2 else
+  begin
+    b      := position shr 6;
     b2     := 1024-b;
-    result.red  := (FColor1.red * b2 + FColor2.red * b + 511) shr 10;
-    result.green := (FColor1.green * b2 + FColor2.green * b + 511) shr 10;
-    result.blue := (FColor1.blue * b2 + FColor2.blue * b + 511) shr 10;
-    result.alpha := (FColor1.alpha * b2 + FColor2.alpha * b + 511) shr 10;
-  end;
+    rw  := (FColor1.red * b2 + FColor2.red * b + 511) shr 2;
+    gw := (FColor1.green * b2 + FColor2.green * b + 511) shr 2;
+    bw := (FColor1.blue * b2 + FColor2.blue * b + 511) shr 2;
+
+    result.red := (GammaExpansionTab[rw shr 8]*NativeUInt(255 - (rw and 255)) + GammaExpansionTab[(rw shr 8)+1]*NativeUInt(rw and 255)) shr 8;
+    result.green := (GammaExpansionTab[gw shr 8]*NativeUInt(255 - (gw and 255)) + GammaExpansionTab[(gw shr 8)+1]*NativeUInt(gw and 255)) shr 8;
+    result.blue := (GammaExpansionTab[bw shr 8]*NativeUInt(255 - (bw and 255)) + GammaExpansionTab[(bw shr 8)+1]*NativeUInt(bw and 255)) shr 8;
+    result.alpha := (FColor1.alpha * b2 + FColor2.alpha * b + 511) shr 2;
+  end;
+end;
+
+function TBGRASimpleGradientWithoutGammaCorrection.GetExpandedColorAtF(
+  position: single): TExpandedPixel;
+begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 1 then
+    result := ec2 else
+    result := GetExpandedColorAt(round(position*65536));
 end;
 
@@ -675 +922 @@
 end;
 
+function TBGRAGradientTriangleScanner.ScanNextExpandedPixel: TExpandedPixel;
+var r,g,b,a: int64;
+begin
+  r := round(FCurColor[1]);
+  g := round(FCurColor[2]);
+  b := round(FCurColor[3]);
+  a := round(FCurColor[4]);
+  if r > 65535 then r := 65535 else
+  if r < 0 then r := 0;
+  if g > 65535 then g := 65535 else
+  if g < 0 then g := 0;
+  if b > 65535 then b := 65535 else
+  if b < 0 then b := 0;
+  if a > 65535 then a := 65535 else
+  if a < 0 then a := 0;
+  result.red := r;
+  result.green := g;
+  result.blue := b;
+  result.alpha := a;
+  FCurColor += FStep;
+end;
+
 { TBGRAGradientScanner }
 
@@ -704 +973 @@
   FVertical := (((gtype =gtLinear) or (gtype=gtReflected)) and (o1.x=o2.x)) or FGradient.Monochrome;
   mergedColor := FGradient.GetAverageColor;
+  mergedExpandedColor := FGradient.GetAverageExpandedColor;
 end;
 
@@ -763 +1033 @@
 end;
 
+function TBGRAGradientScanner.ScanNextExpandedInline: TExpandedPixel;
+var
+  a,a2: single;
+  ai: integer;
+begin
+  if FGradientType >= gtDiamond then
+  begin
+    if FGradientType = gtRadial then
+    begin
+      a := sqrt(sqr(FDotProduct) + sqr(FDotProductPerp));
+      FDotProduct += u.x;
+      FDotProductPerp += u.y;
+    end else
+    begin
+      a   := abs(FDotProduct);
+      a2  := abs(FDotProductPerp);
+      if a2 > a then a := a2;
+      FDotProduct += u.x;
+      FDotProductPerp += u.y;
+    end;
+  end else
+  if FGradientType = gtReflected then
+  begin
+    a := abs(FDotProduct);
+    FDotProduct += u.x;
+  end else
+  begin
+    a := FDotProduct;
+    FDotProduct += u.x;
+  end;
+
+  if FSinus then
+  begin
+    a *= aFactor;
+    if a <= low(int64) then
+      result := FGradient.GetAverageExpandedColor
+    else
+    if a >= high(int64) then
+      result := FGradient.GetAverageExpandedColor
+    else
+    begin
+      ai := Sin65536(round(a));
+      result := FGradient.GetExpandedColorAt(ai);
+    end;
+  end else
+    result := FGradient.GetExpandedColorAtF(a*aFactorF);
+end;
+
 constructor TBGRAGradientScanner.Create(c1, c2: TBGRAPixel;
   gtype: TGradientType; o1, o2: TPointF; gammaColorCorrection: boolean;
@@ -814 +1132 @@
   InitScanInline(X,Y);
   if FVertical then
+  begin
     FHorizColor := ScanNextInline;
+    FHorizExpandedColor := ScanNextExpandedInline;
+  end;
 end;
 
@@ -823 +1144 @@
   else
     result := ScanNextInline;
+end;
+
+function TBGRAGradientScanner.ScanNextExpandedPixel: TExpandedPixel;
+begin
+  if FVertical then
+    result := FHorizExpandedColor
+  else
+    result := ScanNextExpandedInline;
 end;
 
@@ -853 +1182 @@
   begin
     a := a*aFactor;
-    if a <= low(int64) then
-      result := FGradient.GetAverageColor
-    else
-    if a >= high(int64) then
-      result := FGradient.GetAverageColor
+    if (a <= low(int64)) or (a >= high(int64)) then
+      result := mergedColor
     else
     begin
@@ -865 +1191 @@
   end else
     result := FGradient.GetColorAtF(a*aFactorF);
+end;
+
+function TBGRAGradientScanner.ScanAtExpanded(X, Y: Single): TExpandedPixel;
+var p: TPointF;
+    a,a2: single;
+    ai: integer;
+begin
+  if len = 0 then
+  begin
+    result := mergedExpandedColor;
+    exit;
+  end;
+
+  p.x := X - FOrigin1.x;
+  p.y := Y - FOrigin1.y;
+  case FGradientType of
+    gtLinear:    a := p.x * u.x + p.y * u.y;
+    gtReflected: a := abs(p.x * u.x + p.y * u.y);
+    gtDiamond:
+        begin
+          a   := abs(p.x * u.x + p.y * u.y);
+          a2  := abs(p.x * u.y - p.y * u.x);
+          if a2 > a then a := a2;
+        end;
+    gtRadial:    a := sqrt(sqr(p.x * u.x + p.y * u.y) + sqr(p.x * u.y - p.y * u.x));
+  end;
+
+  if FSinus then
+  begin
+    a := a*aFactor;
+    if (a <= low(int64)) or (a >= high(int64)) then
+      result := mergedExpandedColor
+    else
+    begin
+      ai := Sin65536(round(a));
+      result := FGradient.GetExpandedColorAt(ai);
+    end;
+  end else
+    result := FGradient.GetExpandedColorAtF(a*aFactorF);
 end;
 
@@ -961 +1326 @@
 var c: TBGRAPixel;
     alpha: byte;
-    MemMask, pmask, MemTex, ptex: pbgrapixel;
+    pmask, ptex: pbgrapixel;
 
   function GetNext: TBGRAPixel; inline;
@@ -982 +1347 @@
 
 begin
-  getmem(MemMask, count*sizeof(TBGRAPixel));
-  ScannerPutPixels(FMask,MemMask,count,dmSet);
-  getmem(MemTex, count*sizeof(TBGRAPixel));
-  ScannerPutPixels(FTexture,MemTex,count,dmSet);
-
-  pmask := MemMask;
-  ptex := MemTex;
+  if count > length(FMemMask) then setlength(FMemMask, max(length(FMemMask)*2,count));
+  if count > length(FMemTex) then setlength(FMemTex, max(length(FMemTex)*2,count));
+  ScannerPutPixels(FMask,@FMemMask[0],count,dmSet);
+  ScannerPutPixels(FTexture,@FMemTex[0],count,dmSet);
+
+  pmask := @FMemMask[0];
+  ptex := @FMemTex[0];
 
   if FGlobalOpacity <> 255 then
@@ -1071 +1436 @@
     end;
   end;
-
-  freemem(MemMask);
-  freemem(MemTex);
 end;
 
@@ -1125 +1487 @@
 var c: TBGRAPixel;
     alpha: byte;
-    MemMask, pmask: pbgrapixel;
+    pmask: pbgrapixel;
 
   function GetNext: TBGRAPixel; inline;
@@ -1136 +1498 @@
 
 begin
-  getmem(MemMask, count*sizeof(TBGRAPixel));
-  ScannerPutPixels(FMask,MemMask,count,dmSet);
-
-  pmask := MemMask;
+  if count > length(FMemMask) then setlength(FMemMask, max(length(FMemMask)*2,count));
+  ScannerPutPixels(FMask,@FMemMask[0],count,dmSet);
+
+  pmask := @FMemMask[0];
 
   case mode of
@@ -1179 +1541 @@
       end;
   end;
-
-  freemem(MemMask);
 end;
 
@@ -1229 +1589 @@
   mode: TDrawMode);
 var c: TBGRAPixel;
-    MemTex, ptex: pbgrapixel;
+    ptex: pbgrapixel;
 
   function GetNext: TBGRAPixel; inline;
@@ -1239 +1599 @@
 
 begin
-  getmem(MemTex, count*sizeof(TBGRAPixel));
-  ScannerPutPixels(FTexture,MemTex,count,dmSet);
-
-  ptex := MemTex;
+  if count > length(FMemTex) then setlength(FMemTex, max(length(FMemTex)*2,count));
+  ScannerPutPixels(FTexture,@FMemTex[0],count,dmSet);
+
+  ptex := @FMemTex[0];
 
   case mode of
@@ -1282 +1642 @@
       end;
   end;
-
-  freemem(MemTex);
 end;