Subversion Repositories Kolibri OS

;               with a few graphics effects demonstration.

; compiler    : FASM

; system      : KolibriOS

; author      : Macgub aka Maciej Guba

; email       : macgub3@wp.pl

; web         : http://macgub.co.pl, http://macgub.j.pl

; Fell free to use this intro in your own distribution of KolibriOS.

; Special greetings to KolibriOS team .

; I hope because my demos Christian Belive will be near to each of You.

; madis.kalme@mail.ee

; I tried optimizing it a bit, but don't know if it was successful. The objects

; can be:

; 1) Read from a file (*.3DS standard)

; 2) Written in manually (at the end of the code) ; now not exist

SIZE_Y equ 512                               ;      /////     I want definitely

TIMEOUT equ 10                               ;     ------     say:

ROUND equ 10                                 ;     \ @ @/     keep smiling every

TEX_X equ 512    ; texture width             ;      \ ./    / day.

TEX_Y equ 512    ;         height            ;       \/    /

TEX_SHIFT equ 9  ; texture width shifting    ;     __||__ /

TEXTURE_SIZE EQU (TEX_X * TEX_Y)-1           ;   /|      |

TEX equ SHIFTING ; TEX={SHIFTING | FLUENTLY} ;  / \      /

FLUENTLY = 0                                 ; /   |    |

SHIFTING = 1                                 ;     ------

CATMULL_SHIFT equ 8                          ;      |  |

LIGHT_SIZE equ 22                            ;      |  |

NON   =   0                                  ;     -/  \-

MMX   =   1

SSE   =   2

SSE2  =   3

SSE3  =   4

Ext   =   SSE3           ;Ext={ NON | MMX | SSE | SSE2 | SSE3 }

; For now correct only SSE2 and SSE3 versions. if you have older CPU

; use older versions of app. Probably ver 005 will be OK but it need

; re-edit to support new Kolibri features.

USE_LFN = 1  ; App is Kolibri only now.

        org    0x0

        db     'MENUET01'       ; 8 byte id

        dd     0x01             ; header version

        dd     START            ; start of code

        dd     I_END            ; size of image

        dd     MEM_END          ; memory for app

        dd     MEM_END          ; esp

        dd     I_Param          ; I_Param

        dd     0x0              ; I_Icon

        rdtsc

        mov    [rand_seed],ax

        cld

        push   dword (SIZE_Y shr 3) * 3

        fninit

        fild   dword[esp]

        fstp   [rsscale]

        pop    ebx

        call   read_param

        call   read_from_disk    ; read, if all is ok eax = 0

        cmp    eax,0

        jne    .gen

        mov    esi,[fptr]

        cmp    [esi],word 4D4Dh

        jne    .asc

        call   read_tp_variables ; init points and triangles count variables

        cmp    eax,0

        je     .gen

        jmp    .malloc

    .gen:

        call   generate_object

        jmp    .opt

    .asc:

        mov    [triangles_count_var],10000  ; to do: read asc header

        mov    [points_count_var],10000

        call   alloc_mem_for_tp

        call   read_asc

        jmp    .opt

    .malloc:

        call   alloc_mem_for_tp

        call   read_from_file

    .opt:

        call   optimize_object1     ;  proc in file b_procs.asm

                                    ;  set point(0,0,0) in center and  calc all coords

                                    ;  to be in <-1.0,1.0>

        call   normalize_all_light_vectors

        call   copy_lights ; to aligned float

        call   init_triangles_normals2

        call   init_point_normals

        call   init_envmap2

        call   init_envmap_cub

        call   generate_texture2

        call   init_sincos_tab

        call   do_color_buffer   ; intit color_map

     if Ext >= SSE3

        call   init_point_lights

        mov    [fire_flag],0     ; proteza

       end if

        mov    edi,bumpmap

        call   calc_bumpmap

        call   calc_bumpmap_coords   ; bump and texture mapping

        call   do_edges_list

        call   draw_window

     if Ext > SSE2

        mov     eax,1

        cpuid

        bt      ecx,0  ; is sse3 on board?

        jc      @f

        mov     [max_dr_flg],12

        mov     [isSSE3],0

       @@:

     end if

        cmp    [edit_flag],1

        jne    @f

        mov    eax,40         ; set events mask

        mov    ebx,1100000000000000000000000100111b

        jmp    .int

      @@:

        mov    eax,40         ; set events mask

        mov    ebx,111b

      .int:

        int    0x40

      if Ext > SSE2

        cmp    [ray_shd_flag],1

        jne    @f

        cmp    [isSSE3],1

        jne    @f

        mov    eax,10

        jmp    .intt

      end if

        mov     eax,23

        mov     ebx,TIMEOUT

        cmp     [speed_flag],0

        je      .skip

        mov     eax,11

     .skip:

        cmp     [edit_flag],1

        jne     @f

        mov     eax,10

      .intt:

        int     0x40

        je      red

        cmp     eax,2           ; key event ?

        je      key

        cmp     eax,3           ; button event ?

        je      button

        mov     eax,37

        mov     ebx,7           ; get mouse scroll

        int     0x40

        and     eax, 0xFFFF     ; check only vertial

        cmp     eax, 65535

        je      button.zoom_in

        cmp     eax, 1

        je      button.zoom_out

        mov     eax,esi

        jne     @f

        cmp     [edit_flag],1   ; handle mouse only when edit is active

        jne     @f

        mov     eax,37

        mov     ebx,3   ;read mouse state

        int     0x40

        mov     [mouse_state],eax

        call    edit

       @@:

        jmp     noclose

        mov     eax,9  ; get process info

        mov     ebx,procinfo

        mov     ecx,-1

        int     0x40

        mov     eax,[procinfo+42]    ; read params of window

        sub     eax,225

        mov     [size_x_var],ax

        shr     ax,1

        mov     [vect_x],ax

