WebSVN – Kolibri OS – Diff – /programs/demos/3DS/VIEW3DS.ASM


; application : View3ds ver. 0.064 - tiny .3ds files viewer.
; compiler    : FASM
; system      : KolibriOS
; author      : Macgub aka Maciej Guba
; email       : macgub3@wp.pl
; web         : www.macgub.hekko.pl
; Fell free to use this intro in your own distribution of KolibriOS/MenuetOS.
; Special greetings to all MenuetOS maniax in the world.
; I hope because my intros Christian Belive will be near to each of You.
 
 
; Some adjustments made by Madis Kalme
; 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)
;include 'proc32.inc'
 
SIZE_X equ 512
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
Ext   =   SSE2		 ;Ext={ NON | MMX | SSE | SSE2 }
 
; 0 for short names (Menuet-compatible), 1 for long names (Kolibri features)
USE_LFN = 1
 
use32
	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
 
START:	  ; start of execution
	cld
	call   alloc_buffer_mem
	call   read_param
	call   read_from_disk	 ; read, if all is ok eax = 0
	cmp    eax,0
	jne    .gen
	call   read_tp_variables ; init points and triangles count variables
	cmp    eax,0
	je     .gen
	jmp    .malloc
    .gen:
     if USE_LFN
	mov    [triangles_count_var],1000
	mov    [points_count_var],1000
	call   alloc_mem_for_tp
     end if
	call   generate_object
	jmp    .opt
    .malloc:
     if USE_LFN
	call   alloc_mem_for_tp
     end if
	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   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
	call   calc_bumpmap
	call   calc_bumpmap_coords   ; bump and texture mapping
	call   draw_window
 
