Subversion Repositories Kolibri OS

;MOS3DE V 0.1 - MENUETOS 3D  Engine V 0.1

; Compile with FASM for MENUET

; this is a very early Version: I'm so happy that it runs at all.

; Of course it's a bad ASM style and it can be optimized a lot.

; anyway - I have thought I uploap this so other PPL might optimize it

; as well or transform it to something completely diffrent.

; There are some Mouse- and Keyboardhandling Subs and Constructs. They are here

; because I will probably use them for the Navigation in a First Person

; Perspective Game - which is the goal of this project.

; http://www.melog.ch/mos_pub/   dietermarfurt@angelfire.com

; of course you can remove or replace them. It has only linear Texturemapping.

; Perspective Correction is a future option.

; a flag for multiple Textures selection should be implemented in the

; Meshfile Format. As I said - it's a very erarly version.

use32

               org    0x0

               db     'MENUET01'              ; 8 byte id

               dd     0x01                    ; header version

               dd     START                   ; start of code

               dd     I_END                   ; size of image

               dd     0x200000                ; memory for app

               dd     0x7fff0                 ; esp

               dd     0x0 , 0x0               ; I_Param , I_Icon

IMAGE_W		= 320

IMAGE_H		= 240

START:                          ; start of execution

    call init_gfx

    call draw_window            ; at first, draw the window

gamestart:

;   ******* MOUSE CHECK *******

    mov eax,37

    mov ebx,1     ; check mouseposition

    int 0x40

    mov ebx,eax

    shr eax,16

    and eax,0x0000FFFF  ; mousex

    and ebx,0x0000FFFF  ; mousey

    mov [mousex],eax

    mov [mousey],ebx

    cmp eax,5  ; mouse out of window ?

    jb check_refresh  ; it will prevent an app-crash

    cmp ebx,22

    jb check_refresh

    cmp eax, IMAGE_W

    jg check_refresh

    cmp ebx,221

    jg check_refresh

    cmp eax,160 ; navigating?

    jb m_left

    cmp eax,170 ;

    jg m_right

continue:

    cmp ebx,100 ;

    jb s_up

    cmp ebx,144 ;

    jg s_down

;   ******* END OF MOUSE CHECK *******

check_refresh:

    mov eax,23  ; wait for system event with 10 ms timeout

    mov ebx,1   ; wait 10 ms, then continue

    int  0x40

;    mov eax,11 ; or use this for full speed instead

;    int 0x40

    cmp  eax,1                  ; window redraw request ?

    je   red2

    cmp  eax,2                  ; key in buffer ?

    je   key2

    cmp  eax,3                  ; button in buffer ?

    je   button2

    call clear_screen

    call updateworld

    call put_screen

    ;call log ; used for debugging

    mov edi,[mouseya] ; check flag if a refresh has to be done

    cmp edi,1

    jne gamestart

    mov [mouseya],dword 0

    jmp gamestart

; END OF MAINLOOP

red2:                          ; redraw

    call draw_window

;    call draw_stuff

    jmp gamestart

key2:                          ; key

    mov  eax,2

    int  0x40

    cmp  al,1

    je   gamestart     ; keybuffer empty

    cmp ah,27    ; esc=End App

    je finish

    cmp  ah,178  ; up

    je   s_up

    cmp  ah,177  ; down

    je   s_down

    cmp  ah,176  ; left

    je   s_left

    cmp  ah,179  ; right

    je   s_right

    jmp gamestart ; was any other key

s_up:             ; walk forward (key or mouse)

    mov eax,[vpx]

    mov ebx,[vpy]

    mov ecx,[vheading]

    imul ecx,4

    add ecx,sinus

    mov edi,[ecx]

    mov edx,[vheading]

    imul edx,4

    add edx,sinus

    add edx,3600

    cmp edx,eosinus ;cosinus taken from (sinus plus 900) mod 3600

    jb ok200

    sub edx,14400

    ok200:

    mov esi,[edx]

;    sal esi,1  ; edit walking speed here

