WebSVN – Kolibri OS – Diff – /programs/demos/3DS/ASC.INC


; Files *.asc routines by Maciej Guba
; Thanks to Reverend for integer/float/ascii conversion examples
read_asc:
    mov  eax,[fptr]
 .find_vert:
    cmp  dword[eax],'Vert'
    je	 @f
    inc  eax
    jmp  .find_vert
  @@:
    add   eax,4
    cmp   dword[eax],'ices'
    jne   .find_vert
    add   eax,3
  @@:
    inc   eax
    cmp   byte[eax],'0' 	  ; search end of ascii number of vertices string
    jb	  @b
    cmp   byte[eax],'9'
    ja	  @b
;    eax - start ascii number
  @@:
    inc    eax
    cmp    byte[eax],'0'
    jb	  .convert1
    cmp    byte[eax],'9'
    ja	  .convert1
    jmp   @b
  .convert1:
    dec   eax
    mov   ebx,eax
    push  eax
    call  ascii_to_integer
    mov   [points_count_var],edx
    pop   eax
 
  @@:
    inc   eax
    cmp   dword[eax],'Face'
    jne   @b
    add   eax,3
  @@:
    inc   eax
    cmp   byte[eax],'0'
    jb	  @b
    cmp   byte[eax],'9'
    ja	  @b
   ;    eax - start ascii number
  @@:
    inc    eax
    cmp    byte[eax],'0'
    jb	  .convert2
    cmp    byte[eax],'9'
    ja	  .convert2
    jmp   @b
   ;  eax - end ascii number
  .convert2:
    dec   eax
    mov   ebx,eax
    push  eax
    call  ascii_to_integer
    mov   [triangles_count_var],edx
    pop   eax
 
  @@:
    inc   eax
    cmp   dword[eax],'Vert'
    jnz   @b
    inc   eax
 
    mov   edi,[points_ptr]
    xor   ebx,ebx
   .decode_vertices:
    push   ebx
  @@:
    inc   eax
    cmp   dword[eax],'Vert'
    jne   @b
    xor   ecx,ecx
 
  .decode_coord:
    push  ecx
  @@:
    inc   eax
    mov   dl,byte[eax]
    cmp   dl,byte[XYZpartices+ecx]
    jne   @b
  @@:
    inc   eax
    cmp   byte[eax],'.'
    je	  .readF
    cmp   byte[eax],'-'
    je	  .readF
    cmp   byte[eax],'0'
    jb	  @b
    cmp   byte[eax],'9'
    ja	  @b
.readF: ; read float
    mov   esi,eax
    push  eax
    push  ecx
 
    call   atof   ; st0 - desired dword float
 
    pop   ecx
    pop   eax
 
    fstp  dword[edi]
    add   edi,4
 
    pop   ecx
    inc   ecx
    cmp   ecx,3
    jne   .decode_coord
    pop   ebx
    inc   ebx
    cmp   ebx,[points_count_var]
    jne   .decode_vertices
    mov   dword[edi],-1
 
 
 
    mov   esi,eax
   @@:
    inc   esi
    cmp   dword[esi],'Face'
    jne   @b
    xor   edx,edx
    mov   edi,[triangles_ptr]
    cld
 .decode_face:
 
    push  edx
   @@:
    inc   esi
    cmp   dword[esi],'Face'
    jne   @b
 @@:
    inc   esi
    cmp   byte[esi],'0'    ; face number start
    jb	  @b
    cmp   byte[esi],'9'
    ja	  @b
  @@:
    inc    esi
    cmp    byte[esi],'0'
    jb	  @f
    cmp    byte[esi],'9'   ; face number end
    ja	  @f
    jmp   @b
  @@:
    xor ecx,ecx
 .next_vertex_number:
 
    push  ecx
  @@:
    inc   esi
    cmp   byte[esi],'0'
    jb	  @b
    cmp   byte[esi],'9'
    ja	  @b
    ;    eax - start ascii number
  @@:
    inc    esi
    cmp    byte[esi],'0'
    jb	  @f
    cmp    byte[esi],'9'
    ja	  @f
    jmp   @b
   ;  eax - end ascii number
  @@:
    dec   esi
    mov   ebx,esi
    push  esi
    call  ascii_to_integer
    mov   eax,edx
 
    stosd
    pop   esi
    add   esi,4
 
    pop   ecx
    inc   ecx
    cmp   ecx,3
    jne   .next_vertex_number
    pop   edx
    inc   edx
    cmp   edx,[triangles_count_var]
    jne   .decode_face
    mov   dword[edi],-1 ;dword[triangles+ebx+2],-1   ; end mark
    mov   eax,1  ;-> mark if ok
ret
 
ascii_to_integer:
; in ---  [ebx] -> end of ascii string
; out --  edx  -> desired number
    xor    edx,edx
    xor    ecx,ecx
  .again:
    movzx  eax,byte[ebx]
    sub    al,'0'
    cwde
    push   edx
    mul    dword[convert_muler+ecx]
    pop    edx
    add    edx,eax
    dec    ebx
    cmp    byte[ebx],'0'
    jb	   .end
    cmp    byte[ebx],'9'
    ja	   .end
    add    ecx,4
    jmp    .again
  @@:
 
  .end:
ret
 
;===============================================================================
;       ASCII to float conversion procedure
;
;       input:
;       esi - pointer to string
;
;       output:
;       st0 - number changed into float
;
;===============================================================================
 
