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


; application : View3ds ver. 0.069 - 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
; web	      : www.macgub.hekko.pl
; Fell free to use this intro in your own distribution of KolibriOS.
; Special greetings to KolibriOS team .
; I hope because my demos Christian Belive will be near to each of You.
 
 
; 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)
 
 
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
	     ;	 mov	eax,14	 ; window size according to cur res ...
     ;	 int	0x40
     ;	 sub	eax,150 shl 16 + 150
	mov    eax, 500 shl 16 + 600 ; ... or set manually
	mov    [size_y_var],ax
	shr    ax,1
	mov    [vect_y],ax
 
 
	shr    ax,2
	movzx  ebx,ax
	lea    ebx,[ebx*3]
	push   ebx
	fninit
	fild   dword[esp]
	fstp   [rsscale]
	pop    ebx
 
	shr    eax,16
	mov    [size_x_var],ax
	shr    ax,1
	mov    [vect_x],ax
 
	mov    eax, 20 shl  16 + 20
	mov    [x_start],eax
 
 
	call   alloc_buffer_mem
	call   read_param
	call   read_from_disk	 ; read, if all is ok eax = 0
	cmp    eax,0
	jne    .gen
	mov    esi,[fptr]
	cmp    [esi],word 4D4Dh
	jne    .asc
	call   read_tp_variables ; init points and triangles count variables
	cmp    eax,0
	je     .gen
	jmp    .malloc
    .gen:
     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
    .asc:
	mov    [triangles_count_var],10000
	mov    [points_count_var],10000
	call   alloc_mem_for_tp
	call   read_asc
	jmp    .opt
    .malloc:
     if USE_LFN
	call   alloc_mem_for_tp
     end if
	call   read_from_file
    .opt:
 
 
     ;	 call	alloc_buffer_mem ; alloc memfor screnn and z buffer
 
	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
    ;	 mov	 [draw_win_at_first],0
;	 mov	eax,40	       ; set events mask
;	 mov	ebx,1100000000000000000000000100111b
;	 int	0x40
still:
	cmp    [edit_flag],1
	jne    @f
	mov    eax,40	      ; set events mask
	mov    ebx,1100000000000000000000000100111b
	jmp    .int
      @@:
	mov    eax,40	      ; set events mask
	mov    ebx,111b
      .int:
	int    0x40
 
	mov	eax,23
	mov	ebx,TIMEOUT
	cmp	[speed_flag],0
	je	.skip
	mov	eax,11
     .skip:
	cmp	[edit_flag],1
	jne	@f
	mov	eax,10
 
      @@:
	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
	cmp	eax,6
	jne	@f
	cmp	[edit_flag],1
	jne	@f
	mov	eax,37
	mov	ebx,3	;read mouse state
	int	0x40
	mov	[mouse_state],eax
	call	edit
       @@:
	jmp	noclose
 
    red:   ; redraw
	mov	eax,9  ; get process info
	mov	ebx,procinfo
	mov	ecx,-1
	int	0x40
	mov	eax,[procinfo+42]    ; read params of window
	sub	eax,115
	mov	[size_x_var],ax
	shr	ax,1
	mov	[vect_x],ax