;

        mov     eax,[procinfo+46]

        sub     eax,30

        mov     [size_y_var],ax

        shr     ax,1

        mov     [vect_y],ax

        mov     [x_start],ax

        mov     eax,[procinfo+38]

        mov     [y_start],ax

        call    alloc_buffer_mem ;realloc mem for scr & z buffs

        call    draw_window

        mov     eax,2           ; just read it and ignore

        int     0x40

        shr     eax,16          ; use scancodes (al)

        je      button.zoom_in

        cmp     al, 012 ;-

        je      button.zoom_out

        cmp     al, 075 ;left

        je      add_vec_buttons.x_minus

        cmp     al, 077 ;right

        je      add_vec_buttons.x_plus

        cmp     al, 072 ;up

        je      add_vec_buttons.y_minus

        cmp     al, 080 ;down

        je      add_vec_buttons.y_plus

        cmp     al, 073 ;page up

        je      .rot_inc_y

        cmp     al, 081 ;page down

        je      .rot_dec_y

        cmp     al, 051 ;<

        je      .rot_dec_x

        cmp     al, 052 ;>

        je      .rot_inc_x

        cmp     al, 057 ;space

        je      .rot_z

	inc     [angle_x]

	and     [angle_x],0xff

	jmp     noclose.end_rot

	.rot_dec_x:

	dec     [angle_x]

	and     [angle_x],0xff

	jmp     noclose.end_rot

	.rot_inc_y:

	inc     [angle_y]

	and     [angle_y],0xff

	jmp     noclose.end_rot

	.rot_dec_y:

	dec     [angle_y]

	and     [angle_y],0xff

	jmp     noclose.end_rot

	.rot_z:

	inc     [angle_z]

	and     [angle_z],0xff

	jmp     noclose.end_rot

        mov     eax,17          ; get id

        int     0x40

        jne     @f

        int     0x40

    @@:

        cmp     ah,30

        jge     add_vec_buttons

        call    update_flags          ; update flags and write labels of flags

        cmp     ah,3                  ; ah = 3 -> shading model

        jne     .next_m6

        cmp     [dr_flag],2

        jne     @f

   ;     call    init_envmap2    ;   <----! this don't works in env mode

                                 ;          and more than ~18 kb objects

 ;       call    init_envmap_cub2

     @@:

        cmp     [dr_flag],4

        jne     @f

        call    generate_texture2

     .next_m6:

                                      ; ah = 5 -> scale-

        cmp     ah,5

        jne     @f

        .zoom_out:

        mov     dword[scale],0.7

        fninit

        fld     [rsscale]

        fmul    [scale]

        fstp    [rsscale]

       @@:

        cmp     ah,6                 ; ah = 6 ->  scale+

        jne     @f

      .zoom_in:

        mov     dword[scale],1.3

        fninit

        fld     [rsscale]

        fmul    [scale]

        fstp    [rsscale]

       @@:

        cmp     ah,9    ; lights random                 ;    'flat'  0

        jne     .next_m5                                ;    'grd '  1

        call    make_random_lights                      ;    'env '  2

        call    normalize_all_light_vectors             ;    'bump'  3

        call    copy_lights

      if Ext >= SSE3

        call   init_point_lights  ; for ex. ray casting

      end if

        call    do_color_buffer   ; intit color_map     ;    'tex '  4

    .next_m5:

        cmp      ah,11

        je       @f

        cmp      ah,12

        je       @f

        cmp      ah,13

        jne      .next_m4

      @@:

        call     mirror

     .next_m4:

        cmp      ah,14

        jne      @f

		.xchg:

        call     exchange

     @@:

        cmp      ah,15

        jne      @f

        cmp      [emboss_flag],1

     ;   call     init_envmap2

        call     do_emboss

     @@:

