WebSVN – Kolibri OS – Diff – /programs/demos/view3ds/view3ds.asm

-; application : View3ds ver. 0.071 - tiny .3ds and .asc files viewer
+; application : View3ds ver. 0.074 - tiny .3ds and .asc files viewer
 ;               with a few graphics effects demonstration.
 ; compiler    : FASM
 ; system      : KolibriOS
 ; author      : Macgub aka Maciej Guba
 ; email       : macgub3@wp.pl
 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.
 ; 0 for short names (Menuet-compatible), 1 for long names (Kolibri features)
 USE_LFN = 1  ; App is Kolibri only now.
         dd     I_Param          ; I_Param
         dd     0x0              ; I_Icon
 START:    ; start of execution
+        rdtsc
+        mov    [rand_seed],ax
         cld
         push   dword (SIZE_Y shr 3) * 3
         fninit
         fild   dword[esp]
         fstp   [rsscale]
         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
-      if Ext >= SSE3
+        call   copy_lights ; to aligned float
-        call   copy_lights ; to aligned float
-      end if
+        call   init_triangles_normals2
-        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
-        mov    edi,bumpmap
+     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
-        ;mov     [draw_win_at_first],0
+     if Ext > SSE2
+        mov     eax,1
-        ;mov    eax,40         ; set events mask
+        cpuid
+        bt      ecx,0  ; is sse3 on board?
-        ;mov    ebx,1100000000000000000000000100111b
+        jc      @f
+        mov     [max_dr_flg],12
-        ;int    0x40
+        mov     [isSSE3],0
+       @@:
+     end if
 still:
         cmp    [edit_flag],1
         jne    @f
         mov    eax,40         ; set events mask
         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
         jne     @f
         mov     eax,10
       @@:
+      .intt:
         int     0x40
         cmp     eax,1           ; redraw event ?
         je      red
         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
-      if Ext >= SSE3
+        call    copy_lights
-        call    copy_lights
-      end if
+      if Ext >= SSE3
+        call   init_point_lights  ; for ex. ray casting
+      end if
         call    do_color_buffer   ; intit color_map     ;    'tex '  4
         call    init_envmap2    ; update env map if shading model = environment or bump
     .next_m5:
         jne     .next2
         cmp     [move_flag],0
         jne     @f
         .x_minus:
-        sub     [vect_x],10
+        sub     word[vect_x],10
         jmp     .next2
       @@:
         cmp     [move_flag],1
         jne     @f
         sub     [xobs],10         ;  observator = camera position
         jmp     .next2
         jne     .next3
         cmp     [move_flag],0
         jne     @f
         .x_plus:
-        add     [vect_x],10
+        add     word[vect_x],10
         jmp     .next3
       @@:
         cmp     [move_flag],1
         jne     @f
         add     [xobs],10         ;  observator = camera position
         jmp     .next3
     ; 64 indexes    call    sort_triangles
       .no_sort:
         cmp     [dr_flag],7       ; fill if 2tex and texgrd
         jge     @f
-        cmp     [catmull_flag],0  ;non fill if Catmull = off
+        cmp     [dr_flag],6       ; non fill if dots
-        je      .non_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
       @@:
-        call    draw_triangles  ; draw all triangles from the list
+      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
+        movzx   ax,[dr_flag]
+      .dr:
+        call    draw_triangles  ; draw all triangles from the list
         cmp    [edit_flag],0
         jz     .no_edit
         call   clear_vertices_index
-        call   draw_handlers
+        movzx eax,[dr_flag]
+        movzx ebx,[ray_shd_flag]
+        shl   ebx,10
+        or    eax,ebx
+         call   draw_handlers
     ;    call   edit
+    .no_edit:
+      .blurrr:
+        movzx eax,[dr_flag]
-    .no_edit:
+        movzx ebx,[ray_shd_flag]
+        shl   ebx,10
+        or    eax,ebx
+        cmp   [sinus_flag],0
+        je    .no_sin
+        movzx eax,[dr_flag]
-      .blurrr:
+        movzx ebx,[ray_shd_flag]
+        shl   ebx,10
+        or    eax,ebx
-        cmp  [sinus_flag],0
+        call  do_sinus
+      ;  jmp   .finito
-        je   @f
+      .no_sin:
-        call do_sinus
+      @@:
-      @@:
+        movzx   ecx,[fire_flag]
-        cmp     [fire_flag],0
+        cmp     [fire_flag],1
-        jne     @f
+        je      @f
-        cmp     [blur_flag],0
-        je      .no_blur  ; no blur, no fire
-        movzx   ecx,[blur_flag]
+        cmp     [blur_flag],0
-        call    blur_screen    ; blur and fire
+        je      .no_blur  ; no blur, no fire
-        jmp     .no_blur
+        movzx   ecx,[blur_flag]
+      @@:
-    @@:
+        movzx   eax,[dr_flag]
-        cmp     [emboss_flag],0
+        movzx   ebx,[ray_shd_flag]
+        shl     ebx,10
+        or      eax,ebx
-        jne     .emb           ; if emboss=true -> no fire
+        call    blur_screen    ; blur and fire
-        movzx   ecx,[fire_flag]
+     ;   jmp     .finito
         call    blur_screen    ; blur and fire
+    .no_blur:                  ; no blur, no fire
+        cmp     [emboss_flag],0
+        je      @f
-    .no_blur:                  ; no blur, no fire
+        movzx eax,[dr_flag]
-        cmp     [emboss_flag],0
+        movzx ebx,[ray_shd_flag]
-        je      @f
+        shl   ebx,10
-     .emb:
+        or    eax,ebx
         call    do_emboss
     .finito:
     mov     eax,7           ; put image
     mov     ebx,[screen_ptr]
     mov     ecx,[size_y_var]
-    mov    edx,[offset_y]
+    mov     edx,[offset_y]
+    cmp     [ray_shd_flag],1
+    jge     .ff
     cmp     [dr_flag],11
     jge     .ff
     int     0x40
     jmp     .f
   .ff:
 include "3r_phg.inc"
 include '3stencil.inc'
 include '3glass.inc'
 include '3glass_tex.inc'
-end if
+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
       fninit
       fldpi
       fadd      st,st
       mov       esi,[points_ptr]
-      mov       edi,tex_points
+      mov       edi,[tex_points_ptr]
       mov       ecx,[points_count_var]
       inc       ecx
 ;      cmp       [map_tex_flag],1
 ;      jne       .cylindric
       ; spherical mapping around y axle
     .env_done:
          mov     esp,ebp
          pop     ebp
 ret