;    sal edi,1

    add eax,edi ; newPx

    add ebx,esi ; newPy

    mov edi,eax ; newPx / ffff

    mov esi,ebx ; newPy / ffff

    sar edi,16

    sar esi,16

    mov ecx,esi

    sal ecx,5 ; equal *32

    add ecx,edi

    add ecx,grid

    cmp [ecx],byte 0  ; collision check

    jne cannotwalk0

    mov [vpx],eax

    mov [vpy],ebx

    mov [mouseya],dword 1 ; set refresh flag

cannotwalk0:

    jmp check_refresh

s_down:                    ; walk backward

    mov eax,[vpx]

    mov ebx,[vpy]

    mov ecx,[vheading]

    imul ecx,4

    add ecx,sinus

    mov edi,[ecx]

    mov edx,[vheading]

    imul edx,4

    add edx,sinus

    add edx,3600

    cmp edx,eosinus ;cosinus taken from (sinus plus 900) mod 3600

    jb ok201

    sub edx,14400

    ok201:

    mov esi,[edx]

;    sal esi,1  ; edit walking speed here

;    sal edi,1

    sub eax,edi ; newPx

    sub ebx,esi ; newPy

    mov edi,eax ; newPx / ffff

    mov esi,ebx ; newPy / ffff

    sar edi,16

    sar esi,16

    mov ecx,esi

    sal ecx,5

    add ecx,edi

    add ecx,grid

    cmp [ecx],byte 0

    jne cannotwalk1

    mov [vpx],eax

    mov [vpy],ebx

    mov [mouseya],dword 1

cannotwalk1:

    jmp check_refresh

s_left:                                   ; turn left (key)

    mov edi,[vheading]  ; heading

    add edi,50

    cmp edi,1800

    jb ok_heading0

    sub edi,1800

    ok_heading0:

    mov [vheading],edi

    mov [mouseya],dword 1

    jmp check_refresh

s_right:                                  ; turn right

    mov edi,[vheading]

    sub edi,50

    cmp edi,-1

    jg ok_heading1

    add edi,1800

    ok_heading1:

    mov [vheading],edi

    mov [mouseya],dword 1

    jmp check_refresh

m_left:                                   ; turn left (mouse)

    mov edi,[vheading]  ; heading

    mov ecx,160

    sub ecx,eax

    sar ecx,2

    add edi,ecx

    cmp edi,1800

    jb ok_heading2

    sub edi,1800

    ok_heading2:

    mov [vheading],edi

    mov [mouseya],dword 1

    jmp continue    ; allow both: walk and rotate

m_right:                                  ; turn right

    mov edi,[vheading]

    sub eax,170

    sar eax,2

    sub edi,eax

    cmp edi,-1

    jg ok_heading3

    add edi,1800

    ok_heading3:

    mov [vheading],edi

    mov [mouseya],dword 1

    jmp continue

  button2:                       ; button

    mov  eax,17                  ; get id

    int  0x40

    cmp  ah,1                   ; button id=1 ?

    jne  gamestart

; eo GAME mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm

finish:

    mov  eax,-1                 ; close this program

    int  0x40

;   *********************************************

;   *******  WINDOW DEFINITIONS AND DRAW ********

;   *********************************************

draw_window:

    mov  eax,12                   ; function 12:tell os about windowdraw

    mov  ebx,1                    ; 1, start of draw; 2 - end

    int  0x40

	mov eax, 48                   ; get skin height

	mov ebx, 4

	int  0x40

	lea  ecx,[eax + (119 shl 16) + IMAGE_H + 4]

    mov  ebx,192*65536+IMAGE_W+9  ; [x start] *65536 + [x size]

    mov  edx,0x74000000           ; skinned window, not resizable

    mov  edi,labelt               ; window title

    mov  eax,0                    ; function 0 : define and draw window

    int  0x40

    mov  eax,12

    mov  ebx,2

    int  0x40

    ret

; ---------------------------------------------------------------------

init_gfx:

;  Pwidth = 63 Shl 16   ;original texture width in pixels -1 shl 16

;  Pheight = 63 Shl 16 ;original texture height in pixels -1 shl 16

   mov [pwidth],dword 63

   shl dword[pwidth],16

   mov [pheight],dword 63

   shl dword[pheight],16

;; Read in a mesh

   mov eax,0  ; tex1+4

   mov edi,anz

   add edi,4    ; beginning of mesh data