;        cmp      ah,17

;        jne      .next_m

;        cmp      [move_flag],2

;        jne      @f

;        call     draw_window             ; redraw other labels to navigation buttons

;      @@:

;        cmp      [move_flag],0

;        jne      .next_m

;        call     draw_window             ; redraw other labels to navigation buttons

     .next_m:

        cmp      ah,18

        jne      .next_m2

        mov      [triangles_count_var],20000

        mov      [points_count_var],20000

        call     alloc_mem_for_tp

        mov      [re_alloc_flag],0

       ; or       bl,bl

       ; jz       .next_m2

        cmp      bl,1

        jne      @f

        call     generate_object

        jmp      .calc_norm

      @@:

        cmp      bl,4

        jg       @f

        movzx    eax,bl                ; eax < - object number

        call     generate_object2

        jmp     .calc_norm

      @@:

        call    generate_object3

      .calc_norm:

        call    optimize_object1

        call    init_triangles_normals2

        call    init_point_normals

        call    calc_bumpmap_coords   ; bump and texture mapping

        call    do_edges_list

        call    write_info

     .next_m2:

        cmp      ah,19

        je       @f

        cmp      ah,20

        jne      .next_m3

     @@:

        mov      edi,bumpmap

        call     calc_bumpmap

     .next_m3:

        cmp     ah,21            ; re map bumps, texture coordinates

        jne     @f

        call    calc_bumpmap_coords

      @@:

        jmp     noclose

   add_vec_buttons:            ; can move: object, camera,.. list is open

                               ;

        cmp     ah,30

        jne     .next

        cmp     [move_flag],0

        jne     @f

;        cmp     [move_flag],2

;        je      .set_light1

        .y_minus:

        sub     [vect_y],10

        jmp     .next

      @@:

        cmp     [move_flag],1

        jne     @f

        sub     [yobs],10   ;  observator = camera position

        jmp     .next

      @@:

        sub     [sin_amplitude],10

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

;      .set_light1:          ;  r -

;        movzx   ebx,[light_no_flag]  ; * 22

;        mov     ecx,ebx

;        shl     ebx,4

;        shl     ecx,1

;        add     ebx,ecx

;        shl     ecx,1

;        add     ebx,ecx

;        add     ebx,lights+6    ; 6 -> light vector size

;

;        movzx   ecx,[light_comp_flag]

;        lea     ecx,[ecx*3}