-if Ext >= SSE3
+if   Ext >= SSE2
 init_point_normals:
 .z equ dword [ebp-8]
 .y equ dword [ebp-12]
 .x equ [ebp-16]
 .point_number equ dword [ebp-28]
 .hit_faces    equ dword [ebp-32]
         fninit
         push      ebp
         mov       ebp,esp
         sub       esp,64
         and       ebp,-16
         cmp       ecx,[triangles_count_var]
         jne       .ipn_check_face
         cvtsi2ss  xmm6,.hit_faces
         movaps    xmm7,.x
         rcpss     xmm6,xmm6
+        rcpss     xmm6,xmm6
         shufps    xmm6,xmm6,11000000b
         mulps     xmm7,xmm6
-        movaps    xmm6,xmm7
+        movlps    [edi],xmm7
-        mulps     xmm6,xmm6
-        andps     xmm6,[zero_hgst_dd]
-        haddps    xmm6,xmm6
-        haddps    xmm6,xmm6
-        rsqrtps    xmm6,xmm6
-        mulps     xmm7,xmm6
-        movlps    [edi],xmm7
         movhlps   xmm7,xmm7
         movss     [edi+8],xmm7
-        add       edi,12
+        call      normalize_vector
+    ;    movaps    xmm6,xmm7
+    ;    mulps     xmm6,xmm6
+    ;    andps     xmm6,[zero_hgst_dd]
+    ;    haddps    xmm6,xmm6
+    ;    haddps    xmm6,xmm6
+    ;    rsqrtps    xmm6,xmm6
+    ;    mulps     xmm7,xmm6
+    ;    movlps    [edi],xmm7
+    ;    movhlps   xmm7,xmm7
+    ;    movss     [edi+8],xmm7
+        add       edi,12
         inc       .point_number
         mov       edx,.point_number
         cmp       edx,[points_count_var]
         jne       .ipn_loop
         add     ebx,12
         pop     ecx
         sub     ecx,1
         jnz     @b
-       ; cmp     dword[ebp],-1
+ret
-       ; jne     @b
-ret
-if Ext >= SSE3
 copy_lights: ; after normalising !
         mov      esi,lights
         mov      edi,lights_aligned
         mov      ecx,3
        .again:
         inc      esi  ; skip  shiness
         pop      ecx
         loop     .again
 ret
 end if
 clrscr:
         mov     edi,[screen_ptr]
         movzx   ecx,word[size_x_var]
         movzx   eax,word[size_y_var]
 ret
+draw_triangles:
+;  in:  eax - render draw model
+        .tri_no          equ dword[ebp-60]
+        .point_index3    equ [ebp-8]
+        .point_index2    equ [ebp-12]
+        .point_index1    equ [ebp-16]
+        .yy3             equ [ebp-18]
+        .xx3             equ [ebp-20]
+        .yy2             equ [ebp-22]
+        .xx2             equ [ebp-24]
+        .yy1             equ [ebp-26]
+        .xx1             equ [ebp-28]
+        .zz3             equ [ebp-30]
+        .zz2             equ [ebp-32]
+        .zz1             equ [ebp-34]
+        .index3x12       equ [ebp-38]
+        .index2x12       equ [ebp-42]
+        .index1x12       equ [ebp-46]
+        .temp1           equ dword[ebp-50]
+        .temp2           equ dword[ebp-54]
+        .dr_flag         equ word[ebp-56]
+        push    ebp
+        mov     ebp,esp
+        sub     esp,60
+ ;       movzx   ax,[dr_flag]
         mov     .dr_flag,ax
 draw_triangles:
         emms
         paddw   mm1,mm0
         movd    dword[eax],mm1
      @@:
      if Ext >= SSE3
         cmp     [dr_flag],13
+        cmp     .dr_flag,13
         jnge    .no_stencil
         mov     esi,[triangles_ptr]
         mov     ecx,[triangles_count_var]
      @@:
         push    esi
         push    ecx
         cmp     [dr_flag],11
         je      .draw_smooth_line
         mov esi,[triangles_ptr]
-        mov ecx,[triangles_count_var]
+        xor ecx,ecx  ;mov ecx,[triangles_count_var]
+    .again_dts:
+       ; push    ebp
-    .again_dts:
+        push    esi
-        push    ecx
-        mov     ebp,[points_translated_ptr]
-      if Ext >= SSE2
-        mov     eax,dword[esi]
-        mov     [point_index1],eax
-        lea     eax,[eax*3]
-        add     eax,eax
-        push    ebp
-        add     ebp,eax
-        mov     eax,[ebp]
-   ;     cmp     [vertex_edit_no],0
-   ;     jne     @f
-   ;
-   ;   @@:
-        mov     dword[xx1],eax
-        mov     eax,[ebp+4]
+        push    ecx
-        mov     [zz1],ax
-        pop     ebp
-        mov     eax,dword[esi+4]
-        mov     [point_index2],eax
-        lea     eax,[eax*3]
-        add     eax,eax
-        push    ebp
-        add     ebp,eax
-        mov     eax,[ebp]
-        mov     dword[xx2],eax
-        mov     eax,[ebp+4]
-        mov     [zz2],ax
+        mov     .tri_no,ecx
+        mov     eax,[esi]
-        pop     ebp
+        mov     ebx,[esi+4]
-        mov     eax,dword[esi+8]        ; xyz3 = [ebp+[esi+4]*6]
-        mov     [point_index3],eax
-        lea     eax,[eax*3]
-        add     eax,eax
-    ;    push    ebp
-        add     ebp,eax
-        mov     eax,[ebp]
-        mov     dword[xx3],eax
-        mov     eax,[ebp+4]
-        mov     [zz3],ax
-      else
-        movq    mm0,[esi]           ; don't know MMX
+        mov     ecx,[esi+8]
-        mov     qword[point_index1],mm0
-       ; shr     eax,16
-       ; mov     [point_index2],ax
-        mov     eax,dword[esi+8]
-        mov     [point_index3],eax
-        movdqu  xmm0,[esi]
-        paddd   xmm0,xmm0
-        movdqa  xmm1,xmm0
+        mov     .point_index1,eax
-        paddd   xmm0,xmm0
-        paddd   xmm0,xmm1
+        mov     .point_index2,ebx
-        movd    eax,xmm0
-        psrldq  xmm0,4
+        mov     .point_index3,ecx
-        movd    ebx,xmm0
-        psrldq  xmm0,4
-        movd    ecx,xmm0
-        and     eax,0FFFFh
-        and     ebx,0FFFFh
-        and     ecx,0FFFFh
-        movq    mm0,[ebp+eax]
+        imul    eax,[i12]
-        movq    mm1,[ebp+ebx]
-        movq    mm2,[ebp+ecx]
+        imul    ebx,[i12]
-        movq    qword[xx1],mm0
-        movq    qword[xx2],mm1
-        movq    qword[xx3],mm2
-;        emms
-      end if  ; *********************************
- if 0
-        cmp     [vertex_edit_no],0
-        jne     .no_edit
-        mov     ax,[vertex_edit_no]
-        dec     ax
-        cmp     ax,[point_index1]
-        jne     @f
-        movd    mm0,[edit_start_x]
-        psubw   mm0,[edit_end_x]
+        imul    ecx,[i12]
-        movd    mm1,dword[xx1]
-        paddw   mm1,mm0
-        movd    dword[xx1],mm1
+        mov     .index1x12,eax
-        jmp     .no_edit
+        mov     .index2x12,ebx
+        mov     .index3x12,ecx
+        shr     eax,1
-       @@:
+        shr     ebx,1
+        shr     ecx,1
-        cmp     ax,[point_index2]
+        add     eax,[points_translated_ptr]
-        jne     @f
+        add     ebx,[points_translated_ptr]
-        movd    mm0,[edit_start_x]
+        add     ecx,[points_translated_ptr]
-        psubw   mm0,[edit_end_x]
+        push    word[eax+4]
-        movd    mm1,dword[xx2]
+        push    word[ebx+4]
-        paddw   mm1,mm0
+        push    word[ecx+4]
-        movd    dword[xx2],mm1
+        pop     word .zz3
-        jmp     .no_edit
+        pop     word .zz2
-       @@:
+        pop     word .zz1
-        cmp     ax,[point_index3]
+        mov     eax,[eax]
-        jne     @f
+        mov     ebx,[ebx]
-        movd    mm0,[edit_start_x]
+        mov     ecx,[ecx]
-        psubw   mm0,[edit_end_x]
+        ror     eax,16
-        movd    mm1,dword[xx3]
-        paddw   mm1,mm0
-        movd    dword[xx3],mm1
+        ror     ebx,16
-        jmp     .no_edit
+        ror     ecx,16
-       @@:
+        mov     .xx1,eax
         mov     .xx2,ebx
