1:
2:
3:
4:
5:
6:

  if anzahl mod 1000000 = 0 then  // hier statt 100
        begin
          paintbox1.canvas.draw(0, 0, bitmap);
          application.processmessages;
        end;
...                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure TForm1.D1Click(Sender: TObject);
  procedure plasma;

    function _getpixel(x, y: integer): integer;
    begin [...] end;

    function farbmitte(f1, f2, abweich: integer): WORD;
    begin [...] end;

    [usw...]

  begin [...] end;   // von procedure plasma;
begin [...] end;    // von procedure TForm1.D1Click                    

1:
2:
3:
4:
5:

        if anzahl mod n = 0 then
        begin
          paintbox1.canvas.draw(0, 0, bitmap);
          application.processmessages;
        end;                    

1:
2:
3:

//bitmap.canvas.Pixels[xa,ym]:=vfarben[farbe1];
   rowrgb:=bitmap.ScanLine[ym];
   rowrgb[xa]:=prgbtriple(colorlist.items[farbe1])^;                    

1:
2:
3:
4:

    function farbmitte(f1, f2, abweich: integer): byte;
    begin
      Result := max(1,((f1 + f2 - abweich) div 2 + random(abweich)) and 255); // Unith Math in Uses mit einbinden!!
    end;                    

1:

random(abweich) - abweich div 2                    

1:

random(2*abweich) - abweich                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

function randomrange(a,b: integer): integer;
    asm
      push eax
      xchg eax, edx
      sub eax, edx
      imul edx, [randseed], $08088405
      inc edx
      mov [randseed], edx
      mul edx
      pop eax
      add eax, edx
    end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

    function randomrange(a: integer): integer;
    asm
      shr eax, 1
      mov edx, eax
      neg eax
      push eax
      xchg eax, edx
      sub eax, edx
      imul edx, [randseed], $08088405
      mov [randseed], edx
      mul edx
      pop eax
      add eax, edx
    end;                    

1:
2:
3:
4:

    function farbmitte(f1,f2,abweich:integer):byte;
    begin
      farbmitte:=max(1,((f1+f2) div 2+ random(abweich)-abweich div 2) mod 256);
    end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

    function farbmitte(f1,f2,abweich:integer):byte;
      function randomrange(f1,f2,a: integer): integer;
      asm
        add eax, edx
        shr eax, 1
        push eax
        mov eax, ecx
        shr eax, 1
        mov edx, eax
        neg eax
        push eax
        xchg eax, edx
        sub eax, edx
        imul edx, [randseed], $08088405
        mov [randseed], edx
        mul edx
        pop eax
        add eax, edx
        pop edx
        add eax, edx
//      mov ecx, 256
//      div ecx
//      mov eax, edx
      end;
    begin
      farbmitte:=max(1,randomrange(f1,f2,abweich) mod 256);
    end;                    

1:

and eax, 255                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

Aus wingraph 
procedure SetAllPalette(var palette);
var pe: array of PALETTEENTRY;
     i: longint;
begin
  grResult:=grOK;
  if not(grEnabled) then begin
                           grResult:=grNoInitGraph;
                           Exit;
                         end;
  if not(palExist) then begin
                          grResult:=grNoPalette;
                          Exit;
                        end;
  with PaletteType(palette) do
  begin
    if (size > maxColors) then begin
                                 grResult:=grInvalidParam;
                                 Exit;
                               end;
    SetLength(pe,size);
    for i:=0 to size-1 do with pe[i],colTable[i] do
    begin
      peRed:=GetRValue(colors[i]); peGreen:=GetGValue(colors[i]); peBlue:=GetBValue(colors[i]);
      peFlags:=0;
      rgbRed:=peRed; rgbGreen:=peGreen; rgbBlue:=peBlue; rgbReserved:=0;
    end;
    for i:=size to maxColors-1 do with pe[0],colTable[i] do
    begin // all non-used bitmap palette entries equals the first entry
      rgbRed:=peRed; rgbGreen:=peGreen; rgbBlue:=peBlue; rgbReserved:=0;
    end;

    EnterCriticalSection(protect_devices);
    ResizePalette(grPalette,size);
    SetPaletteEntries(grPalette,0,size,pe[0]);
    SetDIBColorTable(grMemory,0,maxColors,colTable[0]);
    MapPaletteColors;
    RealizePalette(grWindow); RealizePalette(grMemory); RealizePalette(grTemp);
    LeaveCriticalSection(protect_devices);

    InvalidateRect(grHandle,nil,false);
    palSize:=size;
    SetLength(pe,0);
  end;