atof:
	.string  equ ebp-4
 
	push	ebp
	mov	ebp,esp
	sub	esp,32
	push	eax ecx esi
	mov	[.string],esi
	fninit
	fldz
	fldz
 
	cld
	cmp	byte [esi], '-'
	jnz	@F
	inc	esi
    @@:
	xor	eax, eax
	align	4
  .loop.integer_part:
	lodsb
	cmp	al, '.'
	jz	.mantisa
	cmp	al,'0'
	jb	.exit
	cmp	al,'9'
	ja	.exit
	fimul	[i10]
	sub	al, '0'
	push	eax
	fiadd	dword [esp]
	add	esp, 4
	jmp	.loop.integer_part
 
  .mantisa:
	xor	 ecx, ecx
	xor	 eax, eax
	cld
	fxch	 st1
     @@:
 
	lodsb
	cmp	al,'0'
	jb	.exit
	cmp	al,'9'
	ja	.exit
	cmp	ecx,7*4
	je	.exit		; max 7 digits in mantisa
	sub	al,'0'
	push	eax
	fild	dword[esp]
	fidiv	dword[convert_muler+4+ecx]
	faddp
	add	esp,4
	add	ecx,4
	jmp	@b
  .exit:
	faddp
 
	mov	eax, [.string]
	cmp	byte [eax], '-'
	jnz	@F
	fchs
    @@:
	cld
	stc				; always returns no error
	pop	esi ecx eax
	mov	esp,ebp
	pop	ebp
	ret
 
 
itoa:		   ; unsigned dword integer to ascii procedure
;     in   eax - variable
;          esi - Pointer to ascii string
;   out    esi - desired ascii string
;          edi - end of ascii string  - ptr to memory
 .temp_string  equ dword[ebp-36]
 .ptr	       equ dword[ebp-40]
 .var	       equ dword[ebp-44]
	   push  ecx
	   push  ebp
	   mov	 ebp,esp
	   sub	 esp,64
	   mov	 .var,eax
	   mov	 eax,-1
	   lea	 edi,.temp_string
	   cld
	   mov	 ecx,9
	   rep	 stosd	    ; make floor
 
 
	   mov	 .ptr,esi
	   lea	 edi,.temp_string
	   add	 edi,34
	   std
	   xor	 eax,eax
	   stosb	       ; mark begin
	   mov	 eax,.var
	   mov	 esi,10
	@@:
	   xor	 edx,edx
	   div	 esi
	   xchg  eax,edx
	   add	 al,'0'
	   stosb
	   xchg  eax,edx
	   or	 eax,eax
	   jnz	 @b
	   stosb		     ; mark end
 
	   lea	 esi,.temp_string
	   cld
	@@:
	   lodsb
	   or	al,al
	   jnz	@b
 
	   mov	edi,.ptr
	 @@:
	   lodsb
	   stosb
	   or	al,al
	   jnz	@b
 
	   mov	esp,ebp
	   pop	ebp
	   pop	ecx
ret
if 1
ftoa_mac:
;   in  :  esi - pointer to  dword float
;          edi - pointer to ascii string
  .ptr_f     equ dword[ebp-4]
  .sign      equ dword[ebp-8]	;  0 ->   less than zero, 1 - otherwise
  .ptr_ascii equ dword[ebp-12]
  .integer   equ dword[ebp-20]
  .fraction  equ dword[ebp-28]
  .status_orginal equ word[ebp-32]
  .status_changed equ word[ebp-34]
	 push	  ecx
	 push	  ebp
	 mov	  ebp,esp
	 sub	  esp,64
	fninit
	fnstcw	.status_orginal
	mov	ax, .status_orginal
	or	ax, 0000110000000000b
	mov	.status_changed, ax
	fldcw	.status_changed
;       --------------------------------
;       check if signed
	xor	eax, eax
	fld	dword[esi]
	fst	.sign
	test	.sign, 80000000h
	setz	al
	mov	.sign, eax
 
	 mov	   .ptr_f,esi
	 mov	   .ptr_ascii,edi
	 fabs
	 fld	   st0
	 frndint
	 fist	   .integer
	 fsubp	   st1, st0
 
	 mov	   eax,.integer
	 mov	   esi,.ptr_ascii
	 call	   itoa
      ;  edi   ->   ptr to end of ascii string
	 dec	   edi
	 mov	   al,'.'
	 stosb
 
	mov	ecx, 6	 ; max 6 digits in fraction part
    .loop:
	fimul	[i10]
	fld	st0
	frndint
	fist	.fraction
	fsubp	st1, st0
	mov	esi,edi
	mov	eax,.fraction
	add	al,'0'
	stosb
	ftst
	fnstsw	ax
	test	ax, 0100000000000000b
	jz	@F
	test	ax, 0000010100000000b
	jz	.finish
    @@:
	loop	.loop
if 0
	fldcw	.status_orginal
	fimul	[i10]
	fist	.fraction
    ;    mov     esi,edi
	mov	eax,.fraction
	add	al,'0'
	stosb
    ;    call    itoa
;       --------------------------------
;       restore previous values
    .finish:
      ;  fstp    st0
	 ffree	   st
	 mov	   eax,.fraction
	 mov	   esi,edi
;         call      itoa
 
	 add	   al,'0'
	 stosb