;        add     ebx,ecx         ; ebx ->  color to set

      .next:

        cmp     ah,31

        jne     .next1

        cmp     [move_flag],1

        je      @f

        add     [vect_z],10

        jmp     .next1

      @@:

        add     [zobs],10         ;  observator = camera position

     .next1:

        cmp     ah,33

        jne     .next2

        cmp     [move_flag],0

        jne     @f

        .x_minus:

        sub     word[vect_x],10

        jmp     .next2

      @@:

        cmp     [move_flag],1

        jne     @f

        sub     [xobs],10         ;  observator = camera position

        jmp     .next2

      @@:

        fninit

        fld     [sin_frq]

        fsub    [sin_delta]

        fstp    [sin_frq]

      .next2:

        cmp     ah,32

        jne     .next3

        cmp     [move_flag],0

        jne     @f

        .x_plus:

        add     word[vect_x],10

        jmp     .next3

      @@:

        cmp     [move_flag],1

        jne     @f

        add     [xobs],10         ;  observator = camera position

        jmp     .next3

      @@:

        fninit

        fld     [sin_frq]      ; change wave effect frequency

        fadd    [sin_delta]

        fstp    [sin_frq]

      .next3:

        cmp     ah,34

        jne     .next4

        cmp     [move_flag],1

        je      @f

        jmp     .next4

      @@:

        sub     [zobs],10         ;  observator = camera position

      .next4:

        cmp     ah,35

        jne     .next5

        cmp     [move_flag],0

        jne      @f

      ;  call    add_vector

            .y_plus:

        add     [vect_y],10

        jmp     .next5

      @@:

        cmp     [move_flag],1

        jne     @f

        add     [yobs],10         ;  observator = camera position

        jmp     .next5

      @@:

        add     [sin_amplitude],10

      .next5:

        jz      .end_rot

        cmp     [r_flag],2

        jne     .no_x

        inc     [angle_x]

        and     [angle_x],0xff

        ;mov     [angle_z],0

        jmp     .end_rot

        cmp     [r_flag],0

        jne     .no_y

        inc     [angle_y]

        and     [angle_y],0xff

        ;mov     [angle_z],0

        jmp     .end_rot

        cmp     [r_flag],1

        jne     .end_rot

        mov     cx,[angle_x]

        inc     cx

        and     cx,0xff

        ;mov     [angle_z],0

        mov     [angle_y],cx

        mov     [angle_x],cx

     .end_rot:

        mov     edi,matrix

        call    make_rotation_matrix

    RDTSC

    push eax

        mov     esi,[points_normals_ptr]

        mov     edi,[points_normals_rot_ptr]

        mov     ebx,matrix

        mov     ecx,[points_count_var]

        call    rotary

        call    add_scale_to_matrix

        mov     edi,[points_rotated_ptr]

        mov     ebx,matrix

        mov     ecx,[points_count_var]

        call    rotary

        mov     edi,[points_translated_ptr]

        mov     ecx,[points_count_var]

        call    translate_points

        jne     @f

        call    clrscr          ; clear the screen

     @@:

    ;    cmp     [catmull_flag],1  ;non sort if Catmull = on

    ;    je      .no_sort

    ; 64 indexes    call    sort_triangles

      .no_sort:

        cmp     [dr_flag],7       ; fill if 2tex and texgrd

        jge     @f

        cmp     [dr_flag],6       ; non fill if dots

        je      .non_f

      @@:

        call    fill_Z_buffer     ; make background

     .non_f:

        cmp     [dr_flag],6

        jne     @f

        call     draw_dots

        jmp      .blurrr

      @@:

      if Ext > SSE2

        cmp     [ray_shd_flag],1  ;non fill if Catmull = off

        jne     @f

        cmp     [isSSE3],1

        jne     @f

        mov     ax,100

        jmp     .dr

       @@:

      end if

      .dr:

        call    draw_triangles  ; draw all triangles from the list

        cmp    [edit_flag],0

        jz     .no_edit

        call   clear_vertices_index

        movzx eax,[dr_flag]

        movzx ebx,[ray_shd_flag]

        shl   ebx,10

        or    eax,ebx

         call   draw_handlers

    ;    call   edit

        movzx eax,[dr_flag]

        movzx ebx,[ray_shd_flag]

        shl   ebx,10

        or    eax,ebx

        cmp   [sinus_flag],0

        je    .no_sin

        movzx eax,[dr_flag]

        movzx ebx,[ray_shd_flag]

        shl   ebx,10

        or    eax,ebx

        call  do_sinus

      ;  jmp   .finito

      .no_sin:

      @@:

        movzx   ecx,[fire_flag]

        cmp     [fire_flag],1

        je      @f

        cmp     [blur_flag],0

        je      .no_blur  ; no blur, no fire

        movzx   ecx,[blur_flag]

      @@:

        movzx   eax,[dr_flag]

        movzx   ebx,[ray_shd_flag]

        shl     ebx,10

        or      eax,ebx

        call    blur_screen    ; blur and fire

     ;   jmp     .finito

        cmp     [emboss_flag],0

        je      @f

        movzx eax,[dr_flag]

        movzx ebx,[ray_shd_flag]

        shl   ebx,10

        or    eax,ebx

        call    do_emboss

    .finito:

     @@:

    je      .no_inc_bright

    movzx   ebx,[inc_bright_flag]

    shl     ebx,4

    mov     esi,[screen_ptr]

    movzx   ecx,word[size_y_var]

    movzx   eax,word[size_x_var]

    mul     ecx

    lea     ecx,[eax*4]

    mov      bh,bl

    push     bx

    shl      ebx,16

    pop      bx

    push     ebx

    push     ebx

    movq     mm0,[esp]

    add      esp,8