end;                    

1:

 if anzahl mod 50000 = 0 then application.processmessages;                    

1:
2:
3:

anzahl mod 50000 = 0 then
lieber etwas wie 
anzahl AND ( (1 shl 16) - 1) = 0 // AND 65535 == Mod 65536                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

function farbmitte(f1,f2,abweich: integer): integer;
    asm
         add eax, edx       //(f1+f2) div 2
         shr eax, 1
         push eax           //(f1+f2) div 2 speichern
         xor eax, eax       //Initialisierung auf 0 bis abweich
         mov edx, ecx
         push eax           //Zufallsgenerator
         xchg eax, edx
         sub eax, edx
         imul edx, [randseed], $08088405
         inc edx
         mov [randseed], edx
         mul edx
         pop eax
         add eax, edx       //in eax steht zufallswert [0,abweich-1] , getestet!!!
         shr ecx, 1         //abweich div 2
         sub eax, ecx       //subtraktion abweich div 2
         pop edx            //(f1+f2) div 2 zurückholen
         add eax, edx       //Addition (f1+f2) div 2
         and eax, 255       //mod 256
         cmp eax, 0         //Test auf größer Null
         jna @null
         ret
         @null: mov eax, 1
       end;                    

1:
2:
3:
4:

    function farbmitte(f1,f2,abweich:integer):byte;
    begin
      result:=max(1,((f1+f2) div 2 + random(abweich) - abweich div 2) mod 256);
    end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

function farbmitte(f1,f2,abweich: integer): integer;
    asm
         [...]
         sub eax, ecx       //subtraktion abweich div 2
         pop edx            //(f1+f2) div 2 zurückholen
         add eax, edx       //Addition (f1+f2) div 2
         and eax,255        //AND setzt bereits Zeroflag, wenn EAX 0 wird
         cmovnz eax,1       //Conditional Move
         ret
       end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:

program unbenannt;

var 
  AnzahlBerechnungen,
  Farbtupfer: longInt;

  procedure fensterOrg(xa,xe,ya,ye:integer);
    var 
        xm,ym,dx,dy:integer;
    begin
          inc(AnzahlBerechnungen);
          xm:=(xa+xe) div 2;
          ym:=(ya+ye) div 2;
          
          if xa>0 then
             else
          begin
             inc(Farbtupfer);
          end;

          if ya>0 then
          else
          begin
             inc(Farbtupfer);
          end;

             inc(Farbtupfer);

             inc(Farbtupfer);

             inc(Farbtupfer);

          //rekursive Konstruktion
          if xm>xa then
          begin
             fensterOrg(xa,xm,ya,ym);
             fensterOrg(xa,xm,ym,ye);
          end;
          if xe>succ(xm) then
          begin
             fensterOrg(xm,xe,ya,ym);
             fensterOrg(xm,xe,ym,ye);
          end;
     end;
// Neue Version mit fruehzeitigem Abbruch und nur den notwendigen Berechnungen
    procedure fenster(xa,xe,ya,ye:integer);
    var 
        xm,ym,dx,dy:integer;
        bDx,bDy : boolean;
    begin
          dx:=(xe-xa);
          dy:=(ye-ya);
          bDx := dx > 1;
          bDy := dy > 1;
          //if Not(bDx) AND Not(bDy)  then 
          if Not(bDx OR bDy)  then 
            exit;

          inc(AnzahlBerechnungen);    
          //Diamond-Square-Algorithmus
 
          xm:=(xa+xe) div 2;
          ym:=(ya+ye) div 2;
          IF xa = 0 then
            inc(farbtupfer);    
          IF ya = 0 then
            inc(farbtupfer);
          
{   Nur bei dy > 1 ergibt sich ein neues ym           
        farbe3:=farbmitte(pixel2,pixel4,dy);
          farbfeld[xe,ym]:=farbe3;
}
          IF bdy then
            inc(farbtupfer,1);
            