end if
 .finish:
  ffree st
	 cmp	   .sign,0
	 jnz	   @f
	 mov	   esi,.ptr_ascii
	 dec	   esi
	 mov	   byte[esi],'-'
       @@:
	 mov	   esp,ebp
	 pop	   ebp
	 pop	   ecx
 
ret
end if
if 0
;===============================================================================
;       float to ASCII conversion procedure
;
;       input:
;       buffer - pointer to memory where output will be saved
;       precision - number of digits after dot
;
;       output:
;       no immediate output
;
;       notes:
;       separate integer and mantisa part with dot '.'
;       so GOOD   123.456
;          WRONG  123,456
;
;       coded by Reverend // HTB + RAG
;===============================================================================
proc	ftoa			buffer, precision
locals
  status_original	      dw ?
  status_changed	      dw ?
  integer		      dd ?
  mantisa		      dd ?
  signed		      dd ?
endl
	push	eax ecx;edi ecx
;       --------------------------------
;       set correct precision
	mov	eax, [precision]
	cmp	eax, 51
	jb	@F
	mov	eax, 51
    @@:
	mov	[precision], eax
;       --------------------------------
;       change control wortd of fpu to prevent rounding
	fnstcw	[status_original]
	mov	ax, [status_original]
	or	ax, 0000110000000000b
	mov	[status_changed], ax
	fldcw	[status_changed]
;       --------------------------------
;       check if signed
	xor	eax, eax
	fst	[signed]
	test	[signed], 80000000h
	setnz	al
	mov	[signed], eax
;       --------------------------------
;       cut integer and mantisa separately
	fld	st0
	fld	st0			; st0 = x, st1 = x
	frndint
	fist	[integer]		; st0 = x, st1 = x
	fabs
	fsubp	st1, st0		; st0 = mantisa(x)
;       --------------------------------
;       save integer part in buffer
    ;    mov     edi, [buffer]
	mov	esi,[buffer]
      ;  push    [signed]
      ;  push    edi
      ;  push    10
      ;  push    [integer]
	mov	eax,[integer]
	call	itoa
 ;       add     edi, eax
	mov	al, '.'
	stosb
	mov	esi,edi
;       --------------------------------
;       save mantisa part in buffer
	mov	ecx, [precision]
	dec	ecx
    .loop:
	fimul	[i10]
	fld	st0
	frndint
	fist	[mantisa]
	fsubp	st1, st0
;        push    0
;        push    edi
;        push    10
;        push    [mantisa]
	mov	esi,edi
	mov	eax,[mantisa]
	call	itoa
      ;  add     edi, eax
	ftst
	fnstsw	ax
	test	ax, 0100000000000000b
	jz	@F
	test	ax, 0000010100000000b
	jz	.finish
    @@:
	loop	.loop
	fldcw	[status_original]
	fimul	[i10]
	fist	[mantisa]
;        push    0
;        push    edi
;        push    10
;        push    [mantisa]
	mov	esi,edi
	mov	eax,[mantisa]
	call	itoa
;       --------------------------------
;       restore previous values
    .finish:
	fstp	st0
	cmp	[signed],1
	jnz   @f
	mov   byte[buffer],'-'
      @@:
	stc
	pop	ecx eax   ;edi eax
	ret
endp
end if
if 0
write_asc:
    .counter equ dword[ebp-4]
	push  ebp
	mov   ebp,esp
	sub   esp,64
	fninit
	mov   edi,asc_file_buffer
	mov   esi,asc_main_header
	cld
      @@:
	lodsb
	cmp   al,1
	jz    @f
	stosb
	jmp   @b
      @@:
 
	mov   esi,asc_info_header
      @@:
	lodsb
	cmp   al,1
	jz    @f
	stosb
	jmp   @b
     @@:
	push   esi  ; -> position in header info
	movzx  eax,[points_count_var]
	mov    esi,edi
	call   itoa		 ; unsigned dword integer to ascii procedure
	pop   esi
	inc   esi
      @@:
	lodsb
	cmp   al,1
	jz    @f
	stosb
	jmp   @b
      @@:
	push  esi
	movzx eax,[triangles_count_var]
	mov   esi,edi
	call  itoa
	pop   esi
	inc   esi
      @@:
	lodsb
	cmp   al,1
	jz    @f
	stosb
	jmp   @b
      @@:
;=============================================================
;================vertex list parser===========================
;=============================================================
 
       xor   ecx,ecx
     .again_vertex:
       push  ecx
       mov   esi,asc_one_vertex_formula
     @@:
       lodsb
       cmp   al,1
       jz    @f
       stosb
       jmp   @b
     @@:
       mov   eax,ecx
 ;      push  ecx
       push  esi
       mov   esi,edi
       call  itoa
       pop   esi