;
	mov	eax,[procinfo+46]
	sub	eax,30
	mov	[size_y_var],ax
	shr	ax,1
	mov	[vect_y],ax
 
	mov	eax,[procinfo+34]
	mov	[x_start],ax
	mov	eax,[procinfo+38]
	mov	[y_start],ax
	call	alloc_buffer_mem ;realloc mem for scr & z buffs
	call	draw_window
 
	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	dword[scale],0.7
	fninit
	fld	[rsscale]
	fmul	[scale]
	fstp	[rsscale]
 
      @@:
	cmp	ah,6		     ; ah = 6 ->  scale+
	jne	@f
	mov	dword[scale],1.3
	fninit
	fld	[rsscale]
	fmul	[scale]
	fstp	[rsscale]
 
      @@:
	cmp	ah,9	; lights random 		;    'flat'  0
	jne	.next_m5				;    'grd '  1
	call	make_random_lights			;    'env '  2
	call	normalize_all_light_vectors		;    'bump'  3
	call	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	[edit_flag],1
	jz	.end_rot
	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
	cmp    [edit_flag],0
	jz     .no_edit
	call   clear_vertices_index
	call   draw_handlers
    ;	 call	edit
 
 
 
 
 
 
    .no_edit:
 
      .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_ptr]
    movzx   ecx,word[size_y_var]
    movzx   eax,word[size_x_var]
    mul     ecx
    lea     ecx,[eax*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
    jnc     .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_ptr]
    movzx   eax,word[size_x_var]
    movzx   ecx,word[size_y_var]
    mul     ecx
    lea     ecx,[eax*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
    jnc     .oop1
end if
  .no_dec_bright:
 
 
    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_ptr]
    mov     ecx,[size_y_var]
  ;  mov     ecx,SIZE_X shl 16 + SIZE_Y
    mov     edx,[offset_y]  ;5 shl 16 + 25
    int     0x40
 
    mov  eax,13
    mov  bx,[size_x_var]
    add  ebx,18
    shl  ebx,16
    mov  bx,60
    mov  cx,[size_y_var]
    sub  cx,2
    shl  ecx,16
    mov  cx,9
    xor  edx,edx
    int  40h
 
    mov  eax,4			   ; function 4 : write text to window
    mov  bx,[size_x_var]
    add  ebx,18
    shl  ebx,16
    mov  bx,[size_y_var]
    sub  bx,2	      ; [x start] *65536 + [y start]
    mov  ecx,0x00888888
    mov  edx,STRdata		   ; pointer to text beginning
    mov  esi,10 		   ; text length
    int  40h
 
 
   ; 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"
include "ASC.INC"
clear_vertices_index:
    mov   edi,[vertices_index_ptr]
    movzx eax,word[size_x_var]
    movzx ecx,word[size_y_var]
    imul  ecx,eax
    xor   eax,eax
    shr   ecx,1
    rep   stosd
ret
edit:	  ; mmx required, edit mesh by vertex
	push   ebp
	mov    ebp,esp
	sub    esp,128
 
	.y_coord equ ebp-2
	.x_coord equ ebp-4
	.points_translated equ ebp-10
	.points 	   equ ebp-22
	.points_rotated    equ ebp-34
	.mx		   equ ebp-70
 
    macro check_bar
    {
	movzx  ebx,word[.x_coord]
	movzx  ecx,word[.y_coord]
	movzx  edx,word[size_x_var]
	imul   edx,ecx
	add    ebx,edx
 
	lea    ecx,[ebx*2]
	lea    ebx,[ebx*3]
	add    ebx,[screen_ptr]
	mov    ebx,[ebx]
	and    ebx,0x00ffffff
	cmp    ebx,0x00ff0000 ; is handle bar  ?
    }
 
	emms
	mov	eax,37	; get mouse state
	mov	ebx,1	; x = 5, y = 25 - offsets
	int	0x40
 
	mov	ebx,[offset_y] ;5 shl 16 + 25
	movd	mm0,ebx
	movd	mm1,eax
	movd	mm3,[size_y_var]
	pcmpgtw mm0,mm1
	pcmpgtw mm3,mm1
	pxor	mm3,mm0
	movd	eax,mm3
	mov	cx,ax
	shr	eax,16
	and	ax,cx
	or	ax,ax
	jz	.no_edit
 
 
	movd	mm0,ebx
	psubw	mm1,mm0
	movd	eax,mm1
 
      ; store both x and y coordinates
	ror    eax,16
       ; push	eax
       ; sub	esp,256
	mov    [.x_coord],eax
	test   word[mouse_state],100000000b
	jz     .not_press  ; check if left mouse button press
 
	;  left button	pressed
 
   ; macro check_bar
   ; {
   ;	 movzx	ebx,word[.x_coord]
   ;	 movzx	ecx,word[.y_coord]
   ;	 imul	ebx,ecx
   ;	 lea	ecx,[ebx*2]
   ;	 lea	ebx,[ebx*3]
   ;	 add	ebx,[screen_ptr]
   ;	 mov	ebx,[ebx]
   ;	 and	ebx,0x00ffffff
   ;	 cmp	ebx,0x00ff0000 ; is handle bar	?
   ; }
 
	check_bar
	jne    .no_edit
	add    ecx,[vertices_index_ptr]
	mov    cx,word[ecx]
	inc    cx
 
 
	mov    [vertex_edit_no],cx ;if vert_edit_no = 0, no vertex selected
 
	mov    eax,dword[.x_coord]
	mov    dword[edit_end_x],eax
	mov    dword[edit_start_x],eax
	jmp    .end
      .not_press:
	test   byte[mouse_state],1b	  ; check if left button is held
	jz     .not_held
       ; check_bar
       ; jne	.no_edit
       ; add	ecx,[vertices_index_ptr]
       ; mov	cx,[ecx]
       ; inc	cx
	cmp    [vertex_edit_no],0 ; cx	; vertex number
	je     .end
	push   dword[.x_coord]
	pop    dword[edit_end_x]
	jmp    .end
      .not_held:
	shr    [mouse_state],16
	test   byte[mouse_state],1b  ; test if left button released
	jz     .end
	check_bar
	jne    .end
 
	movzx  esi,[vertex_edit_no]
	dec    esi
	lea    esi,[esi*3]
	add    esi,esi
	add    esi,[points_translated_ptr]
	emms
 
	movd	mm1,dword[esi]
	paddw	mm1,mm0
	psubw	mm1,qword[vect_x]
	movd	dword[esi],mm1
 
	lea    edi,[.points]
     ; detranslate
	fninit
	fild word[esi+4]
	fstp dword[edi+8]
	fild word[esi+2]
	fisub word[offset_x]
	fstp dword[edi+4]
	fild word[esi]
	fisub word[offset_y]   ; proteza
	fstp dword[edi]
 
	mov	esi,matrix
	lea	edi,[.mx]
	call	reverse_mx_3x3
 
	lea	esi,[.points]
	lea	edi,[.points_rotated]
	lea	ebx,[.mx]
	mov	ecx,1
	call	rotary
 
   ;	inject into vertex list
	movzx	edi,[vertex_edit_no]
	dec	edi
	lea	edi,[edi*3]
	shl	edi,2
	add	edi,[points_ptr]
	lea	esi,[.points_rotated]
	mov	ecx,3
	cld
	rep	movsd
 
 
	mov    dword[edit_end_x],0
	mov    [vertex_edit_no],0
 
      .no_edit:
      .end:
      mov   esp,ebp
      pop   ebp
