UNIT VGA;

(****************************************************************************)
INTERFACE
(****************************************************************************)

(****************************************************************************)
(* Here we go ... procedure definitions. :)                                 *)
(****************************************************************************)

 (** This one changes the screenmode to N ***********************************)
   PROCEDURE SetMode(N : DWORD);

 (** Set a certain color in the VGA palette. ********************************)
   PROCEDURE SetColor(N, R, G, B : BYTE);

 (** Set a color fade between two given colors. *****************************)
   PROCEDURE SetColorFade(N1,N2,R1,G1,B1,R2,G2,B2 : LONGINT);

 (** Allocate a new fake screen. Returns offset *****************************)
   FUNCTION  NewPage : DWORD;

 (** Disposes a fake screen. ************************************************)
   PROCEDURE DisposePage(PageOFfset : DWORD);

 (** The standard pixel procedures. *****************************************)
   PROCEDURE PutPixel(WHERE : DWORD; X,Y : DWORD; C : BYTE);
   PROCEDURE AddPixel(WHERE : DWORD; X,Y : DWORD; C : BYTE);
   FUNCTION  GetPixel(WHERE : DWORD; X,Y : DWORD) : BYTE;

 (* Line drawing procedures *************************************************)
   PROCEDURE Line(WHERE : DWORD; X1, Y1, X2, Y2 : LONGINT; C : BYTE);
   PROCEDURE AddLine(WHERE : DWORD; X1, Y1, X2, Y2 : LONGINT; C : BYTE);
   PROCEDURE GshadeLine(WHERE : DWORD; X1, Y1, X2, Y2 : LONGINT; C1, C2 : BYTE);

 (* Clear a given fake screen ***********************************************)
   VAR ClearPage : PROCEDURE(WHERE : DWORD);

 (* Fills a screen with a given value. **************************************)
   PROCEDURE FillPage(WHERE : DWORD; Color : BYTE);

 (* Copies one page to another. *********************************************)
   VAR CopyPage  : PROCEDURE(From, Too : DWORD);

 (* Transparant copy (no color 0) *******************************************)
   PROCEDURE CopyPageT(FROM, TOO : DWORD);

 (* Loads a 256*256 RAW image. (as source for rotate) ***********************)
   PROCEDURE LoadRAW(Where : DWORD; Name : STRING);

 (* Plots a pixel on a 256*256 image. ***************************************)
   PROCEDURE PutPixel255(Where : DWORD; X, Y, C : BYTE);

 (* Grabs a pixel from a 256*256 image. *************************************)
   FUNCTION GetPixel255(Where : DWORD; X, Y : BYTE): BYTE;

 (* This one rotates a 256*256 source to a 320*200 screen. ******************)
   PROCEDURE Rotate(From, Too : DWORD; Rot : DWORD; X, Y, SCALE : LONGINT);

 (* Transparant rotate. (No color 0) ****************************************)
   PROCEDURE RotateT(From, Too : DWORD; Rot : DWORD; X, Y, SCALE : LONGINT);

 (* Transparant Rotate Warp. (WarpX and WarpY should be < 8) ****************)
   PROCEDURE RotateTW(From, Too : DWORD; Rot : DWORD; X, Y, SCALE : LONGINT; WARPX, WARPY : WORD);

 (* Same as above but high precision warp. warpx and warpy < 2048 ***********)
   PROCEDURE RotateTW2(From, Too : DWORD; Rot : DWORD; X, Y, SCALE, WARPX, WARPY : LONGINT);

 (* Copying pages (320*200) whilst smudging them ****************************)
   VAR CopyPageSmudge:PROCEDURE(FROM,TOO : DWORD);

 (* Copy smudge, check out to know difference :)  ***************************)
   PROCEDURE CopyPageSmudge2(FROM, TOO : DWORD);

 (* Average two pages. Too := (From1+From2)/2 *******************************)
   VAR MixPages  :PROCEDURE(From1,From2,Too : DWORD);

 (* Saturate two pages. too := (From1+From2)<255 ****************************)
   VAR MixPages2 :PROCEDURE(From1,From2,Too : DWORD);

 (* Alpha blend two pages. amount = 255 -> 100% from1 ***********************)
   VAR MixPages3 :PROCEDURE(From1,From2,Too : DWORD; Amount : BYTE);

 (* Bumpmapping with mutliple lightsources **********************************)
   PROCEDURE BumpMap(FROM, TOO, LIGHT : DWORD; LX, LY : WORD);

 (* Bumpmapping with one lightsource. ***************************************)
   PROCEDURE BumpMap2(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER);

 (* Bumpmapping with one lightsource. (no zeros) ****************************)
   PROCEDURE BumpMap2t(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER);

 (* Bumpmapping with one lightsource. height+slope **************************)
   PROCEDURE BumpMap3(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER);

 (* Bumpmapping with one lightsource. height+slope+transparent **************)
   PROCEDURE BumpMap3t(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER);

 (* Scale a 320*200 to 256*256 (to use as rotatesource) *********************)
   PROCEDURE Scale320to256(FROM, TOO : DWORD);
   PROCEDURE Scale256to320(FROM, TOO : DWORD);

 (* Apply distort relocation maps to 256*256 source giving 320*200 **********)
   PROCEDURE Relocate(From, Too, Distort1, Distort2, D1Ofs, D2Ofs : LONGINT);

 (* Relocate not doing color 0. *********************************************)
   PROCEDURE RelocateT(From, Too, Distort1, Distort2, D1Ofs, D2Ofs : LONGINT);

 (* This one does a fire effect. ********************************************)
   PROCEDURE DoFire(From, Too, Flame : DWORD);

 (* Use this one to init the standard light for the bumpmap. ****************)
   PROCEDURE InitBump(Light : DWORD);
   PROCEDURE InitBumpSmall(Light : DWORD);

 (* This one does a ripple. *************************************************)
   VAR Ripple : PROCEDURE(VAR Page1, Page2 : DWORD);

 (* This one does the displacement effect. **********************************)
   PROCEDURE DisPlace(From, Too, Disp : DWORD);

 (* Use these to produce some standard distort maps. ************************)
   PROCEDURE InitTunnel(Distort1, Distort2 : DWORD);
   PROCEDURE InitTunnel2(Distort1, Distort2 : DWORD);
   PROCEDURE InitTunnelFast(Distort1, Distort2 : DWORD);
   PROCEDURE InitFlashke(Distort1, Distort2 : DWORD);
   PROCEDURE InitSpiral(Distort1, Distort2 : DWORD);

(****************************************************************************)
IMPLEMENTATION
(****************************************************************************)
(* MMX instructions don't take direct operands ... that would btw mean an   *)
(* opcode with 8 bytes extra :) ... so ... here's some mask I use to mask   *)
(* out the upper bit of every byte since mmx doesn't have PSRLB !! ..       *)
(****************************************************************************)
CONST SomeBitsOutMask : ARRAY[0..7] OF CHAR = ('','','','','','','','');
      Mask512W : ARRAY[0..3] OF WORD = (512,512,512,512);
      Mask128W : ARRAY[0..3] OF WORD = (128,128,128,128);
(****************************************************************************)
(* This procedure sets the screenmode to a desired mode number.             *)
(****************************************************************************)
  PROCEDURE SetMode(N : DWORD); ASSEMBLER; ASM
    MOV  EAX, [N]                          (* Get modenr.                   *)
    INT  $10                               (* Call video interrupt.         *)
  END;


(****************************************************************************)
(* This one plots a pixel on a 320*200 screen.                              *)
(****************************************************************************)
  PROCEDURE PutPixel(WHERE : DWORD;  (* Offset of destination screen.       *)
                     X,Y : DWORD;    (* Positions in destination.           *)
                     C : BYTE);      (* Color of pixel to plot.             *)
  ASSEMBLER; ASM
  (* What we do here : MEM[Where + X*320 + Y] := C. Just a lot faster :)    *)
    MOV  EAX, [X]             (* Get the line.                              *)
    MOV  EDI, [Y]             (* Get the column number.                     *)
    SHL  EAX, 6               (* Line*64                                    *)
    ADD  EDI, [WHERE]         (* Add source pointer to column.              *)
    MOV  BL,  [C]             (* Get Color.                                 *)
    LEA  EAX, [EAX+4*EAX]     (* Eax := (Line*64) + 4*(line*64) =  Line*320 *)
    MOV  [EDI+EAX], BL        (* Put the color in its place.                *)
  END;


(****************************************************************************)
(* This one adds a pixel to the value current on screen                     *)
(****************************************************************************)
  PROCEDURE AddPixel(WHERE : DWORD;  (* Offset of destination.              *)
                     X,Y : DWORD;    (* Positions of destination pixel.     *)
                     C : BYTE);      (* Amount to add to pixel.             *)
  ASSEMBLER; ASM
  (* What we do here : MEM[Where + X*320 + Y] +:= C. Just a lot faster :)   *)
    MOV  EAX, [X]             (* Get the line.                              *)
    MOV  EDI, [Y]             (* Get the column number.                     *)
    SHL  EAX, 6               (* Line*64                                    *)
    ADD  EDI, [WHERE]         (* Add source pointer to column.              *)
    MOV  BL,  [C]             (* Get Color.                                 *)
    LEA  EAX, [EAX+4*EAX]     (* Eax := (Line*64) + 4*(line*64) =  Line*320 *)
    ADD  [EDI+EAX], BL        (* Add the color to the pixel there.          *)
  END;


(****************************************************************************)
(* This one grabs a pixel from a given screen.                              *)
(****************************************************************************)
  FUNCTION GetPixel(WHERE : DWORD;  (* Offset of page to grab pixel from.   *)
                    X, Y : DWORD)   (* Positions of pixel.                  *)
           : BYTE;                  (* The color returned.                  *)
  ASSEMBLER; ASM
    MOV  EDX, [X]             (* Get line                                   *)
    MOV  EDI, [Y]             (* Get column.                                *)
    SHL  EDX, 6               (* EDX = Line*64                              *)
    ADD  EDI, [WHERE]         (* Add offset of source to column.            *)
    LEA  EDX, [EDX+4*EDX]     (* EDX = (Line*64)+4*(Line*64) = Line*320     *)
    MOV  AL,  [EDI+EDX]       (* Grab pixel.                                *)
  END;