else if Ext >= SSE2

    mov      bh,bl

    push     bx

    shl      ebx,16

    pop      bx

    movd     xmm0,ebx

    shufps   xmm0,xmm0,0

end if

  .oop:

if Ext=NON

    lodsb

    add     al,bl

    jnc     @f

    mov     byte[esi-1],255

    loop    .oop

   @@:

    mov     [esi-1],al

    loop    .oop

else if (Ext=MMX)|(Ext=SSE)

    movq    mm1,[esi]

    movq    mm2,[esi+8]

    paddusb mm1,mm0

    paddusb mm2,mm0

    movq    [esi],mm1

    movq    [esi+8],mm2

    add     esi,16

    sub     ecx,16

    jnz     .oop

else

    movaps  xmm1,[esi]

    paddusb xmm1,xmm0

    movaps  [esi],xmm1

    add     esi,16

    sub     ecx,16

    jnc     .oop

end if

    je      .no_dec_bright

    movzx   ebx,[dec_bright_flag]

    shl     ebx,4

    mov     esi,[screen_ptr]

    movzx   eax,word[size_x_var]

    movzx   ecx,word[size_y_var]

    mul     ecx

    lea     ecx,[eax*4]

 if (Ext = MMX)|(Ext = SSE)

    mov      bh,bl

    push     bx

    shl      ebx,16

    pop      bx

    push     ebx

    push     ebx

    movq     mm0,[esp]

    add      esp,8

else if Ext >=SSE2

    mov      bh,bl

    push     bx

    shl      ebx,16

    pop      bx

    movd     xmm0,ebx

    shufps   xmm0,xmm0,0

end if

 .oop1:

if Ext=NON

    lodsb

    sub     al,bl

    jb      @f

    mov     [esi-1],al

    loop    .oop1

   @@:

    mov     byte[esi-1],0

    loop    .oop1

else if (Ext = MMX)|(Ext=SSE)

    movq    mm1,[esi]

    psubusb mm1,mm0

    movq    [esi],mm1

    add     esi,8

    sub     ecx,8

    jnz     .oop1

else

    movaps  xmm1,[esi]

    psubusb xmm1,xmm0

    movaps  [esi],xmm1

    add     esi,16

    sub     ecx,16

    jnc     .oop1

end if

  .no_dec_bright:

    sub eax,[esp]

    sub eax,41