ret
 
alloc_buffer_mem:
    push    ebp
    mov     ebp,esp
    .temp   equ ebp-4
    push    dword 0
 
    mov     eax, 68
    mov     ebx, 11
    int     0x40    ;  -> create heap, to be sure
 
 
    movzx    ecx,word[size_x_var]
    movzx    eax,word[size_y_var]
    mul      ecx
 
    mov      [.temp],eax
    lea      ecx,[eax*3]
    add      ecx,256
    mov      eax,68
    mov      ebx,20
    mov      edx,[screen_ptr]
    int      0x40
  ;  and      eax,0xfffffff0
    mov      [screen_ptr],eax
 
    mov      ecx,[.temp]
    shl      ecx,2
    add      ecx,256
    mov      eax,68
    mov      ebx,20
    mov      edx,[Zbuffer_ptr]
    int      0x40
  ;  and      eax,0xfffffff0
    mov      [Zbuffer_ptr],eax
 
 
    mov      ecx,[.temp]
    add      ecx,ecx
    add      ecx,256
    mov      eax,68
    mov      ebx,20
    mov      edx,[vertices_index_ptr]
    int      0x40
  ;  and      eax,0xfffffff0
    mov      [vertices_index_ptr],eax
 
    mov      esp,ebp
    pop      ebp
 
 
 
if 0
;old Menuet style alloc
    movzx    ecx,word[size_x_var]
    movzx    eax,word[size_y_var]
    add      eax,200
    mul      ecx
    lea      ecx,[eax*3]
    add      ecx,16
    and      ecx,0xfffffff0
    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