;using a copy will allow inverse kinematic transformations (future option)

   readmesh:

   mov edx,eax

   add edx,a_xwww ; desti

   mov ecx,[edi] ; value in ecx

   mov [edx],ecx

   add edi,4

   ;---

   mov edx,eax

   add edx,a_ywww ; desti

   mov ecx,[edi] ; value in ecx

   mov [edx],ecx

   add edi,4

   ;---

   mov edx,eax

   add edx,a_zwww ; desti

   mov ecx,[edi] ; value in ecx

   mov [edx],ecx

   add edi,4

   ;---

   add eax,4

   cmp edi,eo_mesh

   jl readmesh

;  zoom=-500

   mov [zoom],dword -500

ret

;------------------------------------------------------------------

log:

;write some Variable info to screen (used for debugging)

 pusha

  mov edi,wonder ;a_xwww

  ;add edi,200

  mov [remecx], dword 24

  print:

  mov eax,47

  mov ebx,0x000f0000

  ;mov ebx,0x000f0100  ; hex

  mov ecx,[edi]

  mov edx,[remecx]

  or edx,0x000C0000

  mov esi,0x00ff0000

  int 0x40

  add [remecx],dword 8

  add edi,dword 4

  cmp [remecx], dword 250

  jl print

 popa

ret

; ---------------------------------------------------------------------

;                          UPDATE WORLD

; ---------------------------------------------------------------------

 updateworld:

  mov edx,[a_xw]

; Miny% = 32767

; Maxy% = 0

  mov [miny],dword 32737

  mov [maxy],dword 0

; Color 0,0,0 ; clear screen - l8er

; Rect 0,0,320,240,1

; a=a+1.0 ; automatic rotation...

  add [a],dword 10

  cmp [a],dword 3598

  jl ok360

  mov [a],dword 0

  ok360:

; If a>359.9 Then a=0

; alpha=a

; beta=a

; gamma=a+a Mod 360

  mov eax,[a]

  mov [alpha],eax

  mov [beta], eax

  mov [gamma],eax

  add [gamma],eax

  cmp [gamma],dword 3599

  jl ok360_2

  sub [gamma],dword 3600

  ok360_2:

; mausy#=0.1+(MouseY()/50.0) ; >>>>>>l8er

  mov eax,[alpha]

  mov [alphacopy],eax

  mov eax,[beta]

  mov [betacopy],eax

  mov eax,[gamma]

  mov [gammacopy],eax

; For i=0 To anz ; do rotation and projection  etc

  mov esi,0

  for_i:

; *****************************

;    ROTATE pitch jaw roll...

; *****************************