+        mov     .xx3,ecx
     .no_edit:
 end if
-        push esi                          ;
+      ;  push    esi
         fninit                            ; DO culling AT FIRST
         cmp     [culling_flag],1          ; (if culling_flag = 1)
         jne     .no_culling
+        lea     esi,.point_index1          ; *********************************
+        mov     ecx,3                     ;
-        mov     esi,point_index1          ; *********************************
+      @@:
-        mov     ecx,3                     ;
+        mov     eax,dword[esi]
-      @@:
+        lea     eax,[eax*3]
-        mov     eax,dword[esi]
-        lea     eax,[eax*3]
+        shl     eax,2
-        shl     eax,2
         add     eax,[points_normals_rot_ptr]
-;        lea     eax,[eax+point_normals_rotated]
+        mov     eax,[eax+8]
-        fld     dword[eax+8]             ; *****************************
+        bt      eax,31
-        ftst                             ; CHECKING OF Z COOFICIENT OF
+        jc      @f
-        fstsw   ax                       ; NORMAL VECTOR
+                       ; *****************************
-        sahf
+                       ; CHECKING OF Z COOFICIENT OF
-        jb      @f
+                       ; NORMAL VECTOR
-        ffree   st
+        add     esi,4
         loop    @b
         jmp     .end_draw   ; non visable
       @@:
-        ffree   st  ;is visable
       .no_culling:
-        cmp     [dr_flag],0               ; draw type flag
+        cmp     .dr_flag,0               ; draw type flag
         je      .flat_draw
-        cmp     [dr_flag],2
+        cmp     .dr_flag,2
         je      .env_mapping
-        cmp     [dr_flag],3
+        cmp     .dr_flag,3
         je      .bump_mapping
-        cmp     [dr_flag],4
+        cmp     .dr_flag,4
         je      .tex_mapping
-        cmp     [dr_flag],5
+        cmp     .dr_flag,5
         je      .rainbow
-        cmp     [dr_flag],7
+        cmp     .dr_flag,7
         je      .grd_tex
-        cmp     [dr_flag],8
+        cmp     .dr_flag,8
         je      .two_tex
-        cmp     [dr_flag],9
+        cmp     .dr_flag,9
         je      .bump_tex
-        cmp     [dr_flag],10
+        cmp     .dr_flag,10
         je      .cubic_env_mapping
-        cmp     [dr_flag],11
+        cmp     .dr_flag,11
+        je      .draw_smooth_line
+      if Ext >= SSE3
+        cmp     .dr_flag,12
+        je      .r_phg
+        cmp     .dr_flag,13
-        je      .draw_smooth_line
+        je      .glass
-      if Ext >= SSE3
+        cmp     .dr_flag,14
+        je      .glass_tex
-        cmp     [dr_flag],12
+        cmp     .dr_flag,100
-        je      .r_phg
+        je      .ray_shd
         cmp     [dr_flag],13
-        je      .glass
-        cmp     [dr_flag],14
-        je      .glass_tex
+     end if
      end if                                 ; ****************
-        mov     esi,point_index3      ; do Gouraud shading
+        push    ebp                    ; ****************
-        mov     ecx,3
+        lea     esi,.index3x12      ; do Gouraud shading
-      .again_grd_draw:
+        lea     edi,.zz3
-        mov     eax,dword[esi]
+        mov     ecx,3
-        shl     eax,2
+      .again_grd_draw:
-        lea     eax,[eax*3]
+        mov     eax,dword[esi]
         add     eax,[points_normals_rot_ptr]
         ; texture x=(rotated point normal -> x * 255)+255
         fld     dword[eax]       ; x cooficient of normal vector
         fimul   [correct_tex]
         fiadd   [correct_tex]
-        fistp   [temp1]
+        fistp   .temp1
         ; texture y=(rotated point normal -> y * 255)+255
         fld     dword[eax+4]      ; y cooficient
         fimul   [correct_tex]
         fiadd   [correct_tex]
