teblndwk.pas

Do your applications look a little boring? Would you like to get spectacular yet easy to use visual

      $8D,$0C,$49, 
      $8D,$1C,$5B, 
      $C1,$E1,$04, 
      $C1,$E3,$04, 
      $01,$C1,     
      $01,$F3,     
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[26])^ := Shift;
    PByte(@Data[30])^ := Shift;

    case Factor of
       53: begin
             PByte(@Data[10])^ := $89;
             PByte(@Data[13])^ := $9B;
             PByte(@Data[15])^ := $E0;
             PByte(@Data[18])^ := $E6;
           end;
       57: begin
             PByte(@Data[10])^ := $C9;
             PByte(@Data[13])^ := $DB;
             PByte(@Data[15])^ := $E0;
             PByte(@Data[18])^ := $E6;
           end;
       83: begin
             PByte(@Data[10])^ := $89;
             PByte(@Data[13])^ := $9B;
           end;
       85: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
             PByte(@Data[10])^ := $89;
             PByte(@Data[13])^ := $9B;
           end;
       87: begin
             PByte(@Data[ 4])^ := $C9;
             PByte(@Data[ 7])^ := $DB;
             PByte(@Data[16])^ := $05;
             PByte(@Data[19])^ := $05;
             PByte(@Data[20])^ := $29;
             PByte(@Data[22])^ := $29;
           end;
       89: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
             PByte(@Data[10])^ := $C9;
             PByte(@Data[13])^ := $DB;
             PByte(@Data[15])^ := $E0;
             PByte(@Data[18])^ := $E6;
           end;
       91: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
             PByte(@Data[16])^ := $05;
             PByte(@Data[19])^ := $05;
             PByte(@Data[20])^ := $29;
             PByte(@Data[22])^ := $29;
           end;
       93: begin
             PByte(@Data[16])^ := $05;
             PByte(@Data[19])^ := $05;
             PByte(@Data[20])^ := $29;
             PByte(@Data[22])^ := $29;
           end;
       99: begin
             PByte(@Data[16])^ := $05;
             PByte(@Data[19])^ := $05;
           end;
      101: begin
             PByte(@Data[10])^ := $89;
             PByte(@Data[13])^ := $9B;
             PByte(@Data[16])^ := $05;
             PByte(@Data[19])^ := $05;
             PByte(@Data[15])^ := $E0;
             PByte(@Data[18])^ := $E6;
           end;
      105: begin
             PByte(@Data[10])^ := $C9;
             PByte(@Data[13])^ := $DB;
             PByte(@Data[16])^ := $05;
             PByte(@Data[19])^ := $05;
             PByte(@Data[15])^ := $E0;
             PByte(@Data[18])^ := $E6;
           end;
    end;
    Result := SizeOf(Code);
  end;

  function Mult11(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..32] of Byte = (
      $50,         
      $56,         
      $8D,$04,$89, 
      $8D,$34,$9B, 
      $8D,$0C,$C9, 
      $8D,$1C,$DB, 
      $01,$C1,     
      $01,$F3,     
      $8D,$0C,$C8, 
      $8D,$1C,$DE, 
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[26])^ := Shift;
    PByte(@Data[30])^ := Shift;

    case Factor of
      121: begin
             PByte(@Data[15])^ := $C8;
             PByte(@Data[17])^ := $DE;
             PByte(@Data[20])^ := $C1;
             PByte(@Data[23])^ := $F3;
           end;
    end;
    Result := SizeOf(Code);
  end;

  function Mult12(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..36] of Byte = (
      $50,         
      $56,         
      $8D,$04,$C9, 
      $8D,$34,$DB, 
      $8D,$0C,$89, 
      $8D,$1C,$9B, 
      $01,$C1,     
      $01,$F3,     
      $C1,$E1,$03, 
      $C1,$E3,$03, 
      $29,$C1,     
      $29,$F3,     
      $C1,$E9,$08, 
      $5E,         
      $C1,$EB,$08, 
      $58);        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[30])^ := Shift;
    PByte(@Data[34])^ := Shift;
    Result := SizeOf(Code);
  end;

  function Mult13(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..44] of Byte = (
      $50,                         
      $56,                         
      $8D,$04,$49,                 
      $8D,$34,$5B,                 
      $8D,$0C,$8D,$00,$00,$00,$00, 
      $8D,$1C,$9D,$00,$00,$00,$00, 
      $01,$C1,                     
      $01,$F3,                     
      $C1,$E1,$04,                 
      $C1,$E3,$04,                 
      $01,$C1,                     
      $01,$F3,                     
      $C1,$E9,$08,                 
      $5E,                         
      $C1,$EB,$08,                 
      $58);                        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[38])^ := Shift;
    PByte(@Data[42])^ := Shift;
    Result := SizeOf(Code);
  end;

  function Mult14(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..34] of Byte = (
      $50,                         
      $56,                         
      $8D,$04,$89,                 
      $8D,$34,$9B,                 
      $01,$C9,                     
      $01,$DB,                     
      $01,$C1,                     
      $01,$F3,                     
      $C1,$E1,$04,                 
      $C1,$E3,$04,                 
      $29,$C1,                     
      $29,$F3,                     
      $C1,$E9,$08,                 
      $5E,                         
      $C1,$EB,$08,                 
      $58);                        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[28])^ := Shift;
    PByte(@Data[32])^ := Shift;
    Result := SizeOf(Code);
  end;

  function Mult15(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..34] of Byte = (
      $50,                         
      $56,                         
      $8D,$04,$C9,                 
      $8D,$34,$DB,                 
      $C1,$E0,$02,                 
      $C1,$E6,$02,                 
      $01,$C1,                     
      $01,$F3,                     
      $01,$C0,                     
      $01,$F6,                     
      $01,$C1,                     
      $01,$F3,                     
      $C1,$E9,$08,                 
      $5E,                         
      $C1,$EB,$08,                 
      $58);                        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[28])^ := Shift;
    PByte(@Data[32])^ := Shift;

    case Factor of
      113: begin
             PByte(@Data[ 4])^ := $89;
             PByte(@Data[ 7])^ := $9B;
             PByte(@Data[ 9])^ := $E1;
             PByte(@Data[12])^ := $E3;
             PByte(@Data[10])^ := $07;
             PByte(@Data[13])^ := $07;
             PByte(@Data[14])^ := $29;
             PByte(@Data[16])^ := $29;
             PByte(@Data[22])^ := $29;
             PByte(@Data[24])^ := $29;
           end;
    end;
    Result := SizeOf(Code);
  end;

  function Mult16(Data: PByteArray; Factor, Shift: Byte): Integer;
  const
    Code: array[1..40] of Byte = (
      $50,                         
      $56,                         
      $8D,$04,$49,                 
      $8D,$34,$5B,                 
      $8D,$0C,$89,                 
      $8D,$1C,$9B,                 
      $C1,$E0,$05,                 
      $C1,$E6,$05,                 
      $01,$C8,                     
      $01,$DE,                     
      $01,$C9,                     
      $01,$DB,                     
      $01,$C1,                     
      $01,$F3,                     
      $C1,$E9,$08,                 
      $5E,                         
      $C1,$EB,$08,                 
      $58);                        
  begin
    CopyMemory(Data, @Code, SizeOf(Code));
    PByte(@Data[34])^ := Shift;
    PByte(@Data[38])^ := Shift;
    Result := SizeOf(Code);
  end;

  function Multiply(Data: PByteArray; Factor: Byte; Exchange: Boolean): Integer;
  var
    Shift: Byte;
  begin
    Result := 0;
    if Exchange then
    begin
      if PixelFormat in [pf15bit, pf16bit] then
        Dec(Factor);
      Factor := 255 - Factor;
    end;

    Shift := 8;
    while not Odd(Factor) do
    begin
      Dec(Shift);
      Factor := Factor div 2;
    end;

    if(Factor <> 1) and (TEProcessorInfo.SSE)
    then Result := MultX(Data, Factor, Shift)
    else
    begin
      case Factor of
        1:
          Result := Mult0 (Data, Factor, Shift);
        3, 5, 9:
          Result := Mult1 (Data, Factor, Shift);
        15, 25, 27, 45, 81:
          Result := Mult2 (Data, Factor, Shift);
        19, 21, 37, 41, 73:
          Result := Mult3 (Data, Factor, Shift);
        7, 11:
          Result := Mult4 (Data, Factor, Shift);
        13, 17:
          Result := Mult5 (Data, Factor, Shift);
        39, 43, 75, 77:
          Result := Mult6 (Data, Factor, Shift);
        23, 29, 35, 49, 55, 59, 61, 67, 69, 97, 119, 123, 125:
          Result := Mult7 (Data, Factor, Shift);
        31, 33, 63, 65, 127:
          Result := Mult8 (Data, Factor, Shift);
        47, 71, 79, 95:
          Result := Mult9 (Data, Factor, Shift);
        51, 53, 57, 83, 85, 87, 89, 91, 93, 99, 101, 105:
          Result := Mult10(Data, Factor, Shift);
        117, 121:
          Result := Mult11(Data, Factor, Shift);
        103:
          Result := Mult12(Data, Factor, Shift);
        115:
          Result := Mult13(Data, Factor, Shift);
        107:
          Result := Mult14(Data, Factor, Shift);
        109, 113:
          Result := Mult15(Data, Factor, Shift);
        111:
          Result := Mult16(Data, Factor, Shift);
      end;
    end;
  end;