;;  xl1#=zwww(i)*Sin(gamma)+xwww(i)*Cos(gamma)

    mov eax,esi

    imul eax,4

    add eax,a_zwww

    mov ebx,[eax]

    mov eax,[gammacopy]

    call get_sinus

    imul ebx,[eax]

    mov [tempdiv],ebx ; is zwww(i)*sin(gamma)

    mov eax,esi

    imul eax,4

    add eax,a_xwww

    mov ebx,[eax]

    mov eax,[gammacopy]

    call get_cosinus

    imul ebx,[eax]  ; is xwww*cos(gamma

    add ebx,[tempdiv]

    mov eax,ebx

    ;or eax,1

    cdq

     mov ecx,6553

     idiv ecx

    mov [xl1],eax

;;  yl1#=ywww(i)

    mov eax,esi

    imul eax,4

    add eax,a_ywww

    mov ebx,[eax]

    mov [yl1],ebx

;;  zl1#=zwww(i)*Cos(gamma)-xwww(i)*Sin(gamma)

    mov eax,esi

    imul eax,4

    add eax,a_zwww

    mov ebx,[eax]

    mov eax,[gammacopy]

    call get_cosinus

    imul ebx,[eax]

    mov [tempdiv],ebx ; is zwww(i)*cos(gamma)

    mov eax,esi

    imul eax,4

    add eax,a_xwww

    mov ebx,[eax]

    mov eax,[gammacopy]

    call get_sinus

    imul ebx,[eax]  ; is xwww*sin(gamma

    sub [tempdiv],ebx

    mov eax,[tempdiv]

    ;or eax,1

    cdq

    mov ecx,6553 ; once 6500

    idiv ecx

    mov [zl1],eax

;

;-----------------------------------------------------------------------

;;  xl2#=xl1

    mov eax,[xl1]

    mov [xl2],eax

;;  yl2#=yl1*Cos(beta)-zl1*Sin(beta)

    mov ebx,[yl1]

    mov eax,[betacopy]

    call get_cosinus

    imul ebx,[eax]

    mov [tempdiv],ebx ; is yl1*cos(beta)

    mov ebx,[zl1]  ; zl1

    mov eax,[betacopy]

    call get_sinus

    imul ebx,[eax]  ; is zl1*sin(beta

    sub [tempdiv],ebx

    mov eax,[tempdiv]

    ;or eax,1

    cdq

    mov ecx,6553

    idiv ecx

    mov [yl2],eax

;;  zl2#=yl1*Sin(beta)+zl1*Cos(beta)

    mov ebx,[yl1]

    mov eax,[betacopy]

    call get_sinus

    imul ebx,[eax]

    mov [tempdiv],ebx ; is yl1*sin(beta)

    mov ebx,[zl1]  ; zl1

    mov eax,[betacopy]

    call get_cosinus

    imul ebx,[eax]  ; is zl1*cos(beta

     add ebx,[tempdiv]

     mov eax,ebx

    ;or eax,1

    cdq

    mov ecx,6553

    idiv ecx

    mov [zl2],eax

;-----------------------------------------------------------------------

;;  xl3#=(yl2*Sin(alpha)+xl2*Cos(alpha))

    mov ebx,[yl2]

    mov eax,[alphacopy]

    call get_sinus

    imul ebx,[eax]

    mov [tempdiv],ebx ; is yl2*sin(alpha)

    mov ebx,[xl2]  ; xl2

    mov eax,[alphacopy]

    call get_cosinus

    imul ebx,[eax]  ; is xl2*cos(alpha

    add ebx,[tempdiv]

    mov eax,ebx

    ;or eax,1

    cdq

    mov ecx,6553

    idiv ecx

    mov [xl3],eax

;;  yl3#=(yl2*Cos(alpha)-xl2*Sin(alpha))

    mov ebx,[yl2]

    mov eax,[alphacopy]

    call get_cosinus

    imul ebx,[eax]

    mov [tempdiv],ebx ; is yl2*cos(alpha)

    mov ebx,[xl2]  ; xl2

    mov eax,[alphacopy]

    call get_sinus

    imul ebx,[eax]  ; is xl2*sin(alpha

    sub [tempdiv],ebx

    mov eax,[tempdiv]

    ;or eax,1

    cdq

    mov ecx,6553

    idiv ecx

    mov [yl3],eax

;;  zl3#=(zl2)

    mov eax,[zl2]

    mov [zl3],eax

;-----------------------------------------------------------------------

; *********************

;  PROJECTING 3D to 2D

;  If yloc# - Zoom <> 0 Then yloc = Int(yl3 ) * 200 / (zl3 - Zoom)

   ;-------

   mov ecx,[zl3]

   sub ecx,[zoom]

   mov eax,[yl3]

   imul eax,200

   or eax,1

   cdq

   idiv ecx

   ;mov eax,[yl3] ; no perpective

   mov [yloc],eax

   ;------

 ; If xloc# - Zoom <> 0 Then xloc = Int(xl3 ) * 200 / (zl3 - Zoom)

   ;------

   mov ecx,[zl3]

   sub ecx,[zoom]

   mov eax,[xl3]

   imul eax,200

   or eax,1

   cdq

   idiv ecx

   ;mov eax,[xl3] ; no perspective

   mov [xloc],eax

   ;------

;  xw(i)=((mausy#)*xloc) +160

;  yw(i)=((mausy#)*yloc) +120

;  zw(i)=(zl3+256)

   mov eax,[mousey] ; define scaling

   mov [factor],eax

   cmp eax,32000

   jl positivemousey

   mov [factor],dword 10

   jmp less220

   positivemousey:

   cmp eax,10

   jg more20

   mov [factor],dword 10

   jmp less220

   more20:

   cmp eax,220

   jl less220

   mov [factor],dword 220

   less220:

   mov eax,esi ; i...

   imul eax,4

   mov ecx,[xloc]

   mov eax,esi

   imul eax,4

   mov ebx,a_xw

   add ebx,eax

   imul ecx,[factor]

   sar ecx,5

   mov [ebx],ecx

   add [ebx],dword 160

   mov ecx,[yloc]

;   mov eax,esi

;   imul eax,4

   mov ebx,a_yw

   add ebx,eax

   imul ecx,[factor]

   sar ecx,5

   mov [ebx],ecx

   add [ebx],dword 120

   mov ecx,[zl3] ; used for z sorting

   mov ebx,a_zw

   add ebx,eax

   mov [ebx],ecx

   add [ebx],dword 256

; Next

  inc esi

  cmp esi,[anz]

  jle for_i

;---------------

  mov [sorted_quads],dword 0

; ; z-sorting...

; For i=0 To 10000 ; clear old info

;  zbuffer(i)=-1

; Next

  mov eax,zbuffer

  mov ebx,eax

  add ebx,40000

  clear_zbuffer:

  mov [eax],dword 1000000

  add eax,4

  cmp eax,ebx

  jle clear_zbuffer

; For i=0 To anz-3 Step 4

  mov eax,0

  mov ebx,[anz]

  for_i_0_to_anz:

;  If zw(i)>=0 ; clip Quads behind Camera

   mov ecx,eax

   imul ecx,4

   add ecx,a_zw

   mov edx,[ecx]

   cmp edx,0

   jle behindcamera

;   zwmax=zw(i)

    mov esi,edx

;   ;find quads internal most far point

;   If zwmax

;   If zwmax

;   If zwmax

    ; skip this for debugging

    ; jmp no_internal_sorting

    cmp esi,[ecx+4]

    jge checkmore1

    mov esi,[ecx+4]

    checkmore1:

    cmp esi,[ecx+8]

    jge checkmore2

    mov esi,[ecx+8]

    checkmore2:

    cmp esi,[ecx+12]

    jge checkmore3

    mov esi,[ecx+12]

    checkmore3:

    no_internal_sorting:

    mov [i],eax ; anz-ID in [i] (not times 4)

    push eax

    push ebx

;   While zbuffer(zwmax)<>-1 And zwmax<10000

;    zwmax=zwmax+1

;   Wend

    mov eax,esi  ; is actual z/poititon of point (used for z-order)

    imul eax,4

    findslot:

    mov ebx,eax

    add ebx,zbuffer

    cmp [ebx],dword 1000000

    je found_empty_slot

    add eax,4

    cmp eax,40000

    jl findslot

    found_empty_slot:

;   zbuffer(zwmax)=i

    inc dword[sorted_quads]  ; check slot writing

    mov ecx,[i]

    mov [ebx],ecx

    pop ebx

    pop eax

;  EndIf

   behindcamera:

; Next

  add eax,4

  cmp eax,[anz]  ;ebx

  jl for_i_0_to_anz

  ;----------------

  ;mov [rendered_quads],dword 0 ; debugging...

; For i2=10000 To 0 Step -1 ; reading quads in z-order from far to near

  mov eax,40000

  mov ebx,0

  for_i_0_to_10000:

;  i=zbuffer(i2)

   mov edx,eax

   add edx,zbuffer

   mov ecx,[edx] ; i...

;  If i>-1 And i< anz-2 ; if it isn't -1 then it's a Quad Point 1 ID

   cmp ecx,1000000

   je is_empty_slot

    ;inc dword[rendered_quads] ; used for debugging

;   ;***Mapping***

;   ;GetPolygonPoints(i)

;   ;FindSmallLargeY()

    mov [ilocal],ecx

    call get_polygon_points

    call find_small_large_y

;   X1% = Polypoints%(0, 0)

    mov edi,[polypoints]

    mov [x1],edi

;   Y1% = Polypoints%(0, 1)

    mov edi,[polypoints+4]

    mov [y1],edi

;   X2% = Polypoints%(1, 0)

    mov edi,[polypoints+8]

    mov [x2],edi

;   Y2% = Polypoints%(1, 1)

    mov edi,[polypoints+12]

    mov [y2],edi

;   ScanConvert(X1%, Y1%, X2%, Y2%, 1)     ;scan top of picture

    mov [pside],dword 1

    call scan_convert

;   X1% = Polypoints%(1, 0)

    mov edi,[polypoints+8]

    mov [x1],edi

;   Y1% = Polypoints%(1, 1)

    mov edi,[polypoints+12]

    mov [y1],edi

;   X2% = Polypoints%(2, 0)

    mov edi,[polypoints+16]

    mov [x2],edi

;   Y2% = Polypoints%(2, 1)

    mov edi,[polypoints+20]

    mov [y2],edi

;   ScanConvert(X1%, Y1%, X2%, Y2%, 2)   ;scan Right of picture

    mov [pside],dword 2

    call scan_convert

;   X1% = Polypoints%(2, 0)

    mov edi,[polypoints+16]

    mov [x1],edi

;   Y1% = Polypoints%(2, 1)

    mov edi,[polypoints+20]

    mov [y1],edi

;   X2% = Polypoints%(3, 0)

    mov edi,[polypoints+24]

    mov [x2],edi

;   Y2% = Polypoints%(3, 1)

    mov edi,[polypoints+28]

    mov [y2],edi

;   ScanConvert(X1%, Y1%, X2%, Y2%, 3)  ;scan bottom of picture

    mov [pside],dword 3

    call scan_convert

;   X1% = Polypoints%(3, 0)

    mov edi,[polypoints+24]

    mov [x1],edi

;   Y1% = Polypoints%(3, 1)

    mov edi,[polypoints+28]

    mov [y1],edi

;   X2% = Polypoints%(0, 0)

    mov edi,[polypoints]

    mov [x2],edi

;   Y2% = Polypoints%(0, 1)

    mov edi,[polypoints+4]

    mov [y2],edi

;   ScanConvert(X1%, Y1%, X2%, Y2%, 4)    ;scan Left of picture

    mov [pside],dword 4

    call scan_convert

;   TextureMap()

     call texture_map

;  EndIf

   is_empty_slot:

; Next

  sub eax,4

  cmp eax,0  ;ebx

  jge for_i_0_to_10000

;Wend

ret

;End

; ---------------------------------------------------------------------

get_sinus:

 imul eax,4 ; expects degree*10

 add eax,sinus

ret

get_cosinus:

 imul eax,4 ; expects degree*10

 add eax,sinus

 add eax,10804

 cmp eax,eosinus

 jl ok3600sub

 sub eax,14400

 ok3600sub:

ret

;; ------------------ texture mapping functions-----------------------------

;Function GetPolygonPoints(ilocal%) ; initially read in a rectangle

get_polygon_points:

pusha

; For Count% = 0 To 3

;  Polypoints%(Count%, 0) = xw(ilocal%+Count%)

;  Polypoints%(Count%, 1) = yw(ilocal%+Count%)

; Next

  mov eax,0

; ---

  count_0_3:

  mov ebx,eax

  imul ebx,8         ; count

  add ebx,polypoints  ; desti adr

  mov ecx,eax

  add ecx,[ilocal]

  imul ecx,4

  add ecx,a_xw      ; src adr

  mov edx,[ecx]

  mov [ebx],edx

  ; ----

  add ebx,4          ; desti 2

  mov ecx,eax

  add ecx,[ilocal]

  imul ecx,4

  add ecx,a_yw       ; src 2

  mov edx,[ecx]

  mov [ebx],edx

  ; ----

  inc eax

  cmp eax,4

  jl count_0_3

;End Function

 popa

ret

; -------------------------------------------------------------------------

;Function FindSmallLargeY()

find_small_large_y:

 pusha

; For Count% = 0 To 3

  mov eax,0

  for03b:

;  Ycoord% = Polypoints%(Count%, 1)

   mov ebx,eax

   imul ebx,8

   add ebx,4

   add ebx,polypoints

   mov ecx,[ebx]

;  If Ycoord% < Miny% Then       ; is this the New lowest y co-ord?

;   Miny% = Ycoord%             ; Yes...

;  End If

   cmp ecx,[miny]

   jge isge0

   mov [miny],ecx

   isge0:

;  If Ycoord% > Maxy% Then       ; is this the New highest y co-ord?

;   Maxy% = Ycoord%             ; Yes...

;  End If

   cmp ecx,[maxy]

   jle isge1

   mov [maxy],ecx

   isge1:

; Next

  inc eax

  cmp eax,4

  jl for03b

;End Function

 popa

ret

; -------------------------------------------------------------------------

;Function ScanConvert (X1%, Y1%, X2%, Y2%, Pside)

scan_convert:

 pusha

; If Y2% < Y1% Then

  mov eax,[y1]

  mov ebx,[y2]

  cmp eax,ebx

  jl l_else0

;  temp%=X1% : X1%=X2% : X2%=temp%

;  temp%=Y1% : Y1%=Y2% : Y2%=temp%

;  Lineheight% = (Y2% - Y1%)

;  ScanLeftSide(X1%, X2%, Y1%, Lineheight%, Pside)

   mov [y1],ebx ; swap y,x

   mov [y2],eax

    mov eax,[x1]

    mov ebx,[x2]

   mov [x1],ebx

   mov [x2],eax

   mov eax,[y1]

    mov ebx,[y2]

    ; eo swap

   sub ebx,eax

    mov [lineheight],ebx

    call scan_left_side

   jmp l_endif0

; Else

  l_else0:

;  Lineheight% = (Y2% - Y1%)

;  ScanRightSide(X1%, X2%, Y1%, Lineheight%, Pside)

   sub ebx,eax

   mov [lineheight],ebx

   call scan_right_side

; End If

  l_endif0:

;End Function

 popa

ret

; -------------------------------------------------------------------------

;Function ScanLeftSide (X1%, X2%, Ytop%, Lineheight%, Pside)

 scan_left_side:

  pusha

  mov eax,[y1]

  mov [ytop],eax

; Lineheight% = Lineheight% + 1       ; prevent divide by zero

  inc dword[lineheight]

; Xadd = (X2% - X1%) Shl 16

  mov edi,[x2]

  sub edi,[x1]

  sal edi,16

; Xadd = Xadd / Lineheight%

  mov eax,edi ; whole

  cdq

  mov ebx,[lineheight] ; divisor

; or ebx,1

  idiv ebx ; result now in eax

  mov [v_xadd],eax

; ------------

; If Pside = 1 Then

  cmp [pside],dword 1

  jne psidenot10

;  Px = Pwidth% - 1

;  Py = 0

   mov edi,[pwidth]

   mov esi,edi

   sub esi,1

   mov [px],esi

   mov [py],dword 0

;  Pxadd = -Pwidth%  / Lineheight%

;  Pyadd = 0

   mov eax,0

   sub eax,[pwidth]

   cdq

   mov ebx,[lineheight] ; divisor

   ;or ebx,1

   idiv ebx ; result now in eax

   mov [pxadd],eax

   mov [pyadd],dword 0

; End If

  psidenot10:

; ------------

; If Pside = 2 Then

  cmp [pside],dword 2

  jne psidenot20

;  Px = Pwidth%

;  Py = Pheight%

   mov edi,[pwidth]

   mov esi,[pheight]

   mov [px],edi

   mov [py],esi

;  Pxadd = 0

;  Pyadd = -Pheight%  / Lineheight%

   mov [pxadd],dword 0

   mov eax,0

   sub eax,[pheight]

   cdq

   mov ebx,[lineheight] ; divisor

   ;or ebx,1

   idiv ebx ; result now in eax

   mov [pyadd],eax

; End If

  psidenot20:

; ------------

; If Pside = 3 Then

  cmp [pside],dword 3

  jne psidenot30

;  Px = 0

;  Py = Pheight%

   mov [px],dword 0

   mov edi,[pheight]

   mov [py],edi

;  Pxadd = Pwidth%  / Lineheight%

;  Pyadd = 0

   mov eax,[pwidth]

   cdq

   mov ebx,[lineheight] ; divisor

   ;or ebx,1

   idiv ebx ; result now in eax

   mov [pxadd],eax

   mov [pyadd],dword 0

; End If

  psidenot30:

; ------------