{  Nur bei dx > 1 ergibt sich ein neues xm
         farbe4:=farbmitte(pixel3,pixel4,dx);
          farbfeld[xm,ye]:=farbe4;        
}
          IF bdx then
            inc(farbtupfer);
{Entsprechendes hier
          farbe5:=((farbe1+farbe3) div 2 + (farbe2+farbe4) div 2) div 2;
          farbfeld[xm,ym]:=farbe5;          
}
          IF bdx AND bdy then
            inc(farbtupfer);

          //rekursive Konstruktion
          
          fenster(xa,xm,ya,ym);
          fenster(xa,xm,ym,ye);
          fenster(xm,xe,ya,ym);
          fenster(xm,xe,ym,ye);

     end;
const 
  width= 620;
  height = 568;
BEGIN
  AnzahlBerechnungen := 0;
  farbtupfer:= 4; //Startwerte   

  fenster (0,width-1,0,height-1);  
  writeln(' Anzahl Pixel             :',width*height);
  writeln(' Anzahl Rekursionen       :',AnzahlBerechnungen);  
  writeln(' Anzahl berechneter Pixel :',  FarbTupfer);

  AnzahlBerechnungen := 0;
  farbtupfer:= 4; //Startwerte   
  writeln;
  
  writeln('Original Plasma 8');
  fensterOrg (0,width-1,0,height-1);  
  writeln(' Anzahl Pixel             :',width*height);
  writeln(' Anzahl Rekursionen       :',AnzahlBerechnungen);  
  writeln(' Anzahl berechneter Pixel :',  FarbTupfer);
END.                    

1:
2:
3:
4:
5:
6:
7:
8:

 Anzahl Pixel             :352160
 Anzahl Rekursionen       :164440
 Anzahl berechneter Pixel :352160

Original Plasma 8
 Anzahl Pixel             :352160
 Anzahl Rekursionen       :382805
 Anzahl berechneter Pixel :1150530                    

1:

      result:=max(1,(((f1+f2) div 2) + random(abweich) - (abweich div 2)) mod 256);                    

1:
2:

          bdx := dx>1;
          bdy := dy>1;                    

1:

 if (xe-xa<=1) and (ye-ya<=1) then exit;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

    function farbmitte(f1,f2,abweich: integer): integer;
    //max(1,((f1+f2) div 2 + random(abweich) - abweich div 2) mod 256)
    asm
         add eax, edx       //(f1+f2) div 2
         shr eax, 1
         cmp ecx, 1
         jbe @ohnea         //abweich < 2
         push eax           //(f1+f2) div 2 speichern
         xor eax, eax       //Initialisierung auf 0 bis abweich
         mov edx, ecx
         push eax           //Zufallsgenerator
         xchg eax, edx
         sub eax, edx
         imul edx, [randseed], $08088405
         inc edx
         mov [randseed], edx
         mul edx
         pop eax
         add eax, edx       //in eax steht zufallswert [0,abweich-1]
         pop edx            //(f1+f2) div 2 zurückholen
         add eax, edx       //Addition (f1+f2) div 2
         shr ecx, 1         //abweich div 2
         sub eax, ecx       //subtraktion abweich div 2
         jc @null
         @ohnea: and eax, 255       //mod 256
         cmp eax, 0         //Test auf Null
         jz @null
         ret
         @null: mov eax, 1
       end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

    function farbmitte(f1,f2,abweich: integer): integer;
    //max(1,((f1+f2) div 2 + random(abweich) - abweich div 2) mod 256)
    asm
         add eax, edx       //(f1+f2) div 2
         shr eax, 1
         cmp ecx, 1
         jbe @ohnea         //abweich < 2
         push eax           //(f1+f2) div 2 speichern
         xor edx, edx       //Zufallsgenerator
         mov eax, ecx       //Initialisierung auf 0 bis abweich
         imul edx, [randseed], $08088405
         inc edx
         mov [randseed], edx
         mul edx
         mov eax, edx       //in eax steht zufallswert [0,abweich-1]
         pop edx            //(f1+f2) div 2 zurückholen
         add eax, edx       //Addition (f1+f2) div 2
         shr ecx, 1         //abweich div 2
         sub eax, ecx       //subtraktion abweich div 2
         jc @null
         @ohnea: and eax, 255       //mod 256
         cmp eax, 0         //Test auf Null
         jz @null
         ret
         @null: mov eax, 1
       end;                    