(****************************************************************************)
(* This one draws a line on screen in color C                               *)
(****************************************************************************)
  PROCEDURE Line(WHERE : DWORD;     (* Offset of destination.               *)
                 X1, Y1,            (* Positions of begin pixel.            *)
                 X2, Y2 : LONGINT;  (* Positions of ending pixel.           *)
                 C : BYTE);         (* Color to plot line in.               *)
  VAR CX, CY : LONGINT;   (* Current X and Current Y. 16:16 fixed point.    *)
      DX, DY : LONGINT;   (* Delta X and Delta Y.     16:16 fp.             *)
      L1, L2 : LONGINT;   (* Length(L1) and Loop(L2). Temporary variables.  *)
  BEGIN
  (** Step 0 : Figure out length of line. ***********************************)
    IF ABS(X2-X1) > ABS(Y2-Y1) THEN L1 := ABS(X2-X1)
                               ELSE L1 := ABS(Y2-Y1);
  (** Step 1 : Avoid lines that are of 0 length. ****************************)
    IF L1 = 0 THEN INC(L1);
  (** Step 2 : Calculate starting positions. ********************************)
    CX := X1 SHL 16;
    CY := Y1 SHL 16;
  (** Step 3 : Calculate delta's. What do we need to add every pixel ? ******)
    DX := ((X2-X1) SHL 16) DIV L1;
    DY := ((Y2-Y1) SHL 16) DIV L1;
  (** Step 4 : Loop for as many pixels as there are in the line. ************)
    FOR L2 := 0 TO L1 DO BEGIN
    (** Step 4a : Plot the current pixel. ***********************************)
      PutPixel(Where, CX SHR 16, CY SHR 16, C);
    (** Step 4b : Update the positions. *************************************)
      CX +:= DX;
      CY +:= DY;
    END;
  END;


(****************************************************************************)
(* Same thing, but this time adds a line.                                   *)
(****************************************************************************)
  PROCEDURE AddLine(WHERE : DWORD;   (* Offset of destination screen.       *)
                    X1, Y1,          (* Beginpixel positions                *)
                    X2, Y2 : LONGINT;(* Endpixel positions.                 *)
                    C : BYTE);       (* Amount to add.                      *)
  VAR CX, CY : LONGINT;   (* Current X and Current Y. 16:16 fixed point.    *)
      DX, DY : LONGINT;   (* Delta X and Delta Y.     16:16 fp.             *)
      L1, L2 : LONGINT;   (* Length(L1) and Loop(L2). Temporary variables.  *)
  BEGIN
  (** Step 0 : Figure out length of line. ***********************************)
    IF ABS(X2-X1) > ABS(Y2-Y1) THEN L1 := ABS(X2-X1)
                               ELSE L1 := ABS(Y2-Y1);
  (** Step 1 : Avoid lines that are of 0 length. ****************************)
    IF L1 = 0 THEN INC(L1);
  (** Step 2 : Calculate starting positions. ********************************)
    CX := X1 SHL 16;
    CY := Y1 SHL 16;
  (** Step 3 : Calculate delta's. What do we need to add every pixel ? ******)
    DX := ((X2-X1) SHL 16) DIV L1;
    DY := ((Y2-Y1) SHL 16) DIV L1;
  (** Step 4 : Loop for as many pixels as there are in the line. ************)
    FOR L2 := 0 TO L1 DO BEGIN
    (** Step 4a : Add to the current pixel. *********************************)
      AddPixel(Where, CX SHR 16, CY SHR 16, C);
    (** Step 4b : Update the positions. *************************************)
      CX +:= DX;
      CY +:= DY;
    END;
  END;


(****************************************************************************)
(* This procedure draws a shaded line on where.                             *)
(****************************************************************************)
  PROCEDURE GshadeLine(WHERE : DWORD;     (* Offset of destination.         *)
                 X1, Y1,            (* Positions of begin pixel.            *)
                 X2, Y2 : LONGINT;  (* Positions of ending pixel.           *)
                 C1, C2 : BYTE);    (* Color to plot line in.               *)
  VAR CX, CY, CC : LONGINT;
      DX, DY, DC : LONGINT;
      L1, L2 : LONGINT;
  BEGIN
  (** Step 0 : Figure out length of line. ***********************************)
    IF ABS(X2-X1) > ABS(Y2-Y1) THEN L1 := ABS(X2-X1)
                               ELSE L1 := ABS(Y2-Y1);
  (** Step 1 : Avoid lines that are of 0 length. ****************************)
    IF L1 = 0 THEN INC(L1);
  (** Step 2 : Calculate starting positions. ********************************)
    CX := X1 SHL 16;
    CY := Y1 SHL 16;
    CC := C1 SHL 16;
  (** Step 3 : Calculate delta's. What do we need to add every pixel ? ******)
    DX := ((X2-X1) SHL 16) DIV L1;
    DY := ((Y2-Y1) SHL 16) DIV L1;
    DC := ((C2-C1) SHL 16) DIV L1;
  (** Step 4 : Loop for as many pixels as there are in the line. ************)
    FOR L2 := 0 TO L1 DO BEGIN
    (** Step 4a : Plot the current pixel. ***********************************)
      PutPixel(Where, CX SHR 16, CY SHR 16, CC SHR 16);
    (** Step 4b : Update the positions. *************************************)
      CX +:= DX;
      CY +:= DY;
      CC +:= DC;
    END;
  END;



(****************************************************************************)
(* This procedure sets one palette entry of the VGA to specified colors.    *)
(****************************************************************************)
  PROCEDURE SetColor(N,                (* Nr of color to set.               *)
                     R, G, B : BYTE);  (* Red green and blue component.     *)
  (* Color components are expected to be 0-255 !!!!!!!!!!!!!!!!!!!!!!!!!!!  *)
  ASSEMBLER; ASM
    MOV  DX, $3C7       (* Port $3c7 =  Set palette write index.            *)
    MOV  AL, [N]        (* Get the colorNr                                  *)
    OUT  DX, AL         (* Send it to the VGA card.                         *)
    ADD  DX, 2          (* Port $3c9 =  Palette data Write/read             *)
    MOV  AL, [R]        (* Get the red component.                           *)
    SHR  AL, 2          (* Rescale from 0-255 to standard vga 0-63          *)
    OUT  DX, AL         (* Send it to the VGA card.                         *)
    MOV  AL, [G]        (* Get the green component.                         *)
    SHR  AL, 2          (* Rescale it.                                      *)
    OUT  DX, AL         (* Send it.                                         *)
    MOV  AL, [B]        (* Get the blue component.                          *)
    SHR  AL, 2          (* Rescale it.                                      *)
    OUT  DX, AL         (* send it.                                         *)
  END;


(****************************************************************************)
(* This procedure creates a shade of colors between N1 and N2               *)
(****************************************************************************)
  PROCEDURE SetColorFade(N1,                 (* Starting color nr.          *)
                         N2,                 (* Ending color nr. (N1 < N2)  *)
                         R1,G1,B1,           (* Starting color components.  *)
                         R2,G2,B2 : LONGINT);(* Ending color components.    *)
  VAR CR, CG, CB : LONGINT;  (* Current red, green and blue values. 16:16   *)
      DR, DG, DB : LONGINT;  (* Delta red, green and blue.          16:16   *)
      Counter    : BYTE;     (* a counter. To count shit :)                 *)
  BEGIN
  (** Step 1 : Calculate delta values. **************************************)
    DR := ( (R2-R1) SHL 16) DIV (N2-N1);
    DG := ( (G2-G1) SHL 16) DIV (N2-N1);
    DB := ( (B2-B1) SHL 16) DIV (N2-N1);
  (** Step 2 : Get starting values. *****************************************)
    CR := R1 SHL 16;
    CG := G1 SHL 16;
    CB := B1 SHL 16;
  (** Step 3 : Do the shit :) ***********************************************)
    FOR Counter := N1 TO N2-1 DO BEGIN (* Repeat for all colors.            *)
      PORT[$3c7] := Counter;           (* Send color nr.                    *)
      PORT[$3c9] := CR SHR 18; CR+:=DR;(* Send current red and update.      *)
      PORT[$3c9] := CG SHR 18; CG+:=DG;(* Send current green and update.    *)
      PORT[$3c9] := CB SHR 18; CB+:=DB;(* Send current blue and update.     *)
    END;
  END;


(****************************************************************************)
(* This one fills the screen with a certain color.                          *)
(****************************************************************************)
   PROCEDURE FillPage(WHERE : DWORD; Color : BYTE); ASSEMBLER; ASM
      MOV  EDI, [WHERE]
      MOV  AL,  [COLOR]
      MOV  AH,  AL
      MOV  BX,  AX
      SHL  EAX, 16
      MOV  AX,  BX
      MOV  ECX, 16384
      @LOOP:
        MOV [EDI], EAX
        ADD EDI, 4
        DEC ECX
      JNZ @LOOP
   END;


(****************************************************************************)
(* This one fills the screen completely with 0. mmx version.                *)
(****************************************************************************)
  PROCEDURE ClearPage_mmx(Where : DWORD); ASSEMBLER; ASM
    MOV  EDI, [Where]      (* Get destination pointer.                      *)
    PSLLW mm0, 32          (* Clear mm0 register.                           *)
    MOVQ mm1, mm0          (* Clear mm1 too.                                *)
    MOV  ECX, 4096         (* Repeat 4096 times. (4096*16=65536)            *)
    @LOOP:
      MOVQ [EDI], mm0      (* Send mm0.                                     *)
      MOVQ [EDI+8], mm1    (* Send mm1.                                     *)
      ADD EDI, 16          (* Voila, 16 bytes done.                         *)
    DEC ECX                (* Decrement counter.                            *)
    JNZ @LOOP              (* Jump when counter is not zero.                *)
    EMMS                   (* Exit multimediastate.                         *)
  END;


(****************************************************************************)
(* This one fills the screen completely with zeroes, x86 version            *)
(****************************************************************************)
  PROCEDURE ClearPage_x86(Where : DWORD); ASSEMBLER; ASM
    MOV  EDI, [Where]      (* Get destination pointer.                      *)
    XOR  EAX, EAX          (* Clear EAX.                                    *)
    MOV  ECX, 8192         (* Repeat 8192 times. (8192*8=65536)             *)
    @LOOP:
      MOV [EDI], EAX       (* Send EAX.                                     *)
      MOV [EDI+4], EAX     (* Send EAX one dword further.                   *)
      ADD EDI, 8           (* Increase destination pointer with 8.          *)
    DEC ECX                (* Decrease pixelcounter.                        *)
    JNZ @LOOP              (* Jump when counter is not zero.                *)
  END;


(****************************************************************************)
(* This one copies one page to another, mmx version                         *)
(****************************************************************************)
  PROCEDURE CopyPage_mmx(From,         (* Offset of source page.            *)
                         Too : DWORD); (* Offset of destination page.       *)
  ASSEMBLER; ASM
    MOV  EDI, [TOO]        (* Get destination pointer.                      *)
    MOV  ECX, 4096         (* Set counter. (4096*16=65536)                  *)
    MOV  ESI, [FROM]       (* Get source pointer                            *)
    @LOOP:
      MOVQ mm0, [ESI]      (* Read First 8 bytes into mm0                   *)
      MOVQ mm1, [ESI+8]    (* Read next 8 bytes into mm1                    *)
      ADD  ESI, 16         (* Increase sourcepointer with 16                *)
      MOVQ [EDI], mm0      (* Store first 8 bytes.                          *)
      MOVQ [EDI+8], mm1    (* Store next 8 bytes.                           *)
      ADD  EDI, 16         (* Increase destination pointer with 16          *)
    DEC  ECX               (* Decrease loop counter.                        *)
    JNZ  @LOOP             (* Jump unless counter = 0                       *)
    EMMS                   (* Exit multimediastate                          *)
  END;


(****************************************************************************)
(* This one copies one page to another, x86 version                         *)
(****************************************************************************)
  PROCEDURE CopyPage_X86(From,         (* Offset of source page.            *)
                         Too : DWORD); (* Offset of destination page.       *)
  ASSEMBLER; ASM
    MOV  EDI, [TOO]        (* Get destination pointer.                      *)
    MOV  ECX, 8192         (* Set loop count.                               *)
    MOV  ESI, [FROM]       (* Get source pointer.                           *)
    @LOOP:
      MOV EAX, [ESI]       (* Read first four bytes.                        *)
      MOV EBX, [ESI+4]     (* Read next four bytes.                         *)
      ADD ESI, 8           (* Update sourcep pointer.                       *)
      MOV [EDI], EAX       (* Store first four bytes.                       *)
      MOV [EDI+4], EBX     (* Store next four bytes.                        *)
      ADD EDI, 8           (* Update destination pointer.                   *)
    DEC ECX                (* Decrease loop counter.                        *)
    JNZ @LOOP              (* Jump unless counter is zero.                  *)
  END;


(****************************************************************************)
(* This one copies one page to another, not copying color 0, x86 version    *)
(****************************************************************************)
  PROCEDURE CopyPageT(From, Too : DWORD); ASSEMBLER; ASM
    MOV EDI, [Too]    (* Get destination pointer.                           *)
    MOV ECX, 65536    (* Set pixel count.                                   *)
    MOV ESI, [From]   (* Get source pointer.                                *)
    @LOOP:
      MOV AL, [ESI]   (* Get source pixel.                                  *)
      CMP AL, 0       (* Compare to 0                                       *)
      JZ  @SKIP       (* If 0 then skip plotting.                           *)
      MOV [EDI], AL   (* Plot pixel.                                        *)
      @SKIP:
      INC ESI         (* Increase source pointer.                           *)
      INC EDI         (* Increase destination pointer.                      *)
    DEC ECX           (* Decrease loop counter.                             *)
    JNZ @LOOP         (* Jump unless loopcounter = 0                        *)
  END;


(****************************************************************************)
(* This one smudges one page to another. x86 version                        *)
(****************************************************************************)
  PROCEDURE CopyPageSmudge_x86(From, Too : DWORD); ASSEMBLER; ASM
    MOV  EDI, [TOO]                    (* Get destination pointer.          *)
    MOV  ECX, 63360                    (* Set pixel count (skip top/bottom) *)
    MOV  ESI, [FROM]                   (* Get source addres                 *)
    ADD  EDI, 320                      (* Skip first line on destination.   *)
    ADD  ESI, 320                      (* And skip first line on source.    *)
    @LOOP:
      MOVZX EAX, BYTE PTR [ESI-320]    (* Get pixel above.                  *)
      MOVZX EBX, BYTE PTR [ESI-1]      (* Get pixel left.                   *)
      MOVZX EDX, BYTE PTR [ESI+1]      (* Get pixel right.                  *)
      ADD   EAX, EBX
      MOVZX EBX, BYTE PTR [ESI+320]    (* Get pixel below.                  *)
      ADD   EAX, EDX
      ADD   EAX, EBX                   (* Count four pixels together.       *)
      SHR   EAX, 2                     (* Divide by four.                   *)
      MOV   [EDI], AL                  (* And store the result.             *)
      INC   ESI                        (* Increase source pointer.          *)
      INC   EDI                        (* Increase destination pointer.     *)
    DEC  ECX                           (* Decrease loop count.              *)
    JNZ  @LOOP                         (* Loop until 0                      *)
  END;


(****************************************************************************)
(* This one smudges one page to another, mmx version                        *)
(****************************************************************************)
  PROCEDURE CopyPageSmudge_mmx(From, Too : DWORD); ASSEMBLER; ASM
    MOV  EDI, [TOO]                   (* Get destination page.              *)
    MOV  ECX, 7920                    (* Loop count. (7920*8=65536-640)     *)
    MOV  ESI, [FROM]                  (* Get source page.                   *)
    ADD  EDI, 320                     (* Skip first line.                   *)
    ADD  ESI, 320                     (* Also on source.                    *)
    PSLLQ mm7, 64                     (* Clear mm7                          *)
    @LOOP:
      MOVQ  mm0, QWORD PTR [ESI-320]  (* Get 8 pixels above.                *)
      MOVQ  mm1, QWORD PTR [ESI-1]    (* Get 8 pixels left.                 *)
      MOVQ  mm2, mm0                  (* Copy above pixels.                 *)
      MOVQ  mm3, mm1                  (* Copy left pixels.                  *)
      PUNPCKHBW mm0, mm7              (* Unpack 4 above pxls in mm0 to words*)
      PUNPCKHBW mm1, mm7              (* Unpack 4 left pxls in mm1 to words *)
      PUNPCKLBW mm2, mm7              (* Unpack low above pxls to words.    *)
      PUNPCKLBW mm3, mm7              (* Unpack low left pxls to words.     *)
      PADDUSW mm0, mm1                (* Add above and left pixels.         *)
      PADDUSW mm2, mm3                (* Add 4 next above and left pixels.  *)
      MOVQ  mm4, QWORD PTR [ESI+1]    (* Get 8 right pixels.                *)
      MOVQ  mm5, QWORD PTR [ESI+320]  (* Get 8 below pixels.                *)
      MOVQ  mm1, mm4                  (* Copy 8 right pixels.               *)
      MOVQ  mm3, mm5                  (* Copy 8 below pixels.               *)
      PUNPCKHBW mm4, mm7              (* Unpack high right pxls to words.   *)
      PUNPCKHBW mm5, mm7              (* Unpack high below pxls to words.   *)
      PUNPCKLBW mm1, mm7              (* Unpack low right pxls to words.    *)
      PUNPCKLBW mm3, mm7              (* Unpack low below pxls to words.    *)
      PADDUSW mm4, mm5                (* Add right and below pixels.        *)
      PADDUSW mm1, mm3                (* Add other right and below pixels.  *)
      PADDUSW mm0, mm4                (* Now add 4st 4 pixels all together  *)
      PADDUSW mm2, mm1                (* Same for next four.                *)
      PSRLW   mm0, 2                  (* SHR MM0, 2. Divide by 4            *)
      PSRLW   mm2, 2                  (* SHR MM2, 2. Divide by 4            *)
      PACKUSWB mm2, mm0               (* Pack words in mm2 and mm0 to bytes *)
      MOVQ  [EDI], mm2                (* Store 8 pixels on destination.     *)
      ADD  ESI, 8                     (* Increase source pointer.           *)
      ADD  EDI, 8                     (* Increase destination pointer.      *)
    DEC  ECX                          (* Decrease loop counter.             *)
    JNZ  @LOOP                        (* Jump until ECX = 0                 *)
    EMMS                              (* Exit multimedia state.             *)
  END;


(****************************************************************************)
(* This one does a different kind of smudge ... rather fun :)               *)
(****************************************************************************)
  PROCEDURE CopyPageSmudge2(From, Too : DWORD); ASSEMBLER; ASM
    MOV  EDI, [TOO]                  (* Get destination addres              *)
    MOV  ECX, 63360                  (* Set loop count = 64000-2*320        *)
    MOV  ESI, [FROM]                 (* Get source.                         *)
    ADD  EDI, 320                    (* Skip first line on destination.     *)
    ADD  ESI, 320                    (* Skip first line on source.          *)
    @LOOP:
      MOVZX EAX, BYTE PTR [ESI-320]  (* Get pixel above.                    *)
      MOVZX EBX, BYTE PTR [ESI-1]    (* Get pixel left.                     *)
      MOVZX EDX, BYTE PTR [ESI+1]    (* Get pixel right.                    *)
      ADD   EAX, EBX                 (* EAX := Above + left                 *)
      MOVZX EBX, BYTE PTR [ESI+320]  (* Get pixel under.                    *)
      ADD   EAX, EDX                 (* EAX +:= right.                      *)
      MOVZX EDX, BYTE PTR [ESI-321]  (* Get pixel aboveleft.                *)
      ADD   EAX, EBX                 (* EAX +:= under.                      *)
      MOVZX EBX, BYTE PTR [ESI-319]  (* Get pixel aboveright.               *)
      ADD   EDX, EBX                 (* EDX := Aboveleft+Aboveright.        *)
      MOVZX EBX, BYTE PTR [ESI+319]  (* Get pixel belowleft.                *)
      ADD   EDX, EBX                 (* EDX +:= belowleft.                  *)
      MOVZX EBX, BYTE PTR [ESI+321]  (* Get pixel belowright.               *)
      ADD   EDX, EBX                 (* EDX +:= belowright.                 *)
      MOVZX EBX, BYTE PTR [ESI]      (* Get pixel itself.                   *)
      LEA   EBX, [EBX+2*EBX]         (* Multiply pixel with 3               *)
      ADD   EDX, EBX                 (* EDX +:= 3*pixel                     *)
      SHR   EDX, 1                   (* EDX /:= 2;                          *)
      ADD   EAX, EDX                 (* Add all together.                   *)
      SHR   EAX, 3                   (* Divide by 8                         *)
      MOV   [EDI], AL                (* And put on source.                  *)
      INC   ESI                      (* Increase source pointer.            *)
      INC   EDI                      (* Increase destination pointer.       *)
    DEC  ECX                         (* Decrease loop counter.              *)
    JNZ  @LOOP                       (* Jump until 0                        *)
  END;