still:
 
	mov	eax,23		; wait here for event with timeout
	mov	ebx,TIMEOUT
	cmp	[speed_flag],1
	jne	.skip
	mov	eax,11
    .skip:
	int	0x40
 
	cmp	eax,1		; redraw request ?
	je	red
	cmp	eax,2		; key in buffer ?
	je	key
	cmp	eax,3		; button in buffer ?
	je	button
 
	jmp	noclose
 
    red:			; redraw
	call	draw_window
 
	jmp	noclose
 
    key:			; key
	mov	eax,2		; just read it and ignore
	int	0x40
	jmp	noclose
 
    button:			; button
	mov	eax,17		; get id
	int	0x40
 
	cmp	ah,1		; button id=1 ?
	jne	@f
 
	mov	eax,-1		; close this program
	int	0x40
    @@:
	cmp	ah,30
	jge	add_vec_buttons
	call	update_flags	      ; update flags and write labels of flags
 
				      ; do other operations according to flag
	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
	mov	[scale],0.7
	fninit
	fld	[rsscale]
	fmul	[scale]
	fstp	[rsscale]
 
      @@:
	cmp	ah,6		     ; ah = 6 ->  scale+
	jne	@f
	mov	[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	do_color_buffer   ; intit color_map     ;    'tex '  4
      ;  cmp     [emboss_flag],1                         ;    'pos '  5
      ;  je      @f                                      ;    'dots'  6
      ;  cmp     [dr_flag],8
      ;  jge     @f
      ;  cmp     [dr_flag],2                             ;    'txgr'  7
      ;  jl      .next_m5                            ;    '2tex'  8
      ;  cmp     [dr_flag],3                             ;    'btex'  9
      ;  jg      .next_m5
    ; @@:
	call	init_envmap2	; update env map if shading model = environment or bump
    .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
	call	 exchange
     @@:
	cmp	 ah,15
	jne	 @f
	cmp	 [emboss_flag],1
	call	 init_envmap2
     @@:
;        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
     if USE_LFN
	mov	 [re_alloc_flag],1	 ; reallocate memory
	mov	 [triangles_count_var],1000
	mov	 [points_count_var],1000
	call	 alloc_mem_for_tp
	mov	 [re_alloc_flag],0
     end if
	mov	 bl,[generator_flag]
	or	 bl,bl
	jz	 .next_m2
	cmp	 bl,1
	jne	 @f
	call	 generate_object
	jmp	 .calc_norm
      @@:
	cmp	 bl,4
	jg	 @f
	movzx	 ax,bl		      ; ax < - 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
 
     .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
 
 
			       ; there are 6 navigation buttons each
   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
	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
	sub	[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
	add	[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
 
	sub	[vect_z],10
	jmp	.next4
      @@:
	sub	[zobs],10	  ;  observator = camera position
      .next4:
	cmp	ah,35
	jne	.next5
	cmp	[move_flag],0
	jne	 @f
      ;  call    add_vector
	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:
 
 
 
    noclose:
 
	cmp	[r_flag],2
	jne	.no_x
	inc	[angle_x]
	and	[angle_x],0xff
	mov	[angle_z],0
	jmp	.end_rot
 
      .no_x:
	cmp	[r_flag],0
	jne	.no_y
	inc	[angle_y]
	and	[angle_y],0xff
	mov	[angle_z],0
	jmp	.end_rot
 
      .no_y:
	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	esi,angle_x
	mov	edi,matrix
	call	make_rotation_matrix
    RDTSC
    push eax
	mov	esi,[points_normals_ptr]
	mov	edi,[points_normals_rot_ptr]
	mov	ebx,matrix
	movzx	ecx,[points_count_var]
	call	rotary
 
	mov	esi,matrix
	call	add_scale_to_matrix
 
	mov	esi,[points_ptr]
	mov	edi,[points_rotated_ptr]
	mov	ebx,matrix
	movzx	ecx,[points_count_var]
	call	rotary
 
;    RDTSC
;    pop    ebx
;    sub    eax,ebx
;    sub    eax,41
;    push   eax
 
	mov	esi,[points_rotated_ptr]
	mov	edi,[points_translated_ptr]
	movzx	ecx,[points_count_var]
	call	translate_points
 
;        cmp     [dr_flag],5
;        jne     @f
;        call    calc_attenuation_light
;     @@:
	cmp	[fire_flag],0
	jne	@f
	call	clrscr		; clear the screen
     @@:
	cmp	[catmull_flag],1  ;non sort if Catmull = on
	je	.no_sort
	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
	je	.non_f
	cmp	[dr_flag],6	  ; non fill if dots
	je	.non_f
      @@:
	call	fill_Z_buffer	  ; make background
     .non_f:
;    RDTSC
;    push eax
	cmp	[dr_flag],6
	jne	@f
	call	 draw_dots
	jmp	 .blurrr
      @@:
	call	draw_triangles	; draw all triangles from the list
      .blurrr:
	cmp  [sinus_flag],0
	je   @f
	call do_sinus
      @@:
	cmp	[fire_flag],0
	jne	@f
	cmp	[blur_flag],0
	je	.no_blur  ; no blur, no fire
	movzx	ecx,[blur_flag]
	call	blur_screen    ; blur and fire
	jmp	.no_blur
    @@:
	cmp	[emboss_flag],0
	jne	.emb	       ; if emboss=true -> no fire
	movzx	ecx,[fire_flag]
	call	blur_screen    ; blur and fire
    .no_blur:		       ; no blur, no fire
	cmp	[emboss_flag],0
	je	@f
     .emb:
	call	do_emboss
 
      @@:
 
 
    cmp     [inc_bright_flag],0 	  ; increase brightness
    je	    .no_inc_bright
    movzx   ebx,[inc_bright_flag]
    shl     ebx,4
    mov     esi,screen
    mov     ecx,SIZE_X*SIZE_Y*3
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
  .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
    jnz     .oop
end if
 
.no_inc_bright:
 
 
    cmp     [dec_bright_flag],0
    je	    .no_dec_bright
    movzx   ebx,[dec_bright_flag]
    shl     ebx,4
    mov     esi,screen
    mov     ecx,SIZE_X*SIZE_Y*3
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
    jnz     .oop1
end if
  .no_dec_bright:
;======================================commmented====================
if 0
if Ext >= SSE
    cmp     [max_flag],0
    je	    .no_max
    ;movzx   ebx,[max_flag]
 .again_max:
;    push       ecx
    mov        edi,screen
    mov        ecx,SIZE_X*3/4
  ;   ;    pxor       mm5,mm5
    xor        eax,eax
    rep        stosd
 
    mov        ecx,(SIZE_X*(SIZE_Y-3))*3/8
  .calc_max:
  @@:
    movq       mm0,[edi+SIZE_X*3]
    movq       mm1,[edi-SIZE_X*3]
    movq       mm2,[edi-3]
    movq       mm3,[edi+3]
 
    pmaxub	mm0,mm1
    pmaxub	mm2,mm3
    pmaxub	mm0,mm2
 
    movq       [edi],mm0
    add 	edi,8
    loop	@b
 
    xor        eax,eax
    mov        ecx,SIZE_X*3/4
    rep        stosd
end if
 
.no_max:
 
if Ext >= SSE
    cmp     [min_flag],0
    je	    .no_min
;    push       ecx
    mov        edi,screen
    mov        ecx,SIZE_X*3/4
  ;   ;    pxor       mm5,mm5
    xor        eax,eax
    rep        stosd
 
    mov        ecx,(SIZE_X*(SIZE_Y-3))*3/8
  @@:
    movq       mm0,[edi+SIZE_X*3]
    movq       mm1,[edi-SIZE_X*3]
    movq       mm2,[edi-3]
    movq       mm3,[edi+3]
 
    pminub	mm0,mm1
    pminub	mm2,mm3
    pminub	mm0,mm2
 
    movq       [edi],mm0
    add 	edi,8
    loop	@b
 
    xor        eax,eax
 
    mov        ecx,SIZE_X*3/4
    rep        stosd
end if
.no_min:
end if
 
    RDTSC
    sub eax,[esp]
    sub eax,41
;    pop     eax
 
    mov     ecx,10
  .dc:
    xor     edx,edx
    mov     edi,10
    div     edi
    add     dl,30h
    mov     [STRdata+ecx-1],dl
    loop    .dc
    pop eax
 
    mov     eax,7	    ; put image
    mov     ebx,screen
    mov     ecx,SIZE_X shl 16 + SIZE_Y
    mov     edx,5 shl 16 + 25
    int     0x40
 
	mov  eax,13
    mov  ebx,530*65536+60
    mov  ecx,510*65536+9
    xor  edx,edx
    int  40h
	
    mov  eax,4			   ; function 4 : write text to window
    mov  ebx,530*65536+510	   ; [x start] *65536 + [y start]
    mov  ecx,0x00888888
    mov  edx,STRdata		   ; pointer to text beginning
    mov  esi,10 		   ; text length
    int  40h
 
 
   ; addsubps xmm0,xmm0
 
 
   jmp	   still
 
;--------------------------------------------------------------------------------
;-------------------------PROCEDURES---------------------------------------------
;--------------------------------------------------------------------------------
include "TEX3.INC"
include "FLAT_CAT.INC"
include "TEX_CAT.INC"
include "BUMP_CAT.INC"
include "3DMATH.INC"
include "GRD_LINE.INC"
include "GRD3.INC"
include "FLAT3.INC"
include "BUMP3.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"
 
 
 
alloc_buffer_mem:
    movzx    ecx,[size_x]
    movzx    eax,[size_y]
    mul      ecx
    lea      ecx,[eax*3]
    push     ecx
    shl      eax,2
    add      ecx,eax
    add      ecx,MEM_END
    mov      ebx,1
    mov      eax,64	; allocate mem  - resize app mem
    int      0x40
    mov      [screen_ptr],MEM_END
    mov      [Zbuffer_ptr],MEM_END
    pop      ecx
    add      [Zbuffer_ptr],ecx
ret
 
update_flags:
; 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
     .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
 
	mov	eax,13				 ; function 13 write rectangle
	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	ebx,(SIZE_X+12+70)*65536+25	; [x start] *65536 + [size x]
	mov	edx,0x00000000			;  color  0x00RRGGBB
	int	0x40
 
	mov	eax,4				; function 4 : write text to window
	movzx	ebx,byte[edi]
	sub	bl,2
	lea	ebx,[ebx*3]
	lea	ebx,[ebx*5]
	add	ebx,(SIZE_X+12+70)*65536+28	; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff			; font 1 & color ( 0xF0RRGGBB )
	movzx	edx,byte[edi+12]		; current flag
	shl	edx,2				; * 4 = text length
	add	edx,dword[edi+13]		; pointer to text beginning
	mov	esi,4				; text length -
						; flag description 4 characters
	int	0x40
 
     .no_write:
	pop	ax
ret
normalize_all_light_vectors:
	mov	edi,lights
     @@:
	call	normalize_vector	   ;       3dmath.inc
	add	edi,LIGHT_SIZE
	cmp	edi,lightsend	;ecx
	jl	@b
ret
 
calc_bumpmap_coords:	  ; map texture, bump
;macro .comment222
;                                ; planar mapping
;        mov     esi,points
;        mov     edi,tex_points
;      @@:
;         add     esi,2
;         movsd
;         cmp     dword[esi],dword -1
;         jne     @b
 
;      .Pi2  equ dword[ebp-4]
 
;      mov   ebp,esp
;      sub   esp,4
 
      fninit
      fldpi
      fadd	st,st
      mov	esi,[points_ptr]
      mov	edi,tex_points
      movzx	ecx,[points_count_var]
      inc	ecx
;      cmp       [map_tex_flag],1
;      jne       .cylindric
      ; spherical mapping around y axle
 
   @@:
      fld	dword[esi]     ; x coord
      fld	dword[esi+8]   ; z coord
      fpatan		       ; arctg(st1/st)
;      fdiv      .Pi2
      fdiv	st0,st1
      fimul	[tex_x_div2]
      fiadd	[tex_x_div2]
      fistp	word[edi]      ; x
 
      fld	dword[esi+4]   ; y coord
      fld	dword[esi]     ; x
      fmul	st,st0
      fld	dword[esi+4]   ; y
      fmul	st,st0
      fld	dword[esi+8]   ; z
      fmul	st,st0
      faddp
      faddp
      fsqrt
      fpatan
      fldpi
      fdivp
      fimul    [tex_y_div2]
      fiadd    [tex_y_div2]
      fistp    word[edi+2]     ; y
 
      add      esi,12
      add      edi,4
      loop     @b
      ffree    st0
;      jmp      .end_map
;  .cylindric:
;       fld     dword[esi]     ; around y axle
;       fld     dword[esi+8]
;       fpatan
;       fdiv    st0,st1
;       fimul   [tex_x_div2]
;       fiadd   [tex_x_div2]
;       fistp   word[edi]
 
;       fld     dword[esi+4]
;       fimul   [tex_y_div2]
;       fiadd   [tex_y_div2]
;       fistp   word[edi+2]
 
;       add     esi,12
;       add     edi,4
;       loop    .cylindric
;       ffree    st0
;;      mov      esp,ebp
;   .end_map:
ret
 
 
init_envmap2:	      ; do env_map using many light sources
;env_map 512 x 512 x 3 bytes
.temp  equ word   [ebp-2]
.nEy   equ word  [ebp-4]
.nEx   equ word  [ebp-6]
.col_r equ    [ebp-8]
.col_g equ    [ebp-9]
.col_b equ    [ebp-10]
 
	 push	  ebp
	 mov	  ebp,esp
	 sub	  esp,20
	 mov	  edi,envmap
	 fninit
 
	 mov	  dx,- TEX_Y / 2 ;256   ; dx - vertical coordinate = y
    .ie_ver:
	 mov	  cx,- TEX_X / 2 ;256   ; cx - horizontal coord = x
    .ie_hor:
	 xor	  ebx,ebx
	 mov	  dword .col_b, 0
     .light:
	 lea	  esi,[lights+ebx]
	 fld	  dword[esi]	 ; light vector x cooficient
	 fimul	  [tex_x_div2] ;[i256]
	 mov	  .temp,cx
	 fisubr   .temp
	 fistp	  .nEx
	 fld	  dword[esi+4]	 ; light vector y cooficient
	 fimul	  [tex_y_div2] ;[i256]
	 mov	  .temp,dx
	 fisubr   .temp
	 fistp	  .nEy
 
	 cmp	  .nEx,- TEX_X / 2 ;256
	 jl	  .update_counters
	 cmp	  .nEy,- TEX_Y / 2 ;256
	 jl	  .update_counters
	 cmp	  .nEx,TEX_X / 2 ;256
	 jg	  .update_counters
	 cmp	  .nEy,TEX_Y / 2 ;256
	 jg	  .update_counters
 
	 fild	  .nEx
	 fmul	  st,st0
	 fild	  .nEy
	 fmul	  st,st0
	 faddp
	 fsqrt
	 fisubr   [i256]
	 fmul	  [env_const]
	 fidiv	  [i256]   ; st - 'virtual' dot product
 
	 fcom	  [dot_max]
	 fstsw	  ax
	 sahf
	 jb	  @f
	 ffree	  st
	 fld1	  ;[dot_max]
      @@:
	 fcom	  [dot_min]
	 fstsw	  ax
	 sahf
	 ja	  @f
	 ffree	  st
	 fldz	  ;[dot_min]
      @@:
	 push	  ebp
	 movzx	  ax,byte[esi+21]
	 push	  ax  ;- shines
	 mov	  al,byte[esi+14]   ; b    orginal color
	 push	  ax
	 mov	  al,byte[esi+13]   ; g
	 push	  ax
	 mov	  al,byte[esi+12]   ; r
	 push	  ax
	 mov	  al,byte[esi+20]   ; b     max color
	 push	  ax
	 mov	  al,byte[esi+19]   ; g
	 push	  ax
	 mov	  al,byte[esi+18]   ; r
	 push	  ax
	 mov	  al,byte[esi+17]   ; b    min col
	 push	  ax
	 mov	  al,byte[esi+16]   ; g
	 push	  ax
	 mov	  al,byte[esi+15]   ; r
	 push	  ax
	 push	  eax	      ; earlier - dot pr
      ;  fstp     .dot_product
      ;  push     .dot_product
	 call	  calc_one_col
	 pop	  ebp
	 ; eax-0x00rrggbb
	 cmp	  al,.col_b
	 jbe	  @f
	 mov	  .col_b,al
   @@:			      ;  eax - ggbb00rr
	 shr	  ax,8
	 cmp	  al,.col_g
	 jbe	  @f
	 mov	  .col_g,al
   @@:			      ;  eax - bb0000gg
	 shr	  eax,16
	 cmp	  al,.col_r
	 jbe	  @f
	 mov	  .col_r,al
   @@:
   .update_counters:			 ; update and jump when neccesery
	 add	  ebx,LIGHT_SIZE
	 cmp	  bx,[all_lights_size]
	 jl	  .light    ; next_light
	 mov	  eax,dword .col_b
	 stosd
	 dec	  edi
 
	 inc	  cx
	 cmp	  cx,TEX_X / 2 ;256
	 jne	  .ie_hor
 
	 inc	  dx
	 cmp	  dx,TEX_Y / 2 ;256
	 jne	 .ie_ver
 
	 mov	 esp,ebp
	 pop	 ebp
ret
 
 
 
do_color_buffer:	 ; do color buffer for Gouraud, flat shading
;env_map 512 x 512 x 3 bytes    ; many lights using
.temp  equ word   [ebp-2]
.nz    equ dword  [ebp-6]  ; dword
.ny    equ dword  [ebp-10]
.nx    equ dword  [ebp-14]
.col_r equ    [ebp-16]
.col_g equ    [ebp-17]
.col_b equ    [ebp-18]
 
	 push	  ebp
	 mov	  ebp,esp
	 sub	  esp,20
	 mov	  edi,color_map
	 fninit
 
	 mov	  dx,- TEX_Y / 2 ;-256   ; dx - vertical coordinate = y
    .ie_ver:
	 mov	  cx,- TEX_X / 2 ;256   ; cx - horizontal coord = x
    .ie_hor:
	 mov	  .temp,cx
	 fild	  .temp
	 fidiv	  [i256]   ;st = Nx - vector normal x cooficient
	 fst	  .nx
	 fmul	  st,st0
	 mov	  .temp,dx
	 fild	  .temp
	 fidiv	  [i256]   ; st = Ny - vector normal y coeficient
	 fst	  .ny
	 fmul	  st,st0
	 faddp
	 fld1
	 fchs
	 faddp
	 fabs
	 fsqrt
	 fchs
	 fstp	  .nz		   ; st - Nz - vect normal z coeficient
	 xor	  ebx,ebx
	 mov	  dword .col_b, 0
     .light:
	 push	  edi	;env_map
	 lea	  esi,[lights+ebx]
	 lea	  edi,.nx
	 call	  dot_product
	 pop	  edi
	 fcom	  [dot_min]
	 fstsw	  ax
	 sahf
	 ja	  .env_ok1  ;compare with dot_max
	 ffree	  st
 
	jmp	  .update_counters
      .env_ok1:
	 fcom	 [dot_max]
	 fstsw	 ax
	 sahf
	 jb	 .env_ok2     ; calc col
	 ffree	 st
	 jmp	 .update_counters
      .env_ok2: 	   ;calc col
	 push	  ebp
	 movzx	  ax,byte[esi+21]
	 push	  ax  ;- shines
	 mov	  al,byte[esi+14]   ; b    orginal color
	 push	  ax
	 mov	  al,byte[esi+13]   ; g
	 push	  ax
	 mov	  al,byte[esi+12]   ; r
	 push	  ax
	 mov	  al,byte[esi+20]   ; b     max color
	 push	  ax
	 mov	  al,byte[esi+19]   ; g
	 push	  ax
	 mov	  al,byte[esi+18]   ; r
	 push	  ax
	 mov	  al,byte[esi+17]   ; b    min col
	 push	  ax
	 mov	  al,byte[esi+16]   ; g
	 push	  ax
	 mov	  al,byte[esi+15]   ; r
	 push	  ax
	 push	  eax	      ; earlier - dot pr
      ;  fstp     .dot_product
      ;  push     .dot_product
	 call	  calc_one_col
	 pop	  ebp
	 ; eax-0x00rrggbb
	 cmp	  al,.col_b
	 jbe	  @f
	 mov	  .col_b,al
   @@:
	 shr	  ax,8
	 cmp	  al,.col_g
	 jbe	  @f
	 mov	  .col_g,al
   @@:
	 shr	  eax,16
	 cmp	  al,.col_r
	 jbe	  @f
	 mov	  .col_r,al
  @@:
 .update_counters:				    ; update and jump when neccesery
	add	ebx,LIGHT_SIZE
	cmp	bx,[all_lights_size]
	jl	.light	  ; next_light
	mov	eax,dword .col_b
	stosd
	dec	edi
 
	inc	cx
	cmp	cx,TEX_X / 2 ;256
	jne	.ie_hor
 
	inc	dx
	cmp	dx,TEX_X / 2 ;256
	jne	.ie_ver
 
    .env_done:
	 mov	 esp,ebp
	 pop	 ebp
ret
if 0
init_triangles_normals:
	mov	ebx,triangles_normals
	mov	ebp,triangles
     @@:
	push	ebx
	mov	ebx,vectors
	movzx	esi,word[ebp]	       ; first point index
	lea	esi,[esi*3]
	lea	esi,[points+esi*2]     ; esi - pointer to 1st 3d point
	movzx	edi,word[ebp+2]        ; second point index
	lea	edi,[edi*3]
	lea	edi,[points+edi*2]     ; edi - pointer to 2nd 3d point
	call	make_vector
	add	ebx,12
	mov	esi,edi
	movzx	edi,word[ebp+4]        ; third point index
	lea	edi,[edi*3]
	lea	edi,[points+edi*2]
	call	make_vector
	mov	edi,ebx 		; edi - pointer to 2nd vector
	mov	esi,ebx
	sub	esi,12			; esi - pointer to 1st vector
	pop	ebx
	call	cross_product
	mov	edi,ebx
	call	normalize_vector
	add	ebp,6
	add	ebx,12
	cmp	dword[ebp],-1
	jne	@b
ret
end if
init_point_normals:
.x equ dword [ebp-4]
.y equ dword [ebp-8]
.z equ dword [ebp-12]
.point_number equ word [ebp-26]
.hit_faces    equ word [ebp-28]
 
	fninit
	mov	  ebp,esp
	sub	  esp,28
	mov	  edi,[points_normals_ptr]
	mov	  .point_number,0
    .ipn_loop:
	mov	  .hit_faces,0
	mov	  .x,0
	mov	  .y,0
	mov	  .z,0
	mov	  esi,[triangles_ptr]
	xor	  ecx,ecx	       ; ecx - triangle number
    .ipn_check_face:
	xor	  ebx,ebx	       ; ebx - 'position' in one triangle
    .ipn_check_vertex:
	movzx	  eax,word[esi+ebx]    ;  eax - point_number
	cmp	  ax,.point_number
	jne	  .ipn_next_vertex
	push	  esi
	mov	  esi,ecx
	lea	  esi,[esi*3]
       ; lea       esi,[triangles_normals+esi*4]
	shl	  esi,2
	add	  esi,[triangles_normals_ptr]
 
	fld	  .x
	fadd	  dword[esi+vec_x]	 ; vec_x this defined in 3dmath.asm - x cooficient
	fstp	  .x			 ; of normal vactor
	fld	  .y
	fadd	  dword[esi+vec_y]
	fstp	  .y
	fld	  .z
	fadd	  dword[esi+vec_z]
	fstp	  .z
	pop	  esi
	inc	  .hit_faces
	jmp	  .ipn_next_face
    .ipn_next_vertex:
	add	  ebx,2
	cmp	  ebx,6
	jne	  .ipn_check_vertex
    .ipn_next_face:
	add	  esi,6
	inc	  ecx
	cmp	  cx,[triangles_count_var]
	jne	  .ipn_check_face
 
	fld	  .x
	fidiv	  .hit_faces
	fstp	  dword[edi+vec_x]
	fld	  .y
	fidiv	  .hit_faces
	fstp	  dword[edi+vec_y]
	fld	  .z
	fidiv	  .hit_faces
	fstp	  dword[edi+vec_z]
	call	  normalize_vector
	add	  edi,12  ;type vector 3d
	inc	  .point_number
	mov	  dx,.point_number
	cmp	  dx,[points_count_var]
	jne	  .ipn_loop
 
	mov	  esp,ebp
ret
;===============================================================
 
init_triangles_normals2:
	mov	ebx,[triangles_normals_ptr]
	mov	ebp,[triangles_ptr]
     @@:
	push	ebx
	mov	ebx,vectors
	movzx	esi,word[ebp]	       ; first point index
	lea	esi,[esi*3]
;        lea     esi,[points+esi*2]     ; esi - pointer to 1st 3d point
	shl	esi,2
	add	esi,[points_ptr]
	movzx	edi,word[ebp+2] 	 ; first point index
	lea	edi,[edi*3]
	shl	edi,2
	add	edi,[points_ptr]
;        movzx   edi,word[ebp+2]        ; second point index
;        lea     edi,[edi*3]
;        lea     edi,[points+edi*2]     ; edi - pointer to 2nd 3d point
	call	make_vector_r
	add	ebx,12
	mov	esi,edi
	movzx	edi,word[ebp+4]        ; third point index
	lea	edi,[edi*3]
	shl	edi,2
	add	edi,[points_ptr]
;        lea     edi,[points+edi*2]
	call	make_vector_r
	mov	edi,ebx 		; edi - pointer to 2nd vector
	mov	esi,ebx
	sub	esi,12			; esi - pointer to 1st vector
	pop	ebx
	call	cross_product
	mov	edi,ebx
	call	normalize_vector
	add	ebp,6
	add	ebx,12
	cmp	dword[ebp],-1
	jne	@b
ret
 
 
;=================================================================
sort_triangles:
	mov	esi,[triangles_ptr]
	mov	edi,triangles_with_z
	mov	ebp,[points_translated_ptr]
 
    make_triangle_with_z:	;makes list with triangles and z position
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	movzx	ecx,word[ebp+eax*2+4]
 
	movzx	eax,word[esi+2]
	lea	eax,[eax*3]
	add	cx,word[ebp+eax*2+4]
 
	movzx	eax,word[esi+4]
	lea	eax,[eax*3]
	add	cx,word[ebp+eax*2+4]
 
	mov	ax,cx
       ; cwd
       ; idiv    word[i3]
	movsd			; store vertex coordinates
	movsw
	stosw			; middle vertex coordinate  'z' in triangles_with_z list
	cmp	dword[esi],-1
	jne	make_triangle_with_z
	movsd			; copy end mark
	mov	eax,4
	lea	edx,[edi-8-trizdd]
     ;   lea     edx, [edi-8]
     ;   sub     edx,[triangles_w_z_ptr]
	mov	[high],edx
	call	quicksort
	mov	eax,4
	mov	edx,[high]
	call	insertsort
	jmp	end_sort
 
    quicksort:
	mov	ecx,edx
	sub	ecx,eax
	cmp	ecx,32
	jc	.exit
	lea	ecx,[eax+edx]
	shr	ecx,4
	lea	ecx,[ecx*8-4];
;        mov     edi,[triangles_w_z_ptr]
;        mov     ebx,[edi+eax]
;        mov     esi,[edi+ecx]
;        mov     edi,[edi+edx]
	mov	ebx,[trizdd+eax]; trizdd[l]
	mov	esi,[trizdd+ecx]; trizdd[i]
	mov	edi,[trizdd+edx]; trizdd[h]
	cmp	ebx,esi
	jg	@f		; direction NB! you need to negate these to invert the order
      if Ext=NON
	mov	[trizdd+eax],esi
	mov	[trizdd+ecx],ebx
	mov	ebx,[trizdd+eax-4]
	mov	esi,[trizdd+ecx-4]
	mov	[trizdd+eax-4],esi
	mov	[trizdd+ecx-4],ebx
	mov	ebx,[trizdd+eax]
	mov	esi,[trizdd+ecx]
      else
;        push    ebx
;        mov     ebx,[triangles_w_z_ptr]
;        movq    mm0,[ebx+eax-4]
;        movq    mm1,[ebx+ecx-4]
;        movq    [ebx+ecx-4],mm0
;        movq    [ebx+eax-4],mm1
;        pop     ebx
	movq	mm0,[trizdq+eax-4]
	movq	mm1,[trizdq+ecx-4]
	movq	[trizdq+ecx-4],mm0
	movq	[trizdq+eax-4],mm1
	xchg	ebx,esi
      end if
      @@:
	cmp	ebx,edi
	jg	@f		; direction
      if Ext=NON
	mov	[trizdd+eax],edi
	mov	[trizdd+edx],ebx
	mov	ebx,[trizdd+eax-4]
	mov	edi,[trizdd+edx-4]
	mov	[trizdd+eax-4],edi
	mov	[trizdd+edx-4],ebx
	mov	ebx,[trizdd+eax]
	mov	edi,[trizdd+edx]
      else
;        push    ebx
;        mov     ebx,[triangles_w_z_ptr]
;        movq    mm0,[ebx+eax-4]
;        movq    mm1,[ebx+edx-4]
;        movq    [ebx+edx-4],mm0
;        movq    [ebx+eax-4],mm1
	movq	mm0,[trizdq+eax-4]
	movq	mm1,[trizdq+edx-4]
	movq	[trizdq+edx-4],mm0
	movq	[trizdq+eax-4],mm1
;        pop     ebx
	xchg	ebx,edi
      end if
      @@:
	cmp	esi,edi
	jg	@f		; direction
      if Ext=NON
	mov	[trizdd+ecx],edi
	mov	[trizdd+edx],esi
	mov	esi,[trizdd+ecx-4]
	mov	edi,[trizdd+edx-4]
	mov	[trizdd+ecx-4],edi
	mov	[trizdd+edx-4],esi
      else
;        push    ebx
;        mov     ebx,[triangles_w_z_ptr]
;        movq    mm0,[ebx+ecx-4]
;        movq    mm1,[ebx+edx-4]
;        movq    [ebx+edx-4],mm0
;        movq    [ebx+ecx-4],mm1
;        pop     ebx
 
	movq	mm0,[trizdq+ecx-4]
	movq	mm1,[trizdq+edx-4]
	movq	[trizdq+edx-4],mm0
	movq	[trizdq+ecx-4],mm1
	xchg	ebx,esi
      end if
      @@:
	mov	ebp,eax 	; direction
	add	ebp,8	   ;   j
      if Ext=NON
	mov	esi,[trizdd+ebp]
	mov	edi,[trizdd+ecx]
	mov	[trizdd+ebp],edi
	mov	[trizdd+ecx],esi
	mov	esi,[trizdd+ebp-4]
	mov	edi,[trizdd+ecx-4]
	mov	[trizdd+ecx-4],esi
	mov	[trizdd+ebp-4],edi
      else
;        push    ebx
;        mov     ebx,[triangles_w_z_ptr]
;        movq    mm0,[ebx+ebp-4]
;        movq    mm1,[ebx+ecx-4]
;        movq    [ebx+ecx-4],mm0
;        movq    [ebx+ebp-4],mm1
;        pop     ebx
 
	movq	mm0,[trizdq+ebp-4]
	movq	mm1,[trizdq+ecx-4]
	movq	[trizdq+ecx-4],mm0
	movq	[trizdq+ebp-4],mm1
      end if
	mov	ecx,edx    ;   i; direction
	mov	ebx,[trizdd+ebp]; trizdd[j]
;        mov     ebx, [triangles_w_z_ptr]
;        add     ebx, ebp
 
 ;       push    eax
 ;       mov     eax, [triangles_w_z_ptr]
      .loop:
	sub	ecx,8		; direction
	cmp	[trizdd+ecx],ebx
;        cmp     [eax+ecx],ebx
	jl	.loop		; direction
      @@:
	add	ebp,8		; direction
	cmp	[trizdd+ebp],ebx
;        cmp     [eax+ebp],ebx
	jg	@b		; direction
	cmp	ebp,ecx
	jge	@f		; direction
      if Ext=NON
	mov	esi,[trizdd+ecx]
	mov	edi,[trizdd+ebp]
	mov	[trizdd+ebp],esi
	mov	[trizdd+ecx],edi
	mov	edi,[trizdd+ecx-4]
	mov	esi,[trizdd+ebp-4]
	mov	[trizdd+ebp-4],edi
	mov	[trizdd+ecx-4],esi
      else
;        movq    mm0,[eax+ecx-4]
;        movq    mm1,[eax+ebp-4]
;        movq    [eax+ebp-4],mm0
;        movq    [eax+ecx-4],mm1
	movq	mm0,[trizdq+ecx-4]
	movq	mm1,[trizdq+ebp-4]
	movq	[trizdq+ebp-4],mm0
	movq	[trizdq+ecx-4],mm1
      end if
	jmp	.loop
;        pop     eax
      @@:
      if Ext=NON
	mov	esi,[trizdd+ecx]
	mov	edi,[trizdd+eax+8]
	mov	[trizdd+eax+8],esi
	mov	[trizdd+ecx],edi
	mov	edi,[trizdd+ecx-4]
	mov	esi,[trizdd+eax+4]
	mov	[trizdd+eax+4],edi
	mov	[trizdd+ecx-4],esi
      else
;        push    edx
;        mov     edx,[triangles_w_z_ptr]
;        movq    mm0,[edx+ecx-4]
;        movq    mm1,[edx+eax+4]; dir
;        movq    [edx+eax+4],mm0; dir
;        movq    [edx+ecx-4],mm1
;        pop     edx
 
	movq	mm0,[trizdq+ecx-4]
	movq	mm1,[trizdq+eax+4]; dir
	movq	[trizdq+eax+4],mm0; dir
	movq	[trizdq+ecx-4],mm1
      end if
	add	ecx,8
	push	ecx edx
	mov	edx,ebp
	call	quicksort
	pop	edx eax
	call	quicksort
      .exit:
    ret
    insertsort:
	mov	esi,eax
      .start:
	add	esi,8
	cmp	esi,edx
	ja	.exit
	mov	ebx,[trizdd+esi]
;        mov     ebx,[triangles_w_z_ptr]
;        add     ebx,esi
      if Ext=NON
	mov	ecx,[trizdd+esi-4]
      else
;        push    ebx
;        mov     ebx,[triangles_w_z_ptr]
;        movq    mm1,[ebx+esi-4]
	movq	mm1,[trizdq+esi-4]
;        pop     ebx
      end if
	mov	edi,esi
      @@:
	cmp	edi,eax
	jna	@f
;        push    eax
;        mov     eax,[triangles_w_z_ptr]
;        cmp     [eax+edi-8],ebx
;        pop     eax
       cmp     [trizdd+edi-8],ebx
	jg	@f		   ; direction
      if Ext=NON
	mov	ebp,[trizdd+edi-8]
	mov	[trizdd+edi],ebp
	mov	ebp,[trizdd+edi-12]
	mov	[trizdd+edi-4],ebp
      else
;        push    eax
;        mov     eax,[triangles_w_z_ptr]
;        movq    mm0,[eax+edi-12]
;        movq    [eax+edi-4],mm0
	movq	mm0,[trizdq+edi-12]
	movq	[trizdq+edi-4],mm0
;        pop     eax
      end if
	sub	edi,8
	jmp	@b
      @@:
      if Ext=NON
	mov	[trizdd+edi],ebx
	mov	[trizdd+edi-4],ecx
      else
;        push    eax
;        mov     eax,[triangles_w_z_ptr]
;        movq    [eax+edi-4],mm1
	movq	[trizdq+edi-4],mm1
;        pop     eax
      end if
	jmp	.start
      .exit:
    ret
   end_sort:
    ; translate triangles_with_z to sorted_triangles
	mov	esi,triangles_with_z
;        mov      esi,[triangles_w_z_ptr]
      ;  mov     edi,sorted_triangles
	mov	 edi,[triangles_ptr]
    again_copy:
      if Ext=NON
	movsd
	movsw
	add	esi,2
      else
	movq	mm0,[esi]
	movq	[edi],mm0
	add	esi,8
	add	edi,6
      end if
	cmp	dword[esi],-1
	jne	again_copy
;      if Ext=MMX
;        emms
;      end if
	movsd  ; copy end mark too
ret
 
clrscr:
	mov	edi,screen
	mov	ecx,SIZE_X*SIZE_Y*3/4
	xor	eax,eax
      if Ext=NON
	rep	stosd
      else
	pxor	mm0,mm0
      @@:
	movq	[edi+00],mm0
	movq	[edi+08],mm0
	movq	[edi+16],mm0
	movq	[edi+24],mm0
	add	edi,32
	sub	ecx,8
	jnc	@b
      end if
ret
 
 
draw_triangles:
	mov esi,[triangles_ptr]
	mov [edges_counter],0
    .again_dts:
	mov ebp,[points_translated_ptr]
      if Ext=NON
	movzx	eax,word[esi]
	mov	[point_index1],ax
	lea	eax,[eax*3]
	add	eax,eax
	push	ebp
	add	ebp,eax
	mov	eax,[ebp]
	mov	dword[xx1],eax
	mov	eax,[ebp+4]
	mov	[zz1],ax
	pop	ebp
 
 
	movzx	eax,word[esi+2]
	mov	[point_index2],ax
	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
	pop	ebp
 
 
	movzx	eax,word[esi+4]        ; xyz3 = [ebp+[esi+4]*6]
	mov	[point_index3],ax
	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
	mov	eax,dword[esi]		 ; don't know MMX
	mov	dword[point_index1],eax
       ; shr     eax,16
       ; mov     [point_index2],ax
	mov	ax,word[esi+4]
	mov	[point_index3],ax
	movq	mm0,[esi]
	pmullw	mm0,qword[const6]
	movd	eax,mm0
	psrlq	mm0,16
	movd	ebx,mm0
	psrlq	mm0,16
	movd	ecx,mm0
	and	eax,0FFFFh
	and	ebx,0FFFFh
	and	ecx,0FFFFh
	movq	mm0,[ebp+eax]
	movq	mm1,[ebp+ebx]
	movq	mm2,[ebp+ecx]
	movq	qword[xx1],mm0
	movq	qword[xx2],mm1
	movq	qword[xx3],mm2
;        emms
      end if				  ; *********************************
	push esi			  ;
	fninit				  ; DO culling AT FIRST
	cmp	[culling_flag],1	  ; (if culling_flag = 1)
	jne	.no_culling
	mov	esi,point_index1	  ; *********************************
	mov	ecx,3			  ;
      @@:
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	shl	eax,2
	add	eax,[points_normals_rot_ptr]
;        lea     eax,[eax+point_normals_rotated]
	fld	dword[eax+8]		 ; *****************************
	ftst				 ; CHECKING OF Z COOFICIENT OF
	fstsw	ax			 ; NORMAL VECTOR
	sahf
	jb	@f
	ffree	st
	loop	@b
	jmp	.end_draw   ; non visable
      @@:
	ffree	st  ;is visable
      .no_culling:
	cmp	[dr_flag],0		  ; draw type flag
	je	.flat_draw
	cmp	[dr_flag],2
	je	.env_mapping
	cmp	[dr_flag],3
	je	.bump_mapping
	cmp	[dr_flag],4
	je	.tex_mapping
	cmp	[dr_flag],5
	je	.rainbow
	cmp	[dr_flag],7
	je	.grd_tex
	cmp	[dr_flag],8
	je	.two_tex
	cmp	[dr_flag],9
	je	.bump_tex
	cmp	[dr_flag],10
	je	.cubic_env_mapping
	cmp	[dr_flag],11
	je	.draw_smooth_line
				      ; ****************
	mov	esi,point_index3      ; do Gouraud shading
	mov	ecx,3
      .again_grd_draw:
	movzx	eax,word[esi]
	shl	eax,2
	lea	eax,[eax*3]
	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	word[esp-2]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]	  ; y cooficient
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[esp-4]
 
	movzx	 eax,word[esp-4]
	movzx	 ebx,word[esp-2]
	shl	 eax,TEX_SHIFT
	add	 eax,ebx
	lea	 eax,[eax*3+color_map]
	mov	 eax,dword[eax]
	cmp	[catmull_flag],1      ; put on stack z coordinate if necessary
	jne	 @f
	lea	 edx,[ecx*3]
	push	 word[edx*2+xx1-2]    ; zz1 ,2 ,3
      @@:
	ror	 eax,16 	      ; eax -0xxxrrggbb -> 0xggbbxxrr
	xor	 ah,ah
	push	 ax	    ;r
	rol	 eax,8		      ; eax-0xggbb00rr -> 0xbb00rrgg
	xor	 ah,ah
	push	 ax	    ;g
	shr	 eax,24
	push	 ax	    ;b
 
	sub	 esi,2
	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]
   ;     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]
   .rainbow:
	cmp	[catmull_flag],1      ; put on stack z coordinate if necessary
	jne	 @f
	push	 [zz3]
      @@:
	mov	 eax,dword[yy3]
	mov	 ebx,0x00ff00ff
	and	 eax,ebx
	push	 eax
	neg	 al
	push	 ax
	cmp	[catmull_flag],1
	jne	 @f
	push	 [zz2]
      @@:
	mov	 eax,dword[yy2]
	and	 eax,ebx
	push	 eax
	neg	 al
	push	 ax
	cmp	[catmull_flag],1
	jne	 @f
	push	 [zz1]
      @@:
	mov	 eax,dword[yy1]
	and	 eax,ebx
	push	 eax
	neg	 al
	push	 ax
    .both_draw:
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	lea	edi,[screen]
	cmp	[catmull_flag],0
	je	@f
  ;      lea     esi,[Z_buffer]
	mov	esi,[Zbuffer_ptr]
	call	gouraud_triangle_z
	jmp	.end_draw
       @@:
	call	gouraud_triangle
	jmp	.end_draw
 
     .flat_draw:		     ;**************************
				     ; FLAT DRAWING
	movzx	eax,[point_index1]
	movzx	ebx,[point_index2]
	movzx	ecx,[point_index3]
	shl	eax,2
	shl	ebx,2
	shl	ecx,2
	lea	eax,[eax*3]  ;+point_normals_rotated]
	add	eax,[points_normals_rot_ptr]
	lea	ebx,[ebx*3]  ;+point_normals_rotated]
	add	ebx,[points_normals_rot_ptr]
	lea	ecx,[ecx*3]  ;+point_normals_rotated]
	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	dword[esp-4]	; x temp variables
	fld	dword[eax+4]	; y cooficient of normal vector
	fadd	dword[ebx+4]
	fadd	dword[ecx+4]
	fidiv	[i3]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	dword[esp-8]   ;  y
	mov	edx,dword[esp-8]
	shl	edx,TEX_SHIFT
	add	edx,dword[esp-4]
	lea	eax,[3*edx+color_map]
	mov	edx,dword[eax]
 
	and	edx,0x00ffffff	  ; edx = 0x00rrggbb
 
 
 
     ;   mov     ax,[zz1]      ; z position depend draw
     ;   add     ax,[zz2]
     ;   add     ax,[zz3]
     ;   cwd
     ;   idiv    [i3] ;    = -((a+b+c)/3+130)
     ;   add     ax,130
     ;   neg     al
     ;   xor     edx,edx
     ;   mov     ah,al           ;set color according to z position
     ;   shl     eax,8
     ;   mov     edx,eax
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
       ; mov     edi,screen
	lea	edi,[screen]
	cmp	[catmull_flag],0
	je	@f
   ;     lea     esi,[Z_buffer]
	mov	esi,[Zbuffer_ptr]
	push	word[zz3]
	push	word[zz2]
	push	word[zz1]
	call	flat_triangle_z
	jmp	.end_draw
      @@:
	call	draw_triangle
	jmp	.end_draw
      .env_mapping:
       ; fninit
	cmp	[catmull_flag],0
	je	@f
	push	[zz3]
	push	[zz2]
	push	[zz1]
      @@:
	mov	esi,point_index1
	sub	esp,12
	mov	edi,esp
	mov	ecx,3
      @@:
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	shl	eax,2
	add	eax,[points_normals_rot_ptr]	   ;point_normals_rotated