;    pop     eax

  .dc:

    xor     edx,edx

    mov     edi,10

    div     edi

    add     dl,30h

    mov     [STRdata+ecx-1],dl

    loop    .dc

    pop eax

    mov     ebx,[screen_ptr]

    mov     ecx,[size_y_var]

    mov     edx,[offset_y]

    cmp     [ray_shd_flag],1

    jge     .ff

    cmp     [dr_flag],11

    jge     .ff

    int     0x40

    jmp     .f

  .ff:

    mov     eax,65

    mov     esi,32

    xor     ebp,ebp

    int     0x40

   .f:

    mov  eax,13

    mov  bx,[size_x_var]

    add  ebx,18

    shl  ebx,16

    mov  bx,60

    mov  cx,[size_y_var]

    sub  cx,2

    shl  ecx,16

    mov  cx,9

    xor  edx,edx

    int  40h

    mov  bx,[size_x_var]

    add  ebx,18

    shl  ebx,16

    mov  bx,[size_y_var]

    sub  bx,2         ; [x start] *65536 + [y start]

    mov  ecx,0x00888888

    mov  edx,STRdata               ; pointer to text beginning

    mov  esi,10                    ; text length

    int  40h

;-------------------------PROCEDURES---------------------------------------------

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

include "flat_cat.inc"

include "tex_cat.inc"

include "bump_cat.inc"

include "3dmath.inc"

include "grd_line.inc"

include "b_procs.inc"

include "a_procs.inc"

include "grd_cat.inc"

include "bump_tex.inc"

include "grd_tex.inc"

include "two_tex.inc"

include "asc.inc"

if Ext >= SSE3

include "3r_phg.inc"

include '3stencil.inc'

include '3glass.inc'

include '3glass_tex.inc'

include '3ray_shd.inc'

end if

clear_vertices_index:

    mov   edi,[vertices_index_ptr]

    movzx eax,word[size_x_var]

    movzx ecx,word[size_y_var]

    imul  ecx,eax

    xor   eax,eax

    shr   ecx,1

    rep   stosd

ret

edit:     ; mmx required, edit mesh by vertex

        push   ebp

        mov    ebp,esp

        sub    esp,128

        .x_coord equ ebp-4

        .points_translated equ ebp-10

        .points            equ ebp-22

        .points_rotated    equ ebp-34

        .mx                equ ebp-70

    {

        movzx  ebx,word[.x_coord]

        movzx  ecx,word[.y_coord]

        movzx  edx,word[size_x_var]

        imul   edx,ecx

        add    ebx,edx

        push   ebx

        lea    ecx,[ebx*2]

        lea    ebx,[ebx*3]

        jl    @f

        add    ebx,[esp]

      @@:

        add    esp,4

        add    ebx,[screen_ptr]

        mov    ebx,[ebx]

        and    ebx,0x00ffffff

        cmp    ebx,0x00ff0000 ; is handle bar  ?

    }

        mov     eax,37  ; get mouse state

        mov     ebx,1   ; x = 5, y = 25 - offsets

        int     0x40

        movd    mm0,ebx

        movd    mm1,eax

        movd    mm3,[size_y_var]

        pcmpgtw mm0,mm1

        pcmpgtw mm3,mm1

        pxor    mm3,mm0

        movd    eax,mm3

        mov     cx,ax

        shr     eax,16

        and     ax,cx

        or      ax,ax

        jz      .no_edit

        psubw   mm1,mm0

        movd    eax,mm1

        ror    eax,16

       ; push   eax

       ; sub    esp,256

        mov    [.x_coord],eax

        test   word[mouse_state],100000000b

        jz     .not_press  ; check if left mouse button press

        jne    .no_edit

        add    ecx,[vertices_index_ptr]

        mov    cx,word[ecx]

        inc    cx

        mov    dword[edit_end_x],eax

        mov    dword[edit_start_x],eax

        jmp    .end

      .not_press:

        test   byte[mouse_state],1b       ; check if left button is held

        jz     .not_held

       ; check_bar

       ; jne    .no_edit

       ; add    ecx,[vertices_index_ptr]

       ; mov    cx,[ecx]

       ; inc    cx

        cmp    [vertex_edit_no],0 ; cx  ; vertex number

        je     .end

        push   dword[.x_coord]

        pop    dword[edit_end_x]

        jmp    .end

      .not_held:

        shr    [mouse_state],16

        test   byte[mouse_state],1b  ; test if left button released

        jz     .end

        check_bar

        jne    .end

        dec    esi

        lea    esi,[esi*3]

        add    esi,esi

        add    esi,[points_translated_ptr]

        emms

        paddw   mm1,mm0

        psubw   mm1,qword[vect_x]

        movd    dword[esi],mm1

     ; detranslate

        fninit

        fild word[esi+4]

        fstp dword[edi+8]

        fild word[esi+2]

        fisub word[offset_x]

        fstp dword[edi+4]

        fild word[esi]

        fisub word[offset_y]   ; proteza

        fstp dword[edi]

        lea     edi,[.mx]

        call    reverse_mx_3x3

        lea     edi,[.points_rotated]

        lea     ebx,[.mx]

        mov     ecx,1

        call    rotary

        movzx   edi,[vertex_edit_no]

        dec     edi

        lea     edi,[edi*3]

        shl     edi,2

        add     edi,[points_ptr]

        lea     esi,[.points_rotated]

        cld

        movsd

        movsd

        movsd

     ;   mov     ecx,3

     ;   cld

     ;   rep     movsd

        mov    [vertex_edit_no],0

      .end:

      mov   esp,ebp

      pop   ebp