-        fistp   [temp2]
-        mov      eax,[temp2]
-        mov      ebx,[temp1]
+        fistp   .temp2
-        and      ebx,0xfffffff
-        shl      eax,TEX_SHIFT
+        mov      eax,.temp2
-        add      eax,ebx
+        mov      ebx,.temp1
-        lea      eax,[eax*3+color_map]
+        and      ebx,0xfffffff
-        mov      eax,dword[eax]
+        shl      eax,TEX_SHIFT
-     ;   cmp     [catmull_flag],1      ; put on stack z coordinate if necessary
+        add      eax,ebx
-     ;   jne      @f
+        lea      eax,[eax*3+color_map]
-        lea      edx,[ecx*3]
+        mov      eax,dword[eax]
-        push     word[edx*2+xx1-2]    ; zz1 ,2 ,3
+        push     word[edi]    ; zz1 ,2 ,3
      ; @@:
+        ror      eax,16               ; eax -0xxxrrggbb -> 0xggbbxxrr
-        ror      eax,16               ; eax -0xxxrrggbb -> 0xggbbxxrr
+        xor      ah,ah
-        xor      ah,ah
+        push     ax         ;r
-        push     ax         ;r
+        rol      eax,8                ; eax-0xggbb00rr -> 0xbb00rrgg
-        rol      eax,8                ; eax-0xggbb00rr -> 0xbb00rrgg
-        xor      ah,ah
-        push     ax         ;g
-        shr      eax,24
-        push     ax         ;b
-        sub      esi,4
-        dec      cx
-        jnz      .again_grd_draw
-        jmp      .both_draw
-   ;     movzx   edi,[point_index3]   ;gouraud shading according to light vector
-   ;     lea     edi,[edi*3]
-   ;     lea     edi,[4*edi+point_normals_rotated] ; edi - normal
-   ;     mov     esi,light_vector
-   ;     call    dot_product
-   ;     fabs
-   ;     fimul   [orginal_color_r]
-   ;     fistp   [temp_col]
-   ;     and     [temp_col],0x00ff
-   ;     push    [temp_col]
-   ;     push    [temp_col]
-   ;     push    [temp_col]
-   ;     movzx   edi,[point_index2]
-   ;     lea     edi,[edi*3]
-   ;     lea     edi,[4*edi+point_normals_rotated] ; edi - normal
-   ;     mov     esi,light_vector
-   ;     call    dot_product
-   ;     fabs
-   ;     fimul   [orginal_color_r]
-   ;     fistp    [temp_col]
-   ;     and     [temp_col],0x00ff
-   ;     push    [temp_col]
-   ;     push    [temp_col]
-   ;     push    [temp_col]
-   ;     movzx   edi,[point_index1]
-   ;     lea     edi,[edi*3]
+        xor      ah,ah
-   ;     lea     edi,[4*edi+point_normals_rotated] ; edi - normal
-   ;     mov     esi,light_vector
+        push     ax         ;g
-   ;     call    dot_product
+        shr      eax,24
+        push     ax         ;b
-   ;     fabs
-   ;     fimul   [orginal_color_r]
+        sub      esi,4
-   ;     fistp   [temp_col]
+        sub      edi,2
-   ;     and     [temp_col],0x00ff
+        dec      cx
-   ;     push    [temp_col]
+        jnz      .again_grd_draw
-   ;     push    [temp_col]
+        jmp      .both_draw
    ;     push    [temp_col]
    .rainbow:
-       ; cmp     [catmull_flag],1      ; put on stack z coordinate if necessary
+        push     ebp
+        push     word .zz3
        ; jne      @f
-        push     [zz3]
+        mov      eax, .xx3
-      @@:
+        ror      eax,16
-        mov      eax,dword[yy3]
+        mov      ebx,0x00ff00ff
-        mov      ebx,0x00ff00ff
+        and      eax,ebx
-        and      eax,ebx
+        push     eax
+        neg      al
-        push     eax
+        push     ax
-        neg      al
+        push     word .zz2
         push     ax
-        push     [zz2]
+        mov      eax, .xx2
         ror      eax,16
-        mov      eax,dword[yy2]
+        and      eax,ebx
-        and      eax,ebx
         push     eax
-        neg      al
-        push     ax
+        neg      al
-        push     [zz1]
         push     ax
-        mov      eax,dword[yy1]
+        push     word .zz1
         and      eax,ebx
+        mov      eax, .xx1
-        push     eax
+        ror      eax,16
-        neg      al
+        and      eax,ebx
-        push     ax
+        push     eax
-    .both_draw:
+        neg      al
-        mov     eax,dword[xx1]
+        push     ax
-        ror     eax,16
+    .both_draw:
-        mov     ebx,dword[xx2]
-        ror     ebx,16
-        mov     ecx,dword[xx3]
-        ror     ecx,16
-        mov     edi,[screen_ptr]
+        mov     eax, .xx1
-        mov     esi,[Zbuffer_ptr]
-        call    gouraud_triangle_z
+        mov     ebx, .xx2
-        jmp     .end_draw
         mov     ecx, .xx3
-     .flat_draw:                     ;**************************
+        mov     edi,[screen_ptr]
-        fninit                             ; FLAT DRAWING
+        mov     esi,[Zbuffer_ptr]
-        mov     eax,[point_index1]
+        call    gouraud_triangle_z
-        mov     ebx,[point_index2]
+        pop     ebp
-        mov     ecx,[point_index3]
+        jmp     .end_draw
         shl     eax,2
-        shl     ebx,2
+     .flat_draw:                     ;**************************
-        shl     ecx,2
+        fninit                             ; FLAT DRAWING
-        lea     eax,[eax*3]  ;+point_normals_rotated]
+        mov     eax,.index1x12
-        add     eax,[points_normals_rot_ptr]
+        mov     ebx,.index2x12
-        lea     ebx,[ebx*3]  ;+point_normals_rotated]
+        mov     ecx,.index3x12
-        add     ebx,[points_normals_rot_ptr]
+        add     eax,[points_normals_rot_ptr]
-        lea     ecx,[ecx*3]  ;+point_normals_rotated]
+        add     ebx,[points_normals_rot_ptr]
         add     ecx,[points_normals_rot_ptr]
         fld     dword[eax]      ; x cooficient of normal vector
         fadd    dword[ebx]
         fadd    dword[ecx]
         fidiv   [i3]
         fimul   [correct_tex]
         fiadd   [correct_tex]
-        fistp   [temp1]  ;dword[esp-4]    ; x temp variables
+        fistp   .temp1  ;dword[esp-4]    ; x temp variables
         fld     dword[eax+4]    ; y cooficient of normal vector
      ;   mov     ah,al           ;set color according to z position
      ;   shl     eax,8
      ;   mov     edx,eax