; #
;        fld     dword[eax]
;        fmul    dword[eax+4]
;        fld1
;        fld1
;        faddp
;        fmulp
;        fimul   [correct_tex]
;        fiadd   [correct_tex]
;        fistp   word[edi]
;        mov     word[edi+2],0
;;        fistp   word[edi+2]
; # last change
	; texture x=(rotated point normal -> x * 255)+255
	fld	dword[eax]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi+2]
; # end of last ch.
	add	edi,4
	add	esi,2
	loop	@b
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	esi,envmap
	cmp	[catmull_flag],0
	je	@f
  ;      mov     edx,Z_buffer
	mov	edx,[Zbuffer_ptr]
	call	tex_triangle_z
	jmp	.end_draw
      @@:
	call	tex_triangle
	jmp	.end_draw
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     .cubic_env_mapping:
       ; fninit
	cmp	[catmull_flag],0
	je	@f
	push	[zz3]
	push	[zz2]
	push	[zz1]
      @@:
	mov	esi,point_index1
	sub	esp,12
	mov	edi,esp
	mov	ecx,3
      @@:
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	shl	eax,2
	add	eax,[points_normals_rot_ptr]  ;point_normals_rotated
; #
	fld	dword[eax]
	fmul	dword[eax+4]
	fld1
	fld1
	faddp
	fmulp
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi]
	mov	word[edi+2],0