(****************************************************************************)
(* This one does a putpixel on a 256*256 screen ... (src for rotate).       *)
(****************************************************************************)
  PROCEDURE PutPixel255(Where : DWORD; X, Y, C : BYTE); ASSEMBLER; ASM
    XOR  EAX, EAX             (* Empty EAX                                  *)
    MOV  EDI, [WHERE]         (* Get source addres                          *)
    MOV  AL,  [Y]             (* Get column number.                         *)
    MOV  BL,  [C]             (* Get color.                                 *)
    MOV  AH,  [X]             (* Get line number.                           *)
    MOV  [EDI+EAX], BL        (* Store color at correct place.              *)
  END;


(****************************************************************************)
(* This one grabs a pixel from a 256*256 screen.                            *)
(****************************************************************************)
  FUNCTION GetPixel255(Where : DWORD; X, Y : BYTE) : BYTE; ASSEMBLER; ASM
    XOR  EBX,  EBX           (* Empty EBX.                                  *)
    MOV  EDI,  [WHERE]       (* Get source addres                           *)
    MOV  BH,   [X]           (* Get line.                                   *)
    MOV  BL,   [Y]           (* Get column.                                 *)
    MOV  AL,   [EDI+EBX]     (* Get pixel and return it.                    *)
  END;


(****************************************************************************)
(* This one rotates a 256*256 source image to the screen, tiling it ...     *)
(****************************************************************************)
  PROCEDURE Rotate(From, Too : DWORD; (* Source(256) and Destination.       *)
                   Rot : DWORD;       (* 0 < ROT < 4096                     *)
                   X, Y,              (* pixelmappedtocenter/256*65535      *)
                   SCALE : LONGINT);  (* Sort of scale.                     *)
  VAR ANGLE            : REAL;        (* Temporary real variable. Yuck      *)
      Ddx,Ddy,D2x,D2y  : INTEGER;     (* Delta's to move over source.       *)
      i,j              : INTEGER;     (* Starting coordinates in the bitmap.*)
  BEGIN
   (* Calculate angle. ******************************************************)
     angle := rot * 2 * 3.14159236/ 2048;

   (* Moving delta's. 8:8 fixed point ***************************************)
     Ddx:=trunc(((-Cos(angle)*256)) * SCALE) SHR 8;
     Ddy:=trunc(((Sin(Angle)*256)) * Scale) SHR 8;
     D2x:=trunc(((-Cos(angle+3.14159265/2) * 341))*SCALE) SHR 8;
     D2y:=trunc(((Sin(angle+3.14159265/2) * 341))*SCALE) SHR 8;

   (* Starting coordinates in the source bitmap. *)
     i:=X-Ddx*(160)-D2x*(100);
     j:=y-Ddy*(160)-D2y*(100);

   (* Do the shit :) *)
     ASM
       MOV   ESI, [FROM]      (* Get source addres.                         *)
       MOV   EDI, [TOO]       (* Get destination addres.                    *)
       MOV   ECX, 200         (* The line count.                            *)
       @LineLoop:
         PUSH ECX             (* Store the linecount on the stack.          *)
         MOV   BX, [I]        (* Get starting coordinates for this line.    *)
         MOV   DX, [J]        (* Store them in the BX and DX registers.     *)
         MOV  ECX, 320        (* Set the pixel count.                       *)
         XOR  EAX, EAX        (* Clear the EAX register.                    *)
         @PixelLoop:
           PUSH ECX           (* Store the pixelcount on the stack.         *)
           MOV AH, BH         (* Get current linenr.                        *)
           MOV AL, DH         (* Get current column.                        *)
           MOV CL, [ESI+EAX]  (* Get source pixel.                          *)
           MOV [EDI], CL      (* Store pixel on destination.                *)
           INC EDI            (* Increase destination pointer.              *)
           ADD BX, [DDX]      (* Update source positions for next pixel.    *)
           ADD DX, [DDY]      (* Update source positions for next pixel.    *)
           POP ECX            (* Get pixelcount from stack.                 *)
         DEC  ECX             (* Decrease pixelcount.                       *)
         JNZ  @PixelLoop      (* Jump until pixelcount is 0                 *)
         MOV  AX, [D2X]       (* Get line update vars.                      *)
         MOV  CX, [D2Y]       (* idem dito.                                 *)
         ADD  [I], AX         (* Add these to the starting coordinates of   *)
         ADD  [J], CX         (* the beginning of the line = move to next   *)
         POP  ECX             (* Get linecount.                             *)
       DEC  ECX               (* Decrease linecount.                        *)
       JNZ  @LineLoop         (* Jump until linecount = 0                   *)
     END; (**)
  END;


(****************************************************************************)
(* This one rotates a 256*256 source image to the screen and skips color 0  *)
(****************************************************************************)
  PROCEDURE RotateT(From, Too : DWORD; (* Source(256) and Destination.      *)
                    Rot : DWORD;       (* 0 < ROT < 4096                    *)
                    X, Y,              (* pixelmappedtocenter/256*65535     *)
                    SCALE : LONGINT);  (* Sort of scale.                    *)
  VAR ANGLE            : REAL;        (* Temporary real variable. Yuck      *)
      Ddx,Ddy,D2x,D2y  : INTEGER;     (* Delta's to move over source.       *)
      i,j              : INTEGER;     (* Starting coordinates in the bitmap.*)
  BEGIN
   (* Calculate angle. ******************************************************)
     angle := rot * 2 * 3.14159236/ 2048;

   (* Moving delta's. 8:8 fixed point ***************************************)
     Ddx:=trunc(((-Cos(angle)*256)) * SCALE) SHR 8;
     Ddy:=trunc(((Sin(Angle)*256)) * Scale) SHR 8;
     D2x:=trunc(((-Cos(angle+3.14159265/2) * 341))*SCALE) SHR 8;
     D2y:=trunc(((Sin(angle+3.14159265/2) * 341))*SCALE) SHR 8;

   (* Starting coordinates in the source bitmap. *)
     i:=X-Ddx*(160)-D2x*(100);
     j:=y-Ddy*(160)-D2y*(100);

   (* Do the shit :) *)
     ASM
       MOV   ESI, [FROM]      (* Get source addres.                         *)
       MOV   EDI, [TOO]       (* Get destination addres.                    *)
       MOV   ECX, 200         (* The line count.                            *)
       @LineLoop:
         PUSH ECX             (* Store the linecount on the stack.          *)
         MOV   BX, [I]        (* Get starting coordinates for this line.    *)
         MOV   DX, [J]        (* Store them in the BX and DX registers.     *)
         MOV  ECX, 320        (* Set the pixel count.                       *)
         XOR  EAX, EAX        (* Clear the EAX register.                    *)
         @PixelLoop:
           PUSH ECX           (* Store the pixelcount on the stack.         *)
           MOV AH, BH         (* Get current linenr.                        *)
           MOV AL, DH         (* Get current column.                        *)
           MOV CL, [ESI+EAX]  (* Get source pixel.                          *)
           CMP CL, 0          (* Check if source pixel is 0                 *)
           JZ  @Skip          (* If it is 0 then skip the plotting.         *)
           MOV [EDI], CL      (* Store pixel on destination.                *)
           @Skip:
           INC EDI            (* Increase destination pointer.              *)
           ADD BX, [DDX]      (* Update source positions for next pixel.    *)
           ADD DX, [DDY]      (* Update source positions for next pixel.    *)
           POP ECX            (* Get pixelcount from stack.                 *)
         DEC  ECX             (* Decrease pixelcount.                       *)
         JNZ  @PixelLoop      (* Jump until pixelcount is 0                 *)
         MOV  AX, [D2X]       (* Get line update vars.                      *)
         MOV  CX, [D2Y]       (* idem dito.                                 *)
         ADD  [I], AX         (* Add these to the starting coordinates of   *)
         ADD  [J], CX         (* the beginning of the line = move to next   *)
         POP  ECX             (* Get linecount.                             *)
       DEC  ECX               (* Decrease linecount.                        *)
       JNZ  @LineLoop         (* Jump until linecount = 0                   *)
     END; (**)
  END;


(****************************************************************************)
(* This one rotates a 256*256 source image to the screen and skips color 0  *)
(* and warps the image.                                                     *)
(****************************************************************************)
  PROCEDURE RotateTW(From, Too : DWORD; Rot : DWORD; X, Y, SCALE : LONGINT; WARPX, WARPY : WORD);
  VAR ANGLE            : REAL;            (* Yuck :) *)
      Ddx,Ddy,D2x,D2y  : INTEGER;
      i,j              : INTEGER;
      WARPDDY          : INTEGER;
  BEGIN
   (* Sin and cos only 4 for every screen ... aint gonna waist a look- *)
   (* up table on that ! *)
     angle := rot * 2*3.14159236 / 2048;

   (* Fixed Point Verplaatsingsvectoren geroteerd en gewogen(scale) *)
     Ddx:=trunc(((-Cos(angle)*256)) * SCALE) SHR 8;
     Ddy:=trunc(((Sin(Angle)*256)) * Scale) SHR 8;
     D2x:=trunc(((-Cos(angle+3.14159265/2) * 341))*SCALE) SHR 8;
     D2y:=trunc(((Sin(angle+3.14159265/2) * 341))*SCALE) SHR 8;

   (* Starting coordinates in the source bitmap. *)
     i:=X-Ddx*(160)-D2x*(100);
     j:=y-Ddy*(160)-D2y*(100);

   (* Do the shit :) *)
     ASM
       MOV   ESI, [FROM]
       MOV   EDI, [TOO]
       MOV   ECX, 200
       @LineLoop:
         PUSH ECX
         MOV   BX, [I]
         MOV   DX, [J]
         MOV  ECX, 320
         MOV  AX,  [DDY]
         MOV  [WarpDDY], AX
         XOR  EAX, EAX
         @PixelLoop:
           MOV AH, BH
           MOV AL, DH
           SHL EBX, 8
           MOV BL, [ESI+EAX]
           CMP BL, 0
           JZ  @SKIP
           MOV [EDI], BL
           @SKIP:
           INC EDI
           SHR EBX, 8
           MOV AX, [WarpDDY]
           ADD DX, AX
           ADD AX, [WarpY]
           MOV [WarpDDY], AX
           ADD BX, [DDX]
         DEC  ECX
         JNZ  @PixelLoop
         MOV  AX, [D2X]
         MOV  CX, [D2Y]
         ADD  [I], AX
         ADD  [J], CX
         POP  ECX
         ADD  AX, [WARPX]
         MOV  [D2X], AX
       DEC  ECX
       JNZ  @LineLoop
     END; (**)
  END;