-        mov     eax,dword[xx1]
+        mov     eax,dword .xx1
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     ebx,dword .xx2
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ecx,dword .xx3
-        ror     ecx,16
         mov     edi,[screen_ptr]
+        mov     esi,[Zbuffer_ptr]
-        mov     esi,[Zbuffer_ptr]
+        push    ebp
-        push    word[zz3]
+        push    word .zz3
-        push    word[zz2]
+        push    word .zz2
-        push    word[zz1]
+        push    word .zz1
+        call    flat_triangle_z
-        call    flat_triangle_z
+        pop     ebp
         jmp     .end_draw
+      .env_mapping:
-      .env_mapping:
+        push    ebp
-        push    [zz3]
+        push    word .zz3
-        push    [zz2]
+        push    word .zz2
-        push    [zz1]
+        push    word .zz1
-        mov     esi,point_index1
+        lea     esi, .index1x12
         sub     esp,12
         mov     edi,esp
-        mov     ecx,3
-      @@:
-        mov     eax,dword[esi]
+        mov     ecx,3
-        lea     eax,[eax*3]
+      @@:
-        shl     eax,2
+        mov     eax,dword[esi]
         add     eax,[points_normals_rot_ptr]       ;point_normals_rotated
         ; texture x=(rotated point normal -> x * 255)+255
         add     edi,4
         add     esi,4
         loop    @b
-        mov     eax,dword[xx1]
-        ror     eax,16
+        mov     eax, .xx1
-        mov     ebx,dword[xx2]
-        ror     ebx,16
+        mov     ebx,dword .xx2
-        mov     ecx,dword[xx3]
-        ror     ecx,16
+        mov     ecx,dword .xx3
         mov     edi,[screen_ptr]
         mov     esi,envmap
-        mov     edx,[Zbuffer_ptr]
+        mov     edx,[Zbuffer_ptr]
         call    tex_triangle_z
         pop     ebp
         jmp     .end_draw
 ;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+     .cubic_env_mapping:
-     .cubic_env_mapping:
+        push    ebp
-        push    [zz3]
+        push    word .zz3
-        push    [zz2]
+        push    word .zz2
-        push    [zz1]
+        push    word .zz1
-        mov     esi,point_index1
+        lea     esi,.index1x12
         sub     esp,12
         mov     edi,esp
-        mov     ecx,3
-      @@:
-        mov     eax,dword[esi]
+        mov     ecx,3
-        lea     eax,[eax*3]
+      @@:
-        shl     eax,2
+        mov     eax,dword[esi]
         add     eax,[points_normals_rot_ptr]
         add     edi,4
         add     esi,4
         loop    @b
-        mov     eax,dword[xx1]
+        mov     eax, .xx1
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     ebx, .xx2
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ecx, .xx3
-        ror     ecx,16
         mov     edi,[screen_ptr]
         mov     esi,envmap_cub
         mov     edx,[Zbuffer_ptr]
-        call    tex_triangle_z
+        call    tex_triangle_z
         pop     ebp
         jmp     .end_draw
-;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       .bump_mapping:
+        push    ebp
         push    [Zbuffer_ptr]
-        push    [zz3]
+        push    word .zz3
-        push    [zz2]
+        push    word .zz2
-        push    [zz1]
+        push    word .zz1
-        mov     esi,point_index1
+        lea     esi,.index1x12
         sub     esp,12
-        mov     edi,esp
-        mov     ecx,3
-      @@:
+        mov     edi,esp
-        mov     eax,dword[esi]
+        mov     ecx,3
-        lea     eax,[eax*3]
+      @@:
-        shl     eax,2
+        mov     eax,dword[esi]
         add     eax,[points_normals_rot_ptr]  ;point_normals_rotated
         add     edi,4
         add     esi,4
         loop    @b
-        mov    esi,[point_index3]      ; bump map coords
+        mov    esi, .point_index3      ; bump map coords
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index2]
+        mov    esi, .point_index2
         shl    esi,2
-        add    esi,tex_points
-;       lea    esi,[esi*3]
-;       lea    esi,[points+2+esi*2]
+        add    esi,[tex_points_ptr]
-        push   dword[esi]
-  ;     push   dword[xx2]
+        push   dword[esi]
-        mov    esi,[point_index1]
+        mov    esi, .point_index1
         shl    esi,2
-        add    esi,tex_points
-;       lea     esi,[esi*3]
-;       lea     esi,[points+2+esi*2]
+        add    esi,[tex_points_ptr]
-        push   dword[esi]
-   ;    push     dword[xx1]
+        push   dword[esi]
-        mov     eax,dword[xx1]
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     eax,dword .xx1
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ebx,dword .xx2
-        ror     ecx,16
+        mov     ecx,dword .xx3
         mov     edi,[screen_ptr]
         mov     esi,envmap
-        mov     edx,bumpmap            ;BUMP_MAPPING
+        mov     edx,bumpmap            ;BUMP_MAPPING
         call    bump_triangle_z
+        pop     ebp
         jmp     .end_draw
       .tex_mapping:
         push   ebp
-        push    [zz3]
+        push   word .zz3
-        push    [zz2]
+        push   word .zz2
-        push    [zz1]
+        push   word .zz1
    ;   @@:
-        mov    esi,[point_index3]      ; tex map coords
+        mov    esi, .point_index3      ; tex map coords
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index2]
+        mov    esi, .point_index2
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index1]
+        mov    esi, .point_index1
-        shl    esi,2
-        add    esi,tex_points
+        shl    esi,2
-        push   dword[esi]
+        add    esi,[tex_points_ptr]
-        mov     eax,dword[xx1]
-        ror     eax,16
+        push   dword[esi]
         mov     ebx,dword[xx2]
-        ror     ebx,16
+        mov     eax,dword .xx1
-        mov     ecx,dword[xx3]
+        mov     ebx,dword .xx2
-        ror     ecx,16
+        mov     ecx,dword .xx3
         mov     edi,[screen_ptr]
         mov     esi,texmap
-         mov     edx,[Zbuffer_ptr]
+        mov     edx,[Zbuffer_ptr]
         call    tex_triangle_z
 ;        jmp     .both_draw
      .grd_tex:            ; smooth shading + texture
          push   ebp
-         mov    ebp,esp
-         sub    esp,4
-         push   ebp
-         mov    esi,[point_index3]      ; tex map coords
+         mov    esi, .point_index3      ; tex map coords
          shl    esi,2