;        fistp   word[edi+2]
; # last change
;        ; texture x=(rotated point normal -> x * 255)+255
;        fld     dword[eax]
;        fimul   [correct_tex]
;        fiadd   [correct_tex]
;        fistp   word[edi]
;        ; texture y=(rotated point normal -> y * 255)+255
;        fld     dword[eax+4]
;        fimul   [correct_tex]
;        fiadd   [correct_tex]
;        fistp   word[edi+2]
; # end of last ch.
	add	edi,4
	add	esi,2
	loop	@b
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	esi,envmap_cub
	cmp	[catmull_flag],0
	je	@f
  ;      mov     edx,Z_buffer
	mov	edx,[Zbuffer_ptr]
	call	tex_triangle_z
	jmp	.end_draw
      @@:
	call	tex_triangle
	jmp	.end_draw
 
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
      .bump_mapping:
	; fninit
	cmp	[catmull_flag],0
	je	@f
;        push    Z_buffer
	push	[Zbuffer_ptr]
	push	[zz3]
	push	[zz2]
	push	[zz1]
      @@:
	mov	esi,point_index1
	sub	esp,12
	mov	edi,esp
	mov	ecx,3
      @@:
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	shl	eax,2
	add	eax,[points_normals_rot_ptr]  ;point_normals_rotated
	; texture x=(rotated point normal -> x * 255)+255
	fld	dword[eax]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi+2]
 
	add	edi,4
	add	esi,2
	loop	@b
 
	movzx  esi,[point_index3]      ; bump map coords
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index2]
	shl    esi,2
	add    esi,tex_points
;       lea    esi,[esi*3]
;       lea    esi,[points+2+esi*2]
	push   dword[esi]
  ;     push   dword[xx2]
	movzx  esi,[point_index1]
	shl    esi,2
	add    esi,tex_points
;       lea     esi,[esi*3]
;       lea     esi,[points+2+esi*2]
	push   dword[esi]
   ;    push     dword[xx1]
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	esi,envmap
	mov	edx,bumpmap	       ;BUMP_MAPPING
 
	cmp	[catmull_flag],0
	je	@f
	call	bump_triangle_z
	jmp	.end_draw
      @@:
	call	bump_triangle
	jmp	.end_draw
 
      .tex_mapping:
 
	; fninit
	cmp	[catmull_flag],0
	je	@f
	push	[zz3]
	push	[zz2]
	push	[zz1]
      @@:
	movzx  esi,[point_index3]      ; tex map coords
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index2]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index1]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	esi,texmap
	cmp	[catmull_flag],0
	je	@f
   ;     mov     edx,Z_buffer
	mov	edx,[Zbuffer_ptr]
	call	tex_triangle_z
 ;       call    tex_plus_grd_trianlgle
	jmp	.end_draw
      @@:
	call	tex_triangle
	jmp	.end_draw
;      .ray:
;        grd_triangle according to points index
;        cmp     [catmull_flag],0
;        je      @f
;        push    [zz3]                   ; spot light with attenuation
;     @@:
;        movzx   eax,[point_index3]      ; env_map - points color list
;        shl     eax,1                   ; each color as word, 0x00rr00gg00bb..
;        lea     eax,[3*eax+bumpmap]
;        push    word[eax]
;        push    word[eax+2]
;        push    word[eax+4]
;        cmp     [catmull_flag],0
;        je      @f
;        push    [zz2]
;    @@:
;        movzx   eax,[point_index2]      ; env_map - points color list
;        shl     eax,1                   ; each color as word, 0x00rr00gg00bb..
;        lea     eax,[eax*3+bumpmap]
;        push    word[eax]
;        push    word[eax+2]
;        push    word[eax+4]
;        cmp     [catmull_flag],0
;        je      @f
;        push    [zz1]
;     @@:
;        movzx   eax,[point_index1]      ; env_map - points color list
;        shl     eax,1                   ; each color as word, 0xrr00gg00bb00..
;        lea     eax,[eax*3+bumpmap]
;        push    word[eax]
;        push    word[eax+2]
;        push    word[eax+4]
;        jmp     .both_draw
 
     .grd_tex:		  ; smooth shading + texture
	 push	ebp
	 mov	ebp,esp
	 sub	esp,4
	 push	ebp
 
	 movzx	esi,[point_index3]	; tex map coords
	 shl	esi,2
	 add	esi,tex_points
	 push	dword[esi]		; texture coords as first
	 movzx	esi,[point_index2]	; group of parameters
	 shl	esi,2
	 add	esi,tex_points
	 push	dword[esi]
	 movzx	esi,[point_index1]
	 shl	esi,2
	 add	esi,tex_points
	 push	dword[esi]
 
	 mov	 esi,point_index3
	 mov	 ecx,3
 
      .aagain_grd_draw:
 
	lea	 edx,[ecx*3]
	push	 word[edx*2+xx1-2]    ; zz1 ,2 ,3
 
	movzx	eax,word[esi]
	shl	eax,2
	lea	eax,[eax*3] ;+point_normals_rotated]
	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	word[ebp-2]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]	  ; y cooficient
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[ebp-4]
 
	movzx	 eax,word[ebp-4]
	movzx	 ebx,word[ebp-2]
	shl	 eax,TEX_SHIFT
	add	 eax,ebx
	lea	 eax,[eax*3+color_map]
	mov	 eax,dword[eax]
 
	ror	 eax,16 	      ; eax -0xxxrrggbb -> 0xggbbxxrr
	xor	 ah,ah
	push	 ax	    ;r
	rol	 eax,8		      ; eax-0xggbb00rr -> 0xbb00rrgg
	xor	 ah,ah
	push	 ax	    ;g
	shr	 eax,24
	push	 ax	    ;b
 
	sub	 esi,2
	dec	 cx
	jnz	 .aagain_grd_draw
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	edx,texmap
	mov	esi,[Zbuffer_ptr]
 
	call	tex_plus_grd_triangle
 
	pop	ebp
	mov	esp,ebp
	pop	ebp
	jmp	.end_draw
 
      .two_tex:
	push	[Zbuffer_ptr]
 
	push	word[zz3]
	push	word[zz2]
	push	word[zz1]
 
	movzx  esi,[point_index3]      ; tex map coords
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index2]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index1]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
 
	mov	esi,point_index1     ; env coords
	sub	esp,12
	mov	edi,esp
	mov	ecx,3
      @@:
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	shl	eax,2
	add	eax,[points_normals_rot_ptr]
	; texture x=(rotated point normal -> x * 255)+255
	fld	dword[eax]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi+2]
 
	add	edi,4
	add	esi,2
	loop	@b
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	esi,texmap
	mov	edx,envmap
 
	call	two_tex_triangle_z
	jmp	.end_draw
 
   .bump_tex:
	movzx  esi,[point_index3]      ; tex map coords
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index2]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index1]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
 
	push  dword texmap
 
	push  [Zbuffer_ptr]
	xor   edi,edi
 
	push	word[zz3]
	push	word[zz2]
	push	word[zz1]
 
	mov	esi,point_index1     ; env coords
	sub	esp,12
	mov	edi,esp
	mov	ecx,3
      @@:
	movzx	eax,word[esi]
	lea	eax,[eax*3]
	shl	eax,2
	add	eax,[points_normals_rot_ptr]
	; texture x=(rotated point normal -> x * 255)+255
	fld	dword[eax]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[edi+2]
 
	add	edi,4
	add	esi,2
	loop	@b
 