;       pop   ecx
       inc   esi
       xor   ebx,ebx
    .next_vertex_coef:
       push  ebx
     @@:
       lodsb
       cmp   al,1
       jz    @f
       stosb
       jmp   @b
     @@:
    ; int3
       push  esi
       lea   esi,[ecx*3]
       shl   esi,2
       add   esi,points_r
       add   esi,ebx
     ;  int3
       call  ftoa_mac
     ;  std
     ;  fld     dword[esi]
 
 
     ;  pushad
     ;  stdcall ftoa, edi, 30
     ;  popad
     ;  add   edi,20
 
 
       pop   esi
       pop   ebx
       add   ebx,4
       cmp   ebx,12
       jnz   .next_vertex_coef
     @@:
       lodsb
       cmp   al,1
       jz    @f
       stosb
       jmp   @b
     @@:
       pop   ecx
       inc   ecx
       cmp   cx,[points_count_var]
       jnz   .again_vertex
 
 
   ;   mov  edi,[temp_edi]
 
 
       mov  esi,asc_face_list_header
      @@:
	lodsb
	cmp   al,1	; all face header
	jz    @f
	stosb
	jmp   @b
      @@:
	   ;=====================================
	   ; ==============face list parser======
	   ;=====================================
       xor   ecx,ecx
     .again_face:
       push  ecx
       mov   .counter,ecx
       mov   esi,asc_one_face_formula
     @@:
       lodsb
       cmp   al,1
       jz    @f
       stosb
       jmp   @b
     @@:
       mov   eax,ecx
       push  esi
       mov   esi,edi
       call  itoa
       pop   esi
       inc   esi
     @@:
       lodsb
       cmp   al,1
       jz    @f
       stosb
       jmp   @b
     @@:
 
       xor    ebx,ebx
      .next_face_index:
	push   ebx
	mov    ecx,.counter
	lea    ecx,[ecx*3]
	add    ecx,ecx
	movzx  eax,word[triangles+ecx+ebx]
	push   esi
	mov    esi,edi
	call   itoa
	pop    esi
       @@:
	lodsb
	cmp   al,1
	jz    @f
	stosb
	jmp   @b
      @@:
	pop    ebx
	add    ebx,2
	cmp    ebx,6
	jnz    .next_face_index
 
;        push   esi
	mov   esi,asc_material
     @@:
	lodsb
	cmp   al,1
	jz    @f
	stosb
	jmp   @b
     @@:
;        pop   esi
 
	 pop	ecx
	inc    ecx
	cmp    cx,[triangles_count_var]
	jnz    .again_face
 
	; write file
    sub  edi,asc_file_buffer
  ;  mov  [file_buffer+2],edi
    mov  [FileSize],edi
 
    invoke  CreateFile,asc_file_name, GENERIC_WRITE, 0, 0,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0
    mov  [hfile],eax
    invoke  WriteFile,eax,asc_file_buffer,[FileSize], byteswritten, 0
    invoke  CloseHandle,[hfile]
 
    mov  esp,ebp
    pop  ebp
ret
end if
if 0
asc_file_buffer:
	      rd 65536
ascii_string  rb 50
ftoa_muler dd 1000000000
file_size dd ?
file_handle dd ?
end if
 
if 0
convert_muler:
dd 1, 10, 100, 1000, 10000
XYZpartices:
db 'X','Y','Z'
i10 dw 10
points_count_var dd ?
triangles_count_var dd ?
points rb 100
triangles rb 100
asc_file:
 
file "2TORUS.ASC"
end if