-         add    esi,tex_points
+         add    esi,[tex_points_ptr]
          push   dword[esi]              ; texture coords as first
-         mov    esi,[point_index2]      ; group of parameters
+         mov    esi, .point_index2      ; group of parameters
          shl    esi,2
-         add    esi,tex_points
+         add    esi,[tex_points_ptr]
          push   dword[esi]
-         mov    esi,[point_index1]
+         mov    esi, .point_index1
          shl    esi,2
-         add    esi,tex_points
+         add    esi,[tex_points_ptr]
          push   dword[esi]
          lea     esi, .index3x12
-         mov     esi,point_index3
-         mov     ecx,3
+         lea     edi, .zz3
-      .aagain_grd_draw:
+         mov     ecx,3
        .aagain_grd_draw:
         lea      edx,[ecx*3]
-        push     word[edx*2+xx1-2]    ; zz1 ,2 ,3
-        fninit
-        mov     eax,dword[esi]
+        push     word[edi]    ; zz1 ,2 ,3
-        shl     eax,2
+        fninit
-        lea     eax,[eax*3] ;+point_normals_rotated]
+        mov     eax,dword[esi]
         add     eax,[points_normals_rot_ptr]
         ; texture x=(rotated point normal -> x * 255)+255
         fld     dword[eax]       ; x cooficient of normal vector
         fimul   [correct_tex]
         fiadd   [correct_tex]
-        fistp   [temp1]  ;word[ebp-2]
+        fistp   .temp1  ;word[ebp-2]
         ; texture y=(rotated point normal -> y * 255)+255
         fld     dword[eax+4]      ; y cooficient
         fimul   [correct_tex]
         fiadd   [correct_tex]
-        fistp   [temp2]  ;word[ebp-4]
+        fistp   .temp2  ;word[ebp-4]
-        mov      eax,[temp2]   ;word[ebp-4]
+        mov      eax,.temp2
-        mov      ebx,[temp1]   ;word[ebp-2]
+        mov      ebx,.temp1
-        and      ebx,0xfffffff ; some onjects need thid 'and'
+        and      ebx,0xfffffff ; some onjects need this 'and'
         shl      eax,TEX_SHIFT
         xor      ah,ah
         push     ax         ;g
         shr      eax,24
         push     ax         ;b
         sub      edi,2
-        sub      esi,4
+        sub      esi,4
         dec      cx
         jnz      .aagain_grd_draw
-        mov     eax,dword[xx1]
+        mov     eax, .xx1
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     ebx, .xx2
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ecx, .xx3
-        ror     ecx,16
         mov     edi,[screen_ptr]
         mov     edx,texmap
         mov     esi,[Zbuffer_ptr]
         call    tex_plus_grd_triangle
-        pop     ebp
         mov     esp,ebp
         pop     ebp
+        jmp     .end_draw
         jmp     .end_draw
+      .two_tex:
-      .two_tex:
+        push     ebp
         push    [Zbuffer_ptr]
-        push    word[zz3]
+        push    word .zz3
-        push    word[zz2]
+        push    word .zz2
-        push    word[zz1]
+        push    word .zz1
-        mov    esi,[point_index3]      ; tex map coords
+        mov    esi, .point_index3      ; tex map coords
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index2]
+        mov    esi, .point_index2
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index1]
+        mov    esi, .point_index1
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
         add     edi,4
         add     esi,4
         loop    @b
-        mov     eax,dword[xx1]
+        mov     eax, .xx1
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     ebx, .xx2
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ecx, .xx3
-        ror     ecx,16
         mov     edi,[screen_ptr]
         mov     esi,texmap
         mov     edx,envmap
+        call    two_tex_triangle_z
-        call    two_tex_triangle_z
+        pop     ebp
         jmp     .end_draw
+   .bump_tex:
-   .bump_tex:
+        push   ebp
-        mov    esi,[point_index3]      ; tex map coords
+        mov    esi, .point_index3      ; tex map coords
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index2]
+        mov    esi, .point_index2
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index1]
+        mov    esi, .point_index1
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        push  dword texmap
+        push  dword texmap
-        push  [Zbuffer_ptr]
-        xor   edi,edi
+        push  [Zbuffer_ptr]
-        push    word[zz3]
+        push    word .zz3
-        push    word[zz2]
+        push    word .zz2
-        push    word[zz1]
+        push    word .zz1
-        mov     esi,point_index1     ; env coords
-        sub     esp,12
-        mov     edi,esp
+        lea     esi, .index1x12     ; env coords
-        mov     ecx,3
+        sub     esp,12
-      @@:
+        mov     edi,esp
-        mov     eax,dword[esi]
+        mov     ecx,3
-        lea     eax,[eax*3]
+      @@:
         add     edi,4
         add     esi,4
         loop    @b
-;        push  dword 1 shl 16 + 1  ; emap coords
-;        push  dword 127 shl 16 + 1
-;        push  dword 127 shl 16 + 127
-        mov    esi,[point_index3]      ; bump map coords
+        mov    esi, .point_index3      ; bump map coords
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index2]
+        mov    esi, .point_index2
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
-        push   dword[esi]
+        push   dword[esi]
-        mov    esi,[point_index1]
+        mov    esi, .point_index1
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
-        push   dword[esi]
-;        push  dword 1 shl 16 + 127
-;        push  dword 127 shl 16 + 127
-;        push  dword 1 shl 16 + 1  ; bump coords
+        push   dword[esi]
-        mov     eax,dword[xx1]
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     eax,dword .xx1
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ebx,dword .xx2
-        ror     ecx,16
+        mov     ecx,dword .xx3
         mov     edi,[screen_ptr]
         mov     esi,envmap
-        mov     edx,bumpmap
+        mov     edx,bumpmap
         call bump_tex_triangle_z
         pop     ebp
         punpcklwd xmm5,[the_zero]
         pshufd    xmm5,xmm5,01110011b
-        mov     eax,[point_index1]
+        mov     eax, .index1x12
-        mov     ebx,[point_index2]
+        mov     ebx, .index2x12
-        mov     ecx,[point_index3]
-        imul    eax,[i12]
-        imul    ebx,[i12]
-        imul    ecx,[i12]
+        mov     ecx, .index3x12
         add     eax,[points_normals_rot_ptr]
         add     ebx,[points_normals_rot_ptr]
         add     ecx,[points_normals_rot_ptr]
         movups  xmm0,[eax]
         andps   xmm1,[zero_hgst_dd]
         andps   xmm2,[zero_hgst_dd]
         xorps   xmm3,xmm3