;        push  dword 1 shl 16 + 1  ; emap coords
;        push  dword 127 shl 16 + 1
;        push  dword 127 shl 16 + 127
 
	movzx  esi,[point_index3]      ; bump map coords
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
	movzx  esi,[point_index2]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
 
	movzx  esi,[point_index1]
	shl    esi,2
	add    esi,tex_points
	push   dword[esi]
 
;        push  dword 1 shl 16 + 127
;        push  dword 127 shl 16 + 127
;        push  dword 1 shl 16 + 1  ; bump coords
 
	mov	eax,dword[xx1]
	ror	eax,16
	mov	ebx,dword[xx2]
	ror	ebx,16
	mov	ecx,dword[xx3]
	ror	ecx,16
	mov	edi,screen
	mov	esi,envmap
	mov	edx,bumpmap
 
	call bump_tex_triangle_z
 
	jmp	.end_draw
 
      .draw_smooth_line:
	mov	esi,point_index3
	mov	ecx,3
      .again_line_param:
	movzx	eax,word[esi]
	shl	eax,2
	lea	eax,[eax*3]
	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	word[esp-2]
	; texture y=(rotated point normal -> y * 255)+255
	fld	dword[eax+4]	  ; y cooficient
	fimul	[correct_tex]
	fiadd	[correct_tex]
	fistp	word[esp-4]
 
	movzx	 eax,word[esp-4]
	movzx	 ebx,word[esp-2]
	shl	 eax,TEX_SHIFT
	add	 eax,ebx
	lea	 eax,[eax*3+color_map]
	mov	 eax,dword[eax]
	lea	 ebx,[ecx-1]
	shl	 ebx,2
	mov	 [ebx+col1],eax
 
	sub	 esi,2
	dec	 ecx
	jnz	 .again_line_param
 
;        mov     eax,[edges_ptr]         ;   this not works correctly
;        add     eax,[edges_counter]     ;   I mean chosing overlapped  edges.
;        mov     bl,[eax]                ;
;        test    bl,00000001b            ;
;        jz      @f                      ;
	mov	edi,screen
	mov	esi,[Zbuffer_ptr]
 
	mov	eax,[col1]
	movzx	bx,al
	push	bx		  ; b
	movzx	bx,ah
	push	bx
	rol	eax,16
	xor	ah,ah
	push	ax
	push	[zz1]
	push	[yy1]
	push	[xx1]
 
	mov	eax,[col2]
	movzx	bx,al
	push	bx		  ; b
	movzx	bx,ah
	push	bx
	rol	eax,16
	xor	ah,ah
	push	ax
	push	[zz2]
	push	[yy2]
	push	[xx2]
 
	call	smooth_line
     @@:
;        mov     eax,[edges_ptr]       ;  this not works correctly
;        add     eax,[edges_counter]
;        mov     bl,[eax]
;        test    bl,00000010b
;        jz      @f
 
	mov	edi,screen
	mov	esi,[Zbuffer_ptr]
 
	mov	eax,[col1]
	movzx	bx,al
	push	bx		  ; b
	movzx	bx,ah
	push	bx
	rol	eax,16
	xor	ah,ah
	push	ax
	push	[zz1]
	push	[yy1]
	push	[xx1]
 
	mov	eax,[col3]
	movzx	bx,al
	push	bx		  ; b
	movzx	bx,ah
	push	bx
	rol	eax,16
	xor	ah,ah
	push	ax
	push	[zz3]
	push	[yy3]
	push	[xx3]
 
	call	smooth_line
      @@:
 
;        mov     eax,[edges_ptr]        ;  this not works correctly
;        add     eax,[edges_counter]    ;
;        mov     bl,[eax]               ;
;        test    bl,00000100b           ;
;        jz      @f                     ;
 
	mov	edi,screen
	mov	esi,[Zbuffer_ptr]
 
	mov	eax,[col3]
	movzx	bx,al
	push	bx		  ; b
	movzx	bx,ah
	push	bx
	rol	eax,16
	xor	ah,ah
	push	ax
	push	[zz3]
	push	[yy3]
	push	[xx3]
 
	mov	eax,[col2]
	movzx	bx,al
	push	bx		  ; b
	movzx	bx,ah
	push	bx
	rol	eax,16
	xor	ah,ah
	push	ax
	push	[zz2]
	push	[yy2]
	push	[xx2]
 
	call	smooth_line
      @@:
 
      .end_draw:
	pop	esi
	add	esi,6
	inc	[edges_counter]
	cmp	dword[esi],-1
	jne	.again_dts
ret
 
 
fill_Z_buffer:
	mov	eax,0x70000000
      ;  mov     edi,Z_buffer
	mov	edi,[Zbuffer_ptr]
	mov	ecx,SIZE_X*SIZE_Y
	rep	stosd
ret
 
read_tp_variables:	      ; read [triangles_count_var] and  [points_count_var]
 
			      ; and  allocate memory
	xor	ebx,ebx
	xor	ebp,ebp
	mov	[points_count_var],bx
	mov	[triangles_count_var],bx
   if USE_LFN = 0
	mov	esi,SourceFile
   else
	mov	esi,[fptr]
   end if
 
	cmp	[esi],word 4D4Dh
	je	@f ;Must be legal .3DS file
	xor	eax,eax
	ret
    @@:
	mov	eax,dword[esi+2]
	cmp	eax,[fsize] ;This must tell the length
	je	@f
	xor	eax,eax
	ret
     @@:
	add	eax,esi
	mov	[EndFile],eax	 ;
 
	add	esi,6
      @@:
 
	cmp	[esi],word 3D3Dh
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	add	esi,6
      .find4k:
	cmp	[esi],word 4000h
	je	@f
	add	esi,[esi+2]
	cmp	esi,[EndFile]
	jc	.find4k
	jmp	.exit
      @@:
	add	esi,6
      @@:
	cmp	[esi],byte 0
	je	@f
	inc	esi
	jmp	@b
      @@:
	inc	esi
      @@:
	cmp	[esi],word 4100h
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	add	esi,6
      @@:
	cmp	[esi],word 4110h
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	movzx	ecx,word[esi+6]
	add	[points_count_var],cx
 
	mov	edx,ecx
	add	esi,8
     @@:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	add	ebx,6
	add	esi,12
     ;   dec     ecx
	loop	 @b
      @@:
 
 
 
 
 
      @@:
	cmp	[esi],word 4120h
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	movzx	ecx,word[esi+6]
	add	[triangles_count_var],cx
	add	esi,8
 
 
      @@:
	add	esi,8
 
 
 
 
 
 
 
 
	dec	ecx
	jnz	@b
;        xor     ecx,ecx
	add	ebp,edx
	jmp	.find4k
	mov	eax,-1 ;<---mark if OK
      .exit:
ret
 
 
read_from_file:
	fninit
	mov	edi,[triangles_ptr]
	xor	ebx,ebx
	xor	ebp,ebp
	mov	[points_count_var],0
	mov	[triangles_count_var],0
   if USE_LFN = 0
	mov	esi,SourceFile
   else
	mov	esi,[fptr]
   end if
	cmp	[esi],word 4D4Dh
 
	jne	.exit ;Must be legal .3DS file
;        cmp     dword[esi+2],EndFile-SourceFile
;        jne     .exit ;This must tell the length
 
	mov	eax,dword[esi+2]
  ;      cmp     eax,[fsize]
  ;      jne     .exit
 
 
	add	eax,esi
 
	mov	[EndFile],eax	 ;
 
	add	esi,6
      @@:
	cmp	[esi],word 3D3Dh
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	add	esi,6
      .find4k:
	cmp	[esi],word 4000h
	je	@f
	add	esi,[esi+2]
	cmp	esi,[EndFile]
	jc	.find4k
	jmp	.exit
      @@:
	add	esi,6
      @@:
	cmp	[esi],byte 0
	je	@f
	inc	esi
	jmp	@b
      @@:
	inc	esi
      @@:
	cmp	[esi],word 4100h
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	add	esi,6
      @@:
	cmp	[esi],word 4110h
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	movzx	ecx,word[esi+6]
	add	[points_count_var],cx
 
	mov	edx,ecx
	add	esi,8
     @@:
	push	edi
	mov	edi,[points_ptr]
	push	dword[esi+4]
	pop	dword[edi+ebx*2+0]
	push	dword[esi+8]
	pop	dword[edi+ebx*2+4]
	push	dword[esi+0]
	pop	dword[edi+ebx*2+8]
	pop	edi
;        fld     dword[esi+4]
;        fstp    dword[real_points+ebx*2+0]  ; x
;        fld     dword[esi+8]
;        fstp   dword[real_points+ebx*2+4]  ; y
;        fld     dword[esi+0]
;        fstp   dword[real_points+ebx*2+8]  ; z
 
	add	ebx,6
	add	esi,12
	dec	ecx
	jnz	@b
      @@:
  ;      mov     dword[points+ebx],-1
	push	edi
	mov	edi,[points_ptr]
	mov	dword[edi+ebx*2],-1	   ; end mark (not always in use)
	pop	edi
      @@:
	cmp	[esi],word 4120h
	je	@f
	add	esi,[esi+2]
	jmp	@b
      @@:
	movzx	ecx,word[esi+6]
	add	[triangles_count_var],cx
	add	esi,8
	;mov     edi,triangles
 
      @@:
	movsd
	movsw
	add	word[edi-6],bp
	add	word[edi-4],bp
	add	word[edi-2],bp
	add	esi,2
	dec	ecx
	jnz	@b
	add	ebp,edx
 
	jmp	.find4k
	mov	eax,-1 ;<---mark if OK
      .exit:
	mov	dword[edi],-1
ret
 
if USE_LFN
alloc_mem_for_tp:
	mov	eax, 68
	cmp	[re_alloc_flag],1
	jz	@f
	mov	ebx, 12
	jmp	.alloc
    @@:
	mov	ebx,20
    .alloc:
 
	movzx	ecx, [triangles_count_var]
	inc	ecx
	lea	ecx, [ecx*3]
	add	ecx, ecx
	mov	edx,[triangles_ptr]
	int	0x40		       ;  -> allocate memory to triangles
	mov	[triangles_ptr], eax   ;  -> eax = pointer to allocated mem
 
;        mov     eax, 68
;        movzx   ecx, [triangles_count_var]
;        inc     ecx
;        mov     edx,[edges_ptr]
;        int     0x40                   ;  -> allocate memory to edges
;        mov     [edges_ptr], eax   ;  -> eax = pointer to allocated mem
 