ret

    push    ebp

    mov     ebp,esp

    .temp   equ ebp-4

    push    dword 0

    mov     ebx, 11

    int     0x40    ;  -> create heap, to be sure

    movzx    eax,word[size_y_var]

    mul      ecx

    lea      ecx,[eax*4]    ; more mem for r_phg cause

    add      ecx,256

    mov      eax,68

    mov      ebx,20

    mov      edx,[screen_ptr]

    int      0x40

    mov      [screen_ptr],eax

    shl      ecx,2

    add      ecx,256

    mov      eax,68

    mov      ebx,20

    mov      edx,[Zbuffer_ptr]

    int      0x40

    mov      [Zbuffer_ptr],eax

    add      ecx,ecx

    add      ecx,256

    mov      eax,68

    mov      ebx,20

    mov      edx,[vertices_index_ptr]

    int      0x40

    mov      [vertices_index_ptr],eax

    pop      ebp

; updates flags and writing flag description

; in    ah - button number

        push    ax

        mov     edi,menu

      .ch_another:

        cmp     ah,byte[edi]     ; ah = button id

        jne     @f

        mov     bl,byte[edi+11]  ; max_flag + 1

        cmp     bl,255

        je      .no_write

        inc     byte[edi+12]     ; flag

        cmp     byte[edi+12],bl

        jne     .write

        mov     byte[edi+12],0

        jmp     .write

      @@:

        add     edi,17

        cmp     byte[edi],-1

        jne     .ch_another

        jmp     .no_write

     .write:

;     clreol   {pascal never dies}

;          * eax = 13 - function number

;  * ebx = [coordinate on axis x]*65536 + [size on axis x]

;  * ecx = [coordinate on axis y]*65536 + [size on axis y]

;  * edx = color 0xRRGGBB or 0x80RRGGBB for gradient fill

        movzx   ecx,byte[edi]

        sub     cl,2

        lea     ecx,[ecx*3]

        lea     ecx,[ecx*5]

        add     ecx,28

        shl     ecx,16

        add     ecx,14   ;  ecx = [coord y]*65536 + [size y]

        mov     bx,[size_x_var]

        shl     ebx,16

        add     ebx,(12+70)*65536+25     ; [x start] *65536 + [size x]

        mov     edx,0x00000000                  ;  color  0x00RRGGBB

        int     0x40

        movzx   ebx,byte[edi]

        sub     bl,2

        lea     ebx,[ebx*3]

        lea     ebx,[ebx*5]

        mov     cx,[size_x_var]