forked from KolibriOS/kolibrios
2101 lines
46 KiB
NASM
2101 lines
46 KiB
NASM
;
|
|
; application : Caritas - flat shading, Gouraud shading,
|
|
; enviornament mapping, bump mapping
|
|
; compiler : FASM
|
|
; system : KolibriOS
|
|
; author : macgub alias Maciej Guba
|
|
; email : macgub3@wp.pl
|
|
; web : www.menuet.xt.pl
|
|
; Fell free to use this intro in your own distribution of KolibriOS.
|
|
; Special greetings to all MenuetOS maniax in the world.
|
|
; I hope because my intros Christian Belive will be near to each of You.
|
|
|
|
|
|
; Some adjustments made by Madis Kalme
|
|
; madis.kalme@mail.ee
|
|
; I tried optimizing it a bit, but don't know if it was successful. The objects
|
|
; can be:
|
|
; 1) Read from a file (*.3DS standard)
|
|
; 2) Written in manually (at the end of the code)
|
|
SIZE_X equ 350
|
|
SIZE_Y equ 350
|
|
TIMEOUT equ 4
|
|
ROUND equ 10
|
|
TEX_X equ 512 ; texture width
|
|
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
|
|
NON = 0
|
|
MMX = 1
|
|
|
|
Ext = MMX ;Ext={ NON | MMX}
|
|
|
|
use32
|
|
org 0x0
|
|
db 'MENUET01' ; 8 byte id
|
|
dd 0x01 ; header version
|
|
dd START ; start of code
|
|
dd I_END ; size of image
|
|
dd I_END ; memory for app
|
|
dd I_END ; esp
|
|
dd 0x0 , 0x0 ; I_Param , I_Icon
|
|
|
|
START: ; start of execution
|
|
cld
|
|
; call alloc_buffer_mem
|
|
call read_from_file
|
|
call init_triangles_normals
|
|
call init_point_normals
|
|
call init_envmap
|
|
mov edi,bumpmap
|
|
call calc_bumpmap
|
|
call calc_bumpmap_coords
|
|
call draw_window
|
|
|
|
|
|
still:
|
|
mov eax,23 ; wait here for event with timeout
|
|
mov ebx,TIMEOUT
|
|
cmp [speed_flag],1
|
|
jne .skip
|
|
mov eax,11
|
|
.skip:
|
|
int 0x40
|
|
|
|
cmp eax,1 ; redraw request ?
|
|
je red
|
|
cmp eax,2 ; key in buffer ?
|
|
je key
|
|
cmp eax,3 ; button in buffer ?
|
|
je button
|
|
|
|
jmp noclose
|
|
|
|
red: ; redraw
|
|
call draw_window
|
|
jmp noclose
|
|
|
|
key: ; key
|
|
mov eax,2 ; just read it and ignore
|
|
int 0x40
|
|
jmp noclose
|
|
|
|
button: ; button
|
|
mov eax,17 ; get id
|
|
int 0x40
|
|
|
|
cmp ah,1 ; button id=1 ?
|
|
jne .ch_another
|
|
|
|
mov eax,-1 ; close this program
|
|
int 0x40
|
|
.ch_another:
|
|
cmp ah,2
|
|
jne .ch_another1
|
|
inc [r_flag]
|
|
cmp [r_flag],3
|
|
jne noclose
|
|
mov [r_flag],0
|
|
.ch_another1:
|
|
cmp ah,3
|
|
jne .ch_another2
|
|
inc [dr_flag]
|
|
cmp [dr_flag],4
|
|
jne noclose
|
|
mov [dr_flag],0
|
|
.ch_another2:
|
|
cmp ah,4 ; toggle speed
|
|
jne @f
|
|
inc [speed_flag]
|
|
cmp [speed_flag],2
|
|
jne noclose
|
|
mov [speed_flag],0
|
|
@@:
|
|
cmp ah,5
|
|
jne @f ;scale-
|
|
mov [scale], dword 0.7
|
|
fninit
|
|
fld [sscale]
|
|
fmul [scale]
|
|
fstp [sscale]
|
|
call read_from_file
|
|
mov ax,[vect_x] ;-- last change
|
|
mov bx,[vect_y]
|
|
mov cx,[vect_z]
|
|
call add_vector
|
|
; call do_scale
|
|
@@:
|
|
cmp ah,6
|
|
jne @f ; scale+
|
|
mov [scale], dword 1.3
|
|
fninit
|
|
fld [sscale]
|
|
fmul [scale]
|
|
fstp [sscale]
|
|
call read_from_file
|
|
mov ax,[vect_x]
|
|
mov bx,[vect_y]
|
|
mov cx,[vect_z]
|
|
call add_vector
|
|
call init_triangles_normals
|
|
call init_point_normals
|
|
@@:
|
|
cmp ah,7
|
|
jne @f
|
|
xor ax,ax ;add vector to object and rotary point
|
|
mov bx,-10
|
|
xor cx,cx
|
|
call add_vector
|
|
sub [vect_y],10
|
|
sub [yo],10
|
|
@@:
|
|
cmp ah,8
|
|
jne @f
|
|
xor ax,ax
|
|
xor bx,bx
|
|
mov cx,10
|
|
call add_vector
|
|
add [vect_z],10
|
|
add [zo],10
|
|
@@:
|
|
cmp ah,9
|
|
jne @f
|
|
mov ax,-10
|
|
xor bx,bx
|
|
xor cx,cx
|
|
call add_vector
|
|
sub [vect_x],10
|
|
sub [xo],10
|
|
@@:
|
|
cmp ah,10
|
|
jne @f
|
|
mov ax,10
|
|
xor bx,bx
|
|
xor cx,cx
|
|
call add_vector
|
|
add [vect_x],10
|
|
add [xo],10
|
|
@@:
|
|
cmp ah,11
|
|
jne @f
|
|
xor ax,ax
|
|
xor bx,bx
|
|
mov cx,-10
|
|
call add_vector
|
|
sub [vect_z],10
|
|
sub [zo],10
|
|
@@:
|
|
cmp ah,12
|
|
jne @f
|
|
xor ax,ax
|
|
mov bx,10
|
|
xor cx,cx
|
|
call add_vector
|
|
add [vect_y],10
|
|
add [yo],10
|
|
@@:
|
|
cmp ah,13 ; change main color -
|
|
jne @f ; - lead color setting
|
|
cmp [max_color_r],245
|
|
jge @f
|
|
add [max_color_r],10
|
|
call init_envmap
|
|
@@:
|
|
cmp ah,14
|
|
jne @f
|
|
cmp [max_color_g],245
|
|
jge @f
|
|
add [max_color_g],10
|
|
call init_envmap
|
|
@@:
|
|
cmp ah,15
|
|
jne @f
|
|
cmp [max_color_b],245
|
|
jge @f
|
|
add [max_color_b],10
|
|
call init_envmap
|
|
@@:
|
|
cmp ah,16 ; change main color
|
|
jne @f
|
|
cmp [max_color_r],10
|
|
jle @f
|
|
sub [max_color_r],10
|
|
call init_envmap
|
|
@@:
|
|
cmp ah,17
|
|
jne @f
|
|
cmp [max_color_g],10
|
|
jle @f
|
|
sub [max_color_g],10
|
|
call init_envmap
|
|
@@:
|
|
cmp ah,18
|
|
jne @f
|
|
cmp [max_color_b],10
|
|
jle @f
|
|
sub [max_color_b],10
|
|
call init_envmap
|
|
@@:
|
|
cmp ah,19
|
|
jne @f
|
|
inc [catmull_flag]
|
|
cmp [catmull_flag],2
|
|
jne @f
|
|
mov [catmull_flag],0
|
|
@@:
|
|
noclose:
|
|
|
|
call calculate_angle ; calculates sinus and cosinus
|
|
call copy_point_normals
|
|
; copy normals and rotate the copy using sin/cosbeta - best way
|
|
call rotate_point_normals
|
|
cmp [dr_flag],2
|
|
jge @f
|
|
call calculate_colors
|
|
@@:
|
|
call copy_points
|
|
call rotate_points
|
|
call translate_perspective_points; translate from 3d to 2d
|
|
call clrscr ; clear the screen
|
|
cmp [catmull_flag],1 ;non sort if Catmull
|
|
je .no_sort
|
|
call sort_triangles
|
|
.no_sort:
|
|
call fill_Z_buffer ; make background
|
|
|
|
RDTSC
|
|
push eax
|
|
call draw_triangles ; draw all triangles from the list
|
|
|
|
RDTSC
|
|
sub eax,[esp]
|
|
sub eax,41
|
|
; lea esi,[debug_points]
|
|
; lea edi,[debug_points+6]
|
|
; lea ebx,[debug_vector1]
|
|
; call make_vector
|
|
; fninit
|
|
; fld [sinbeta_one]
|
|
; fimul [debug_dwd]
|
|
; fistp [debug_dd]
|
|
; movzx eax,[debug_dd]
|
|
|
|
|
|
mov ecx,10
|
|
.dc:
|
|
|
|
pop eax
|
|
macro show
|
|
{
|
|
mov eax,7 ; put image
|
|
mov ebx,screen
|
|
mov ecx,SIZE_X shl 16 + SIZE_Y
|
|
xor edx,edx
|
|
int 0x40
|
|
}
|
|
show
|
|
|
|
|
|
jmp still
|
|
|
|
;--------------------------------------------------------------------------------
|
|
;-------------------------PROCEDURES---------------------------------------------
|
|
;--------------------------------------------------------------------------------
|
|
include "tex3.ASM"
|
|
include "flat_cat.ASM"
|
|
include "grd_cat.ASM"
|
|
include "tex_cat.ASM"
|
|
include "bump_cat.ASM"
|
|
include "3dmath.asm"
|
|
include "grd3.asm"
|
|
include "flat3.asm"
|
|
include "bump3.asm"
|
|
include "b_procs.asm"
|
|
|
|
|
|
;alloc_buffer_mem:
|
|
; mov eax,68
|
|
; mov ebx,5
|
|
; mov ecx,SIZE_X*SIZE_Y*3
|
|
; int 0x40
|
|
; mov [screen],eax
|
|
;ret
|
|
calc_bumpmap_coords:
|
|
; fninit
|
|
mov esi,points
|
|
mov edi,tex_points
|
|
; @@:
|
|
; add esi,2
|
|
; fild word[esi]
|
|
; fmul [bump_scale]
|
|
; fistp word[edi]
|
|
; fild word[esi+2]
|
|
; fmul [bump_scale]
|
|
; fistp word[edi+2]
|
|
; add esi,4
|
|
; add edi,4
|
|
; cmp [esi],dword -1
|
|
; jnz @b
|
|
@@:
|
|
add esi,2
|
|
movsd
|
|
; add esi,2
|
|
cmp dword[esi],dword -1
|
|
jne @b
|
|
ret
|
|
;bump_scale dd 1.4 ;TEX_X/SIZE_X
|
|
|
|
init_envmap:
|
|
|
|
.temp equ word [ebp-2]
|
|
push ebp
|
|
mov ebp,esp
|
|
sub esp,2
|
|
mov edi,envmap
|
|
fninit
|
|
|
|
mov dx,-256
|
|
.ie_ver:
|
|
mov cx,-256
|
|
.ie_hor:
|
|
mov .temp,cx
|
|
fild .temp
|
|
fmul st,st0
|
|
mov .temp,dx
|
|
fild .temp
|
|
fmul st,st0
|
|
faddp
|
|
fsqrt
|
|
mov .temp,254
|
|
fisubr .temp
|
|
fmul [env_const]
|
|
fistp .temp
|
|
mov ax,.temp
|
|
|
|
or ax,ax
|
|
jge .ie_ok1
|
|
xor ax,ax
|
|
jmp .ie_ok2
|
|
.ie_ok1:
|
|
cmp ax,254
|
|
jle .ie_ok2
|
|
mov ax,254
|
|
.ie_ok2:
|
|
push dx
|
|
mov bx,ax
|
|
mul [max_color_b]
|
|
shr ax,8
|
|
stosb
|
|
mov ax,bx
|
|
mul [max_color_g]
|
|
shr ax,8
|
|
stosb
|
|
mov ax,bx
|
|
mul [max_color_r]
|
|
shr ax,8
|
|
stosb
|
|
pop dx
|
|
|
|
inc cx
|
|
cmp cx,256
|
|
jne .ie_hor
|
|
|
|
inc dx
|
|
cmp dx,256
|
|
jne .ie_ver
|
|
|
|
mov esp,ebp
|
|
pop ebp
|
|
macro debug
|
|
{
|
|
mov edi,envmap
|
|
mov ecx,512*512*3/4
|
|
mov eax,0xffffffff
|
|
rep stosd
|
|
}
|
|
ret
|
|
calculate_colors:
|
|
fninit
|
|
xor ebx,ebx
|
|
movzx ecx,[points_count_var]
|
|
lea ecx,[ecx*3]
|
|
add ecx,ecx
|
|
.cc_again:
|
|
mov esi,light_vector
|
|
lea edi,[point_normals_rotated+ebx*2]
|
|
call dot_product
|
|
fcom [dot_min]
|
|
fstsw ax
|
|
sahf
|
|
ja .cc_ok1
|
|
ffree st
|
|
mov dword[points_color+ebx],0
|
|
mov word[points_color+ebx+4],0
|
|
add ebx,6
|
|
cmp ebx,ecx
|
|
jne .cc_again
|
|
jmp .cc_done
|
|
.cc_ok1:
|
|
fcom [dot_max]
|
|
fstsw ax
|
|
sahf
|
|
jb .cc_ok2
|
|
ffree st
|
|
mov dword[points_color+ebx],0 ; clear r,g,b
|
|
mov word[points_color+ebx+4],0
|
|
add ebx,6
|
|
cmp ebx,ecx
|
|
jne .cc_again
|
|
jmp .cc_done
|
|
.cc_ok2:
|
|
fld st
|
|
fld st
|
|
fimul [max_color_r]
|
|
fistp word[points_color+ebx] ;each color as word
|
|
fimul [max_color_g]
|
|
fistp word[points_color+ebx+2]
|
|
fimul [max_color_b]
|
|
fistp word[points_color+ebx+4]
|
|
add ebx,6
|
|
cmp ebx,ecx
|
|
jne .cc_again
|
|
.cc_done:
|
|
ret
|
|
copy_point_normals:
|
|
movzx ecx,[points_count_var]
|
|
shl ecx,2
|
|
inc ecx
|
|
mov esi,point_normals
|
|
mov edi,point_normals_rotated
|
|
rep movsd
|
|
ret
|
|
rotate_point_normals:
|
|
movzx ecx,[points_count_var]
|
|
mov ebx,point_normals_rotated
|
|
fninit ; for now only rotate around Z axle
|
|
.again_r:
|
|
cmp [r_flag],1
|
|
je .z_rot
|
|
cmp [r_flag],2
|
|
je .x_rot
|
|
|
|
.y_rot:
|
|
fld dword[ebx] ; x
|
|
fld [sinbeta]
|
|
fmul dword[ebx+8] ; z * sinbeta
|
|
fchs
|
|
fld [cosbeta]
|
|
fmul dword[ebx] ; x * cosbeta
|
|
faddp
|
|
fstp dword[ebx] ; new x
|
|
fmul [sinbeta] ; old x * sinbeta
|
|
fld [cosbeta]
|
|
fmul dword[ebx+8] ; z * cosbeta
|
|
faddp
|
|
fstp dword[ebx+8] ; new z
|
|
add ebx,12
|
|
loop .y_rot
|
|
jmp .end_rot
|
|
.z_rot:
|
|
fld dword[ebx] ;x
|
|
fld [sinbeta]
|
|
fmul dword[ebx+4] ;y
|
|
fld [cosbeta]
|
|
fmul dword[ebx] ;x
|
|
faddp
|
|
fstp dword[ebx] ;new x
|
|
fmul [sinbeta] ; sinbeta * old x
|
|
fchs
|
|
fld [cosbeta]
|
|
fmul dword[ebx+4] ; cosbeta * y
|
|
faddp
|
|
fstp dword[ebx+4] ; new y
|
|
add ebx,12
|
|
loop .z_rot
|
|
jmp .end_rot
|
|
.x_rot:
|
|
fld dword[ebx+4] ;y
|
|
fld [sinbeta]
|
|
fmul dword[ebx+8] ;z
|
|
fld [cosbeta]
|
|
fmul dword[ebx+4] ;y
|
|
faddp
|
|
fstp dword[ebx+4] ; new y
|
|
fmul [sinbeta] ; sinbeta * old y
|
|
fchs
|
|
fld [cosbeta]
|
|
fmul dword[ebx+8]
|
|
faddp
|
|
fstp dword[ebx+8]
|
|
add ebx,12
|
|
loop .x_rot
|
|
.end_rot:
|
|
ret
|
|
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
|
|
|
|
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,point_normals
|
|
mov .point_number,0
|
|
.ipn_loop:
|
|
mov .hit_faces,0
|
|
mov .x,0
|
|
mov .y,0
|
|
mov .z,0
|
|
mov esi,triangles
|
|
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
|
|
|
|
fld .x
|
|
fadd dword[esi+vec_x]
|
|
fstp .x
|
|
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
|
|
|
|
add_vector:
|
|
mov ebp,points
|
|
@@:
|
|
add word[ebp],ax
|
|
add word[ebp+2],bx
|
|
add word[ebp+4],cx
|
|
add ebp,6
|
|
cmp dword[ebp],-1
|
|
jne @b
|
|
ret
|
|
;do_scale:
|
|
; fninit
|
|
; mov ebp,points
|
|
; .next_sc:
|
|
; fld1
|
|
; fsub [scale]
|
|
; fld st
|
|
; fimul [xo]
|
|
; fld [scale]
|
|
; fimul word[ebp] ;x
|
|
; faddp
|
|
; fistp word[ebp]
|
|
; fld st
|
|
; fimul [yo]
|
|
; fld [scale]
|
|
; fimul word[ebp+2]
|
|
; faddp
|
|
; fistp word[ebp+2]
|
|
; fimul [zo]
|
|
; fld [scale]
|
|
; fimul word[ebp+4]
|
|
; faddp
|
|
; fistp word[ebp+4]
|
|
; add ebp,6
|
|
; cmp dword[ebp],-1
|
|
; jne .next_sc
|
|
;ret
|
|
sort_triangles:
|
|
mov esi,triangles
|
|
mov edi,triangles_with_z
|
|
mov ebp,points_rotated
|
|
|
|
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]
|
|
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]; i
|
|
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
|
|
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
|
|
movq mm0,[trizdq+eax-4]
|
|
movq mm1,[trizdq+edx-4]
|
|
movq [trizdq+edx-4],mm0
|
|
movq [trizdq+eax-4],mm1
|
|
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
|
|
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
|
|
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]
|
|
.loop:
|
|
sub ecx,8 ; direction
|
|
cmp [trizdd+ecx],ebx
|
|
jl .loop ; direction
|
|
@@:
|
|
add ebp,8 ; direction
|
|
cmp [trizdd+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,[trizdq+ecx-4]
|
|
movq mm1,[trizdq+ebp-4]
|
|
movq [trizdq+ebp-4],mm0
|
|
movq [trizdq+ecx-4],mm1
|
|
end if
|
|
jmp .loop
|
|
@@:
|
|
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
|
|
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]
|
|
if Ext=NON
|
|
mov ecx,[trizdd+esi-4]
|
|
else
|
|
movq mm1,[trizdq+esi-4]
|
|
end if
|
|
mov edi,esi
|
|
@@:
|
|
cmp edi,eax
|
|
jna @f
|
|
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
|
|
movq mm0,[trizdq+edi-12]
|
|
movq [trizdq+edi-4],mm0
|
|
end if
|
|
sub edi,8
|
|
jmp @b
|
|
@@:
|
|
if Ext=NON
|
|
mov [trizdd+edi],ebx
|
|
mov [trizdd+edi-4],ecx
|
|
else
|
|
movq [trizdq+edi-4],mm1
|
|
end if
|
|
jmp .start
|
|
.exit:
|
|
ret
|
|
end_sort:
|
|
; translate triangles_with_z to sorted_triangles
|
|
mov esi,triangles_with_z
|
|
; mov edi,sorted_triangles
|
|
mov edi,triangles
|
|
again_copy:
|
|
if Ext=NON
|
|
movsd
|
|
movsw
|
|
add esi,2
|
|
else
|
|
movq mm0,[esi]
|
|
movq [edi],mm0
|
|
add esi,8
|
|
add edi,6
|
|
end if
|
|
cmp dword[esi],-1
|
|
jne again_copy
|
|
; if Ext=MMX
|
|
; emms
|
|
; end if
|
|
movsd ; copy end mark too
|
|
ret
|
|
|
|
clrscr:
|
|
mov edi,screen
|
|
mov ecx,SIZE_X*SIZE_Y*3/4
|
|
xor eax,eax
|
|
if Ext=NON
|
|
rep stosd
|
|
else
|
|
pxor mm0,mm0
|
|
@@:
|
|
movq [edi+00],mm0
|
|
movq [edi+08],mm0
|
|
movq [edi+16],mm0
|
|
movq [edi+24],mm0
|
|
add edi,32
|
|
sub ecx,8
|
|
jnc @b
|
|
end if
|
|
ret
|
|
|
|
calculate_angle:
|
|
fninit
|
|
; fldpi
|
|
; fidiv [i180]
|
|
fld [piD180]
|
|
fimul [angle_counter]
|
|
fsincos
|
|
fstp [sinbeta]
|
|
fstp [cosbeta]
|
|
inc [angle_counter]
|
|
cmp [angle_counter],360
|
|
jne end_calc_angle
|
|
mov [angle_counter],0
|
|
end_calc_angle:
|
|
ret
|
|
|
|
rotate_points:
|
|
fninit
|
|
mov ebx,points_rotated
|
|
again_r:
|
|
cmp [r_flag],1
|
|
je .z_rot
|
|
cmp [r_flag],2
|
|
je .x_rot
|
|
.y_rot:
|
|
mov eax,[ebx+2] ;z
|
|
mov ax,word[ebx] ;x
|
|
sub eax,dword[xo]
|
|
mov dword[xsub],eax
|
|
fld [sinbeta]
|
|
fimul [zsub]
|
|
fchs
|
|
fld [cosbeta]
|
|
fimul [xsub]
|
|
faddp
|
|
fiadd [xo]
|
|
fistp word[ebx] ;x
|
|
fld [sinbeta]
|
|
fimul [xsub]
|
|
fld [cosbeta]
|
|
fimul [zsub]
|
|
faddp
|
|
fiadd [zo]
|
|
fistp word[ebx+4] ;z
|
|
jmp .end_rot
|
|
.z_rot:
|
|
mov ax,word[ebx]
|
|
sub ax,word[xo] ;need optimization
|
|
mov [xsub],ax
|
|
mov ax,word[ebx+2]
|
|
sub ax,word[yo]
|
|
mov [ysub],ax
|
|
fld [sinbeta]
|
|
fimul [ysub]
|
|
fld [cosbeta]
|
|
fimul [xsub]
|
|
faddp
|
|
fiadd [xo]
|
|
fistp word[ebx]
|
|
fld [cosbeta]
|
|
fimul [ysub]
|
|
fld [sinbeta]
|
|
fimul [xsub]
|
|
fchs
|
|
faddp
|
|
fiadd [yo]
|
|
fistp word[ebx+2]
|
|
jmp .end_rot
|
|
.x_rot:
|
|
mov ax,word[ebx+2]
|
|
sub ax,[yo]
|
|
mov [ysub],ax
|
|
mov ax,word[ebx+4]
|
|
sub ax,word[zo]
|
|
mov [zsub],ax
|
|
fld [sinbeta]
|
|
fimul [zsub]
|
|
fld [cosbeta]
|
|
fimul [ysub]
|
|
faddp
|
|
fiadd [yo]
|
|
fistp word[ebx+2];y
|
|
fld [cosbeta]
|
|
fimul [zsub]
|
|
fld [sinbeta]
|
|
fimul [ysub]
|
|
fchs
|
|
faddp
|
|
fiadd [zo]
|
|
fistp word[ebx+4]
|
|
.end_rot:
|
|
add ebx,6
|
|
cmp dword[ebx],-1
|
|
jne again_r
|
|
ret
|
|
|
|
draw_triangles:
|
|
mov esi,triangles
|
|
.again_dts:
|
|
mov ebp,points_rotated
|
|
if Ext=NON
|
|
movzx eax,word[esi]
|
|
mov [point_index1],ax
|
|
lea eax,[eax*3]
|
|
add eax,eax
|
|
push ebp
|
|
add ebp,eax
|
|
mov eax,[ebp]
|
|
mov dword[xx1],eax
|
|
mov eax,[ebp+4]
|
|
mov [zz1],ax
|
|
pop ebp
|
|
|
|
|
|
movzx eax,word[esi+2]
|
|
mov [point_index2],ax
|
|
lea eax,[eax*3]
|
|
add eax,eax
|
|
push ebp
|
|
add ebp,eax
|
|
mov eax,[ebp]
|
|
mov dword[xx2],eax
|
|
mov eax,[ebp+4]
|
|
mov [zz2],ax
|
|
pop ebp
|
|
|
|
|
|
movzx eax,word[esi+4] ; xyz3 = [ebp+[esi+4]*6]
|
|
mov [point_index3],ax
|
|
lea eax,[eax*3]
|
|
add eax,eax
|
|
; push ebp
|
|
add ebp,eax
|
|
mov eax,[ebp]
|
|
mov dword[xx3],eax
|
|
mov eax,[ebp+4]
|
|
mov [zz3],ax
|
|
else
|
|
mov eax,dword[esi] ; don't know MMX
|
|
mov dword[point_index1],eax
|
|
; shr eax,16
|
|
; mov [point_index2],ax
|
|
mov ax,word[esi+4]
|
|
mov [point_index3],ax
|
|
movq mm0,[esi]
|
|
pmullw mm0,qword[const6]
|
|
movd eax,mm0
|
|
psrlq mm0,16
|
|
movd ebx,mm0
|
|
psrlq mm0,16
|
|
movd ecx,mm0
|
|
and eax,0FFFFh
|
|
and ebx,0FFFFh
|
|
and ecx,0FFFFh
|
|
movq mm0,[ebp+eax]
|
|
movq mm1,[ebp+ebx]
|
|
movq mm2,[ebp+ecx]
|
|
movq qword[xx1],mm0
|
|
movq qword[xx2],mm1
|
|
movq qword[xx3],mm2
|
|
; emms
|
|
end if
|
|
push esi
|
|
; culling
|
|
fninit
|
|
mov esi,point_index1
|
|
mov ecx,3
|
|
@@:
|
|
movzx eax,word[esi]
|
|
lea eax,[eax*3]
|
|
shl eax,2
|
|
lea eax,[eax+point_normals_rotated]
|
|
fld dword[eax+8] ; I check Z element of normal vector
|
|
ftst
|
|
fstsw ax
|
|
sahf
|
|
jb @f
|
|
ffree st
|
|
loop @b
|
|
jmp .end_draw
|
|
@@:
|
|
ffree st ;is visable
|
|
|
|
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 [catmull_flag],1
|
|
je @f
|
|
|
|
movzx edi,[point_index3] ; do gouraud shading catmull off
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
push word[edi]
|
|
push word[edi+2]
|
|
push word[edi+4]
|
|
movzx edi,[point_index2]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
push word[edi]
|
|
push word[edi+2]
|
|
push word[edi+4]
|
|
movzx edi,[point_index1]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
push word[edi]
|
|
push word[edi+2]
|
|
push word[edi+4]
|
|
jmp .both_draw
|
|
@@:
|
|
movzx edi,[point_index3] ; do gouraud shading catmull on
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
push [zz3]
|
|
push word[edi]
|
|
push word[edi+2]
|
|
push word[edi+4]
|
|
movzx edi,[point_index2]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
push [zz2]
|
|
push word[edi]
|
|
push word[edi+2]
|
|
push word[edi+4]
|
|
movzx edi,[point_index1]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
push [zz1]
|
|
push word[edi]
|
|
push word[edi+2]
|
|
push word[edi+4]
|
|
|
|
; 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 [max_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 [max_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 [max_color_r]
|
|
; fistp [temp_col]
|
|
; and [temp_col],0x00ff
|
|
; push [temp_col]
|
|
; push [temp_col]
|
|
; push [temp_col]
|
|
|
|
; xor edx,edx ; draw acording to position
|
|
; mov ax,[zz3]
|
|
; add ax,128
|
|
; neg al
|
|
; and ax,0x00ff
|
|
; push ax
|
|
; neg al
|
|
; push ax
|
|
; mov dx,[yy3]
|
|
; and dx,0x00ff
|
|
; push dx
|
|
; mov ax,[zz2]
|
|
; add ax,128
|
|
; neg al
|
|
; and ax,0x00ff
|
|
; push ax
|
|
; neg al
|
|
; push ax
|
|
; mov dx,[yy2]
|
|
; and dx,0x00ff
|
|
; push dx
|
|
; mov ax,[zz1]
|
|
; add ax,128
|
|
; neg al
|
|
; and ax,0x00ff
|
|
; push ax
|
|
; neg al
|
|
; push ax
|
|
; mov dx,[yy1]
|
|
; and dx,0x00ff
|
|
; push dx
|
|
.both_draw:
|
|
mov eax,dword[xx1]
|
|
ror eax,16
|
|
mov ebx,dword[xx2]
|
|
ror ebx,16
|
|
mov ecx,dword[xx3]
|
|
ror ecx,16
|
|
lea edi,[screen]
|
|
cmp [catmull_flag],0
|
|
je @f
|
|
lea esi,[Z_buffer]
|
|
call gouraud_triangle_z
|
|
jmp .end_draw
|
|
@@:
|
|
call gouraud_triangle
|
|
jmp .end_draw
|
|
|
|
.flat_draw:
|
|
movzx edi,[point_index3]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
movzx eax,word[edi]
|
|
movzx ebx,word[edi+2]
|
|
movzx ecx,word[edi+4]
|
|
movzx edi,[point_index2]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
add ax,word[edi]
|
|
add bx,word[edi+2]
|
|
add cx,word[edi+4]
|
|
movzx edi,[point_index1]
|
|
lea edi,[edi*3]
|
|
lea edi,[points_color+edi*2]
|
|
add ax,word[edi]
|
|
add bx,word[edi+2]
|
|
add cx,word[edi+4]
|
|
cwd
|
|
idiv [i3]
|
|
mov di,ax
|
|
shl edi,16
|
|
mov ax,bx
|
|
cwd
|
|
idiv [i3]
|
|
mov di,ax
|
|
shl di,8
|
|
mov ax,cx
|
|
cwd
|
|
idiv [i3]
|
|
mov edx,edi
|
|
mov dl,al
|
|
and edx,0x00ffffff
|
|
|
|
|
|
; mov ax,[zz1] ; z position depend draw
|
|
; add ax,[zz2]
|
|
; add ax,[zz3]
|
|
; cwd
|
|
; idiv [i3] ; = -((a+b+c)/3+130)
|
|
; add ax,130
|
|
; neg al
|
|
; xor edx,edx
|
|
; mov ah,al ;set color according to z position
|
|
; shl eax,8
|
|
; mov edx,eax
|
|
|
|
mov eax,dword[xx1]
|
|
ror eax,16
|
|
mov ebx,dword[xx2]
|
|
ror ebx,16
|
|
mov ecx,dword[xx3]
|
|
ror ecx,16
|
|
; mov edi,screen
|
|
lea edi,[screen]
|
|
cmp [catmull_flag],0
|
|
je @f
|
|
lea esi,[Z_buffer]
|
|
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,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
|
|
|
|
mov eax,dword[xx1]
|
|
ror eax,16
|
|
mov ebx,dword[xx2]
|
|
ror ebx,16
|
|
mov ecx,dword[xx3]
|
|
ror ecx,16
|
|
mov edi,screen
|
|
mov esi,envmap
|
|
cmp [catmull_flag],0
|
|
je @f
|
|
mov edx,Z_buffer
|
|
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 [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,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]
|
|
shl esi,2
|
|
add esi,tex_points
|
|
push dword[esi]
|
|
movzx esi,[point_index2]
|
|
shl esi,2
|
|
add esi,tex_points
|
|
; lea esi,[esi*3]
|
|
; lea esi,[points+2+esi*2]
|
|
push dword[esi]
|
|
; push dword[xx2]
|
|
movzx esi,[point_index1]
|
|
shl esi,2
|
|
add esi,tex_points
|
|
; lea esi,[esi*3]
|
|
; lea esi,[points+2+esi*2]
|
|
push dword[esi]
|
|
; push dword[xx1]
|
|
|
|
mov eax,dword[xx1]
|
|
ror eax,16
|
|
mov ebx,dword[xx2]
|
|
ror ebx,16
|
|
mov ecx,dword[xx3]
|
|
ror ecx,16
|
|
mov edi,screen
|
|
mov esi,envmap
|
|
mov edx,bumpmap ;BUMP_MAPPING
|
|
|
|
cmp [catmull_flag],0
|
|
je @f
|
|
call bump_triangle_z
|
|
jmp .end_draw
|
|
@@:
|
|
call bump_triangle
|
|
|
|
.end_draw:
|
|
pop esi
|
|
add esi,6
|
|
cmp dword[esi],-1
|
|
jne .again_dts
|
|
ret
|
|
translate_points:
|
|
; fninit
|
|
; mov ebx,points_rotated
|
|
; again_trans:
|
|
; fild word[ebx+4] ;z1
|
|
; fmul [sq]
|
|
; fld st
|
|
; fiadd word[ebx] ;x1
|
|
; fistp word[ebx]
|
|
; fchs
|
|
; fiadd word[ebx+2] ;y1
|
|
; fistp word[ebx+2] ;y1
|
|
|
|
; add ebx,6
|
|
; cmp dword[ebx],-1
|
|
; jne again_trans
|
|
;ret
|
|
translate_perspective_points: ;translate points from 3d to 2d using
|
|
fninit ;perspective equations
|
|
mov ebx,points_rotated
|
|
.again_trans:
|
|
fild word[ebx]
|
|
fisub [xobs]
|
|
fimul [zobs]
|
|
fild word[ebx+4]
|
|
fisub [zobs]
|
|
fdivp
|
|
fiadd [xobs]
|
|
fistp word[ebx]
|
|
fild word[ebx+2]
|
|
fisub [yobs]
|
|
fimul [zobs]
|
|
fild word[ebx+4]
|
|
fisub [zobs]
|
|
fdivp
|
|
fchs
|
|
fiadd [yobs]
|
|
fistp word[ebx+2]
|
|
add ebx,6
|
|
cmp dword[ebx],-1
|
|
jne .again_trans
|
|
ret
|
|
|
|
|
|
copy_points:
|
|
mov esi,points
|
|
mov edi,points_rotated
|
|
mov ecx,points_count*3+2
|
|
rep movsw
|
|
ret
|
|
|
|
|
|
|
|
read_from_file:
|
|
mov edi,triangles
|
|
xor ebx,ebx
|
|
xor ebp,ebp
|
|
mov esi,SourceFile
|
|
cmp [esi],word 4D4Dh
|
|
jne .exit ;Must be legal .3DS file
|
|
cmp dword[esi+2],EndFile-SourceFile
|
|
jne .exit ;This must tell the length
|
|
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]
|
|
mov [points_count_var],cx
|
|
mov edx,ecx
|
|
add esi,8
|
|
@@:
|
|
fld dword[esi+4]
|
|
fmul [sscale]
|
|
fadd [xoffset]
|
|
fld dword[esi+8]
|
|
fchs
|
|
fmul [sscale]
|
|
fadd [yoffset]
|
|
fld dword[esi+0]
|
|
fchs
|
|
fmul [sscale]
|
|
fistp word[points+ebx+4]
|
|
fistp word[points+ebx+2]
|
|
fistp word[points+ebx+0]
|
|
add ebx,6
|
|
add esi,12
|
|
dec ecx
|
|
jnz @b
|
|
@@:
|
|
mov dword[points+ebx],-1
|
|
@@:
|
|
cmp [esi],word 4120h
|
|
je @f
|
|
add esi,[esi+2]
|
|
jmp @b
|
|
@@:
|
|
movzx ecx,word[esi+6]
|
|
mov [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
|
|
|
|
.exit:
|
|
mov dword[edi],-1
|
|
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
|
|
|
|
; SKIN WIDTH
|
|
mov eax,48
|
|
mov ebx,4
|
|
int 0x40
|
|
mov esi, eax
|
|
|
|
; DRAW WINDOW
|
|
mov eax,0 ; function 0 : define and draw window
|
|
mov ebx,100*65536+SIZE_X+9+80 ; [x start] *65536 + [x size]
|
|
mov ecx,100*65536+SIZE_Y+4 ; [y start] *65536 + [y size]
|
|
add ecx, esi
|
|
mov edx,0x74000000 ; color of work area RRGGBB,8->color gl
|
|
mov edi,labelt
|
|
int 0x40
|
|
|
|
; BLACK BAR
|
|
mov eax,13 ; function 8 : define and draw button
|
|
mov ebx,SIZE_X*65536+80 ; [x start] *65536 + [x size]
|
|
mov ecx,0*65536+SIZE_Y ; [y start] *65536 + [y size]
|
|
mov edx,0 ; color RRGGBB
|
|
int 0x40
|
|
|
|
; ROTARY BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62 ; [x start] *65536 + [x size]
|
|
mov ecx,25*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,2 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
; ROTARY LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+28 ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelrot ; pointer to text beginning
|
|
mov esi,labelrotend-labelrot ; text length
|
|
int 0x40
|
|
|
|
; DRAW MODE BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,3 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
; DRAW MODE LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+28+15 ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labeldrmod ; pointer to text beginning
|
|
mov esi,labeldrmodend-labeldrmod ; text length
|
|
int 0x40
|
|
|
|
; SPEED BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*2)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,4 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
; SPEED MODE LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*2) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelspeedmod ; pointer to text beginning
|
|
mov esi,labelspeedmodend-labelspeedmod ; text length
|
|
int 0x40
|
|
|
|
; SCALE- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*3)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,5 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
; SCALE- MODE LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*3) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelzoomout ; pointer to text beginning
|
|
mov esi,labelzoomoutend-labelzoomout ; text length
|
|
int 0x40
|
|
|
|
; SCALE+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*4)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,6 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
; SCALE+ MODE LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*4) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelzoomin ; pointer to text beginning
|
|
mov esi,labelzoominend-labelzoomin ; text length
|
|
int 0x40
|
|
; ADD VECTOR LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*5) ; [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
|
|
int 0x40
|
|
; VECTOR Y- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+20)*65536+62-42 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*6)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,7 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;VECTOR Y- LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+20)*65536+(28+15*6) ; [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
|
|
int 0x40
|
|
; VECTOR Z+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+41)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*6)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,8 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;VECTOR Z+ LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+41)*65536+(28+15*6) ; [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
|
|
int 0x40
|
|
; VECTOR x- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*7)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,9 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;VECTOR x- LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*7) ; [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
|
|
int 0x40
|
|
; VECTOR x+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+41)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*7)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,10 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;VECTOR x+ LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+41)*65536+(28+15*7) ; [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
|
|
int 0x40
|
|
; VECTOR z- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*8)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,11 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;VECTOR z- LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*8) ; [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
|
|
int 0x40
|
|
;VECTOR Y+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+20)*65536+62-42 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*8)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,12 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;VECTOR Y+ LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+20)*65536+(28+15*8) ; [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
|
|
int 0x40
|
|
; LEAD COLOR LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*9) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelmaincolor ; pointer to text beginning
|
|
mov esi,labelmaincolorend-labelmaincolor ; text length
|
|
int 0x40
|
|
|
|
;RED+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*10)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,13 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;RED+ LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*10) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelredplus ; pointer to text beginning
|
|
mov esi,labelredplusend-labelredplus ; text length
|
|
int 0x40
|
|
;GREEN+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+20)*65536+62-42 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*10)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,14 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;GREEN+ LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+20)*65536+(28+15*10) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelgreenplus ; pointer to text beginning
|
|
mov esi,labelgreenplusend-labelgreenplus ; text length
|
|
int 0x40
|
|
;BLUE+ BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+41)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*10)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,15 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;BLUE+ LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+41)*65536+(28+15*10) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelblueplus ; pointer to text beginning
|
|
mov esi,labelblueplusend-labelblueplus ; text length
|
|
int 0x40
|
|
;RED- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*11)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,16 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;RED- LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*11) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelredminus ; pointer to text beginning
|
|
mov esi,labelredminusend-labelredminus ; text length
|
|
int 0x40
|
|
;GREEN- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+20)*65536+62-42 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*11)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,17 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;GREEN- LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+20)*65536+(28+15*11) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelgreenminus ; pointer to text beginning
|
|
mov esi,labelgreenminusend-labelgreenminus ; text length
|
|
int 0x40
|
|
;BLUE- BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10+41)*65536+62-41 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*11)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,18 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
;BLUE- LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12+41)*65536+(28+15*11) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelblueminus ; pointer to text beginning
|
|
mov esi,labelblueminusend-labelblueminus ; text length
|
|
int 0x40
|
|
; Catmull LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*12) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelcatmullmod ; pointer to text beginning
|
|
mov esi,labelcatmullmodend-labelcatmullmod ; text length
|
|
int 0x40
|
|
; on/off BUTTON
|
|
mov eax,8 ; function 8 : define and draw button
|
|
mov ebx,(SIZE_X+10)*65536+62 ; [x start] *65536 + [x size]
|
|
mov ecx,(25+15*13)*65536+12 ; [y start] *65536 + [y size]
|
|
mov edx,19 ; button id
|
|
mov esi,0x6688dd ; button color RRGGBB
|
|
int 0x40
|
|
; on/off LABEL
|
|
mov eax,4 ; function 4 : write text to window
|
|
mov ebx,(SIZE_X+12)*65536+(28+15*13) ; [x start] *65536 + [y start]
|
|
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
|
|
mov edx,labelonoff ; pointer to text beginning
|
|
mov esi,labelonoffend-labelonoff ; text length
|
|
int 0x40
|
|
|
|
|
|
mov eax,12 ; function 12:tell os about windowdraw
|
|
mov ebx,2 ; 2, end of draw
|
|
int 0x40
|
|
|
|
ret
|
|
|
|
|
|
; DATA AREA
|
|
i3 dw 3
|
|
light_vector dd 0.0,0.0,-1.0
|
|
; debug_vector dd 0.0,2.0,2.0 ;--debug
|
|
; debug_vector1 dd 0.0,0.0,0.0
|
|
; debug_points dw 1,1,1,3,4,20
|
|
; debug_dd dw ?
|
|
; debug_dwd dd 65535
|
|
; debug_counter dw 0
|
|
dot_max dd 1.0 ; dot product max and min
|
|
dot_min dd 0.0
|
|
env_const dd 1.2
|
|
correct_tex dw 255
|
|
max_color_r dw 255
|
|
max_color_g dw 25
|
|
max_color_b dw 35
|
|
xobs dw SIZE_X / 2 ;200 ;observer
|
|
yobs dw SIZE_Y / 2 ;200 ;coordinates
|
|
zobs dw -500
|
|
|
|
|
|
angle_counter dw 0
|
|
piD180 dd 0.017453292519943295769236907684886
|
|
; sq dd 0.70710678118654752440084436210485
|
|
const6 dw 6,6,6,6
|
|
xo dw 150;87 ; rotary point coodinates
|
|
zo dw 0
|
|
yo dw 100
|
|
xoffset dd 150.0
|
|
yoffset dd 170.0
|
|
sscale dd 8.0 ; real scale
|
|
vect_x dw 0
|
|
vect_y dw 0
|
|
vect_z dw 0
|
|
|
|
|
|
r_flag db 0 ; rotary flag
|
|
dr_flag db 2 ; drawing mode flag
|
|
speed_flag db 0
|
|
catmull_flag db 1
|
|
SourceFile file 'hrt.3ds'
|
|
EndFile:
|
|
labelrot:
|
|
db 'rotary'
|
|
labelrotend:
|
|
labeldrmod:
|
|
db 'shd. mode'
|
|
labeldrmodend:
|
|
labelspeedmod:
|
|
db 'speed'
|
|
labelspeedmodend:
|
|
labelzoomout:
|
|
db 'zoom out'
|
|
labelzoomoutend:
|
|
labelzoomin:
|
|
db 'zoom in'
|
|
labelzoominend:
|
|
labelvector:
|
|
db 'add vector'
|
|
labelvectorend:
|
|
labelyminus:
|
|
db 'y -'
|
|
labelyminusend:
|
|
labelzplus:
|
|
db 'z +'
|
|
labelzplusend:
|
|
labelxminus:
|
|
db 'x -'
|
|
labelxminusend:
|
|
labelxplus:
|
|
db 'x +'
|
|
labelxplusend:
|
|
labelzminus:
|
|
db 'z -'
|
|
labelzminusend:
|
|
labelyplus:
|
|
db 'y +'
|
|
labelyplusend:
|
|
labelmaincolor:
|
|
db 'main color'
|
|
labelmaincolorend:
|
|
labelredplus:
|
|
db 'r +'
|
|
labelredplusend:
|
|
labelgreenplus:
|
|
db 'g +'
|
|
labelgreenplusend:
|
|
labelblueplus:
|
|
db 'b +'
|
|
labelblueplusend:
|
|
labelredminus:
|
|
db 'r -'
|
|
labelredminusend:
|
|
labelgreenminus:
|
|
db 'g -'
|
|
labelgreenminusend:
|
|
labelblueminus:
|
|
db 'b -'
|
|
labelblueminusend:
|
|
labelcatmullmod:
|
|
db 'catmull'
|
|
labelcatmullmodend:
|
|
labelonoff:
|
|
db 'on/off'
|
|
labelonoffend:
|
|
labelt:
|
|
db 'Ave cruce salus mea',0
|
|
align 8
|
|
@col dd ?
|
|
@y1 dw ?
|
|
@x1 dw ?;+8
|
|
@y2 dw ?
|
|
@x2 dw ?
|
|
@y3 dw ?
|
|
@x3 dw ?;+16
|
|
|
|
@dx12 dd ?
|
|
@dx13 dd ?;+24
|
|
@dx23 dd ?
|
|
|
|
sinbeta dd ?;+32
|
|
cosbeta dd ?
|
|
|
|
xsub dw ?
|
|
zsub dw ?;+40
|
|
ysub dw ?
|
|
|
|
xx1 dw ?
|
|
yy1 dw ?
|
|
zz1 dw ?;+48
|
|
xx2 dw ?
|
|
yy2 dw ?
|
|
zz2 dw ?
|
|
xx3 dw ?;+56
|
|
yy3 dw ?
|
|
zz3 dw ?
|
|
scale dd ? ; help scale variable
|
|
;screen dd ? ;pointer to screen buffer
|
|
triangles_count_var dw ?
|
|
points_count_var dw ?
|
|
|
|
|
|
point_index1 dw ? ;-\
|
|
point_index2 dw ? ; } don't change order
|
|
point_index3 dw ? ;-/
|
|
temp_col dw ?
|
|
high dd ?
|
|
align 8
|
|
buffer dq ?
|
|
|
|
;err dd ?
|
|
drr dd ?
|
|
xx dd ?
|
|
yy dd ?
|
|
xst dd ?
|
|
yst dd ?
|
|
align 16
|
|
points:
|
|
rw (EndFile-SourceFile)/12*3
|
|
points_count = ($-points)/6
|
|
triangles:
|
|
rw (EndFile-SourceFile)/12*3
|
|
triangles_count = ($-triangles)/6
|
|
|
|
align 16
|
|
points_rotated rw points_count*3 + 2
|
|
align 16
|
|
label trizdd dword
|
|
label trizdq qword
|
|
triangles_with_z rw triangles_count*4 + 2 ; triangles triple dw + z position
|
|
align 16
|
|
triangles_normals rb triangles_count * 12 ;
|
|
point_normals rb points_count * 12 ;one 3dvector - triple float dword x,y,z
|
|
align 16
|
|
point_normals_rotated rb points_count * 12
|
|
align 16
|
|
vectors rb 24
|
|
points_color rb 6*points_count ; each color as word
|
|
; sorted_triangles rw triangles_count*3 + 2
|
|
;align 16
|
|
bumpmap rb TEXTURE_SIZE + 1
|
|
envmap rb (TEXTURE_SIZE +1) * 3
|
|
tex_points rb points_count * 4 ; bump_map points
|
|
; each point word x, word y
|
|
screen rb SIZE_X * SIZE_Y * 3 ; screen buffer
|
|
Z_buffer rb SIZE_X * SIZE_Y * 4
|
|
memStack rb 1000 ;memory area for stack
|
|
I_END:
|