;        mov     eax,-1                       ; fill edges list
;        movzx   ecx,[triangles_count_var]    ; importand if object generated
;        shr     ecx,2
;        inc     ecx
;        mov     edi,[edges_ptr]
;        cld
;        rep     stosd
 
 
;        mov     eax, 68
;        mov     ebx, 12
;        movzx   ecx, [triangles_count_var]
;        shl     ecx, 4
;        int     0x40
;        mov     [triangles_w_z_ptr], eax   ; for trainagles_with_z list
					    ; ststic  memory
 
	mov	eax, 68
	movzx	ecx, [triangles_count_var]
	lea	ecx, [3+ecx*3]
	shl	ecx, 2
	mov	edx,[triangles_normals_ptr]
	int	0x40			       ;  -> allocate memory for triangles normals
	mov	[triangles_normals_ptr], eax   ;  -> eax = pointer to allocated mem
 
	mov	eax, 68
	movzx	ecx, [points_count_var]
	lea	ecx,[3+ecx*3]
	shl	ecx, 2
	mov	edx,[points_normals_ptr]
	int	0x40
	mov	[points_normals_ptr], eax
 
	mov	eax, 68
    ;    mov     ebx, 12
	movzx	ecx, [points_count_var]
	lea	ecx,[3+ecx*3]
	shl	ecx, 2
	mov	edx,[points_normals_rot_ptr]
	int	0x40
	mov	[points_normals_rot_ptr], eax
 
	mov	eax, 68
	mov	edx,[points_ptr]
	int	0x40
	mov	[points_ptr], eax
 
	mov	eax, 68
	mov	edx,[points_rotated_ptr]
	int	0x40
	mov	[points_rotated_ptr], eax
 
	mov	eax, 68
	movzx	ecx, [points_count_var]
	inc	ecx
	shl	ecx, 3
	mov	edx,[points_translated_ptr]
	int	0x40
	mov	[points_translated_ptr], eax
ret
end if
 
 
read_from_disk:
if USE_LFN
;-
    mov     eax, 70
    mov     ebx, file_info
    mov     dword[ebx], 5	   ;  -> subfunction number
    int     0x40		   ;  -> read file size
    mov     ebx, [fptr]
    mov     ebx, dword[ebx+32]
    inc     ebx
    mov     [fsize], ebx
 
    mov     eax, 68
    mov     ebx, 11
    int     0x40		   ;  -> create heap
 
    mov     eax, 68
    mov     ebx, 12
    mov     ecx, [fsize]
    int     0x40		   ;  -> allocate memory for file
    mov     [fptr], eax 	   ;  -> eax = pointer to allocated mem
 
    mov     eax, 70
    mov     ebx, file_info
    mov     dword[ebx],0
    int     0x40		   ; -> read file
 
    mov     [fsize],ebx
 
    cmp     eax,6
    jnz     @f
    xor     eax,eax	;;;;---
  @@:
else
    mov      eax,58
    mov      ebx,file_info
    int      0x40
 
    mov      eax,ebx
    shr      eax,9
    inc      eax
    mov      [fsize],eax
;    mov      ecx,ebx
;    add      ecx,MEM_END
;    mov      ebx,1
;    mov      eax,64     ; allocate mem  - resize app mem
			; for points and  triangles
    int      0x40
 
    mov      eax,58
    mov      ebx,file_info
    int      0x40
end if
  ;  eax = 0   -> ok file loaded
ret
read_param:
    mov        esi,I_Param
    cmp        dword[esi],0
    je	       .end
    cmp        byte[esi],'/'
    je	       .copy
    mov        edi,esi
    mov        ecx,25	; 25 - would be enought
    repe       scasb
    jne        .end
    dec        edi
    mov        esi,edi
 .copy:
    mov 	edi,file_name
    mov 	ecx,50
    rep 	movsd
 .end:
ret
buttons:				      ; draw some buttons (all but navigation and close )
	mov	edi,menu
      .again:
	mov	eax,8			      ; function 8 : define and draw button
	mov	ebx,(SIZE_X+10)*65536+62      ; [x start] *65536 + [x size]
	movzx	ecx,byte[edi]		      ; button id = position+2
	sub	cl,2
	lea	ecx,[ecx*5]
	lea	ecx,[ecx*3]
	add	ecx,25
	shl	ecx,16
	add	ecx,12
	movzx	edx,byte[edi]			; button id
	mov	esi,0x6688dd			; button color RRGGBB
	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
	lea	ebx,[ebx*3]
	lea	ebx,[ebx*5]
	add	ebx,(SIZE_X+12)*65536+28	; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff			; font 1 & color ( 0xF0RRGGBB )
	lea	edx,[edi+1]			; pointer to text beginning
	mov	esi,10				; text length
	int	0x40
	cmp	byte[edi+11],255		; if max_flag=255
	je	@f				; skip
	; flag description
;       mov     eax,4                           ; function 4 : write text to window
;       movzx   ebx,byte[edi]
;       sub     bl,2
;       lea     ebx,[ebx*3]
;       lea     ebx,[ebx*5]
;       add     ebx,(SIZE_X+12+70)*65536+28     ; [x start] *65536 + [y start]
	add	ebx,70*65536
;       mov     ecx,0x20ddeeff                  ; font 1 & color ( 0xF0RRGGBB )
	movzx	edx,byte[edi+12]		; current flag
	shl	edx,2				; * 4 = text length
	add	edx,dword[edi+13]		; pointer to text beginning
	mov	esi,4				; text length
	int	0x40
 
    @@:
	add	edi,17
	cmp	byte[edi],-1
	jnz	.again