-        mov     eax,[point_index1]
+        mov     eax, .index1x12
-        mov     ebx,[point_index2]
+        mov     ebx, .index2x12
-        mov     ecx,[point_index3]
+        mov     ecx, .index3x12
-        imul    eax,[i12]
-        imul    ebx,[i12]
-        imul    ecx,[i12]
         add     eax,[points_rotated_ptr]
         add     ebx,[points_rotated_ptr]
         add     ecx,[points_rotated_ptr]
         push    dword[ecx+8]
         push    dword[ebx+8]
         andps   xmm4,[zero_hgst_dd]
-        mov     eax,dword[xx1]
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     eax,dword .xx1
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ebx,dword .xx2
-        ror     ecx,16
+        mov     ecx,dword .xx3
         mov     edi,[screen_ptr]
         punpcklwd xmm5,[the_zero]
         pshufd    xmm5,xmm5,01110011b
-        mov     eax,[point_index1]
+        mov     eax, .index1x12
-        mov     ebx ,[point_index2]
+        mov     ebx, .index2x12
-        mov     ecx,[point_index3]
-        imul    eax,[i12]
-        imul    ebx,[i12]
-        imul    ecx,[i12]
+        mov     ecx, .index3x12
         add     eax,[points_normals_rot_ptr]
         add     ebx,[points_normals_rot_ptr]
         add     ecx,[points_normals_rot_ptr]
         movups  xmm0,[eax]
         andps   xmm1,[zero_hgst_dd]
         andps   xmm2,[zero_hgst_dd]
         xorps   xmm3,xmm3
-        mov     eax,[point_index1]
+        mov     eax, .index1x12
-        mov     ebx,[point_index2]
+        mov     ebx, .index2x12
-        mov     ecx,[point_index3]
+        mov     ecx, .index3x12
-        imul    eax,[i12]
-        imul    ebx,[i12]
-        imul    ecx,[i12]
         add     eax,[points_rotated_ptr]
         add     ebx,[points_rotated_ptr]
         add     ecx,[points_rotated_ptr]
         push    dword[ecx+8]
         push    dword[ebx+8]
         andps   xmm4,[zero_hgst_dd]
-        mov     eax,dword[xx1]
-        ror     eax,16
-        mov     ebx,dword[xx2]
+        mov     eax, .xx1
-        ror     ebx,16
-        mov     ecx,dword[xx3]
+        mov     ebx, .xx2
-        ror     ecx,16
+        mov     ecx, .xx3
         mov     edi,[screen_ptr]
         mov     edx,[Zbuffer_ptr]
         movd      xmm5,[size_y_var]
         punpcklwd xmm5,[the_zero]
         pshufd    xmm5,xmm5,01110011b
-        mov     eax,[point_index1]
+        mov     eax, .index1x12
-        mov     ebx,[point_index2]
+        mov     ebx, .index2x12
-        mov     ecx,[point_index3]
+        mov     ecx, .index3x12
-        imul    eax,[i12]
-        imul    ebx,[i12]
-        imul    ecx,[i12]
         add     eax,[points_normals_rot_ptr]
         add     ebx,[points_normals_rot_ptr]
         add     ecx,[points_normals_rot_ptr]
         movups  xmm0,[eax]
         movups  xmm1,[ebx]
         andps   xmm1,[zero_hgst_dd]
         andps   xmm2,[zero_hgst_dd]
         xorps   xmm3,xmm3
-        mov     eax,[point_index1]
+        mov     eax, .index1x12
-        mov     ebx,[point_index2]
+        mov     ebx, .index2x12
-        mov     ecx,[point_index3]
+        mov     ecx, .index3x12
-        imul    eax,[i12]
-        imul    ebx,[i12]
-        imul    ecx,[i12]
         add     eax,[points_rotated_ptr]
         add     ebx,[points_rotated_ptr]
         add     ecx,[points_rotated_ptr]
         push    dword[ecx+8]
         push    dword[ebx+8]
         push    dword[eax+8]
         movups  xmm4,[esp]
         add     esp,12
         andps   xmm4,[zero_hgst_dd]
-        mov    esi,[point_index3]      ; tex map coords
+        mov    esi,.point_index3      ; tex map coords
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index2]
+        mov    esi,.point_index2
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
-        mov    esi,[point_index1]
+        mov    esi,.point_index1
         shl    esi,2
-        add    esi,tex_points
+        add    esi,[tex_points_ptr]
         push   dword[esi]
         movups xmm6,[esp]
         add    esp,12
      ;   pshuflw xmm6,xmm6,10110001b
         pslldq xmm7,12
         por    xmm6,xmm7
-        mov     eax,dword[xx1]
-        ror     eax,16
+        mov     eax,dword .xx1
-        mov     ebx,dword[xx2]
-        ror     ebx,16
+        mov     ebx,dword .xx2
-        mov     ecx,dword[xx3]
-        ror     ecx,16
+        mov     ecx,dword .xx3
         mov     edx,texmap
         mov     edi,[screen_ptr]
         mov     esi,[Zbuffer_ptr]
+        call    glass_tex_tri
+        jmp     .end_draw
+   .ray_shd:
+        emms
+        movd      xmm5,[size_y_var]
+        punpcklwd xmm5,[the_zero]
+        pshufd    xmm5,xmm5,01110011b
+        mov     eax, .index1x12
+        mov     ebx, .index2x12
+        mov     ecx, .index3x12
+        add     eax,[points_normals_rot_ptr]
+        add     ebx,[points_normals_rot_ptr]
+        add     ecx,[points_normals_rot_ptr]
+        movups  xmm0,[eax]
+        movups  xmm1,[ebx]
+        movups  xmm2,[ecx]
+        andps   xmm0,[zero_hgst_dd]
+        andps   xmm1,[zero_hgst_dd]
+        andps   xmm2,[zero_hgst_dd]
+        xorps   xmm3,xmm3
+   ;     mov     ebx,.tri_no
+   ;     cmp     ebx,0
+   ;     je      @f
+   ;     int3
+   ;   @@:
+        mov     eax, .index1x12
+        mov     ebx, .index2x12
+        mov     ecx, .index3x12
+        add     eax,[points_rotated_ptr]
+        add     ebx,[points_rotated_ptr]
+        add     ecx,[points_rotated_ptr]
+        push    dword[ecx+8]
+        push    dword[ebx+8]
+        push    dword[eax+8]
+        movups  xmm4,[esp]
+        add     esp,12
+        andps   xmm4,[zero_hgst_dd]
+        movd    mm7,.tri_no
+   ;     mm7 - intialised
+        mov     eax,dword .xx1
+        mov     ebx,dword .xx2
+        mov     ecx,dword .xx3
+        mov     edx,texmap
+        mov     edi,[screen_ptr]
+        mov     esi,[Zbuffer_ptr]
-        call    glass_tex_tri
+        call    ray_shad
+end if
+      .end_draw:
+    ;    pop     ebp
+        pop     ecx
+        pop     esi
-end if
-      .end_draw:
         pop     esi
         add     esi,12
         inc     ecx
         jl        .again_cc
         sub       esp,16
         movups    [esp],xmm1
         add       esi,4