(****************************************************************************)
(* This one rotates a 256*256 source image to the screen and skips color 0  *)
(* and warps the image. (Slower but high precision warping.)                *)
(****************************************************************************)
  PROCEDURE RotateTW2(From, Too : DWORD; Rot : DWORD; X, Y, SCALE, WARPX, WARPY : LONGINT);
  VAR ANGLE            : REAL;            (* Yuck :) *)
      Ddx,Ddy,D2x,D2y  : LONGINT;
      i,j              : LONGINT;
      WARPDDY          : LONGINT;
  BEGIN
   (* Sin and cos only 4 for every screen ... aint gonna waist a look- *)
   (* up table on that ! *)
     angle := rot * 2*3.14159236 / 2048;

   (* Fixed Point Verplaatsingsvectoren geroteerd en gewogen(scale) *)
     Ddx:=trunc(((-Cos(angle)*65536)) * SCALE) SHR 8;
     Ddy:=trunc(((Sin(Angle)*65536)) * Scale) SHR 8;
     D2x:=trunc(((-Cos(angle+3.14159265/2) * 87296))*SCALE) SHR 8;
     D2y:=trunc(((Sin(angle+3.14159265/2) * 87296))*SCALE) SHR 8;

   (* Starting coordinates in the source bitmap. *)
     i:=(X SHL 8)-(Ddx)*(160)-(D2x + 100 * WarpX)*(100);
     j:=(y SHL 8)-(Ddy + 160*WarpY)*(160)-(D2y)*(100);

   (* Do the shit :) *)
     ASM
       MOV   ESI, [FROM]
       MOV   EDI, [TOO]
       MOV   ECX, 200
       @LineLoop:
         PUSH ECX
         MOV  EBX, [I]
         MOV  EDX, [J]
         MOV  ECX, 320
         MOV  EAX, [DDY]
         MOV  [WarpDDY], EAX
         XOR  EAX, EAX
         @PixelLoop:
           PUSH ECX
           XOR EAX, EAX
           MOV ECX, EBX
           SHR ECX, 8
           MOV AH, CH
           MOV ECX, EDX
           SHR ECX, 8
           MOV AL, CH
           MOV CL, [ESI+EAX]
           CMP CL, 0
           JZ  @SKIP
           MOV [EDI], CL
           @SKIP:
           INC EDI
           MOV EAX, [WarpDDY]
           ADD EDX, EAX
           ADD EAX, [WarpY]
           MOV [WarpDDY], EAX
           ADD EBX, [DDX]
           POP ECX
         DEC  ECX
         JNZ  @PixelLoop
         MOV  EAX, [D2X]
         MOV  ECX, [D2Y]
         ADD  [I], EAX
         ADD  [J], ECX
         POP  ECX
         ADD  EAX, [WARPX]
         MOV  [D2X], EAX
       DEC  ECX
       JNZ  @LineLoop
     END; (**)
  END;


(****************************************************************************)
(* This one mixes two pages and stores the result. x86 version              *)
(****************************************************************************)
  PROCEDURE MixPages_x86(From1, From2, Too : DWORD); ASSEMBLER; ASM
    MOV  ESI, [FROM1]
    MOV  EBX, [FROM2]
    MOV  EDI, [TOO]
    MOV  ECX, 64000
    @PixelLoop:
      MOVZX  EAX, BYTE PTR [ESI]
      INC    ESI
      MOVZX  EDX, BYTE PTR [EBX]
      INC    EBX
      ADD    EAX, EDX
      SHR    EAX, 1
      MOV    [EDI], AL
      INC    EDI
    DEC  ECX
    JNZ  @PixelLoop
  END;


(****************************************************************************)
(* This one mixes two pages and stores. mmx version                         *)
(****************************************************************************)
  PROCEDURE MixPages_MMX(From1, From2, Too : DWORD); ASSEMBLER; ASM
    MOV  ESI, [FROM1]
    MOV  EBX, [FROM2]
    MOV  EDI, [TOO]
    MOVQ  mm2, QWORD PTR [SomeBitsOutMask]
    MOV  ECX, 8192
    @PixelLoop:
      MOVQ   mm0, [ESI]
      ADD    ESI, 8
      MOVQ   mm1, [EBX]
      PSRLQ  mm0, 1
      PSRLQ  mm1, 1
      PAND   mm0, mm2
      PAND   mm1, mm2
      ADD    EBX, 8
      PADDUSB mm0, mm1
      MOVQ   [EDI], mm0
      ADD    EDI, 8
    DEC  ECX
    JNZ  @PixelLoop
    EMMS
  END;


(****************************************************************************)
(* This one mixes pages with saturation, just (A+B) and trim on 255         *)
(****************************************************************************)
  PROCEDURE MixPages2_x86(From1, From2, Too : DWORD); ASSEMBLER; ASM
    MOV  ESI, [FROM1]
    MOV  EBX, [FROM2]
    MOV  EDI, [TOO]
    MOV  ECX, 64000
    @PixelLoop:
      MOVZX  EAX, BYTE PTR [ESI]
      INC    ESI
      MOVZX  EDX, BYTE PTR [EBX]
      INC    EBX
      ADD    EAX, EDX
      CMP    EAX, 255
      JB     @OK
      MOV    AL, 255
      @OK:
      MOV    [EDI], AL
      INC    EDI
    DEC  ECX
    JNZ  @PixelLoop
  END;


(****************************************************************************)
(* This one does a saturated add of two pages, mmx version                  *)
(****************************************************************************)
  PROCEDURE MixPages2_MMX(From1, From2, Too : DWORD); ASSEMBLER; ASM
    MOV  ESI, [FROM1]
    MOV  EBX, [FROM2]
    MOV  EDI, [TOO]
    MOV  ECX, 8000
    @PixelLoop:
      MOVQ   mm0, [ESI]
      ADD    ESI, 8
      MOVQ   mm1, [EBX]
      ADD    EBX, 8
      PADDUSB mm0, mm1
      MOVQ   [EDI], mm0
      ADD    EDI, 8
    DEC  ECX
    JNZ  @PixelLoop
    EMMS
  END;


(****************************************************************************)
(* This one does an alphablended mix of two pages.                          *)
(****************************************************************************)
  PROCEDURE MixPages3_x86(From1, From2, Too : DWORD; Amount : BYTE);ASSEMBLER; ASM
    MOV ESI, [FROM1]
    MOV EBX, [FROM2]
    MOV ECX, 64000
    MOV EDI, [TOO]
    @LOOP:
       MOV AL, [ESI]
       MUL [amount]
       MOV DH, AH
       MOV AL, [EBX]
       MOV DL, [Amount]
       NOT DL
       MUL DL
       SHR AX, 8
       ADD AL, DH
       MOV [EDI], AL
       INC ESI
       INC EBX
       INC EDI
    DEC ECX
    JNZ @LOOP
  END;


(****************************************************************************)
(* This one does an alphablended mix of two pages. mmx version.             *)
(****************************************************************************)
  PROCEDURE MixPages3_mmx(FROM1, FROM2, TOO : DWORD; Amount : BYTE); ASSEMBLER; ASM
    MOV ESI, [FROM1]
    MOVZX DX,  [Amount]
    MOV EBX, [FROM2]
    SHL EDX, 16
    MOV EDI, [TOO]
    MOV ECX, 8000
    MOVZX DX,  [Amount]
    MOV AX, DX
    NOT AL
    SHL EAX, 16
    MOV AX, DX
    NOT AL
    MOVD mm0, EDX
    MOVD mm1, EDX
    PSLLQ mm1, 32
    POR  mm0, mm1
    MOVD mm1, EAX
    MOVD mm2, EAX
    PSLLQ mm2, 32
    POR  mm1, mm2
    PSLLQ mm7, 64
    @QuadPixelLoop:
      MOVQ mm2, [ESI]
      MOVQ mm3, [EBX]
      MOVQ mm4, mm2
      MOVQ mm5, mm3
      PUNPCKHBW mm2, mm7
      PUNPCKLBW mm4, mm7
      PMULLW mm2, mm0
      PUNPCKHBW mm3, mm7
      PMULLW mm4, mm0
      PUNPCKLBW mm5, mm7
      PMULLW mm3, mm1
      ADD ESI, 8
      PMULLW mm5, mm1
      PADDUSW mm2, mm3
      ADD EBX, 8
      PADDUSW mm4, mm5
      PSRLW mm2, 8
      PSRLW mm4, 8
      PACKUSWB mm4, mm2
      MOVQ [EDI], mm4
      ADD EDI, 8
    DEC ECX
    JNZ @QuadPixelLoop
    EMMS
  END;

(****************************************************************************)
(* This one does a bump-map.                                                *)
(****************************************************************************)
  PROCEDURE BumpMap(FROM, TOO, LIGHT : DWORD; LX, LY : WORD); ASSEMBLER;
  VAR X, Y : WORD;
  ASM
    MOV   ESI,   [FROM]
    MOV   EDI,   [TOO]
    MOV   EDX,   [LIGHT]
    MOV   ECX,   63360
    ADD   ESI,   320
    ADD   EDI,   320
    MOV   [X],   0
    MOV   [Y],   0
    @PixelLoop:
      MOVZX EAX, BYTE [ESI-320]
      MOV   AH,  BYTE [ESI+320]
      SUB   AL,  AH
      MOV   BH,  BYTE [ESI-1]
      MOV   BL,  BYTE [ESI+1]
      SUB   BL,  BH
      MOV   AH,  0
      MOV   BH,  0
      ADD   AX,  [LX]
      ADD   BX,  [LY]
      ADD   AX,  [X]
      ADD   BX,  [Y]
      MOV   AH,  BL
      INC   [X]
      CMP   [X], 320
      JNZ   @NO
      INC   [Y]
      MOV   [X], 0;
      @NO:
      MOV   BL,  [EDX+EAX]
      MOV   [EDI], BL
      INC   ESI
      INC   EDI
    DEC   ECX
    JNZ   @PixelLoop
  END;