ret
;   *********************************************
;   *******  WINDOW DEFINITIONS AND DRAW ********
;   *********************************************
    draw_window:
	mov	eax,12		; function 12:tell os about windowdraw
	mov	ebx,1		; 1, start of draw
	int	0x40
 
	; DRAW WINDOW
	mov	eax,0		; function 0 : define and draw window
	mov	ebx,100*65536;+SIZE_X;+80+30 ; [x start] *65536 + [x size]
	mov	ecx,100*65536;+SIZE_Y;+30    ; [y start] *65536 + [y size]
	mov	bx,[size_x]
	add	bx,115
	mov	cx,[size_y]
	add	cx,30
	mov	edx,0x14000000	; color of work area RRGGBB,8->color gl
	mov	edi,labelt	; WINDOW LABEL
	int	0x40
 
	call	buttons 	; more buttons
 
	.Y_ADD equ 1   ;-> offset of 'add vector' buttons
 
	; ADD VECTOR LABEL      ; add vector buttons - 30 ++
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+12)*65536+(168+15*(13+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelvector      ; pointer to text beginning
	mov	esi,labelvectorend-labelvector	   ; text length
    ;    cmp     [move_flag],2
    ;    jne     @f
    ;    add     edx,navigation_size
    ;  @@:
	int	0x40
	 ; VECTOR Y- BUTTON
	mov	eax,8		; function 8 : define and draw button
	mov	ebx,(SIZE_X+30)*65536+20     ; [x start] *65536 + [x size]
	mov	ecx,(165+15*(14+.Y_ADD))*65536+12  ; [y start] *65536 + [y size]
	mov	edx,30		 ; button id
	mov	esi,0x6688dd	; button color RRGGBB
	int	0x40
	;VECTOR Y- LABEL
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+32)*65536+(168+15*(14+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelyminus      ; pointer to text beginning
	mov	esi,labelyminusend-labelyminus	   ; text length
	cmp	[move_flag],2
   ;     jne     @f
   ;     add     edx,navigation_size
   ;   @@:
	int	0x40
	; VECTOR Z+ BUTTON
	mov	eax,8		; function 8 : define and draw button
	mov	ebx,(SIZE_X+51)*65536+21     ; [x start] *65536 + [x size]
	mov	ecx,(165+15*(14+.Y_ADD))*65536+12  ; [y start] *65536 + [y size]
	mov	edx,31		 ; button id
	mov	esi,0x6688dd	; button color RRGGBB
	int	0x40
	;VECTOR Z+ LABEL
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+53)*65536+(168+15*(14+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelzplus	    ; pointer to text beginning
	mov	esi,labelzplusend-labelzplus	 ; text length
   ;     cmp     [move_flag],2
   ;     jne     @f
   ;     add     edx,navigation_size
   ;   @@:
 
	int	0x40
	; VECTOR x- BUTTON
	mov	eax,8		; function 8 : define and draw button
	mov	ebx,(SIZE_X+10)*65536+21     ; [x start] *65536 + [x size]
	mov	ecx,(165+15*(15+.Y_ADD))*65536+12  ; [y start] *65536 + [y size]
	mov	edx,32		 ; button id
	mov	esi,0x6688dd	; button color RRGGBB
	int	0x40
	;VECTOR x- LABEL
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+12)*65536+(168+15*(15+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelxminus      ; pointer to text beginning
	mov	esi,labelxminusend-labelxminus	   ; text length
   ;     cmp     [move_flag],2
   ;     jne     @f
   ;     add     edx,navigation_size
   ;   @@:
	int	0x40
	; VECTOR x+ BUTTON
	mov	eax,8		; function 8 : define and draw button
	mov	ebx,(SIZE_X+51)*65536+21     ; [x start] *65536 + [x size]
	mov	ecx,(165+15*(15+.Y_ADD))*65536+12  ; [y start] *65536 + [y size]
	mov	edx,33		 ; button id
	mov	esi,0x6688dd	; button color RRGGBB
	int	0x40
	;VECTOR x+ LABEL
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+53)*65536+(168+15*(15+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelxplus	    ; pointer to text beginning
	mov	esi,labelxplusend-labelxplus	 ; text length
   ;     cmp     [move_flag],2
   ;     jne     @f
   ;     add     edx,navigation_size
   ;   @@:
	int	0x40
	; VECTOR z- BUTTON
	mov	eax,8		; function 8 : define and draw button
	mov	ebx,(SIZE_X+10)*65536+62-41	; [x start] *65536 + [x size]
	mov	ecx,(25+140+15*(16+.Y_ADD))*65536+12  ; [y start] *65536 + [y size]
	mov	edx,34		 ; button id
	mov	esi,0x6688dd	; button color RRGGBB
	int	0x40
	;VECTOR z- LABEL
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+12)*65536+(168+15*(16+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelzminus      ; pointer to text beginning
	mov	esi,labelzminusend-labelzminus	   ; text length
   ;     cmp     [move_flag],2
   ;     jne     @f
   ;     add     edx,navigation_size
   ;   @@:
	int	0x40
       ;VECTOR Y+ BUTTON
	mov	eax,8		; function 8 : define and draw button
	mov	ebx,(SIZE_X+10+20)*65536+20	; [x start] *65536 + [x size]
	mov	ecx,(165+15*(16+.Y_ADD))*65536+12  ; [y start] *65536 + [y size]
	mov	edx,35		 ; button id
	mov	esi,0x6688dd	; button color RRGGBB
	int	0x40
	;VECTOR Y+ LABEL
	mov	eax,4		; function 4 : write text to window
	mov	ebx,(SIZE_X+32)*65536+(168+15*(16+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x20ddeeff	; font 1 & color ( 0xF0RRGGBB )
	mov	edx,labelyplus	    ; pointer to text beginning
	mov	esi,labelyplusend-labelyplus	 ; text length
   ;     cmp     [move_flag],2
   ;     jne     @f
   ;     add     edx,navigation_size
   ;   @@:
	int	0x40
 
	mov	eax,12		; function 12:tell os about windowdraw
	mov	ebx,2		; 2, end of draw
	int	0x40
	ret
 
 
   ; DATA AREA  ************************************
 
   include 'DATA.INC'
 
MEM_END:

Rev 2984	Rev 3066
1	; application : View3ds ver. 0.063 - tiny .3ds files viewer.	1	; application : View3ds ver. 0.064 - tiny .3ds files viewer.
2	; compiler : FASM	2	; compiler : FASM
3	; system : KolibriOS	3	; system : KolibriOS
4	; author : Macgub aka Maciej Guba	4	; author : Macgub aka Maciej Guba
5	; email : macgub3@wp.pl	5	; email : macgub3@wp.pl
6	; web : www.macgub.hekko.pl	6	; web : www.macgub.hekko.pl
7	; Fell free to use this intro in your own distribution of KolibriOS/MenuetOS.	7	; Fell free to use this intro in your own distribution of KolibriOS/MenuetOS.
8	; Special greetings to all MenuetOS maniax in the world.	8	; Special greetings to all MenuetOS maniax in the world.
9	; I hope because my intros Christian Belive will be near to each of You.	9	; I hope because my intros Christian Belive will be near to each of You.
10		10
11		11
12	; Some adjustments made by Madis Kalme	12	; Some adjustments made by Madis Kalme
13	; madis.kalme@mail.ee	13	; madis.kalme@mail.ee
14	; I tried optimizing it a bit, but don't know if it was successful. The objects	14	; I tried optimizing it a bit, but don't know if it was successful. The objects
15	; can be:	15	; can be:
16	; 1) Read from a file (*.3DS standard)	16	; 1) Read from a file (*.3DS standard)
17	; 2) Written in manually (at the end of the code)	17	; 2) Written in manually (at the end of the code)
18	;include 'proc32.inc'	18	;include 'proc32.inc'
19		19
20	SIZE_X equ 512	20	SIZE_X equ 512
21	SIZE_Y equ 512 ; ///// I want definitely	21	SIZE_Y equ 512 ; ///// I want definitely
22	TIMEOUT equ 10 ; ------ say:	22	TIMEOUT equ 10 ; ------ say:
23	ROUND equ 10 ; \ @ @/ keep smiling every	23	ROUND equ 10 ; \ @ @/ keep smiling every
24	TEX_X equ 512 ; texture width ; \ ./ / day.	24	TEX_X equ 512 ; texture width ; \ ./ / day.
25	TEX_Y equ 512 ; height ; \/ /	25	TEX_Y equ 512 ; height ; \/ /
26	TEX_SHIFT equ 9 ; texture width shifting ; __\|\|__ /	26	TEX_SHIFT equ 9 ; texture width shifting ; __\|\|__ /
27	TEXTURE_SIZE EQU (TEX_X * TEX_Y)-1 ; /\| \|	27	TEXTURE_SIZE EQU (TEX_X * TEX_Y)-1 ; /\| \|
28	TEX equ SHIFTING ; TEX={SHIFTING \| FLUENTLY} ; / \ /	28	TEX equ SHIFTING ; TEX={SHIFTING \| FLUENTLY} ; / \ /
29	FLUENTLY = 0 ; / \| \|	29	FLUENTLY = 0 ; / \| \|
30	SHIFTING = 1 ; ------	30	SHIFTING = 1 ; ------
31	CATMULL_SHIFT equ 8 ; \| \|	31	CATMULL_SHIFT equ 8 ; \| \|
32	LIGHT_SIZE equ 22 ; \| \|	32	LIGHT_SIZE equ 22 ; \| \|
33	NON = 0 ; -/ \-	33	NON = 0 ; -/ \-
34	MMX = 1	34	MMX = 1
35	SSE = 2	35	SSE = 2
36	SSE2 = 3	36	SSE2 = 3
37	Ext = SSE2 ;Ext={ NON \| MMX \| SSE \| SSE2 }	37	Ext = SSE2 ;Ext={ NON \| MMX \| SSE \| SSE2 }
38		38
39	; 0 for short names (Menuet-compatible), 1 for long names (Kolibri features)	39	; 0 for short names (Menuet-compatible), 1 for long names (Kolibri features)
40	USE_LFN = 1	40	USE_LFN = 1
41		41
42	use32	42	use32
43	org 0x0	43	org 0x0
44	db 'MENUET01' ; 8 byte id	44	db 'MENUET01' ; 8 byte id
45	dd 0x01 ; header version	45	dd 0x01 ; header version
46	dd START ; start of code	46	dd START ; start of code
47	dd I_END ; size of image	47	dd I_END ; size of image
48	dd MEM_END ; memory for app	48	dd MEM_END ; memory for app
49	dd MEM_END ; esp	49	dd MEM_END ; esp
50	dd I_Param ; I_Param	50	dd I_Param ; I_Param
51	dd 0x0 ; I_Icon	51	dd 0x0 ; I_Icon
52		52
53	START: ; start of execution	53	START: ; start of execution
54	cld	54	cld
55	call alloc_buffer_mem	55	call alloc_buffer_mem
56	call read_param	56	call read_param
57	call read_from_disk ; read, if all is ok eax = 0	57	call read_from_disk ; read, if all is ok eax = 0
58	cmp eax,0	58	cmp eax,0
59	jne .gen	59	jne .gen
60	call read_tp_variables ; init points and triangles count variables	60	call read_tp_variables ; init points and triangles count variables
61	cmp eax,0	61	cmp eax,0
62	je .gen	62	je .gen
63	jmp .malloc	63	jmp .malloc
64	.gen:	64	.gen:
65	if USE_LFN	65	if USE_LFN
66	mov [triangles_count_var],1000	66	mov [triangles_count_var],1000
67	mov [points_count_var],1000	67	mov [points_count_var],1000
68	call alloc_mem_for_tp	68	call alloc_mem_for_tp
69	end if	69	end if
70	call generate_object	70	call generate_object
71	jmp .opt	71	jmp .opt
72	.malloc:	72	.malloc:
73	if USE_LFN	73	if USE_LFN
74	call alloc_mem_for_tp	74	call alloc_mem_for_tp
75	end if	75	end if
76	call read_from_file	76	call read_from_file
77	.opt:	77	.opt:
78	call optimize_object1 ; proc in file b_procs.asm	78	call optimize_object1 ; proc in file b_procs.asm
79	; set point(0,0,0) in center and calc all coords	79	; set point(0,0,0) in center and calc all coords
80	; to be in <-1.0,1.0>	80	; to be in <-1.0,1.0>
81	call normalize_all_light_vectors	81	call normalize_all_light_vectors
82	call init_triangles_normals2	82	call init_triangles_normals2
83	call init_point_normals	83	call init_point_normals
84	call init_envmap2	84	call init_envmap2
85	call init_envmap_cub	85	call init_envmap_cub
86	call generate_texture2	86	call generate_texture2
87	call init_sincos_tab	87	call init_sincos_tab
88		88
89	call do_color_buffer ; intit color_map	89	call do_color_buffer ; intit color_map
90	mov edi,bumpmap	90	mov edi,bumpmap
91	call calc_bumpmap	91	call calc_bumpmap
92	call calc_bumpmap_coords ; bump and texture mapping	92	call calc_bumpmap_coords ; bump and texture mapping
93	call draw_window	93	call draw_window
94		94
95	still:	95	still:
96		96
97	mov eax,23 ; wait here for event with timeout	97	mov eax,23 ; wait here for event with timeout
98	mov ebx,TIMEOUT	98	mov ebx,TIMEOUT
99	cmp [speed_flag],1	99	cmp [speed_flag],1
100	jne .skip	100	jne .skip
101	mov eax,11	101	mov eax,11
102	.skip:	102	.skip:
103	int 0x40	103	int 0x40
104		104
105	cmp eax,1 ; redraw request ?	105	cmp eax,1 ; redraw request ?
106	je red	106	je red
107	cmp eax,2 ; key in buffer ?	107	cmp eax,2 ; key in buffer ?
108	je key	108	je key
109	cmp eax,3 ; button in buffer ?	109	cmp eax,3 ; button in buffer ?
110	je button	110	je button
111		111
112	jmp noclose	112	jmp noclose
113		113
114	red: ; redraw	114	red: ; redraw
115	call draw_window	115	call draw_window
116		116
117	jmp noclose	117	jmp noclose
118		118
119	key: ; key	119	key: ; key
120	mov eax,2 ; just read it and ignore	120	mov eax,2 ; just read it and ignore
121	int 0x40	121	int 0x40
122	jmp noclose	122	jmp noclose
123		123
124	button: ; button	124	button: ; button
125	mov eax,17 ; get id	125	mov eax,17 ; get id
126	int 0x40	126	int 0x40
127		127
128	cmp ah,1 ; button id=1 ?	128	cmp ah,1 ; button id=1 ?
129	jne @f	129	jne @f
130		130
131	mov eax,-1 ; close this program	131	mov eax,-1 ; close this program
132	int 0x40	132	int 0x40
133	@@:	133	@@:
134	cmp ah,30	134	cmp ah,30
135	jge add_vec_buttons	135	jge add_vec_buttons
136	call update_flags ; update flags and write labels of flags	136	call update_flags ; update flags and write labels of flags
137		137
138	; do other operations according to flag	138	; do other operations according to flag
139	cmp ah,3 ; ah = 3 -> shading model	139	cmp ah,3 ; ah = 3 -> shading model
140	jne .next_m6	140	jne .next_m6
141	cmp [dr_flag],2	141	cmp [dr_flag],2
142	jne @f	142	jne @f
143	; call init_envmap2 ; <----! this don't works in env mode	143	; call init_envmap2 ; <----! this don't works in env mode
144	; and more than ~18 kb objects	144	; and more than ~18 kb objects
145	; call init_envmap_cub2	145	; call init_envmap_cub2
146	@@:	146	@@:
147	cmp [dr_flag],4	147	cmp [dr_flag],4
148	jne @f	148	jne @f
149	call generate_texture2	149	call generate_texture2
150		150
151	@@:	151	@@:
152	.next_m6:	152	.next_m6:
153	; ah = 5 -> scale-	153	; ah = 5 -> scale-
154	cmp ah,5	154	cmp ah,5
155	jne @f	155	jne @f
156	mov [scale],0.7	156	mov [scale],0.7
157	fninit	157	fninit
158	fld [rsscale]	158	fld [rsscale]
159	fmul [scale]	159	fmul [scale]
160	fstp [rsscale]	160	fstp [rsscale]
161		161
162	@@:	162	@@:
163	cmp ah,6 ; ah = 6 -> scale+	163	cmp ah,6 ; ah = 6 -> scale+
164	jne @f	164	jne @f
165	mov [scale],1.3	165	mov [scale],1.3
166	fninit	166	fninit
167	fld [rsscale]	167	fld [rsscale]
168	fmul [scale]	168	fmul [scale]
169	fstp [rsscale]	169	fstp [rsscale]
170		170
171	@@:	171	@@:
172	cmp ah,9 ; lights random ; 'flat' 0	172	cmp ah,9 ; lights random ; 'flat' 0
173	jne .next_m5 ; 'grd ' 1	173	jne .next_m5 ; 'grd ' 1
174	call make_random_lights ; 'env ' 2	174	call make_random_lights ; 'env ' 2
175	call normalize_all_light_vectors ; 'bump' 3	175	call normalize_all_light_vectors ; 'bump' 3
176	call do_color_buffer ; intit color_map ; 'tex ' 4	176	call do_color_buffer ; intit color_map ; 'tex ' 4
177	; cmp [emboss_flag],1 ; 'pos ' 5	177	; cmp [emboss_flag],1 ; 'pos ' 5
178	; je @f ; 'dots' 6	178	; je @f ; 'dots' 6
179	; cmp [dr_flag],8	179	; cmp [dr_flag],8
180	; jge @f	180	; jge @f
181	; cmp [dr_flag],2 ; 'txgr' 7	181	; cmp [dr_flag],2 ; 'txgr' 7
182	; jl .next_m5 ; '2tex' 8	182	; jl .next_m5 ; '2tex' 8
183	; cmp [dr_flag],3 ; 'btex' 9	183	; cmp [dr_flag],3 ; 'btex' 9
184	; jg .next_m5	184	; jg .next_m5
185	; @@:	185	; @@:
186	call init_envmap2 ; update env map if shading model = environment or bump	186	call init_envmap2 ; update env map if shading model = environment or bump
187	.next_m5:	187	.next_m5:
188	cmp ah,11	188	cmp ah,11
189	je @f	189	je @f
190	cmp ah,12	190	cmp ah,12
191	je @f	191	je @f
192	cmp ah,13	192	cmp ah,13
193	jne .next_m4	193	jne .next_m4
194	@@:	194	@@:
195	call mirror	195	call mirror
196	.next_m4:	196	.next_m4:
197	cmp ah,14	197	cmp ah,14
198	jne @f	198	jne @f
199	call exchange	199	call exchange
200	@@:	200	@@:
201	cmp ah,15	201	cmp ah,15
202	jne @f	202	jne @f
203	cmp [emboss_flag],1	203	cmp [emboss_flag],1
204	call init_envmap2	204	call init_envmap2
205	@@:	205	@@:
206	; cmp ah,17	206	; cmp ah,17
207	; jne .next_m	207	; jne .next_m
208	; cmp [move_flag],2	208	; cmp [move_flag],2
209	; jne @f	209	; jne @f
210	; call draw_window ; redraw other labels to navigation buttons	210	; call draw_window ; redraw other labels to navigation buttons
211	; @@:	211	; @@:
212	; cmp [move_flag],0	212	; cmp [move_flag],0
213	; jne .next_m	213	; jne .next_m
214	; call draw_window ; redraw other labels to navigation buttons	214	; call draw_window ; redraw other labels to navigation buttons
215	.next_m:	215	.next_m:
216	cmp ah,18	216	cmp ah,18
217	jne .next_m2	217	jne .next_m2
218	if USE_LFN	218	if USE_LFN
219	mov [re_alloc_flag],1 ; reallocate memory	219	mov [re_alloc_flag],1 ; reallocate memory
220	mov [triangles_count_var],1000	220	mov [triangles_count_var],1000
221	mov [points_count_var],1000	221	mov [points_count_var],1000
222	call alloc_mem_for_tp	222	call alloc_mem_for_tp
223	mov [re_alloc_flag],0	223	mov [re_alloc_flag],0
224	end if	224	end if
225	mov bl,[generator_flag]	225	mov bl,[generator_flag]
226	or bl,bl	226	or bl,bl
227	jz .next_m2	227	jz .next_m2
228	cmp bl,1	228	cmp bl,1
229	jne @f	229	jne @f
230	call generate_object	230	call generate_object
231	jmp .calc_norm	231	jmp .calc_norm
232	@@:	232	@@:
233	cmp bl,4	233	cmp bl,4
234	jg @f	234	jg @f
235	movzx ax,bl ; ax < - object number	235	movzx ax,bl ; ax < - object number
236	call generate_object2	236	call generate_object2
237	jmp .calc_norm	237	jmp .calc_norm
238	@@:	238	@@:
239	call generate_object3	239	call generate_object3
240	.calc_norm:	240	.calc_norm:
241	call optimize_object1	241	call optimize_object1
242	call init_triangles_normals2	242	call init_triangles_normals2
243	call init_point_normals	243	call init_point_normals
244	call calc_bumpmap_coords ; bump and texture mapping	244	call calc_bumpmap_coords ; bump and texture mapping
245		245
246	.next_m2:	246	.next_m2:
247	cmp ah,19	247	cmp ah,19
248	je @f	248	je @f
249	cmp ah,20	249	cmp ah,20
250	jne .next_m3	250	jne .next_m3
251	@@:	251	@@:
252	mov edi,bumpmap	252	mov edi,bumpmap
253	call calc_bumpmap	253	call calc_bumpmap
254	.next_m3:	254	.next_m3:
255	cmp ah,21 ; re map bumps, texture coordinates	255	cmp ah,21 ; re map bumps, texture coordinates
256	jne @f	256	jne @f
257	call calc_bumpmap_coords	257	call calc_bumpmap_coords
258	@@:	258	@@:
259	jmp noclose	259	jmp noclose
260		260
261		261
262	; there are 6 navigation buttons each	262	; there are 6 navigation buttons each
263	add_vec_buttons: ; can move: object, camera,.. list is open	263	add_vec_buttons: ; can move: object, camera,.. list is open
264	;	264	;
265	cmp ah,30	265	cmp ah,30
266	jne .next	266	jne .next
267	cmp [move_flag],0	267	cmp [move_flag],0
268	jne @f	268	jne @f
269	; cmp [move_flag],2	269	; cmp [move_flag],2
270	; je .set_light1	270	; je .set_light1
271	sub [vect_y],10	271	sub [vect_y],10
272	jmp .next	272	jmp .next
273	@@:	273	@@:
274	cmp [move_flag],1	274	cmp [move_flag],1
275	jne @f	275	jne @f
276	sub [yobs],10 ; observator = camera position	276	sub [yobs],10 ; observator = camera position
277	jmp .next	277	jmp .next
278	@@:	278	@@:
279	sub [sin_amplitude],10	279	sub [sin_amplitude],10
280	;--------------------------------------------------	280	;--------------------------------------------------
281	; .set_light1: ; r -	281	; .set_light1: ; r -
282	; movzx ebx,[light_no_flag] ; * 22	282	; movzx ebx,[light_no_flag] ; * 22
283	; mov ecx,ebx	283	; mov ecx,ebx
284	; shl ebx,4	284	; shl ebx,4
285	; shl ecx,1	285	; shl ecx,1
286	; add ebx,ecx	286	; add ebx,ecx
287	; shl ecx,1	287	; shl ecx,1
288	; add ebx,ecx	288	; add ebx,ecx
289	; add ebx,lights+6 ; 6 -> light vector size	289	; add ebx,lights+6 ; 6 -> light vector size
290	;	290	;
291	; movzx ecx,[light_comp_flag]	291	; movzx ecx,[light_comp_flag]
292	; lea ecx,[ecx*3}	292	; lea ecx,[ecx*3}
293	; add ebx,ecx ; ebx -> color to set	293	; add ebx,ecx ; ebx -> color to set
294		294
295	;---------------------------------------------------	295	;---------------------------------------------------
296	.next:	296	.next:
297	cmp ah,31	297	cmp ah,31
298	jne .next1	298	jne .next1
299	cmp [move_flag],1	299	cmp [move_flag],1
300	je @f	300	je @f
301	add [vect_z],10	301	add [vect_z],10
302	jmp .next1	302	jmp .next1
303	@@:	303	@@:
304	add [zobs],10 ; observator = camera position	304	add [zobs],10 ; observator = camera position
305	.next1:	305	.next1:
306	cmp ah,33	306	cmp ah,33
307	jne .next2	307	jne .next2
308	cmp [move_flag],0	308	cmp [move_flag],0
309	jne @f	309	jne @f
310	sub [vect_x],10	310	sub [vect_x],10
311	jmp .next2	311	jmp .next2
312	@@:	312	@@:
313	cmp [move_flag],1	313	cmp [move_flag],1
314	jne @f	314	jne @f
315	sub [xobs],10 ; observator = camera position	315	sub [xobs],10 ; observator = camera position
316	jmp .next2	316	jmp .next2
317	@@:	317	@@:
318	fninit	318	fninit
319	fld [sin_frq]	319	fld [sin_frq]
320	fsub [sin_delta]	320	fsub [sin_delta]
321	fstp [sin_frq]	321	fstp [sin_frq]
322	.next2:	322	.next2:
323	cmp ah,32	323	cmp ah,32
324	jne .next3	324	jne .next3
325	cmp [move_flag],0	325	cmp [move_flag],0
326	jne @f	326	jne @f
327	add [vect_x],10	327	add [vect_x],10
328	jmp .next3	328	jmp .next3
329	@@:	329	@@:
330	cmp [move_flag],1	330	cmp [move_flag],1
331	jne @f	331	jne @f
332	add [xobs],10 ; observator = camera position	332	add [xobs],10 ; observator = camera position
333	jmp .next3	333	jmp .next3
334	@@:	334	@@:
335	fninit	335	fninit
336	fld [sin_frq] ; change wave effect frequency	336	fld [sin_frq] ; change wave effect frequency
337	fadd [sin_delta]	337	fadd [sin_delta]
338	fstp [sin_frq]	338	fstp [sin_frq]
339	.next3:	339	.next3:
340	cmp ah,34	340	cmp ah,34
341	jne .next4	341	jne .next4
342	cmp [move_flag],1	342	cmp [move_flag],1
343	je @f	343	je @f
344		344
345	sub [vect_z],10	345	sub [vect_z],10
346	jmp .next4	346	jmp .next4
347	@@:	347	@@:
348	sub [zobs],10 ; observator = camera position	348	sub [zobs],10 ; observator = camera position
349	.next4:	349	.next4:
350	cmp ah,35	350	cmp ah,35
351	jne .next5	351	jne .next5
352	cmp [move_flag],0	352	cmp [move_flag],0
353	jne @f	353	jne @f
354	; call add_vector	354	; call add_vector
355	add [vect_y],10	355	add [vect_y],10
356	jmp .next5	356	jmp .next5
357	@@:	357	@@:
358	cmp [move_flag],1	358	cmp [move_flag],1
359	jne @f	359	jne @f
360	add [yobs],10 ; observator = camera position	360	add [yobs],10 ; observator = camera position
361	jmp .next5	361	jmp .next5
362	@@:	362	@@:
363	add [sin_amplitude],10	363	add [sin_amplitude],10
364	.next5:	364	.next5:
365		365
366		366
367		367
368	noclose:	368	noclose:
369		369
370	cmp [r_flag],2	370	cmp [r_flag],2
371	jne .no_x	371	jne .no_x
372	inc [angle_x]	372	inc [angle_x]
373	and [angle_x],0xff	373	and [angle_x],0xff
374	mov [angle_z],0	374	mov [angle_z],0
375	jmp .end_rot	375	jmp .end_rot
376		376
377	.no_x:	377	.no_x:
378	cmp [r_flag],0	378	cmp [r_flag],0
379	jne .no_y	379	jne .no_y
380	inc [angle_y]	380	inc [angle_y]
381	and [angle_y],0xff	381	and [angle_y],0xff
382	mov [angle_z],0	382	mov [angle_z],0
383	jmp .end_rot	383	jmp .end_rot
384		384
385	.no_y:	385	.no_y:
386	cmp [r_flag],1	386	cmp [r_flag],1
387	jne .end_rot	387	jne .end_rot
388	mov cx,[angle_x]	388	mov cx,[angle_x]
389	inc cx	389	inc cx
390	and cx,0xff	390	and cx,0xff
391	mov [angle_z],0	391	mov [angle_z],0
392	mov [angle_y],cx	392	mov [angle_y],cx
393	mov [angle_x],cx	393	mov [angle_x],cx
394	.end_rot:	394	.end_rot:
395		395
396	mov esi,angle_x	396	mov esi,angle_x
397	mov edi,matrix	397	mov edi,matrix
398	call make_rotation_matrix	398	call make_rotation_matrix
399	RDTSC	399	RDTSC
400	push eax	400	push eax
401	mov esi,[points_normals_ptr]	401	mov esi,[points_normals_ptr]
402	mov edi,[points_normals_rot_ptr]	402	mov edi,[points_normals_rot_ptr]
403	mov ebx,matrix	403	mov ebx,matrix
404	movzx ecx,[points_count_var]	404	movzx ecx,[points_count_var]
405	call rotary	405	call rotary
406		406
407	mov esi,matrix	407	mov esi,matrix
408	call add_scale_to_matrix	408	call add_scale_to_matrix
409		409
410	mov esi,[points_ptr]	410	mov esi,[points_ptr]
411	mov edi,[points_rotated_ptr]	411	mov edi,[points_rotated_ptr]
412	mov ebx,matrix	412	mov ebx,matrix
413	movzx ecx,[points_count_var]	413	movzx ecx,[points_count_var]
414	call rotary	414	call rotary
415		415
416	; RDTSC	416	; RDTSC
417	; pop ebx	417	; pop ebx
418	; sub eax,ebx	418	; sub eax,ebx
419	; sub eax,41	419	; sub eax,41
420	; push eax	420	; push eax
421		421
422	mov esi,[points_rotated_ptr]	422	mov esi,[points_rotated_ptr]
423	mov edi,[points_translated_ptr]	423	mov edi,[points_translated_ptr]
424	movzx ecx,[points_count_var]	424	movzx ecx,[points_count_var]
425	call translate_points	425	call translate_points
426		426
427	; cmp [dr_flag],5	427	; cmp [dr_flag],5
428	; jne @f	428	; jne @f
429	; call calc_attenuation_light	429	; call calc_attenuation_light
430	; @@:	430	; @@:
431	cmp [fire_flag],0	431	cmp [fire_flag],0
432	jne @f	432	jne @f
433	call clrscr ; clear the screen	433	call clrscr ; clear the screen
434	@@:	434	@@:
435	cmp [catmull_flag],1 ;non sort if Catmull = on	435	cmp [catmull_flag],1 ;non sort if Catmull = on
436	je .no_sort	436	je .no_sort
437	call sort_triangles	437	call sort_triangles
438	.no_sort:	438	.no_sort:
439	cmp [dr_flag],7 ; fill if 2tex and texgrd	439	cmp [dr_flag],7 ; fill if 2tex and texgrd
440	jge @f	440	jge @f
441	cmp [catmull_flag],0 ;non fill if Catmull = off	441	cmp [catmull_flag],0 ;non fill if Catmull = off
442	je .non_f	442	je .non_f
443	cmp [dr_flag],6 ; non fill if dots	443	cmp [dr_flag],6 ; non fill if dots
444	je .non_f	444	je .non_f
445	@@:	445	@@:
446	call fill_Z_buffer ; make background	446	call fill_Z_buffer ; make background
447	.non_f:	447	.non_f:
448	; RDTSC	448	; RDTSC
449	; push eax	449	; push eax
450	cmp [dr_flag],6	450	cmp [dr_flag],6
451	jne @f	451	jne @f
452	call draw_dots	452	call draw_dots
453	jmp .blurrr	453	jmp .blurrr
454	@@:	454	@@:
455	call draw_triangles ; draw all triangles from the list	455	call draw_triangles ; draw all triangles from the list
456	.blurrr:	456	.blurrr:
457	cmp [sinus_flag],0	457	cmp [sinus_flag],0
458	je @f	458	je @f
459	call do_sinus	459	call do_sinus
460	@@:	460	@@:
461	cmp [fire_flag],0	461	cmp [fire_flag],0
462	jne @f	462	jne @f
463	cmp [blur_flag],0	463	cmp [blur_flag],0
464	je .no_blur ; no blur, no fire	464	je .no_blur ; no blur, no fire
465	movzx ecx,[blur_flag]	465	movzx ecx,[blur_flag]
466	call blur_screen ; blur and fire	466	call blur_screen ; blur and fire
467	jmp .no_blur	467	jmp .no_blur
468	@@:	468	@@:
469	cmp [emboss_flag],0	469	cmp [emboss_flag],0
470	jne .emb ; if emboss=true -> no fire	470	jne .emb ; if emboss=true -> no fire
471	movzx ecx,[fire_flag]	471	movzx ecx,[fire_flag]
472	call blur_screen ; blur and fire	472	call blur_screen ; blur and fire
473	.no_blur: ; no blur, no fire	473	.no_blur: ; no blur, no fire
474	cmp [emboss_flag],0	474	cmp [emboss_flag],0
475	je @f	475	je @f
476	.emb:	476	.emb:
477	call do_emboss	477	call do_emboss
478		478
479	@@:	479	@@:
480		480
481		481
482	cmp [inc_bright_flag],0 ; increase brightness	482	cmp [inc_bright_flag],0 ; increase brightness
483	je .no_inc_bright	483	je .no_inc_bright
484	movzx ebx,[inc_bright_flag]	484	movzx ebx,[inc_bright_flag]
485	shl ebx,4	485	shl ebx,4
486	mov esi,screen	486	mov esi,screen
487	mov ecx,SIZE_XSIZE_Y3	487	mov ecx,SIZE_XSIZE_Y3
488	if (Ext = MMX)\|(Ext = SSE)	488	if (Ext = MMX)\|(Ext = SSE)
489	mov bh,bl	489	mov bh,bl
490	push bx	490	push bx
491	shl ebx,16	491	shl ebx,16
492	pop bx	492	pop bx
493	push ebx	493	push ebx
494	push ebx	494	push ebx
495	movq mm0,[esp]	495	movq mm0,[esp]
496	add esp,8	496	add esp,8
497	else if Ext >= SSE2	497	else if Ext >= SSE2
498	mov bh,bl	498	mov bh,bl
499	push bx	499	push bx
500	shl ebx,16	500	shl ebx,16

Subversion Repositories Kolibri OS

(root)/programs/demos/3DS/VIEW3DS.ASM @ 3066 – Rev 2984 → 3066