end if
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	bx,[size_x_var]
	shl	ebx,16
	add	ebx,(12+70)*65536+25	 ; [x start] *65536 + [size x]
	mov	edx,0x00000000			;  color  0x00RRGGBB
	int	0x40
 
	mov	eax,4				; function 4 : write text to window
	movzx	ebx,byte[edi]
	sub	bl,2
	lea	ebx,[ebx*3]
	lea	ebx,[ebx*5]
	mov	cx,[size_x_var]
	shl	ecx,16
	add	ebx,ecx
	add	ebx,(12+70)*65536+28	 ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff			; 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_ptr]
	movzx	ecx,word[size_x_var]
	movzx	eax,word[size_y_var]
	imul	ecx,eax
	lea	ecx,[ecx*3]
	shr	ecx,2
	xor	eax,eax
      if Ext=NON
	rep	stosd
      else if Ext = MMX
	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
      else
	push	ecx
	mov	ecx,edi
	and	ecx,0x0000000f
	rep	stosb
	pop	ecx
	and	ecx,0xfffffff0
	xorps	xmm0,xmm0
      @@:
	movaps	[edi],xmm0
	movaps	[edi+16],xmm0
	movaps	[edi+32],xmm0
	movaps	[edi+48],xmm0
	add	edi,64
	sub	ecx,16
	jnz	@b
      end if
 
ret
 
 
draw_triangles:
 
	emms
      ;  update translated list  MMX required
	cmp	[vertex_edit_no],0
	je	@f
	movzx	eax,[vertex_edit_no]
	dec	eax
	movd	mm0,[edit_end_x]
	psubw	mm0,[edit_start_x]
	lea	eax,[eax*3]
	add	eax,eax
	add	eax,[points_translated_ptr]
	movd	mm1,dword[eax]
	paddw	mm1,mm0
	movd	dword[eax],mm1
    @@:
 
 
 
	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]
	cmp	[vertex_edit_no],0
	jne	@f
 
      @@:
	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  ; *********************************
 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]
	movd	mm1,dword[xx1]
	paddw	mm1,mm0
	movd	dword[xx1],mm1
	jmp	.no_edit
       @@:
 
	cmp	ax,[point_index2]
	jne	@f
	movd	mm0,[edit_start_x]
	psubw	mm0,[edit_end_x]
	movd	mm1,dword[xx2]
	paddw	mm1,mm0
	movd	dword[xx2],mm1
	jmp	.no_edit
       @@:
 
	cmp	ax,[point_index3]
	jne	@f
	movd	mm0,[edit_start_x]
	psubw	mm0,[edit_end_x]
	movd	mm1,dword[xx3]
	paddw	mm1,mm0
	movd	dword[xx3],mm1
	jmp	.no_edit
       @@:
 
 
    .no_edit:
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
	mov	edi,[screen_ptr]
	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
	mov	edi,[screen_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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_ptr]
	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
 
 
 
 
 
 
 
draw_handlers:
 
       push  ebp
       mov   ebp,esp
 
       .counter  equ ebp-16
       .xres3m18 equ ebp-8
       .xres2m12 equ ebp-12
 
 
     ; init counter
       sub   esp,12
       push  dword 0
 
       movzx eax,word[size_x_var]
       lea   ebx,[eax*3]
       sub   ebx,18
       add   eax,eax
       sub   eax,12
       mov   [.xres3m18],ebx
       mov   [.xres2m12],eax
 
       mov   esi,[points_translated_ptr]
     .loop:
       push  esi
					 ; DO culling AT FIRST
	cmp	[culling_flag],1	 ; (if culling_flag = 1)
	jne	.no_culling
	mov	edi,[.counter]		 ; *********************************
	lea	edi,[edi*3]
	shl	edi,2
	add	edi,[points_normals_rot_ptr]
	mov	eax,[edi+8]		 ; check sign of z coof
	shr	eax,31
	cmp	eax,1
	jnz	.skip
    .no_culling:
       mov   eax,[esi]
       movzx ebx,ax	    ; ebx - x
       shr   eax,16	    ; eax - y
       cmp   eax,4	    ; check if markers not exceedes screen
       jle   .skip
       cmp   ebx,4
       jle   .skip
       movzx edx,word[size_x_var]
       sub   edx,4
       movzx ecx,word[size_y_var]
       sub   ecx,4
       cmp   ebx,edx
       jge   .skip
       cmp   eax,ecx
       jge   .skip
 
       movzx edx,word[size_x_var]
    ;	sub   ebx,3
    ;	sub   eax,3
       imul  eax,edx
       add   eax,ebx
       lea   edi,[eax*3]
       lea   eax,[eax*2]
       ; draw bar 6x6
       add   edi,[screen_ptr]
       add   eax,dword[vertices_index_ptr]
 
 
 
 
       mov   edx,[.counter]
       mov   ecx,6
 
     .oop:
       push  ecx
       mov   ecx,6
 
     @@:
       mov   word[edi],0x0000 ;ax
       mov   byte[edi+2],0xff	;al
       mov   word[eax],dx
       add   eax,2
       add   edi,3
       loop  @b
       add   edi,[.xres3m18]
       add   eax,[.xres2m12]
       pop   ecx
       loop  .oop
 
    .skip:
       pop   esi
       add   esi,6
       inc   dword[.counter]
       mov   ecx,[.counter]
       cmp   cx,[points_count_var]
       jng   .loop
 
       mov   esp,ebp
       pop   ebp
 