1:
2:
3:

      paintbox1.canvas.copyrect(zrect,bitmap.canvas,zrect);

      QueryPerformanceCounter(Time2);                    

1:
2:
3:
4:
5:

assembler:
       cmp ecx, 1
       jbe @ohnea         //abweich < 2
...
       @ohnea:                    

1:
2:
3:
4:
5:

    asm
         mov eax, f1
         mov edx, f2
         mov ecx, abweich
...                    

1:

farbmitte:=max(1,((f1+f2) div 2 + random(abweich) - abweich div 2) mod 256)                    

1:
2:
3:
4:
5:
6:

//xm im Bereich 4/16..12/16 des Intervalles
          xm:=xa+((xe-xa)*(random(9)+4)) shr 4;
          ym:=ya+((ye-ya)*(random(9)+4)) shr 4;
{xm immer in der Mitte
          xm:=(xa+xe) shr 1;
          ym:=(ya+ye) shr 1;}                    

1:
2:

mov ebx,1
cmovnz eax,ebx                    

1:

shr ecx, 1                    

1:
2:
3:
4:
5:

      //Startwerte
      farbfeld[0,0]:=random(255)+1;
      farbfeld[hoehe-1,0]:=random(255)+1;
      farbfeld[0,breite-1]:=random(255)+1;
      farbfeld[hoehe-1,breite-1]:=random(255)+1;                    

1:

setlength(farbfeld,paintbox1.height,paintbox1.Width);                    

1:
2:
3:
4:

farbe1:=farbmitte(pixel1,pixel3,dy);
             farbfeld[xa,ym]:=farbe1;
in
             farbfeld[ym,xa]:=farbe1;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

procedure TForm1.InsBildKopieren(Sender: TObject);
var
  i,j,index:integer;
  pfF,pPix:pByte;
begin

{$IFDEF FPC}
  pPix:= Bitmap.RawImage.Data;
  for i:=0 to paintbox1.height-1 do
    begin
    pfF := @farbfeld[i,0];
    for j:=0 to paintbox1.width-1 do
      begin
      index := pfF^;
      IF index <> 0 then
        begin
        index := (index + cyclestart);
        IF Index > 255 then
          dec(Index,254);
        end;
      inc(pfF);
      with pal[index] do
        begin
        pPix^:= r;inc(pPix);
        pPix^:= g;inc(pPix);
        pPix^:= b;inc(pPix);
        // bitmap.canvas.pixels[i,j]:=rgb(r,b,g);
        end;
      end;
    end;

{$ELSE}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

        if uy then begin
          farbe5:=(farbe1+farbe2+farbe3+farbe4) shr 2;
          farbfeld[ym,xm]:=farbe5;
          //rekursive Konstruktion
          fenster(xa,xm,ya,ym);
          fenster(xm,xe,ya,ym);
        end;
        fenster(xa,xm,ym,ye);
        fenster(xm,xe,ym,ye);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

procedure TForm1.InsBildKopieren;
var
  i,j,index:integer;
  pfF,pPix:pByte;
  rowrgb : pbytearray;
  BitmapRawData :ptrUint;
  delta : ptrUint;//DWord;