var
  BC: PByteArray;
  OffsetDst,
  OffsetMult: Integer;
  Limit: DWord;
  Exchange,
  DoComp: Boolean;
begin
  DoComp := EqualPerc >= 10;

  if PixelFormat in [pf15bit, pf16bit] then
    Alpha := Alpha * 8;

  Exchange := Alpha > 128;
  
  GetMem(BC, SizeOf(CommonBody1) + SizeOf(CommonBody2) + 60 + SizeOf(CommonBody3));
  try
    CopyMemory(@(BC[0]), @CommonBody1, SizeOf(CommonBody1));
    OffsetDst := BodyDst(@(BC[SizeOf(CommonBody1)]), DoComp, IsColor, Exchange,
      Color);
    CopyMemory(@(BC[SizeOf(CommonBody1) + OffsetDst]), @CommonBody2,
      SizeOf(CommonBody2));

    OffsetMult :=
      Multiply(@(BC[SizeOf(CommonBody1) + OffsetDst + SizeOf(CommonBody2)]),
        Alpha, Exchange);
    CopyMemory(@(BC[SizeOf(CommonBody1) + OffsetDst + SizeOf(CommonBody2) +
      OffsetMult]), @CommonBody3, SizeOf(CommonBody3));

    Limit := DWord(Work) + DWord(Size);
    PDWord(@BC[20])^ := Limit;
    PInteger(@BC[26])^ := PInteger(@BC[26])^ + OffsetDst + OffsetMult;
    PDWord(@BC[33 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
      SizeOf(CommonBody2)])^ := Limit;
    PInteger(@BC[39 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
      SizeOf(CommonBody2)])^ :=
      PInteger(@BC[39 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
        SizeOf(CommonBody2)])^ - OffsetDst - OffsetMult;

    case PixelFormat of
      pf15bit:
        begin
          PDWord(@BC[ 6 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $7C1F03E0;
          PDWord(@BC[12 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $7C1F03E0;
          PByte (@BC[18 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $05;
          PDWord(@BC[21 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $3E07C1F;
          PByte (@BC[27 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $05;
          PDWord(@BC[30 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $3E07C1F;
          PByte (@BC[ 6 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
            SizeOf(CommonBody2)])^ := $05;
          PDWord(@BC[ 9 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
            SizeOf(CommonBody2)])^ := $3E07C1F;
          PDWord(@BC[15 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
            SizeOf(CommonBody2)])^ := $7C1F03E0;
        end;
      pf16bit:
        begin
          PDWord(@BC[ 6 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $F81F07E0;
          PDWord(@BC[12 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $F81F07E0;
          PByte (@BC[18 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $05;
          PDWord(@BC[21 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $07E0F81F;
          PByte (@BC[27 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $05;
          PDWord(@BC[30 + SizeOf(CommonBody1) + OffsetDst])^ :=
            $07E0F81F;
          PByte (@BC[ 6 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
            SizeOf(CommonBody2)])^ := $05;
          PDWord(@BC[ 9 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
            SizeOf(CommonBody2)])^ := $07E0F81F;
          PDWord(@BC[15 + SizeOf(CommonBody1) + OffsetDst + OffsetMult +
            SizeOf(CommonBody2)])^ := $F81F07E0;
        end;
    end;

    if Exchange
    then TAlphaBlendAsmProc(BC)(Work, Src, Dst)
    else TAlphaBlendAsmProc(BC)(Work, Dst, Src);
  finally
    FreeMem(BC);
  end;
end;

procedure BlendBmps(WorkBmp, DstBmp, SrcBmp, BrushBmp: TBitmap;
  PixelFormat: TPixelFormat; Level, EqualQuads: Integer);

  procedure DoFuse(WorkBmp, DstBmp, SrcBmp, BrushBmp: TBitmap; Level: Longint);
  var
    i: Integer;
  begin
    for i := 1 to Level do
      StandardFuseFrame(BrushBmp, i);

    WorkBmp.Canvas.Brush.Bitmap := BrushBmp;