-        loop      .aga_n
+        dec       ecx
+        jnz      .aga_n
         movups    xmm0,[esp]
         movups    xmm1,[esp+16]
         add       esp,32
         sub       esi,8
         movd    xmm7,[ecx]
         movhps  xmm7,[edx]
         pshufd  xmm7,xmm7,11101000b
         movdqa  xmm6,xmm7
+        movdqa  xmm3,xmm7
+        movdqa  xmm4,xmm7
         movd    xmm5,[size_y_var]
         pshuflw xmm5,xmm5,00010001b
+        pcmpeqw xmm3,xmm5
+        pcmpeqw xmm4,[the_zero]
         pcmpgtw xmm7,xmm5
         pcmpgtw xmm6,[the_zero]
         pxor    xmm7,xmm6
+        pxor    xmm3,xmm4
+        pxor    xmm7,xmm3
         pmovmskb eax,xmm7
         cmp     al,-1
         jnz      .skp
         inc     ecx
         cmp     ecx,[edges_count]
         jnz     .again_s_line
+   .eend:
+        add      esp,60
+        pop      ebp
- ret
+ret
+draw_handlers:
-draw_handlers:
+       ;  in eax - render model
        push  ebp
-       push  ebp
+       mov   ebp,esp
-       mov   ebp,esp
        .counter  equ ebp-16
-       .counter  equ ebp-16
+       .xres3m18 equ ebp-8
-       .xres3m18 equ ebp-8
+       .xres2m12 equ ebp-12
-       .xres2m12 equ ebp-12
+       .dr_model equ dword[ebp-4]
      ; init counter
        imul  eax,edx
        add   eax,ebx
        push   eax
        lea   edi,[eax*3]
-       cmp    [dr_flag],12
+       cmp    .dr_model,12
        jl    @f
        add    edi,[esp]
       @@:
        add    esp,4
        lea   eax,[eax*2]
        ; draw bar 6x6
        mov   word[edi],0x0000 ;ax
        mov   byte[edi+2],0xff   ;al
        mov   word[eax],dx
        add   eax,2
-       cmp    [dr_flag],12
+       cmp   .dr_model,12
        jl    @f
        add   edi,4
        loop  .do
        jmp   .ad
       @@:
        add   edi,3
         mov     eax,-1 ;<---mark if OK
       .exit:
         mov     dword[edi],-1
 ret
 alloc_mem_for_tp:
-alloc_mem_for_tp:
         mov     eax, 68
         cmp     [re_alloc_flag],1
         jz      @f
         mov     ebx, 12
         jmp     .alloc
         int     0x40
         mov     [points_rotated_ptr], eax
         mov     eax, 68
+        mov     ebx, 12
+        mov     ecx, [points_count_var]
+        shl     ecx,2
+        mov     edx,[tex_points_ptr]
+        int     0x40
+        mov     [tex_points_ptr], eax
+        mov     eax, 68
         mov     ecx, [points_count_var]
         inc     ecx
         shl     ecx, 3
         mov     edx,[points_translated_ptr]
         int     0x40
         mov     [points_translated_ptr], eax
 ret
 read_from_disk:
     mov     eax, 68
 buttons:                                      ; draw some buttons (all but navigation and close )
         mov     edi,menu
       .again:
         mov     eax,8             ; function 8 : define and draw button
-        mov     bx,[size_x_var]
+        movzx   ebx,word[size_x_var]
         shl     ebx,16
         add     ebx,(10)*65536+62      ; [x start] *65536 + [x size]
         movzx   ecx,byte[edi]                 ; button id = position+2
-        sub     cl,2
+        sub     ecx,2
         lea     ecx,[ecx*5]
         lea     ecx,[ecx*3]
         add     ecx,25
         shl     ecx,16
         add     ecx,12
         movzx   edx,byte[edi]                   ; button id
         int     0x40
          ; BUTTON  LABEL
         mov     eax,4                           ; function 4 : write text to window
         movzx   ebx,byte[edi]
-        sub     bl,2                            ; button id, according to position
+        sub     ebx,2                            ; button id, according to position
         lea     ebx,[ebx*3]
         lea     ebx,[ebx*5]
-        mov     cx,[size_x_var]
+        movzx   ecx,word[size_x_var]
         shl     ecx,16
         add     ebx,ecx
         add     ebx,(12)*65536+28        ; [x start] *65536 + [y start]
         mov     ecx,0x00ddeeff                  ; font 1 & color ( 0xF0RRGGBB )
         lea     edx,[edi+1]                     ; pointer to text beginning
         mov     esi,10                          ; text length
 ;   *********************************************
 ;   *******  WINDOW DEFINITIONS AND DRAW ********
 ;   *********************************************
     draw_window:
-        mov     eax,12          ; function 12:tell os about windowdraw
+        movzx   eax,[fire_flag]
+        push    eax
+    ;    int3
+        mov     eax,12          ; function 12:tell os about windowdraw
         mov     ebx,1           ; 1, start of draw
         int     0x40
         ; DRAW WINDOW
      ;   shl     edx,16
      ;   add     edx,130*65536+60  ; [x start] *65536 + [y start]
      ;   mov     esi,0x00ddeeff  ; font 1 & color ( 0xF0RRGGBB )
      ;   int     0x40
        call  write_info
+       call  write_info
         ; ADD VECTOR LABEL      ; add vector buttons - 30 ++
         mov     eax,4           ; function 4 : write text to window
         movzx   ebx,word[size_x_var]
         mov     eax,12          ; function 12:tell os about windowdraw
         mov     ebx,2           ; 2, end of draw
         int     0x40
+        pop     eax
+        mov     [fire_flag],al
         ret

Subversion Repositories Kolibri OS

(root)/programs/demos/view3ds/view3ds.asm @ 8719 – Rev 8719 → 9237