begin
  Bitmap.BeginUpdate();
  // Abstand Zeile n bis Zeile n+1 bei pf24Bit= 3 Byte aufgerundet auf 32Bit-Teilbarkeit
  // So sind Bitmap definiert.
  {$IFDEF FPC}
  delta := ((Bitmap.Width*3-1)DIV 4+1)*4;
  BitmapRawData:= ptrUint(Bitmap.RawImage.Data);
  {$ENDIF}
  for j:=0 to bitmap.height-1 do
    begin
    {$IFDEF FPC}
    pPix := pbyte(BitmapRawData+j*delta);
    {$ELSE}
    pPix:= pbyte(bitmap.scanline[j]);
    {$ENDIF}
    pfF := @FarbFeld[j,0];
    for i:=0 to bitmap.width-1 do
      begin
      index := pfF^;

      IF index <> 0 then
        begin
        index := (index + cyclestart);
        IF Index > 255 then
          dec(Index,254);
        end;
      inc(pfF);
      with pal[index] do
        begin
        pPix^:= r;inc(pPix);
        pPix^:= g;inc(pPix);
        pPix^:= b;inc(pPix);
        end;
      end;
    end;
  Bitmap.EndUpdate();
  paintbox1.canvas.draw(0,0,bitmap);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:

      index := pfF^;

      IF index <> 0 then
        begin
        index := (index + cyclestart);
        IF Index > 255 then
          dec(Index,254);
        end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:

    {$ELSE}
    //Mittelwert der Farben berechnen
    function farbmitte(f1,f2,abweich: integer): integer;
    begin
      result := (f1+f2) shr 1;
      IF abweich > 0 then
        result:=max(1,(result + random(abweich) - abweich shr 1) AND 255)
    end;
    {$ENDIF}

    procedure fensterX0(ya,ye:integer);
    var
      ym,dy:integer;
    begin
      IF ye-ya > 1 then
        begin
        dy := (ye-ya)*faktor;
        ym := (ya+ye) shr 1;
        farbfeld[ym,0] :=farbmitte(farbfeld[ye,0],farbfeld[ya,0],0);
        fensterX0(ya,ym);
        fensterX0(ym,ye);
        end;
    end;

    procedure fensterY0(xa,xe:integer);
    var
      xm,dx:integer;
    begin
      IF xe-xa > 1 then
        begin
        dx := (xe-xa)*Faktor;
        xm := (xa+xe) shr 1;
        farbfeld[0,xm] :=farbmitte(farbfeld[0,xe],farbfeld[0,xa],0);
        fensterY0(xa,xm);
        fensterY0(xm,xe);
        end;
    end;


    procedure fenster(xa,xe,ya,ye:integer);
    var
        xm,ym,dx,dy:integer;
        sum:word;
        ux,uy:boolean;
        pixel2,pixel3,pixel4,farbe:byte;

    begin
        if (xe-xa<2) and (ye-ya<2) then
           EXIT;

        //Diamond-Square-Algorithmus
        xm:=(xa+xe) shr 1;
        ym:=(ya+ye) shr 1;

        pixel2:=farbfeld[ya,xe];
        pixel3:=farbfeld[ye,xa];
        pixel4:=farbfeld[ye,xe];

        dy:=(ye-ya)*faktor;
        dx:=(xe-xa)*faktor;
        if waagerecht then ux:=xm<xe
                      else ux:=xm>xa;
        uy:=ym>ya;

        sum :=farbfeld[ya,xm]+farbfeld[ym,xa];

        if uy then begin
          farbe:=farbmitte(pixel2,pixel4,dy);
          farbfeld[ym,xe]:=farbe;
          inc(sum,farbe);
        end;

        if ux then begin
          farbe:=farbmitte(pixel3,pixel4,dx);
          farbfeld[ye,xm]:=farbe;
          inc(sum,farbe);
        end else exit;

        if uy then begin
          farbfeld[ym,xm]:=sum shr 2;;

          fenster(xa,xm,ya,ym);
          fenster(xm,xe,ya,ym);
        end;

        fenster(xa,xm,ym,ye);
        fenster(xm,xe,ym,ye);
     end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

 //Mittelwert der Farben berechnen
    function farbmitte(f1,f2,abweich: integer): integer;
    asm
         shr ecx, 1
         add eax, edx       //(f1+f2) div 2
         shr eax, 1
         cmp ecx, 1
         jbe @ohnea         //abweich < 2
         push eax           //(f1+f2) div 2 speichern
         xor edx, edx       //Zufallsgenerator
         mov eax, ecx       //Initialisierung auf 0 bis abweich
         imul edx, [randseed], $08088405
         inc edx
         mov [randseed], edx
         mul edx
         mov eax, edx       //in eax steht zufallswert [0,abweich-1]
         pop edx            //(f1+f2) div 2 zurückholen
         add eax, edx       //Addition (f1+f2) div 2
         shr ecx, 1         //abweich div 2
         sub eax, ecx       //subtraktion abweich div 2
         jc @null
         @ohnea: and eax, 255       //mod 256
         cmp eax, 0         //Test auf Null
         jz @null
         ret               //HIER KOMMT DIE EKCEPTION            
         @null: mov eax, 1
       end;                    

1:
2:
3:
4:
5:

         cmp eax, 0         //Test auf Null
         jz @null
         jmp @exit
         @null: mov eax, 1
         @exit: