[Back to GRAPHICS SWAG index] [Back to Main SWAG index] [Original]

    {
     AL> Does anyone have any basic graphics routines in assembler that I
     AL> could learn from. ie. graphics mode asm
     AL> int 13h
     AL> mov DX, ??
     AL> end

    That would be something like:
            ASM
               mov  ax,0013h
               int  10h
            END;

    Here's some routines I've been using for awhile:
    ------------------------------ CUT --------------------------------------- }
    {                   A simple
    graphics unit.                           }{ Routines by Denthor of Asphyxia,
    Vassago and Cenor of Fata Morgana. } {          Feel free to use these
    routines. Have fun!                 }
    UNIT GFX;

    INTERFACE

    USES Crt;

    CONST VGA = $A000;

    TYPE Virtual = Array [1..64000] of byte;  { The size of our Virtual Screen }
         VirtPtr = ^Virtual;                  { Pointer to the virtual screen }

    PROCEDURE Paint( StartPoint,EndPoint , From, Dest : Word );
       { Paints screen over another one, doesn't handle color 0 }
    PROCEDURE ScrollUp(Where:Word);
       { Scrolls screen up, fast with virtualscreen }
    PROCEDURE ScrollUp2(Where:Word);
       { Scrolls screen up, faster when virtualscreen are not used }
    PROCEDURE ShutDown;
       { This frees the memory used by the virtual screen }
    PROCEDURE SetUpVirtual;
       { This sets up the memory needed for the virtual screen }
    PROCEDURE Cls (Where:word;Col : Byte);
       { This clears the screen to the specified color }
    PROCEDURE Flip (source,dest:Word);
      { This copies the entire screen at "source" to destination }
    PROCEDURE Pal (Col,R,G,B : Byte);
      { This sets the Red, Green and Blue values of a certain color }
    PROCEDURE GetPal (Col : Byte; Var R,G,B : Byte);
      { This gets the Red, Green and Blue values of a certain color }
    PROCEDURE Putpixel (X,Y : Integer; Col : Byte; where:word);
      { This puts pixel directly to memory, fast }
    FUNCTION  Getpixel (X,Y : Integer; where:word):byte;
      { This gets color of pixel from memory, fast }
    PROCEDURE SetMCGA;
      { This procedure gets you into 320x200x256 mode. }
    PROCEDURE SetText;
      { This procedure returns you to text mode.  }
    PROCEDURE WaitRetrace;
      { Waits fo vertical retrace }

    VAR    Virscr : VirtPtr;                      { 1st Virtual Screen }
           VirScr2 : VirtPtr;                     { 2nd Virtual Screen }
           VirScr3 : VirtPtr;                     { 3rd Virtual Screen }
           VirtualScreen1  : word;                { Virtual Screen 1. seg }
           VirtualScreen2 : Word;                 { Virtual Screen 2. seg }
           VirtualScreen3 : Word;                 { Virtual Screen 3. seg }

           Palette,Palette2 : Array[0..255,1..3] of Byte;
           Scr_Ofs : Array[0..199] of Word;

    IMPLEMENTATION

    PROCEDURE Paint( StartPoint,EndPoint , From, Dest : Word ); BEGIN;
          StartPoint:=StartPoint*320;
          EndPoint:=EndPoint*320-StartPoint;
          ASM
             push    ds
             mov     ax, From
             mov     es, ax
             mov     ax, Dest
             mov     ds, ax
             mov     di, EndPoint
             mov     Cx, StartPoint
          @Looppi:
             mov     Al, Es:[Di]
             cmp     Al, 0
             jz      @Ohi
             mov     Ds:[di], Al
          @Ohi:
             inc     di
             loop    @Looppi
             pop     ds
         END;
    END;

    PROCEDURE ScrollUp(Where:Word); Assembler; ASM
            push    ds
            mov     ax, [Where]
            mov     es, ax
            mov     ax, [Where]
            mov     ds, ax
            mov     Si, 320
            mov     di, 0
            mov     cx, 31840
            rep     movsw
            pop     ds
    END;

    PROCEDURE ScrollUp2(Where:Word); Assembler; ASM
            push    ds
            mov     ax, [Where]
            mov     es, ax
            mov     ax, [Where]
            mov     ds, ax
            mov     Si, 320
            mov     di, 0
            mov     cx,15920
            db      0F3h, 66h, 0A5h
            pop     ds
    END;

    Procedure ShutDown;
       { This frees the memory used by the virtual screen }
    BEGIN
      FreeMem (VirScr,64000);
      FreeMem (VirScr2,64000);
      FreeMem (VirScr3,64000);
    END;

    Procedure SetUpVirtual;
       { This sets up the memory needed for the virtual screen }
    BEGIN
      GetMem (VirScr,64000);
      VirtualScreen1 := seg (virscr^);
      GetMem (VirScr2,64000);
      VirtualScreen2 := seg (virscr2^);
      GetMem (VirScr3,64000);
      VirtualScreen3 := seg (virscr3^);
    END;

    Procedure Cls (Where:word;Col : Byte); assembler;
       { This clears the screen to the specified color }
    asm
       push    es
       mov     cx, 32000;
       mov     es,[where]
       xor     di,di
       mov     al,[col]
       mov     ah,al
       rep     stosw
       pop     es
    End;

    procedure flip(source,dest:Word); assembler;
      { This copies the entire screen at "source" to destination }
    asm
      push    ds
      mov     ax, [Dest]
      mov     es, ax
      mov     ax, [Source]
      mov     ds, ax
      xor     si, si
      xor     di, di
      mov     cx, 32000
      rep     movsw
      pop     ds
    end;

    Procedure Pal(Col,R,G,B : Byte); assembler;
      { This sets the Red, Green and Blue values of a certain color }
    asm
       mov    dx,3c8h
       mov    al,[col]
       out    dx,al
       inc    dx
       mov    al,[r]
       out    dx,al
       mov    al,[g]
       out    dx,al
       mov    al,[b]
       out    dx,al
    end;

    Procedure GetPal(Col : Byte; Var R,G,B : Byte);
      { This gets the Red, Green and Blue values of a certain color }
    Var
       rr,gg,bb : Byte;
    Begin
       asm
          mov    dx,3c7h
          mov    al,col
          out    dx,al

          add    dx,2

          in     al,dx
          mov    [rr],al
          in     al,dx
          mov    [gg],al
          in     al,dx
          mov    [bb],al
       end;
       r := rr;
       g := gg;
       b := bb;
    end;

    Procedure Putpixel (X,Y : Integer; Col : Byte; where:word); assembler;
      { This puts a pixel on the screen by writing directly to memory. }
    asm
       mov  ax,where
       mov  es,ax
       mov  bx,[y]
       shl  bx,1
       mov  di,word ptr [Scr_Ofs + bx]
       add  di,[x]
       mov  al,[col]
       mov  es:[di],al
    end;

    Function Getpixel (X,Y : Integer; where:word):byte; assembler;
      { This puts a pixel on the screen by writing directly to memory. }
    asm
       mov  ax,where
       mov  es,ax
       mov  bx,[y]
       shl  bx,1
       mov  di,word ptr [Scr_Ofs + bx]
       add  di,[x]
       mov  al,es:[di]
    end;

    Procedure SetMCGA;  { This procedure gets you into 320x200x256 mode. } BEGIN
      asm
         mov        ax,0013h
         int        10h
      end;
    END;

    Procedure SetText;  { This procedure returns you to text mode.  } BEGIN
      asm
         mov        ax,0003h
         int        10h
      end;
    END;

    procedure WaitRetrace; assembler;
      {  This waits for a vertical retrace to reduce snow on the screen }
    label
      l1, l2;
    asm
        mov dx,3DAh
    l1:
        in al,dx
        and al,08h
        jnz l1
    l2:
        in al,dx
        and al,08h
        jz  l2
    end;

    VAR Loop1:integer;

    BEGIN
      For Loop1 := 0 to 199 do
        Scr_Ofs[Loop1] := Loop1 * 320;
    END.

[Back to GRAPHICS SWAG index] [Back to Main SWAG index] [Original]