Rev 5486	Rev 8014
1	; Files *.asc routines by Maciej Guba	1	; Files *.asc routines by Maciej Guba
2	; Thanks to Reverend for integer/float/ascii conversion examples	2	; Thanks to Reverend for integer/float/ascii conversion examples
3	read_asc:	3	read_asc:
4	mov eax,[fptr]	4	mov eax,[fptr]
5	.find_vert:	5	.find_vert:
6	cmp dword[eax],'Vert'	6	cmp dword[eax],'Vert'
7	je @f	7	je @f
8	inc eax	8	inc eax
9	jmp .find_vert	9	jmp .find_vert
10	@@:	10	@@:
11	add eax,4	11	add eax,4
12	cmp dword[eax],'ices'	12	cmp dword[eax],'ices'
13	jne .find_vert	13	jne .find_vert
14	add eax,3	14	add eax,3
15	@@:	15	@@:
16	inc eax	16	inc eax
17	cmp byte[eax],'0' ; search end of ascii number of vertices string	17	cmp byte[eax],'0' ; search end of ascii number of vertices string
18	jb @b	18	jb @b
19	cmp byte[eax],'9'	19	cmp byte[eax],'9'
20	ja @b	20	ja @b
21	; eax - start ascii number	21	; eax - start ascii number
22	@@:	22	@@:
23	inc eax	23	inc eax
24	cmp byte[eax],'0'	24	cmp byte[eax],'0'
25	jb .convert1	25	jb .convert1
26	cmp byte[eax],'9'	26	cmp byte[eax],'9'
27	ja .convert1	27	ja .convert1
28	jmp @b	28	jmp @b
29	.convert1:	29	.convert1:
30	dec eax	30	dec eax
31	mov ebx,eax	31	mov ebx,eax
32	push eax	32	push eax
33	call ascii_to_integer	33	call ascii_to_integer
34	mov [points_count_var],dx	34	mov [points_count_var],edx
35	pop eax	35	pop eax
36		36
37	@@:	37	@@:
38	inc eax	38	inc eax
39	cmp dword[eax],'Face'	39	cmp dword[eax],'Face'
40	jne @b	40	jne @b
41	add eax,3	41	add eax,3
42	@@:	42	@@:
43	inc eax	43	inc eax
44	cmp byte[eax],'0'	44	cmp byte[eax],'0'
45	jb @b	45	jb @b
46	cmp byte[eax],'9'	46	cmp byte[eax],'9'
47	ja @b	47	ja @b
48	; eax - start ascii number	48	; eax - start ascii number
49	@@:	49	@@:
50	inc eax	50	inc eax
51	cmp byte[eax],'0'	51	cmp byte[eax],'0'
52	jb .convert2	52	jb .convert2
53	cmp byte[eax],'9'	53	cmp byte[eax],'9'
54	ja .convert2	54	ja .convert2
55	jmp @b	55	jmp @b
56	; eax - end ascii number	56	; eax - end ascii number
57	.convert2:	57	.convert2:
58	dec eax	58	dec eax
59	mov ebx,eax	59	mov ebx,eax
60	push eax	60	push eax
61	call ascii_to_integer	61	call ascii_to_integer
62	mov [triangles_count_var],dx	62	mov [triangles_count_var],edx
63	pop eax	63	pop eax
64		64
65	@@:	65	@@:
66	inc eax	66	inc eax
67	cmp dword[eax],'Vert'	67	cmp dword[eax],'Vert'
68	jnz @b	68	jnz @b
69	inc eax	69	inc eax
70		70
71	mov edi,[points_ptr]	71	mov edi,[points_ptr]
72	xor ebx,ebx	72	xor ebx,ebx
73	.decode_vertices:	73	.decode_vertices:
74	push ebx	74	push ebx
75	@@:	75	@@:
76	inc eax	76	inc eax
77	cmp dword[eax],'Vert'	77	cmp dword[eax],'Vert'
78	jne @b	78	jne @b
79	xor ecx,ecx	79	xor ecx,ecx
80		80
81	.decode_coord:	81	.decode_coord:
82	push ecx	82	push ecx
83	@@:	83	@@:
84	inc eax	84	inc eax
85	mov dl,byte[eax]	85	mov dl,byte[eax]
86	cmp dl,byte[XYZpartices+ecx]	86	cmp dl,byte[XYZpartices+ecx]
87	jne @b	87	jne @b
88	@@:	88	@@:
89	inc eax	89	inc eax
90	cmp byte[eax],'.'	90	cmp byte[eax],'.'
91	je .readF	91	je .readF
92	cmp byte[eax],'-'	92	cmp byte[eax],'-'
93	je .readF	93	je .readF
94	cmp byte[eax],'0'	94	cmp byte[eax],'0'
95	jb @b	95	jb @b
96	cmp byte[eax],'9'	96	cmp byte[eax],'9'
97	ja @b	97	ja @b
98	.readF: ; read float	98	.readF: ; read float
99	mov esi,eax	99	mov esi,eax
100	push eax	100	push eax
101	push ecx	101	push ecx
102		102
103	call atof ; st0 - desired dword float	103	call atof ; st0 - desired dword float
104		104
105	pop ecx	105	pop ecx
106	pop eax	106	pop eax
107		107
108	fstp dword[edi]	108	fstp dword[edi]
109	add edi,4	109	add edi,4
110		110
111	pop ecx	111	pop ecx
112	inc ecx	112	inc ecx
113	cmp ecx,3	113	cmp ecx,3
114	jne .decode_coord	114	jne .decode_coord
115	pop ebx	115	pop ebx
116	inc ebx	116	inc ebx
117	cmp bx,[points_count_var]	117	cmp ebx,[points_count_var]
118	jne .decode_vertices	118	jne .decode_vertices
119	mov dword[edi],-1	119	mov dword[edi],-1
120		120
121		121
122		122
123	mov esi,eax	123	mov esi,eax
124	@@:	124	@@:
125	inc esi	125	inc esi
126	cmp dword[esi],'Face'	126	cmp dword[esi],'Face'
127	jne @b	127	jne @b
128	xor edx,edx	128	xor edx,edx
129	mov edi,[triangles_ptr]	129	mov edi,[triangles_ptr]
130	cld	130	cld
131	.decode_face:	131	.decode_face:
132		132
133	push edx	133	push edx
134	@@:	134	@@:
135	inc esi	135	inc esi
136	cmp dword[esi],'Face'	136	cmp dword[esi],'Face'
137	jne @b	137	jne @b
138	@@:	138	@@:
139	inc esi	139	inc esi
140	cmp byte[esi],'0' ; face number start	140	cmp byte[esi],'0' ; face number start
141	jb @b	141	jb @b
142	cmp byte[esi],'9'	142	cmp byte[esi],'9'
143	ja @b	143	ja @b
144	@@:	144	@@:
145	inc esi	145	inc esi
146	cmp byte[esi],'0'	146	cmp byte[esi],'0'
147	jb @f	147	jb @f
148	cmp byte[esi],'9' ; face number end	148	cmp byte[esi],'9' ; face number end
149	ja @f	149	ja @f
150	jmp @b	150	jmp @b
151	@@:	151	@@:
152	xor ecx,ecx	152	xor ecx,ecx
153	.next_vertex_number:	153	.next_vertex_number:
154		154
155	push ecx	155	push ecx
156	@@:	156	@@:
157	inc esi	157	inc esi
158	cmp byte[esi],'0'	158	cmp byte[esi],'0'
159	jb @b	159	jb @b
160	cmp byte[esi],'9'	160	cmp byte[esi],'9'
161	ja @b	161	ja @b
162	; eax - start ascii number	162	; eax - start ascii number
163	@@:	163	@@:
164	inc esi	164	inc esi
165	cmp byte[esi],'0'	165	cmp byte[esi],'0'
166	jb @f	166	jb @f
167	cmp byte[esi],'9'	167	cmp byte[esi],'9'
168	ja @f	168	ja @f
169	jmp @b	169	jmp @b
170	; eax - end ascii number	170	; eax - end ascii number
171	@@:	171	@@:
172	dec esi	172	dec esi
173	mov ebx,esi	173	mov ebx,esi
174	push esi	174	push esi
175	call ascii_to_integer	175	call ascii_to_integer
176	mov eax,edx	176	mov eax,edx
177		177
178	stosw	178	stosd
179	pop esi	179	pop esi
180	add esi,2	180	add esi,4
181		181
182	pop ecx	182	pop ecx
183	inc ecx	183	inc ecx
184	cmp ecx,3	184	cmp ecx,3
185	jne .next_vertex_number	185	jne .next_vertex_number
186	pop edx	186	pop edx
187	inc edx	187	inc edx
188	cmp dx,[triangles_count_var]	188	cmp edx,[triangles_count_var]
189	jne .decode_face	189	jne .decode_face
190	mov dword[edi],-1 ;dword[triangles+ebx+2],-1 ; end mark	190	mov dword[edi],-1 ;dword[triangles+ebx+2],-1 ; end mark
191	mov eax,1 ;-> mark if ok	191	mov eax,1 ;-> mark if ok
192	ret	192	ret
193		193
194	ascii_to_integer:	194	ascii_to_integer:
195	; in --- [ebx] -> end of ascii string	195	; in --- [ebx] -> end of ascii string
196	; out -- edx -> desired number	196	; out -- edx -> desired number
197	xor edx,edx	197	xor edx,edx
198	xor ecx,ecx	198	xor ecx,ecx
199	.again:	199	.again:
200	movzx eax,byte[ebx]	200	movzx eax,byte[ebx]
201	sub al,'0'	201	sub al,'0'
202	cwde	202	cwde
203	push edx	203	push edx
204	mul dword[convert_muler+ecx]	204	mul dword[convert_muler+ecx]
205	pop edx	205	pop edx
206	add edx,eax	206	add edx,eax
207	dec ebx	207	dec ebx
208	cmp byte[ebx],'0'	208	cmp byte[ebx],'0'
209	jb .end	209	jb .end
210	cmp byte[ebx],'9'	210	cmp byte[ebx],'9'
211	ja .end	211	ja .end
212	add ecx,4	212	add ecx,4
213	jmp .again	213	jmp .again
214	@@:	214	@@:
215		215
216	.end:	216	.end:
217	ret	217	ret
218		218
219	;===============================================================================	219	;===============================================================================
220	; ASCII to float conversion procedure	220	; ASCII to float conversion procedure
221	;	221	;
222	; input:	222	; input:
223	; esi - pointer to string	223	; esi - pointer to string
224	;	224	;
225	; output:	225	; output:
226	; st0 - number changed into float	226	; st0 - number changed into float
227	;	227	;
228	;===============================================================================	228	;===============================================================================
229		229
230	atof:	230	atof:
231	.string equ ebp-4	231	.string equ ebp-4
232		232
233	push ebp	233	push ebp
234	mov ebp,esp	234	mov ebp,esp
235	sub esp,32	235	sub esp,32
236	push eax ecx esi	236	push eax ecx esi
237	mov [.string],esi	237	mov [.string],esi
238	fninit	238	fninit
239	fldz	239	fldz
240	fldz	240	fldz
241		241
242	cld	242	cld
243	cmp byte [esi], '-'	243	cmp byte [esi], '-'
244	jnz @F	244	jnz @F
245	inc esi	245	inc esi
246	@@:	246	@@:
247	xor eax, eax	247	xor eax, eax
248	align 4	248	align 4
249	.loop.integer_part:	249	.loop.integer_part:
250	lodsb	250	lodsb
251	cmp al, '.'	251	cmp al, '.'
252	jz .mantisa	252	jz .mantisa
253	cmp al,'0'	253	cmp al,'0'
254	jb .exit	254	jb .exit
255	cmp al,'9'	255	cmp al,'9'
256	ja .exit	256	ja .exit
257	fimul [i10]	257	fimul [i10]
258	sub al, '0'	258	sub al, '0'
259	push eax	259	push eax
260	fiadd dword [esp]	260	fiadd dword [esp]
261	add esp, 4	261	add esp, 4
262	jmp .loop.integer_part	262	jmp .loop.integer_part
263		263
264	.mantisa:	264	.mantisa:
265	xor ecx, ecx	265	xor ecx, ecx
266	xor eax, eax	266	xor eax, eax
267	cld	267	cld
268	fxch st1	268	fxch st1
269	@@:	269	@@:
270		270
271	lodsb	271	lodsb
272	cmp al,'0'	272	cmp al,'0'
273	jb .exit	273	jb .exit
274	cmp al,'9'	274	cmp al,'9'
275	ja .exit	275	ja .exit
276	cmp ecx,7*4	276	cmp ecx,7*4
277	je .exit ; max 7 digits in mantisa	277	je .exit ; max 7 digits in mantisa
278	sub al,'0'	278	sub al,'0'
279	push eax	279	push eax
280	fild dword[esp]	280	fild dword[esp]
281	fidiv dword[convert_muler+4+ecx]	281	fidiv dword[convert_muler+4+ecx]
282	faddp	282	faddp
283	add esp,4	283	add esp,4
284	add ecx,4	284	add ecx,4
285	jmp @b	285	jmp @b
286	.exit:	286	.exit:
287	faddp	287	faddp
288		288
289	mov eax, [.string]	289	mov eax, [.string]
290	cmp byte [eax], '-'	290	cmp byte [eax], '-'
291	jnz @F	291	jnz @F
292	fchs	292	fchs
293	@@:	293	@@:
294	cld	294	cld
295	stc ; always returns no error	295	stc ; always returns no error
296	pop esi ecx eax	296	pop esi ecx eax
297	mov esp,ebp	297	mov esp,ebp
298	pop ebp	298	pop ebp
299	ret	299	ret
300		300
301		301
302	itoa: ; unsigned dword integer to ascii procedure	302	itoa: ; unsigned dword integer to ascii procedure
303	; in eax - variable	303	; in eax - variable
304	; esi - Pointer to ascii string	304	; esi - Pointer to ascii string
305	; out esi - desired ascii string	305	; out esi - desired ascii string
306	; edi - end of ascii string - ptr to memory	306	; edi - end of ascii string - ptr to memory
307	.temp_string equ dword[ebp-36]	307	.temp_string equ dword[ebp-36]
308	.ptr equ dword[ebp-40]	308	.ptr equ dword[ebp-40]
309	.var equ dword[ebp-44]	309	.var equ dword[ebp-44]
310	push ecx	310	push ecx
311	push ebp	311	push ebp
312	mov ebp,esp	312	mov ebp,esp
313	sub esp,64	313	sub esp,64
314	mov .var,eax	314	mov .var,eax
315	mov eax,-1	315	mov eax,-1
316	lea edi,.temp_string	316	lea edi,.temp_string
317	cld	317	cld
318	mov ecx,9	318	mov ecx,9
319	rep stosd ; make floor	319	rep stosd ; make floor
320		320
321		321
322	mov .ptr,esi	322	mov .ptr,esi
323	lea edi,.temp_string	323	lea edi,.temp_string
324	add edi,34	324	add edi,34
325	std	325	std
326	xor eax,eax	326	xor eax,eax
327	stosb ; mark begin	327	stosb ; mark begin
328	mov eax,.var	328	mov eax,.var
329	mov esi,10	329	mov esi,10
330	@@:	330	@@:
331	xor edx,edx	331	xor edx,edx
332	div esi	332	div esi
333	xchg eax,edx	333	xchg eax,edx
334	add al,'0'	334	add al,'0'
335	stosb	335	stosb
336	xchg eax,edx	336	xchg eax,edx
337	or eax,eax	337	or eax,eax
338	jnz @b	338	jnz @b
339	stosb ; mark end	339	stosb ; mark end
340		340
341	lea esi,.temp_string	341	lea esi,.temp_string
342	cld	342	cld
343	@@:	343	@@:
344	lodsb	344	lodsb
345	or al,al	345	or al,al
346	jnz @b	346	jnz @b
347		347
348	mov edi,.ptr	348	mov edi,.ptr
349	@@:	349	@@:
350	lodsb	350	lodsb
351	stosb	351	stosb
352	or al,al	352	or al,al
353	jnz @b	353	jnz @b
354		354
355	mov esp,ebp	355	mov esp,ebp
356	pop ebp	356	pop ebp
357	pop ecx	357	pop ecx
358	ret	358	ret
359	if 1	359	if 1
360	ftoa_mac:	360	ftoa_mac:
361	; in : esi - pointer to dword float	361	; in : esi - pointer to dword float
362	; edi - pointer to ascii string	362	; edi - pointer to ascii string
363	.ptr_f equ dword[ebp-4]	363	.ptr_f equ dword[ebp-4]
364	.sign equ dword[ebp-8] ; 0 -> less than zero, 1 - otherwise	364	.sign equ dword[ebp-8] ; 0 -> less than zero, 1 - otherwise
365	.ptr_ascii equ dword[ebp-12]	365	.ptr_ascii equ dword[ebp-12]
366	.integer equ dword[ebp-20]	366	.integer equ dword[ebp-20]
367	.fraction equ dword[ebp-28]	367	.fraction equ dword[ebp-28]
368	.status_orginal equ word[ebp-32]	368	.status_orginal equ word[ebp-32]
369	.status_changed equ word[ebp-34]	369	.status_changed equ word[ebp-34]
370	push ecx	370	push ecx
371	push ebp	371	push ebp
372	mov ebp,esp	372	mov ebp,esp
373	sub esp,64	373	sub esp,64
374	fninit	374	fninit
375	fnstcw .status_orginal	375	fnstcw .status_orginal
376	mov ax, .status_orginal	376	mov ax, .status_orginal
377	or ax, 0000110000000000b	377	or ax, 0000110000000000b
378	mov .status_changed, ax	378	mov .status_changed, ax
379	fldcw .status_changed	379	fldcw .status_changed
380	; --------------------------------	380	; --------------------------------
381	; check if signed	381	; check if signed
382	xor eax, eax	382	xor eax, eax
383	fld dword[esi]	383	fld dword[esi]
384	fst .sign	384	fst .sign
385	test .sign, 80000000h	385	test .sign, 80000000h
386	setz al	386	setz al
387	mov .sign, eax	387	mov .sign, eax
388		388
389	mov .ptr_f,esi	389	mov .ptr_f,esi
390	mov .ptr_ascii,edi	390	mov .ptr_ascii,edi
391	fabs	391	fabs
392	fld st0	392	fld st0
393	frndint	393	frndint
394	fist .integer	394	fist .integer
395	fsubp st1, st0	395	fsubp st1, st0
396		396
397	mov eax,.integer	397	mov eax,.integer
398	mov esi,.ptr_ascii	398	mov esi,.ptr_ascii
399	call itoa	399	call itoa
400	; edi -> ptr to end of ascii string	400	; edi -> ptr to end of ascii string
401	dec edi	401	dec edi
402	mov al,'.'	402	mov al,'.'
403	stosb	403	stosb
404		404
405	mov ecx, 6 ; max 6 digits in fraction part	405	mov ecx, 6 ; max 6 digits in fraction part
406	.loop:	406	.loop:
407	fimul [i10]	407	fimul [i10]
408	fld st0	408	fld st0
409	frndint	409	frndint
410	fist .fraction	410	fist .fraction
411	fsubp st1, st0	411	fsubp st1, st0
412	mov esi,edi	412	mov esi,edi
413	mov eax,.fraction	413	mov eax,.fraction
414	add al,'0'	414	add al,'0'
415	stosb	415	stosb
416	ftst	416	ftst
417	fnstsw ax	417	fnstsw ax
418	test ax, 0100000000000000b	418	test ax, 0100000000000000b
419	jz @F	419	jz @F
420	test ax, 0000010100000000b	420	test ax, 0000010100000000b
421	jz .finish	421	jz .finish
422	@@:	422	@@:
423	loop .loop	423	loop .loop
424	if 0	424	if 0
425	fldcw .status_orginal	425	fldcw .status_orginal
426	fimul [i10]	426	fimul [i10]
427	fist .fraction	427	fist .fraction
428	; mov esi,edi	428	; mov esi,edi
429	mov eax,.fraction	429	mov eax,.fraction
430	add al,'0'	430	add al,'0'
431	stosb	431	stosb
432	; call itoa	432	; call itoa
433	; --------------------------------	433	; --------------------------------
434	; restore previous values	434	; restore previous values
435	.finish:	435	.finish:
436	; fstp st0	436	; fstp st0
437	ffree st	437	ffree st
438	mov eax,.fraction	438	mov eax,.fraction
439	mov esi,edi	439	mov esi,edi
440	; call itoa	440	; call itoa
441		441
442	add al,'0'	442	add al,'0'
443	stosb	443	stosb
444	end if	444	end if
445	.finish:	445	.finish:
446	ffree st	446	ffree st
447	cmp .sign,0	447	cmp .sign,0
448	jnz @f	448	jnz @f
449	mov esi,.ptr_ascii	449	mov esi,.ptr_ascii
450	dec esi	450	dec esi
451	mov byte[esi],'-'	451	mov byte[esi],'-'
452	@@:	452	@@:
453	mov esp,ebp	453	mov esp,ebp
454	pop ebp	454	pop ebp
455	pop ecx	455	pop ecx
456		456
457	ret	457	ret
458	end if	458	end if
459	if 0	459	if 0
460	;===============================================================================	460	;===============================================================================
461	; float to ASCII conversion procedure	461	; float to ASCII conversion procedure
462	;	462	;
463	; input:	463	; input:
464	; buffer - pointer to memory where output will be saved	464	; buffer - pointer to memory where output will be saved
465	; precision - number of digits after dot	465	; precision - number of digits after dot
466	;	466	;
467	; output:	467	; output:
468	; no immediate output	468	; no immediate output
469	;	469	;
470	; notes:	470	; notes:
471	; separate integer and mantisa part with dot '.'	471	; separate integer and mantisa part with dot '.'
472	; so GOOD 123.456	472	; so GOOD 123.456
473	; WRONG 123,456	473	; WRONG 123,456
474	;	474	;
475	; coded by Reverend // HTB + RAG	475	; coded by Reverend // HTB + RAG
476	;===============================================================================	476	;===============================================================================
477	proc ftoa buffer, precision	477	proc ftoa buffer, precision
478	locals	478	locals
479	status_original dw ?	479	status_original dw ?
480	status_changed dw ?	480	status_changed dw ?
481	integer dd ?	481	integer dd ?
482	mantisa dd ?	482	mantisa dd ?
483	signed dd ?	483	signed dd ?
484	endl	484	endl
485	push eax ecx;edi ecx	485	push eax ecx;edi ecx
486	; --------------------------------	486	; --------------------------------
487	; set correct precision	487	; set correct precision
488	mov eax, [precision]	488	mov eax, [precision]
489	cmp eax, 51	489	cmp eax, 51
490	jb @F	490	jb @F
491	mov eax, 51	491	mov eax, 51
492	@@:	492	@@:
493	mov [precision], eax	493	mov [precision], eax
494	; --------------------------------	494	; --------------------------------
495	; change control wortd of fpu to prevent rounding	495	; change control wortd of fpu to prevent rounding
496	fnstcw [status_original]	496	fnstcw [status_original]
497	mov ax, [status_original]	497	mov ax, [status_original]
498	or ax, 0000110000000000b	498	or ax, 0000110000000000b
499	mov [status_changed], ax	499	mov [status_changed], ax
500	fldcw [status_changed]	500	fldcw [status_changed]

Subversion Repositories Kolibri OS

(root)/programs/demos/3DS/ASC.INC – Rev 5486 → 8014