(****************************************************************************)
(* This one does a bump-map. (no tiled lights)                              *)
(****************************************************************************)
  PROCEDURE BumpMap2(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER); ASSEMBLER;
  VAR X, Y : WORD;
  ASM
    MOV   ESI,   [FROM]
    MOV   EDI,   [TOO]
    MOV   ECX,   63360
    ADD   ESI,   320
    ADD   EDI,   320
    MOV   [X],   0
    MOV   [Y],   0
    @PixelLoop:
      MOVZX EAX, BYTE [ESI-320]
      MOVZX DX,  BYTE [ESI+320]
      SUB   AX,  DX
      MOVZX BX,  BYTE [ESI-1]
      MOVZX DX,  BYTE [ESI+1]
      SUB   BX,  DX
      ADD   AX,  [LX]
      ADD   BX,  [LY]
      ADD   AX,  [X]
      ADD   BX,  [Y]
      CMP   AH,  0
      JZ    @XinRange
      MOV   AL,  0
      MOV   BL,  0
      @XinRange:
      CMP   BH,  0
      JZ    @YinRange
      MOV   AL,  0
      MOV   BL,  0
      @YinRange:
      MOV   AH,  BL
      INC   [X]
      MOV   EDX,   [LIGHT]
      CMP   [X], 320
      JNZ   @NO
      INC   [Y]
      MOV   [X], 0;
      @NO:
      MOV   BL,  [EDX+EAX]
      MOV   [EDI], BL
      INC   ESI
      INC   EDI
    DEC   ECX
    JNZ   @PixelLoop
  END;


(****************************************************************************)
(* This one does a bump-map. (no tiled lights, no color 0)                  *)
(****************************************************************************)
  PROCEDURE BumpMap2T(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER); ASSEMBLER;
  VAR X, Y : WORD;
  ASM
    MOV   ESI,   [FROM]
    MOV   EDI,   [TOO]
    MOV   ECX,   63360
    ADD   ESI,   320
    ADD   EDI,   320
    MOV   [X],   0
    MOV   [Y],   0
    @PixelLoop:
      MOV   BL,  BYTE PTR [ESI]
      CMP   BL,  0
      JZ    @Skip
      MOVZX EAX, BYTE [ESI-320]
      MOVZX DX,  BYTE [ESI+320]
      SUB   AX,  DX
      MOVZX BX,  BYTE [ESI-1]
      MOVZX DX,  BYTE [ESI+1]
      SUB   BX,  DX
      ADD   AX,  [LX]
      ADD   BX,  [LY]
      ADD   AX,  [X]
      ADD   BX,  [Y]
      CMP   AH,  0
      JZ    @XinRange
      MOV   AL,  0
      MOV   BL,  0
      @XinRange:
      CMP   BH,  0
      JZ    @YinRange
      MOV   AL,  0
      MOV   BL,  0
      @YinRange:
      MOV   AH,  BL
      MOV   EDX,   [LIGHT]
      MOV   BL,  [EDX+EAX]
      @Skip:
      INC   [X]
      CMP   [X], 320
      JNZ   @NO
      INC   [Y]
      MOV   [X], 0;
      @NO:
      MOV   [EDI], BL
      INC   ESI
      INC   EDI
    DEC   ECX
    JNZ   @PixelLoop
  END;


(****************************************************************************)
(* This one does a bump-map. (no tiled lights)                              *)
(****************************************************************************)
  PROCEDURE BumpMap3(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER); ASSEMBLER;
  VAR X, Y : WORD;
  ASM
    MOV   ESI,   [FROM]
    MOV   EDI,   [TOO]
    MOV   ECX,   63360
    ADD   ESI,   320
    ADD   EDI,   320
    MOV   [X],   0
    MOV   [Y],   0
    @PixelLoop:
      MOVZX EAX, BYTE [ESI-320]
      MOVZX DX,  BYTE [ESI+320]
      SUB   AX,  DX
      MOVZX EBX, BYTE [ESI-1]
      MOVZX DX,  BYTE [ESI+1]
      SUB   BX,  DX
      ADD   AX,  [LX]
      ADD   BX,  [LY]
      ADD   AX,  [X]
      ADD   BX,  [Y]
      MOVZX DX, BYTE [ESI]
      NOT   DL
      SHR   DL, 1
      ADD   DL, 128
      MUL   DX
      SHR   EAX,  8
      MOV   AH, DL
      XCHG  EAX,  EBX
      MOVZX DX, BYTE [ESI]
      NOT   DL
      SHR   DL, 1
      ADD   DL, 128
      MUL   DX
      SHR   EAX,  8
      MOV   AH, DL
      XCHG  EAX, EBX
      CMP   AH,  0
      JZ    @XinRange
      MOV   AL,  0
      MOV   BL,  0
      @XinRange:
      CMP   BH,  0
      JZ    @YinRange
      MOV   AL,  0
      MOV   BL,  0
      @YinRange:
      MOV   AH,  BL
      INC   [X]
      MOV   EDX,   [LIGHT]
      CMP   [X], 320
      JNZ   @NO
      INC   [Y]
      MOV   [X], 0;
      @NO:
      MOV   BL,  [EDX+EAX]
      MOV   [EDI], BL
      INC   ESI
      INC   EDI
    DEC   ECX
    JNZ   @PixelLoop
  END;



(****************************************************************************)
(* This one does a bump-map. (slope+heights+transparent)                    *)
(****************************************************************************)
  PROCEDURE BumpMap3t(FROM, TOO, LIGHT : DWORD; LX, LY : INTEGER); ASSEMBLER;
  VAR X, Y : WORD;
  ASM
    MOV   ESI,   [FROM]
    MOV   EDI,   [TOO]
    MOV   ECX,   63360
    ADD   ESI,   320
    ADD   EDI,   320
    MOV   [X],   0
    MOV   [Y],   0
    @PixelLoop:
      MOV   BL,  [ESI]
      CMP   BL,  0
      JZ    @Skip
      MOVZX EAX, BYTE [ESI-320]
      MOVZX DX,  BYTE [ESI+320]
      SUB   AX,  DX
      MOVZX EBX, BYTE [ESI-1]
      MOVZX DX,  BYTE [ESI+1]
      SUB   BX,  DX
      ADD   AX,  [LX]
      ADD   BX,  [LY]
      ADD   AX,  [X]
      ADD   BX,  [Y]
      MOVZX DX, BYTE [ESI]
      NOT   DL
      SHR   DL, 1
      ADD   DL, 128
      MUL   DX
      SHR   EAX,  8
      MOV   AH, DL
      XCHG  EAX,  EBX
      MOVZX DX, BYTE [ESI]
      NOT   DL
      SHR   DL, 1
      ADD   DL, 128
      MUL   DX
      SHR   EAX,  8
      MOV   AH, DL
      XCHG  EAX, EBX
      CMP   AH,  0
      JZ    @XinRange
      MOV   AL,  0
      MOV   BL,  0
      @XinRange:
      CMP   BH,  0
      JZ    @YinRange
      MOV   AL,  0
      MOV   BL,  0
      @YinRange:
      MOV   AH,  BL
      MOV   EDX,   [LIGHT]
      MOV   BL,  [EDX+EAX]
      @Skip:
      INC   [X]
      CMP   [X], 320
      JNZ   @NO
      INC   [Y]
      MOV   [X], 0;
      @NO:
      MOV   [EDI], BL
      INC   ESI
      INC   EDI
    DEC   ECX
    JNZ   @PixelLoop
  END;



(****************************************************************************)
(* This one scales a 320*200 to 256*256 to use as source for rotate :)      *)
(****************************************************************************)
  PROCEDURE Scale320to256(FROM, TOO : DWORD);
  ASSEMBLER; VAR EEX, EFX : LONGINT; ASM
      MOV  ESI, [FROM]
      MOV  EDI, [TOO]
      MOV  ECX,  256
      MOV  [EFX], 0
      @LineLoop:
        PUSH ECX
        MOV  [EEX], 0
        MOV  ECX, 256
        @PixelLoop:
          MOV  EAX, [EFX]
          MOV  EBX, [EEX]
          SHR  EAX, 8
          SHR  EBX, 8
          MOV  EDX, 320
          mul  EDX
          ADD  EAX, EBX
          MOV  DL,  [ESI+EAX]
          MOV  [EDI], DL
          INC  EDI
          ADD  [EEX], 320
        DEC  CL
        JNZ  @PixelLoop
      ADD  [EFX], 200
      POP  ECX
      DEC  ECX
      JNZ  @LineLoop
  END;


(****************************************************************************)
(* This one scales a 256*256 to 320*200.                                    *)
(****************************************************************************)
  PROCEDURE Scale256to320(FROM, TOO : DWORD);
  VAR CX, CY : LONGINT;
      DX, DY : LONGINT;
      W1, W2 : LONGINT;
  BEGIN
     DX := (255 SHL 8) DIV 199;
     DY := (255 SHL 8) DIV 319;
     CX := 0;
     CY := 0;
     FOR W1 := 0 TO 199 DO BEGIN
      CY := 0;
      FOR W2 := 0 TO 319 DO BEGIN
       PutPixel(Too, W1, W2, GetPixel255(From, CX SHR 8, CY SHR 8));
       CY +:= DY;
      END;
      CX +:= DX;
     END;
  END;


(****************************************************************************)
(* This one applys two relocation maps to from. (from is 255*255 !)         *)
(****************************************************************************)
  PROCEDURE Relocate(From, Too, Distort1, Distort2, D1Ofs, D2Ofs : LONGINT); ASSEMBLER; ASM
      MOV   ESI, [FROM]
      MOV   EDI, [TOO]
      MOV   EDX, [Distort1]
      MOV   EBX, [Distort2]
      MOV   ECX, 64000
      @LOOP:
        PUSH   ECX
        MOVZX  EAX, BYTE PTR [EDX]
        ADD    EAX, [D1Ofs]
        SHL    EAX, 8
        MOVZX  ECX, BYTE PTR [EBX]
        SHL    ECX, 1
        ADD    ECX, [D2Ofs]
        ADD    EAX, ECX
        AND    EAX, $FFFF
        MOV    CL,  [ESI+EAX]
        MOV    [EDI], CL
        INC    EDX
        INC    EBX
        INC    EDI
        POP    ECX
      DEC   ECX
      JNZ   @Loop
  END;