ret
 
 
fill_Z_buffer:
	mov	eax,0x70000000
	mov	edi,[Zbuffer_ptr]
	movzx	ecx,word[size_x_var]
	movzx	ebx,word[size_y_var]
	imul	ecx,ebx
      if     Ext>=SSE2
	movd	xmm0,eax
	shufps	xmm0,xmm0,0
	push	ecx
	mov	ecx,edi
	and	edi,0xffffff00
	and	ecx,0x000000ff
	mov	edx,ecx
	rep	stosd
	pop	ecx
	sub	ecx,edx
      @@:
	movaps	[edi],xmm0
	movaps	[edi+16],xmm0
	movaps	[edi+32],xmm0
	movaps	[edi+48],xmm0
	add	edi,64
	sub	ecx,16
	jnc	@b
      else
	rep	stosd
      end if
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+0]
	pop	dword[edi+ebx*2+0]
	push	dword[esi+4]
	pop	dword[edi+ebx*2+4]
	push	dword[esi+8]
	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,[2+ecx*2]
   ;	 mov	 edx,dword [vertices_index_ptr]
   ;	 int	 0x40
   ;	 mov	 dword[vertices_index_ptr], eax
 
	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
      ;  int3
 
 
      ;  int3
 
 
	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, 68
 
 
 
 
 
 
 
 
 
    mov     ebx, 11
    int     0x40		   ;  -> init heap
 
    ;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, 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	;;;;---
	
    ;cmp     eax,6
    ;jnz     @f
    ;xor     eax,eax	;;;;---
 
    ;load kpacked files by Leency
 
	mov     eax,68
	mov     ebx,27
	mov     ecx,I_Param
 
 
 
	int     0x40
 
 
 
 
    mov     [fsize],edx
	mov     [file_info+16],eax
	
	test    eax,eax
	jnz     .open_opened_well
	mov     eax,6 ;otherwise => failed
	jmp     @f
	.open_opened_well:
	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	bx,[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
	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]
	mov	cx,[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
	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,0x00ddeeff			; 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	bx,[x_start]
	shl	ebx,16
	mov	cx,[y_start]
	shl	ecx,16
;ebx -	[x start] *65536 + [x size]
;ecx -	[y start] *65536 + [y size]
	mov	bx,[size_x_var]
	add	bx,115
	mov	cx,[size_y_var]
	add	cx,30
    ; @@:
	mov	edx,0x13000000	; color of work area RRGGBB,8->color gl
	mov	edi,labelt	; WINDOW LABEL
	int	0x40
 
	call	buttons 	; more buttons
 
	.Y_ADD equ 2   ;-> offset of 'add vector' buttons
 
	; ADD VECTOR LABEL	; add vector buttons - 30 ++
	mov	eax,4		; function 4 : write text to window
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(12)*65536+(168+15*(13+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(32)*65536+(168+15*(14+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(53)*65536+(168+15*(14+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(12)*65536+(168+15*(15+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(53)*65536+(168+15*(15+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(12)*65536+(168+15*(16+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(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
	movzx	ebx,word[size_x_var]
	shl	ebx,16
	add	ebx,(32)*65536+(168+15*(16+.Y_ADD))   ; [x start] *65536 + [y start]
	mov	ecx,0x00ddeeff	; 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'
   align 16
MEM_END:

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

Subversion Repositories Kolibri OS

(root)/programs/demos/3DS/VIEW3DS.ASM @ 8025 – Rev 7280 → 7788