(****************************************************************************)
(* Same, but doesn't draw color 0                                           *)
(****************************************************************************)
  PROCEDURE RelocateT(From, Too, Distort1, Distort2, D1Ofs, D2Ofs : LONGINT); ASSEMBLER; ASM
      MOV   ESI, [FROM]
      MOV   EDI, [TOO]
      MOV   EDX, [Distort1]
      MOV   EBX, [Distort2]
      MOV   ECX, 64000
      @LOOP:
        PUSH   ECX
        MOVZX  EAX, BYTE PTR [EDX]
        ADD    EAX, [D1Ofs]
        SHL    EAX, 8
        MOVZX  ECX, BYTE PTR [EBX]
        SHL    ECX, 1
        ADD    ECX, [D2Ofs]
        ADD    EAX, ECX
        AND    EAX, $FFFF
        MOV    CL,  [ESI+EAX]
        CMP    CL,  0
        JZ     @Skip
        MOV    [EDI], CL
        @Skip:
        INC    EDX
        INC    EBX
        INC    EDI
        POP    ECX
      DEC   ECX
      JNZ   @Loop
  END;



(****************************************************************************)
(* This one does a ripple. (X86 version)                                    *)
(****************************************************************************)
  PROCEDURE Ripple_x86(VAR Page1, Page2 : DWORD); ASSEMBLER; ASM
    MOV  ECX, [Page1]
    MOV  EDX, [Page2]
    MOV  ESI, [ECX]
    MOV  EDI, [EDX]
    MOV  [ECX], EDI
    MOV  [EDX], ESI
    ADD  ESI, 320
    ADD  EDI, 320
    MOV  ECX, 63360
    @LOOP:
      MOVZX EAX, BYTE [ESI-320]
      MOVZX EBX, BYTE [ESI-1]
      MOVZX EDX, BYTE [ESI+1]
      ADD   EAX, EBX
      MOVZX EBX, BYTE [ESI+320]
      ADD   EAX, EDX
      MOVZX EDX, BYTE [EDI]
      ADD   EAX, EBX
      SUB   EAX, 512
      SUB   EDX, 128
      INC   ESI
      SAR   EAX, 1
      SUB   EAX, EDX
      MOV   EBX, EAX
      SAR   EAX, 5
      SUB   EBX, EAX
      MOV   EAX, EBX
      ADD   EAX, 128
      CMP   EAX, 0
      JA    @OK1
      MOV   EAX, 0
      @OK1:
      CMP   EAX, 255
      JB    @OK2
      MOV   EAX, 255
      @OK2:
      MOV   [EDI], AL
      INC   EDI
    DEC  ECX
    JNZ  @Loop
  END;



(****************************************************************************)
(* This one does a ripple. (mmx version)                                    *)
(****************************************************************************)
  PROCEDURE Ripple_mmx(VAR Page1, Page2 : DWORD); ASSEMBLER; ASM
    MOV  ECX, [Page1]
    MOV  EDX, [Page2]
    MOV  ESI, [ECX]
    MOV  EDI, [EDX]
    MOV  [ECX], EDI
    MOV  [EDX], ESI
    MOV  ECX, 7920                    (* Loop count. (7920*8=65536-640)     *)
    ADD  EDI, 320                     (* Skip first line.                   *)
    ADD  ESI, 320                     (* Also on source.                    *)
    PSLLQ mm7, 64                     (* Clear mm7                          *)
    @LOOP:
      MOVQ  mm0, QWORD PTR [ESI-320]  (* Get 8 pixels above.                *)
      MOVQ  mm1, QWORD PTR [ESI-1]    (* Get 8 pixels left.                 *)
      MOVQ  mm2, mm0                  (* Copy above pixels.                 *)
      MOVQ  mm3, mm1                  (* Copy left pixels.                  *)
      PUNPCKHBW mm0, mm7              (* Unpack 4 above pxls in mm0 to words*)
      PUNPCKHBW mm1, mm7              (* Unpack 4 left pxls in mm1 to words *)
      PUNPCKLBW mm2, mm7              (* Unpack low above pxls to words.    *)
      PUNPCKLBW mm3, mm7              (* Unpack low left pxls to words.     *)
      PADDUSW mm0, mm1                (* Add above and left pixels.         *)
      PADDUSW mm2, mm3                (* Add 4 next above and left pixels.  *)
      MOVQ  mm4, QWORD PTR [ESI+1]    (* Get 8 right pixels.                *)
      MOVQ  mm5, QWORD PTR [ESI+320]  (* Get 8 below pixels.                *)
      MOVQ  mm1, mm4                  (* Copy 8 right pixels.               *)
      MOVQ  mm3, mm5                  (* Copy 8 below pixels.               *)
      PUNPCKHBW mm4, mm7              (* Unpack high right pxls to words.   *)
      PUNPCKHBW mm5, mm7              (* Unpack high below pxls to words.   *)
      PUNPCKLBW mm1, mm7              (* Unpack low right pxls to words.    *)
      PUNPCKLBW mm3, mm7              (* Unpack low below pxls to words.    *)
      PADDUSW mm4, mm5                (* Add right and below pixels.        *)
      PADDUSW mm1, mm3                (* Add other right and below pixels.  *)
      PADDUSW mm0, mm4                (* Now add 4st 4 pixels all together  *)
      PADDUSW mm2, mm1                (* Same for next four.                *)
      PSUBW   mm0, [MASK512W]
      PSUBW   mm2, [MASK512W]
      MOVQ    mm4, QWORD PTR [EDI]
      MOVQ    mm1, mm4
      PUNPCKHBW mm4, mm7
      PUNPCKLBW mm1, mm7
      PSUBW   mm4, [MASK128W]
      PSUBW   mm1, [MASK128W]
      PSRAW   mm0, 1
      PSRAW   mm2, 1
      PSUBW   mm0, mm4
      PSUBW   mm2, mm1
      MOVQ    mm3, mm0
      MOVQ    mm4, mm2
      PSRAW   mm3, 5
      PSRAW   mm4, 5
      PSUBW   mm0, mm3
      PSUBW   mm2, mm4
      PADDW   mm0, [MASK128W]
      PADDW   mm2, [MASK128W]
      PACKUSWB mm2, mm0               (* Pack words in mm2 and mm0 to bytes *)
      MOVQ  [EDI], mm2                (* Store 8 pixels on destination.     *)
      ADD  ESI, 8                     (* Increase source pointer.           *)
      ADD  EDI, 8                     (* Increase destination pointer.      *)
    DEC  ECX                          (* Decrease loop counter.             *)
    JNZ  @LOOP                        (* Jump until ECX = 0                 *)
    EMMS                              (* Exit multimedia state.             *)
  END;



(****************************************************************************)
(* Displacement effect.                                                     *)
(****************************************************************************)
  PROCEDURE DisPlace(From, Too, Disp : DWORD); ASSEMBLER; ASM
    MOV   EDI, [Too]
    MOV   ESI, [Disp]
    ADD   EDI, 320
    MOV   EDX, 1
    @LineLoop:
      XOR   ECX, ECX
      @PixelLoop:
        PUSH   EDX
        PUSH   ECX
        MOVZX  EBX, BYTE [ESI-320]
        MOVZX  EAX, BYTE [ESI+320]
        SUB    EBX, EAX
        ADD    EDX, EBX
        MOVZX  EBX, BYTE [ESI-1]
        MOVZX  EAX, BYTE [ESI+1]
        SUB    EBX, EAX
        ADD    ECX, EBX
        CMP    ECX, 0
        JA     @OK1
        MOV    ECX, 0
        @OK1:
        CMP    ECX, 319
        JB     @OK2
        MOV    ECX, 319
        @OK2:
        CMP    EDX, 0
        JA     @OK3
        MOV    EDX, 0
        @OK3:
        CMP    EDX, 199
        JB     @OK4
        MOV    EDX, 199
        @OK4:
          LEA    EDX, [EDX+4*EDX]
          MOV    EBX, 0
          SHL    EDX, 6
          ADD    EDX, ECX
          MOV    EBX, [FROM]
          MOV    AL, [EBX+EDX]
          MOV    BYTE [EDI], AL
          INC    EDI
          INC    ESI
          POP    ECX
          POP    EDX
      INC   ECX
      CMP   ECX, 320
      JNZ   @PixelLoop
    INC   EDX
    CMP   EDX, 195
    JNZ   @LineLoop
  END;

(****************************************************************************)
(* This one does a fire effect.                                             *)
(****************************************************************************)
  PROCEDURE DoFire(From, Too, Flame : DWORD); ASSEMBLER; ASM
    MOV  EDI, [TOO]
    MOV  ECX, 63360
    MOV  ESI, [FROM]
    MOV  EDX, [Flame]
    @LOOP:
      MOVZX EAX, BYTE PTR [ESI]
      MOVZX EBX, BYTE PTR [ESI+319]
      ADD   EAX, EBX
      MOVZX EBX, BYTE PTR [ESI+320]
      SHL   EBX, 2
      ADD   EAX, EBX
      MOVZX EBX, BYTE PTR [ESI+321]
      ADD   EAX, EBX
      MOVZX EBX, BYTE PTR [ESI+640]
      ADD   EAX, EBX
      SHR   EAX, 3
      MOVZX EBX, BYTE PTR [EDX]
      SHR   EBX, 3
      SUB   EAX,  EBX
      JNS   @Skip
      MOV   AL,  0
      @Skip:
      MOV   [EDI], AL
      INC   ESI
      INC   EDI
      INC   EDX
    DEC  ECX
    JNZ  @LOOP
  END;


(****************************************************************************)
(* Initialise two distortion maps for tunnel effect.                        *)
(****************************************************************************)
  PROCEDURE InitTunnel(Distort1, Distort2 : DWORD);
  VAR W1, W2, W3, W4, W5 : LONGINT;
      R1, R2, R3 : REAL;
  BEGIN
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN W3:=W1 ELSE W3:=1;
        IF W2<>0 THEN W4:=W2 ELSE W4:=1;
        R1:=Trunc(Exp(Ln(262144*(SQRT(W1*W1+W2*W2)+0.001))*0.1)*256);
        W5:=trunc(R1+(32*Sin(R1*1.284/64)));
        PutPixel(Distort1, W1+100, W2+160, W5 AND $FF);
      END;
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN R2:=W1 ELSE R2:=0.0001;
        IF W2<>0 THEN R3:=W2 ELSE R3:=0.0001;
        R1:=ArcTan(R3/R2)*(256/6.284);
        W3:=Trunc(R1);
        PutPixel(Distort2, W1+100, W2+160, W3 AND $FF);
      END;
  END;


(****************************************************************************)
(* Initialise two distortion maps for tunnel effect.                        *)
(****************************************************************************)
  PROCEDURE InitTunnel2(Distort1, Distort2 : DWORD);
  VAR W1, W2, W3, W4, W5 : LONGINT;
      R1, R2, R3 : REAL;
  BEGIN
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN W3:=W1 ELSE W3:=1;
        IF W2<>0 THEN W4:=W2 ELSE W4:=1;
        R1:=Trunc(Exp(Ln(262144*(SQRT(W1*W1+W2*W2)+0.001))*0.1)*256);
        W5:=trunc(R1+(32*Sin(R1*1.284/64)));
        W5:=TRUNC(R1);
        PutPixel(Distort1, W1+100, W2+160, W5 AND $FF);
      END;
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN R2:=W1 ELSE R2:=0.0001;
        IF W2<>0 THEN R3:=W2 ELSE R3:=0.0001;
        R1:=ArcTan(R3/R2)*(256/6.284) + ArcTan(SQRT(W1*W1+W2*W2))*2000;
        W3:=Trunc(R1);
        PutPixel(Distort2, W1+100, W2+160, W3 AND $FF);
      END;
  END;


(****************************************************************************)
(* Initialise two distortion maps for tunnel effect.                        *)
(****************************************************************************)
  PROCEDURE InitTunnelFast(Distort1, Distort2 : DWORD);
  VAR W1, W2, W3, W4, W5 : LONGINT;
      R1, R2, R3 : REAL;
  BEGIN
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN W3:=W1 ELSE W3:=1;
        IF W2<>0 THEN W4:=W2 ELSE W4:=1;
      	R1:=TRUNC(SQRT(((W3*W3)+(W4*W4))));
        R1:=Trunc(Exp((Ln(Ln(256*R1))*0.41))*256);
        W5:=Trunc(r1+(64*Cos(R1*1.284/64)));
        PutPixel(Distort1, W1+100, W2+160, W5 AND $FF);
      END;
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN R2:=W1 ELSE R2:=0.0001;
        IF W2<>0 THEN R3:=W2 ELSE R3:=0.0001;
        R1:=ArcTan(R3/R2)*(256/6.284);
        W3:=Trunc(R1);
        PutPixel(Distort2, W1+100, W2+160, W3 AND $FF);
      END;
  END;



(****************************************************************************)
(* Initialise two distortion maps for flashke effect.                       *)
(****************************************************************************)
  PROCEDURE InitFlashke(Distort1, Distort2 : DWORD);
  VAR W1, W2, W3, W4, W5 : LONGINT;
      R1, R2, R3 : REAL;
  BEGIN
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN W3:=W1 ELSE W3:=1;
        IF W2<>0 THEN W4:=W2 ELSE W4:=1;
      	R1:=TRUNC(SQRT(((W3*W3)+(W4*W4))));
        R1:=Trunc(Exp(Ln(256*R1)*0.21)*256);
        W5:=Trunc(R1+(64*Cos(R1*1.284/32)));
        PutPixel(Distort1, W1+100, W2+160, W5 AND $FF);
      END;
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN R2:=W1 ELSE R2:=0.0001;
        IF W2<>0 THEN R3:=W2 ELSE R3:=0.0001;
        R1:=ArcTan(R3/R2)*(256/6.284) + SQRT(R2*R2 + R3*R3);
        W3:=Trunc(R1);
        PutPixel(Distort2, W1+100, W2+160, W3 AND $FF);
      END;
  END;


(****************************************************************************)
(* Initialise two distortion maps for flashke effect.                       *)
(****************************************************************************)
  PROCEDURE InitSpiral(Distort1, Distort2 : DWORD);
  VAR W1, W2, W3, W4, W5 : LONGINT;
      R1, R2, R3 : REAL;
  BEGIN
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN W3:=W1 ELSE W3:=1;
        IF W2<>0 THEN W4:=W2 ELSE W4:=1;
       	R1:=TRUNC(SQRT(((W3*W3)+(W4*W4))));
        R1:=Trunc((exp(ln( ABS(Sin(R1/256))*128 )*0.2))*256);
        W5:=TRUNC(r1/(sin(R1/256)/cos(r1/256)));
        PutPixel(Distort1, W1+100, W2+160, W5 AND $FF);
      END;
  FOR W1:=-100 TO 99 DO
    FOR W2:=-160 TO 159 DO
      BEGIN
        IF W1<>0 THEN R2:=W1 ELSE R2:=0.0001;
        IF W2<>0 THEN R3:=W2 ELSE R3:=0.0001;
        R1:=(ArcTan(R3/R2)*(256/6.284)*4) + SIN(SQRT((SQR(R2)+SQR(R3))/256))*64 + COS(SQRT((SQR(R2)+SQR(R3))/256))*64;
        W3:=Trunc(R1);
        PutPixel(Distort2, W1+100, W2+160, W3 AND $FF);
      END;
  END;

(****************************************************************************)
(* Init's the standard light for the bumpmapper.                            *)
(****************************************************************************)
  PROCEDURE InitBump(Light : DWORD);
  VAR W1, W2 : LONGINT;
  FUNCTION CL(X:LONGINT):LONGINT;BEGIN IF X < 0 THEN CL:=0 ELSE CL := X END;
  BEGIN
   FOR W1 := 0 TO 255 DO
    FOR W2 := 0 TO 255 DO
     PutPixel255(Light, W1, W2, CL(255-TRUNC(SQRT(SQR(W1-128)+SQR(W2-128))/191*370)));
  END;
(****************************************************************************)
(* This one init's a lightmap with a smaller light.                         *)
(****************************************************************************)
  PROCEDURE InitBumpSmall(Light : DWORD);
  VAR W1, W2 : LONGINT;
  FUNCTION CL(X:LONGINT):LONGINT;BEGIN IF X < 0 THEN CL:=0 ELSE CL := X END;
  BEGIN
   FOR W1 := 0 TO 255 DO
    FOR W2 := 0 TO 255 DO
     PutPixel255(Light, W1, W2, CL(255-TRUNC(SQRT(SQR(W1-128)+SQR(W2-128))/191*740)));
  END;


(****************************************************************************)
(* This one loads a raw image from disk onto a fake screen. Only 256*256*8b *)
(****************************************************************************)
  PROCEDURE LoadRAW(Where : DWORD; Name : STRING);
  TYPE Square255 = ARRAY[0..255,0..255] OF BYTE;
  VAR F : FILE;
      P : ^Square255;
  BEGIN
    ASSIGN(F, Name);
    {$i-}
    RESET(F, 1);
    {$i+}
    P := PTR(Where);
    IF IORESULT = 0 THEN BEGIN
      BlockRead(F, P^, 65536);
    END;
    CLOSE(F);
  END;


(****************************************************************************)
(* This one allocate memory for a new fake screen. Returns offset           *)
(****************************************************************************)
  FUNCTION NewPage : DWORD;
  VAR Temp : POINTER;
  BEGIN
    getmem(temp, 65536);
    NewPage := OFS(Temp^);  (* Returns new page offset *)
  END;


(****************************************************************************)
(* This one allocates the memory allocated to the given offset.             *)
(****************************************************************************)
  PROCEDURE DisposePage(PageOffset : DWORD);
  VAR  Temp : Pointer;
  BEGIN
    Temp := PTR(PAgeOffset);
    Freemem(Temp, 65536);
  END;


(****************************************************************************)
(* This one detects if mmx is available.                                    *)
(****************************************************************************)
  FUNCTION MMXsupported : BOOLEAN;ASSEMBLER; ASM
    (* First check if the CPUID instruction is supported. *******************)
      PUSHFD                    (* PUSH Extended flags                      *)
      POP      EAX              (* Pop'em into EAX                          *)
      MOV      EBX, EAX         (* Copy into EBX                            *)
      XOR      EAX, $200000     (* Change the 21st byte                     *)
      PUSH     EAX              (* Push this new altered value              *)
      POPFD                     (* Pop'em into the EFLAGS register.         *)
      PUSHFD                    (* Push the flags again.                    *)
      POP      EAX              (* Pop'em into EAX again.                   *)
      CMP      EAX, EBX         (* See if we could change the 21st bit.     *)
      JZ       @NoMMX           (* nopez we could'nt .. CPUID NOT SUPPORTED *)
    (* Now check for mmx. ***************************************************)
      MOV      EAX, 1           (* Call subfunction 1.                      *)
      CPUID                     (* Execute CPUID                            *)
      AND      ECX, $00800000   (* Mask out mmx bit.                        *)
      JZ       @NOMMX           (* It's a zero .. no mmx.                   *)
      MOV      AL, 1            (* Yups ... we got mmx.                     *)
      @NOMMX:
  END;
(****************************************************************************)

BEGIN
  Write ('þ Mute''s educational VGA engine : ');
  IF (MMXSupported = TRUE) OR NOT(ParamSTR(1) = 'NOMMX') THEN BEGIN
    WriteLn ('using MMX technology !');
    ClearPage      := ClearPage_mmx;
    CopyPage       := CopyPage_mmx;
    CopyPageSmudge := CopyPageSmudge_mmx;
    MixPages       := MixPages_mmx;
    MixPages2      := MixPages2_mmx;
    MixPages3      := MixPages3_mmx;
    Ripple         := Ripple_mmx;
  END ELSE BEGIN
    WriteLn ('using X86 technology !');
    ClearPage      := ClearPage_x86;
    CopyPage       := CopyPage_x86;
    CopyPageSmudge := CopyPageSmudge_x86;
    MixPages       := MixPages_x86;
    MixPages2      := MixPages2_x86;
    MixPages3      := MixPages3_x86;
    Ripple         := Ripple_x86;
  END;
END.
Published in: Pascal
Download

Related snippets