; application : View3ds ver. 0.076 - 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 : http://macgub.co.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) ; now not exist
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
SSE3 = 4
Ext = SSE3 ;Ext={ NON | MMX | SSE | SSE2 | SSE3 }
; For now correct only SSE2 and SSE3 versions. if you have older CPU
; use older versions of app. Probably ver 005 will be OK but it need
; re-edit to support new Kolibri features.
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
rdtsc
mov [rand_seed],ax
cld
push dword (SIZE_Y shr 3) * 3
fninit
fild dword[esp]
fstp [rsscale]
pop ebx
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:
call generate_object
jmp .opt
.asc:
mov [triangles_count_var],10000 ; to do: read asc header
mov [points_count_var],10000
call alloc_mem_for_tp
call read_asc
jmp .opt
.malloc:
call alloc_mem_for_tp
call read_from_file
.opt:
call optimize_object1 ; proc in file b_procs.asm
; set point(0,0,0) in center and calc all coords
; to be in <-1.0,1.0>
call normalize_all_light_vectors
call copy_lights ; to aligned float
call init_triangles_normals2
if Ext >= SSE2
call detect_chunks
mov [chunks_number],ecx
mov [chunks_ptr],ebx
; esi - tri_ch
; edi - t_ptr - every vertice index - pointer to to all triangles
; that have this index
end if
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
if Ext >= SSE3
call init_point_lights
mov [fire_flag],0 ; proteza
end if
mov edi,bumpmap
call calc_bumpmap
call calc_bumpmap_coords ; bump and texture mapping
call do_edges_list
call draw_window
if Ext > SSE2
mov eax,1
cpuid
bt ecx,0 ; is sse3 on board?
jc @f
mov byte[max_dr_flg],12
mov [isSSE3],0
@@:
end if
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
if Ext > SSE2
cmp [ray_shd_flag],1
jne @f
cmp [isSSE3],1
jne @f
mov eax,10
jmp .intt
end if
@@:
mov eax,23
mov ebx,TIMEOUT
cmp [speed_flag],0
je .skip
mov eax,11
.skip:
cmp [edit_flag],1
jne @f
mov eax,10
@@:
.intt:
int 0x40
cmp eax,1 ; redraw event ?
je red
cmp eax,2 ; key event ?
je key
cmp eax,3 ; button event ?
je button
mov esi,eax
mov eax,37
mov ebx,7 ; get mouse scroll
int 0x40
and eax, 0xFFFF ; check only vertial
cmp eax, 65535
je button.zoom_in
cmp eax, 1
je button.zoom_out
mov eax,esi
cmp eax,6 ; mouse event ?
jne @f
cmp [edit_flag],1 ; handle mouse only when edit is active
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,225
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
shr eax,16 ; use scancodes (al)
cmp al, 013 ;+
je button.zoom_in
cmp al, 012 ;-
je button.zoom_out
cmp al, 075 ;left
je add_vec_buttons.x_minus
cmp al, 077 ;right
je add_vec_buttons.x_plus
cmp al, 072 ;up
je add_vec_buttons.y_minus
cmp al, 080 ;down
je add_vec_buttons.y_plus
cmp al, 073 ;page up
je .rot_inc_y
cmp al, 081 ;page down
je .rot_dec_y
cmp al, 051 ;<
je .rot_dec_x
cmp al, 052 ;>
je .rot_inc_x
cmp al, 057 ;space
je .rot_z
jmp noclose
.rot_inc_x:
inc [angle_x]
and [angle_x],0xff
jmp noclose.end_rot
.rot_dec_x:
dec [angle_x]
and [angle_x],0xff
jmp noclose.end_rot
.rot_inc_y:
inc [angle_y]
and [angle_y],0xff
jmp noclose.end_rot
.rot_dec_y:
dec [angle_y]
and [angle_y],0xff
jmp noclose.end_rot
.rot_z:
inc [angle_z]
and [angle_z],0xff
jmp noclose.end_rot
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
.zoom_out:
mov dword[scale],0.7
fninit
fld [rsscale]
fmul [scale]
fstp [rsscale]
@@:
cmp ah,6 ; ah = 6 -> scale+
jne @f
.zoom_in:
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 copy_lights
if Ext >= SSE3
call init_point_lights ; for ex. ray casting
end if
call do_color_buffer ; intit color_map ; 'tex ' 4
call init_envmap2 ; update env map if shading model = environment or bump
.next_m5:
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
.xchg:
call exchange
@@:
cmp ah,15
jne @f
cmp [emboss_flag],1
; call init_envmap2
call do_emboss
@@:
; 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
mov [re_alloc_flag],1 ; reallocate memory
mov [triangles_count_var],20000
mov [points_count_var],20000
call alloc_mem_for_tp
mov [re_alloc_flag],0
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 eax,bl ; eax < - 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
call do_edges_list
call write_info
.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
.y_minus:
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
.x_minus:
sub word[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
.x_plus:
add word[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
.y_plus:
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
mov 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
mov ecx,[points_count_var]
call rotary
mov esi,[points_rotated_ptr]
mov edi,[points_translated_ptr]
mov ecx,[points_count_var]
call translate_points
cmp [fire_flag],0
jne @f
call clrscr ; clear the screen
@@:
; cmp [catmull_flag],1 ;non sort if Catmull = on
; je .no_sort
; 64 indexes call sort_triangles
.no_sort:
cmp [dr_flag],7 ; fill if 2tex and texgrd
jge @f
cmp [dr_flag],6 ; non fill if dots
je .non_f
@@:
call fill_Z_buffer ; make background
.non_f:
cmp [dr_flag],6
jne @f
call draw_dots
jmp .blurrr
@@:
if Ext > SSE2
cmp [ray_shd_flag],1 ;non fill if Catmull = off
jne @f
cmp [isSSE3],1
jne @f
mov ax,100
jmp .dr
@@:
end if
movzx ax,[dr_flag]
.dr:
call draw_triangles ; draw all triangles from the list
cmp [edit_flag],0
jz .no_edit
call clear_vertices_index
movzx eax,[dr_flag]
movzx ebx,[ray_shd_flag]
shl ebx,10
or eax,ebx
call draw_handlers
; call edit
.no_edit:
.blurrr:
movzx eax,[dr_flag]
movzx ebx,[ray_shd_flag]
shl ebx,10
or eax,ebx
cmp [sinus_flag],0
je .no_sin
movzx eax,[dr_flag]
movzx ebx,[ray_shd_flag]
shl ebx,10
or eax,ebx
call do_sinus
; jmp .finito
.no_sin:
@@:
movzx ecx,[fire_flag]
cmp [fire_flag],1
je @f
cmp [blur_flag],0
je .no_blur ; no blur, no fire
movzx ecx,[blur_flag]
@@:
movzx eax,[dr_flag]
movzx ebx,[ray_shd_flag]
shl ebx,10
or eax,ebx
call blur_screen ; blur and fire
; jmp .finito
.no_blur: ; no blur, no fire
cmp [emboss_flag],0
je @f
movzx eax,[dr_flag]
movzx ebx,[ray_shd_flag]
shl ebx,10
or eax,ebx
call do_emboss
.finito:
@@:
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*4]
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*4]
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 edx,[offset_y]
cmp [ray_shd_flag],1
jge .ff
cmp [dr_flag],11
jge .ff
int 0x40
jmp .f
.ff:
mov eax,65
mov esi,32
xor ebp,ebp
int 0x40
.f:
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
jmp still
;--------------------------------------------------------------------------------
;-------------------------PROCEDURES---------------------------------------------
;--------------------------------------------------------------------------------
include "flat_cat.inc"
include "tex_cat.inc"
include "bump_cat.inc"
include "3dmath.inc"
include "grd_line.inc"
include "b_procs.inc"
include "a_procs.inc"
include "chunks.inc"
include "grd_cat.inc"
include "bump_tex.inc"
include "grd_tex.inc"
include "two_tex.inc"
include "asc.inc"
if Ext >= SSE3
include "3r_phg.inc"
include '3stencil.inc'
include '3glass.inc'
include '3glass_tex.inc'
include '3ray_shd.inc'
end if
clear_vertices_index:
mov edi,[vertices_index_ptr]
movzx eax,word[size_x_var]
movzx ecx,word[size_y_var]
imul ecx,eax
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
push ebx
mov ecx,ebx
shl ecx,2
; lea ecx,[ebx*2]
lea ebx,[ebx*3]
cmp [dr_flag],12
jl @f
add ebx,[esp]
@@:
add esp,4
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
check_bar
jne .no_edit
add ecx,[vertices_index_ptr]
mov ecx,[ecx]
; cmp ecx,-1
; je .no_edit
mov [vertex_edit_no],ecx ;if vert_edit_no = -1, 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],-1 ; 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
mov 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
mov edi,[vertex_edit_no]
; dec edi
lea edi,[edi*3]
shl edi,2
add edi,[points_ptr]
lea esi,[.points_rotated]
cld
movsd
movsd
movsd
; mov ecx,3
; cld
; rep movsd
mov dword[edit_end_x],0
mov [vertex_edit_no],-1
.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*4] ; more mem for r_phg cause
add ecx,256
mov eax,68
mov ebx,20
mov edx,[screen_ptr]
int 0x40
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
mov [Zbuffer_ptr],eax
mov ecx,[.temp]
shl ecx,2
add ecx,256
mov eax,68
mov ebx,20
mov edx,[vertices_index_ptr]
int 0x40
mov [vertices_index_ptr],eax
mov esp,ebp
pop ebp
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
jmp .no_write
.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_ptr]
mov 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 Ext >= SSE2
init_point_normals:
;in:
; esi - tri_ch
; edi - t_ptr
.z equ dword [ebp-8]
.y equ dword [ebp-12]
.x equ [ebp-16]
.point_number equ dword [ebp-28]
.hit_faces equ dword [ebp-32]
.t_ptr equ dword [ebp-36]
.tri_ch equ dword [ebp-40]
.max_val equ dword [ebp-44]
push ebp
mov ebp,esp
sub esp,64
and ebp,-16
mov .t_ptr,edi
mov .tri_ch,esi
mov ecx,[triangles_count_var]
shl ecx,3
lea ecx,[ecx*3]
add ecx,.tri_ch
mov .max_val,ecx
xor edx,edx
.lp1:
mov ebx,edx
shl ebx,2
add ebx,.t_ptr
mov esi,[ebx]
or esi,esi
jz .old
xorps xmm1,xmm1
xor ecx,ecx
@@:
mov eax,[esi+4] ; eax - tri index
mov ebx,[esi]
imul eax,[i12]
add eax,[triangles_normals_ptr]
movups xmm0,[eax]
inc ecx
addps xmm1,xmm0
add esi,8
cmp esi,.max_val ; some objects need this check
ja .old ;old method
cmp ebx,[esi]
je @b
cvtsi2ss xmm2,ecx
rcpss xmm2,xmm2
shufps xmm2,xmm2,0
mulps xmm1,xmm2
mov edi,edx
imul edi,[i12]
add edi,[points_normals_ptr]
movlps [edi],xmm1
movhlps xmm1,xmm1
movss [edi+8],xmm1
call normalize_vector
inc edx
cmp edx,[points_count_var]
jnz .lp1
jmp .end
.old:
mov edi,[points_normals_ptr]
mov .point_number,edx
.ipn_loop:
movd xmm0,.point_number
pshufd xmm0,xmm0,0
mov .hit_faces,0
mov .x,dword 0
mov .y,0
mov .z,0
mov esi,[triangles_ptr]
xor ecx,ecx ; ecx - triangle number
.ipn_check_face:
movdqu xmm1,[esi]
pcmpeqd xmm1,xmm0
pmovmskb eax,xmm1
and eax,0xfff
or eax,eax
jz .ipn_next_face
push esi
mov esi,ecx
lea esi,[esi*3]
shl esi,2
add esi,[triangles_normals_ptr]
movups xmm7,[esi]
addps xmm7,.x
movaps .x,xmm7
pop esi
inc .hit_faces
.ipn_next_face:
add esi,12
inc ecx
cmp ecx,[triangles_count_var]
jne .ipn_check_face
cvtsi2ss xmm6,.hit_faces
movaps xmm7,.x
rcpss xmm6,xmm6
shufps xmm6,xmm6,11000000b
mulps xmm7,xmm6
movlps [edi],xmm7
movhlps xmm7,xmm7
movss [edi+8],xmm7
call normalize_vector
; movaps xmm6,xmm7
; mulps xmm6,xmm6
; andps xmm6,[zero_hgst_dd]
; haddps xmm6,xmm6
; haddps xmm6,xmm6
; rsqrtps xmm6,xmm6
; mulps xmm7,xmm6
; movlps [edi],xmm7
; movhlps xmm7,xmm7
; movss [edi+8],xmm7
add edi,12
inc .point_number
mov edx,.point_number
cmp edx,[points_count_var]
jne .ipn_loop
.end:
mov eax,68
mov ebx,13
mov ecx,.t_ptr
int 0x40
mov eax,68
mov ebx,13
mov ecx,.tri_ch
int 0x40
add esp,64
pop ebp
ret
else
init_point_normals:
.x equ dword [ebp-4]
.y equ dword [ebp-8]
.z equ dword [ebp-12]
.point_number equ dword [ebp-28]
.hit_faces equ dword [ebp-32]
fninit
mov ebp,esp
sub esp,32
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:
mov eax,dword[esi+ebx] ; eax - point_number
cmp eax,.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,4
cmp ebx,12
jne .ipn_check_vertex
.ipn_next_face:
add esi,12
inc ecx
cmp ecx,[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 edx,.point_number
cmp edx,[points_count_var]
jne .ipn_loop
mov esp,ebp
ret
;===============================================================
end if
init_triangles_normals2:
mov ebx,[triangles_normals_ptr]
mov ebp,[triangles_ptr]
mov ecx,[triangles_count_var]
@@:
push ecx
push ebx
mov ebx,vectors
mov esi,dword[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]
mov edi,dword[ebp+4] ; 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
mov edi,dword[ebp+8] ; 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,12
add ebx,12
pop ecx
sub ecx,1
jnz @b
ret
copy_lights: ; after normalising !
mov esi,lights
mov edi,lights_aligned
mov ecx,3
.again:
push ecx
mov ecx,3
cld
rep movsd
xor eax,eax
stosd
mov ecx,3
.b:
push ecx
mov ecx,3
@@:
movzx ebx,byte[esi]
cvtsi2ss xmm0,ebx
movss [edi],xmm0
inc esi
add edi,4
loop @b
stosd
pop ecx
loop .b
inc esi ; skip shiness
pop ecx
loop .again
ret
clrscr:
mov edi,[screen_ptr]
movzx ecx,word[size_x_var]
movzx eax,word[size_y_var]
imul ecx,eax
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:
; in: eax - render draw model
.tri_no equ dword[ebp-60]
.point_index3 equ [ebp-8]
.point_index2 equ [ebp-12]
.point_index1 equ [ebp-16]
.yy3 equ [ebp-18]
.xx3 equ [ebp-20]
.yy2 equ [ebp-22]
.xx2 equ [ebp-24]
.yy1 equ [ebp-26]
.xx1 equ [ebp-28]
.zz3 equ [ebp-30]
.zz2 equ [ebp-32]
.zz1 equ [ebp-34]
.index3x12 equ [ebp-38]
.index2x12 equ [ebp-42]
.index1x12 equ [ebp-46]
.temp1 equ dword[ebp-50]
.temp2 equ dword[ebp-54]
.dr_flag equ word[ebp-56]
push ebp
mov ebp,esp
sub esp,60
; movzx ax,[dr_flag]
mov .dr_flag,ax
emms
; update translated list MMX required
cmp [vertex_edit_no],-1
je @f
mov 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
@@:
if Ext >= SSE3
cmp .dr_flag,13
jnge .no_stencil
mov esi,[triangles_ptr]
mov ecx,[triangles_count_var]
@@:
push esi
push ecx
mov eax,[esi]
mov ebx,[esi+4]
mov ecx,[esi+8]
imul eax,[i12]
imul ebx,[i12]
imul ecx,[i12]
add eax,[points_rotated_ptr]
add ebx,[points_rotated_ptr]
add ecx,[points_rotated_ptr]
push dword[ecx+8]
push dword[ebx+8]
push dword[eax+8]
movups xmm0,[esp]
add esp,12
andps xmm0,[zero_hgst_dd]
mov eax,[esi]
mov ebx,[esi+4]
mov ecx,[esi+8]
shl eax,1
shl ebx,1
shl ecx,1
lea eax,[eax*3]
lea ebx,[ebx*3]
lea ecx,[ecx*3]
add eax,[points_translated_ptr]
add ebx,[points_translated_ptr]
add ecx,[points_translated_ptr]
mov eax,[eax]
mov ebx,[ebx]
mov ecx,[ecx]
ror eax,16
ror ebx,16
ror ecx,16
mov esi,[Zbuffer_ptr]
call stencil_tri
pop ecx
pop esi
add esi,12
dec ecx
jnz @b
.no_stencil:
end if
cmp [dr_flag],11
je .draw_smooth_line
mov esi,[triangles_ptr]
xor ecx,ecx ;mov ecx,[triangles_count_var]
.again_dts:
; push ebp
push esi
push ecx
mov .tri_no,ecx
mov eax,[esi]
mov ebx,[esi+4]
mov ecx,[esi+8]
mov .point_index1,eax
mov .point_index2,ebx
mov .point_index3,ecx
imul eax,[i12]
imul ebx,[i12]
imul ecx,[i12]
mov .index1x12,eax
mov .index2x12,ebx
mov .index3x12,ecx
shr eax,1
shr ebx,1
shr ecx,1
add eax,[points_translated_ptr]
add ebx,[points_translated_ptr]
add ecx,[points_translated_ptr]
push word[eax+4]
push word[ebx+4]
push word[ecx+4]
pop word .zz3
pop word .zz2
pop word .zz1
mov eax,[eax]
mov ebx,[ebx]
mov ecx,[ecx]
ror eax,16
ror ebx,16
ror ecx,16
mov .xx1,eax
mov .xx2,ebx
mov .xx3,ecx
; push esi
fninit ; DO culling AT FIRST
cmp [culling_flag],1 ; (if culling_flag = 1)
jne .no_culling
lea esi,.point_index1 ; *********************************
mov ecx,3 ;
@@:
mov eax,dword[esi]
lea eax,[eax*3]
shl eax,2
add eax,[points_normals_rot_ptr]
mov eax,[eax+8]
bt eax,31
jc @f
; *****************************
; CHECKING OF Z COOFICIENT OF
; NORMAL VECTOR
add esi,4
loop @b
jmp .end_draw ; non 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
if Ext >= SSE3
cmp .dr_flag,12
je .r_phg
cmp .dr_flag,13
je .glass
cmp .dr_flag,14
je .glass_tex
cmp .dr_flag,100
je .ray_shd
end if
push ebp ; ****************
lea esi,.index3x12 ; do Gouraud shading
lea edi,.zz3
mov ecx,3
.again_grd_draw:
mov eax,dword[esi]
add eax,[points_normals_rot_ptr]
; texture x=(rotated point normal -> x * 255)+255
fld dword[eax] ; x cooficient of normal vector
fimul [correct_tex]
fiadd [correct_tex]
fistp .temp1
; texture y=(rotated point normal -> y * 255)+255
fld dword[eax+4] ; y cooficient
fimul [correct_tex]
fiadd [correct_tex]
fistp .temp2
mov eax,.temp2
mov ebx,.temp1
and ebx,0xfffffff
shl eax,TEX_SHIFT
add eax,ebx
lea eax,[eax*3+color_map]
mov eax,dword[eax]
push word[edi] ; 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,4
sub edi,2
dec cx
jnz .again_grd_draw
jmp .both_draw
.rainbow:
push ebp
push word .zz3
mov eax, .xx3
ror eax,16
mov ebx,0x00ff00ff
and eax,ebx
push eax
neg al
push ax
push word .zz2
mov eax, .xx2
ror eax,16
and eax,ebx
push eax
neg al
push ax
push word .zz1
mov eax, .xx1
ror eax,16
and eax,ebx
push eax
neg al
push ax
.both_draw:
mov eax, .xx1
mov ebx, .xx2
mov ecx, .xx3
mov edi,[screen_ptr]
mov esi,[Zbuffer_ptr]
call gouraud_triangle_z
pop ebp
jmp .end_draw
.flat_draw: ;**************************
fninit ; FLAT DRAWING
mov eax,.index1x12
mov ebx,.index2x12
mov ecx,.index3x12
add eax,[points_normals_rot_ptr]
add ebx,[points_normals_rot_ptr]
add ecx,[points_normals_rot_ptr]
fld dword[eax] ; x cooficient of normal vector
fadd dword[ebx]
fadd dword[ecx]
fidiv [i3]
fimul [correct_tex]
fiadd [correct_tex]
fistp .temp1 ;dword[esp-4] ; x temp variables
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 .temp2 ;dword[esp-8] ; y
mov edx,.temp2 ;dword[esp-8]
and edx,0xfffffff
and .temp1,0xfffffff
shl edx,TEX_SHIFT
add edx,.temp1 ;dword[esp-4]
lea eax,[3*edx]
add eax,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
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edi,[screen_ptr]
mov esi,[Zbuffer_ptr]
push ebp
push word .zz3
push word .zz2
push word .zz1
call flat_triangle_z
pop ebp
jmp .end_draw
.env_mapping:
push ebp
push word .zz3
push word .zz2
push word .zz1
lea esi, .index1x12
sub esp,12
mov edi,esp
mov ecx,3
@@:
mov eax,dword[esi]
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,4
loop @b
mov eax, .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edi,[screen_ptr]
mov esi,envmap
mov edx,[Zbuffer_ptr]
call tex_triangle_z
pop ebp
jmp .end_draw
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.cubic_env_mapping:
push ebp
push word .zz3
push word .zz2
push word .zz1
lea esi,.index1x12
sub esp,12
mov edi,esp
mov ecx,3
@@:
mov eax,dword[esi]
add eax,[points_normals_rot_ptr]
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,4
loop @b
mov eax, .xx1
mov ebx, .xx2
mov ecx, .xx3
mov edi,[screen_ptr]
mov esi,envmap_cub
mov edx,[Zbuffer_ptr]
call tex_triangle_z
pop ebp
jmp .end_draw
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.bump_mapping:
push ebp
push [Zbuffer_ptr]
push word .zz3
push word .zz2
push word .zz1
lea esi,.index1x12
sub esp,12
mov edi,esp
mov ecx,3
@@:
mov eax,dword[esi]
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,4
loop @b
mov esi, .point_index3 ; bump map coords
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi, .point_index2
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi, .point_index1
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov eax,dword .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edi,[screen_ptr]
mov esi,envmap
mov edx,bumpmap ;BUMP_MAPPING
call bump_triangle_z
pop ebp
jmp .end_draw
.tex_mapping:
push ebp
push word .zz3
push word .zz2
push word .zz1
; @@:
mov esi, .point_index3 ; tex map coords
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi, .point_index2
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi, .point_index1
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov eax,dword .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edi,[screen_ptr]
mov esi,texmap
mov edx,[Zbuffer_ptr]
call tex_triangle_z
pop ebp
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 esi, .point_index3 ; tex map coords
shl esi,2
add esi,[tex_points_ptr]
push dword[esi] ; texture coords as first
mov esi, .point_index2 ; group of parameters
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi, .point_index1
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
lea esi, .index3x12
lea edi, .zz3
mov ecx,3
.aagain_grd_draw:
push word[edi] ; zz1 ,2 ,3
fninit
mov eax,dword[esi]
add eax,[points_normals_rot_ptr]
; texture x=(rotated point normal -> x * 255)+255
fld dword[eax] ; x cooficient of normal vector
fimul [correct_tex]
fiadd [correct_tex]
fistp .temp1 ;word[ebp-2]
; texture y=(rotated point normal -> y * 255)+255
fld dword[eax+4] ; y cooficient
fimul [correct_tex]
fiadd [correct_tex]
fistp .temp2 ;word[ebp-4]
mov eax,.temp2
mov ebx,.temp1
and ebx,0xfffffff ; some onjects need this 'and'
shl eax,TEX_SHIFT
add eax,ebx
lea eax,[eax*3]
add eax,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 edi,2
sub esi,4
dec cx
jnz .aagain_grd_draw
mov eax, .xx1
mov ebx, .xx2
mov ecx, .xx3
mov edi,[screen_ptr]
mov edx,texmap
mov esi,[Zbuffer_ptr]
call tex_plus_grd_triangle
pop ebp
jmp .end_draw
.two_tex:
push ebp
push [Zbuffer_ptr]
push word .zz3
push word .zz2
push word .zz1
fninit
lea esi, .point_index3 ; env coords
mov edi,esp
sub esp,24
mov ecx,3
@@:
mov eax,dword[esi]
shl eax,2
mov ebx,eax
; mov ebx,eax
add ebx,[tex_points_ptr]
mov ebx,[ebx]
mov [edi-8],ebx
lea eax,[eax*3]
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-4]
and word[edi-4],0x7fff ; some objects need it
; texture y=(rotated point normal -> y * 255)+255
fld dword[eax+4]
fimul [correct_tex]
fiadd [correct_tex]
fistp word[edi-2]
and word[edi-2],0x7fff ; some objects need it
sub edi,8
sub esi,4
loop @b
mov eax, .xx1
mov ebx, .xx2
mov ecx, .xx3
mov edi,[screen_ptr]
mov esi,texmap
mov edx,envmap
call two_tex_triangle_z
pop ebp
jmp .end_draw
.bump_tex:
push ebp
fninit
push dword texmap
push [Zbuffer_ptr]
push word .zz3
push word .zz2
push word .zz1
lea ebx, .point_index1
sub esp,36
mov edi,esp
mov ecx,3
@@:
mov eax,[ebx]
shl eax,2
mov esi,eax
lea esi,[esi*3]
add eax,[tex_points_ptr]
mov eax,[eax]
ror eax,16
mov [edi],eax
mov [edi+8],eax
add esi,[points_normals_rot_ptr]
; texture x=(rotated point normal -> x * 255)+255
fld dword[esi]
fimul [correct_tex]
fiadd [correct_tex]
fistp word[edi+6] ; env coords
; texture y=(rotated point normal -> y * 255)+255
fld dword[esi+4]
fimul [correct_tex]
fiadd [correct_tex]
fistp word[edi+4]
add ebx,4
add edi,12
loop @b
mov eax,dword .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edi,[screen_ptr]
mov esi,envmap
mov edx,bumpmap
call bump_tex_triangle_z
pop ebp
jmp .end_draw
if Ext >= SSE3
.r_phg:
movd xmm5,[size_y_var]
punpcklwd xmm5,[the_zero]
pshufd xmm5,xmm5,01110011b
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_normals_rot_ptr]
add ebx,[points_normals_rot_ptr]
add ecx,[points_normals_rot_ptr]
movups xmm0,[eax]
movups xmm1,[ebx]
movups xmm2,[ecx]
andps xmm0,[zero_hgst_dd]
andps xmm1,[zero_hgst_dd]
andps xmm2,[zero_hgst_dd]
xorps xmm3,xmm3
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_rotated_ptr]
add ebx,[points_rotated_ptr]
add ecx,[points_rotated_ptr]
push dword[ecx+8]
push dword[ebx+8]
push dword[eax+8]
movups xmm4,[esp]
add esp,12
andps xmm4,[zero_hgst_dd]
mov eax,dword .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edi,[screen_ptr]
mov esi,[Zbuffer_ptr]
call real_phong_tri_z
jmp .end_draw
.glass:
movd xmm5,[size_y_var]
punpcklwd xmm5,[the_zero]
pshufd xmm5,xmm5,01110011b
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_normals_rot_ptr]
add ebx,[points_normals_rot_ptr]
add ecx,[points_normals_rot_ptr]
movups xmm0,[eax]
movups xmm1,[ebx]
movups xmm2,[ecx]
andps xmm0,[zero_hgst_dd]
andps xmm1,[zero_hgst_dd]
andps xmm2,[zero_hgst_dd]
xorps xmm3,xmm3
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_rotated_ptr]
add ebx,[points_rotated_ptr]
add ecx,[points_rotated_ptr]
push dword[ecx+8]
push dword[ebx+8]
push dword[eax+8]
movups xmm4,[esp]
add esp,12
andps xmm4,[zero_hgst_dd]
mov eax, .xx1
mov ebx, .xx2
mov ecx, .xx3
mov edi,[screen_ptr]
mov edx,[Zbuffer_ptr]
mov esi,[Zbuffer_ptr]
call glass_tri
jmp .end_draw
.glass_tex:
movd xmm5,[size_y_var]
punpcklwd xmm5,[the_zero]
pshufd xmm5,xmm5,01110011b
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_normals_rot_ptr]
add ebx,[points_normals_rot_ptr]
add ecx,[points_normals_rot_ptr]
movups xmm0,[eax]
movups xmm1,[ebx]
movups xmm2,[ecx]
andps xmm0,[zero_hgst_dd]
andps xmm1,[zero_hgst_dd]
andps xmm2,[zero_hgst_dd]
xorps xmm3,xmm3
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_rotated_ptr]
add ebx,[points_rotated_ptr]
add ecx,[points_rotated_ptr]
push dword[ecx+8]
push dword[ebx+8]
push dword[eax+8]
movups xmm4,[esp]
add esp,12
andps xmm4,[zero_hgst_dd]
mov esi,.point_index3 ; tex map coords
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi,.point_index2
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
mov esi,.point_index1
shl esi,2
add esi,[tex_points_ptr]
push dword[esi]
movups xmm6,[esp]
add esp,12
; pshuflw xmm6,xmm6,10110001b
; pshufhw xmm6,xmm6,10110001b
movzx eax,word[size_x_var]
andps xmm6,[zero_hgst_dd]
movd xmm7,eax
pslldq xmm7,12
por xmm6,xmm7
mov eax,dword .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edx,texmap
mov edi,[screen_ptr]
mov esi,[Zbuffer_ptr]
call glass_tex_tri
jmp .end_draw
.ray_shd:
emms
movd xmm5,[size_y_var]
punpcklwd xmm5,[the_zero]
pshufd xmm5,xmm5,01110011b
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_normals_rot_ptr]
add ebx,[points_normals_rot_ptr]
add ecx,[points_normals_rot_ptr]
movups xmm0,[eax]
movups xmm1,[ebx]
movups xmm2,[ecx]
andps xmm0,[zero_hgst_dd]
andps xmm1,[zero_hgst_dd]
andps xmm2,[zero_hgst_dd]
xorps xmm3,xmm3
; mov ebx,.tri_no
; cmp ebx,0
; je @f
; int3
; @@:
mov eax, .index1x12
mov ebx, .index2x12
mov ecx, .index3x12
add eax,[points_rotated_ptr]
add ebx,[points_rotated_ptr]
add ecx,[points_rotated_ptr]
push dword[ecx+8]
push dword[ebx+8]
push dword[eax+8]
movups xmm4,[esp]
add esp,12
andps xmm4,[zero_hgst_dd]
movd mm7,.tri_no
; mm7 - intialised
mov eax,dword .xx1
mov ebx,dword .xx2
mov ecx,dword .xx3
mov edx,texmap
mov edi,[screen_ptr]
mov esi,[Zbuffer_ptr]
call ray_shad
end if
.end_draw:
; pop ebp
pop ecx
pop esi
add esi,12
inc ecx
cmp ecx,[triangles_count_var]
jnz .again_dts
jmp .eend
.draw_smooth_line:
mov esi,[edges_ptr]
xor ecx,ecx
.again_s_line:
push ecx
push esi
mov ecx,2
.aga_n:
mov eax,[esi]
shl eax,2
lea eax,[eax*3]
add eax,[points_normals_rot_ptr]
movups xmm0,[eax]
xorps xmm1,xmm1
mov edx,lights_aligned
.again_cc:
movaps xmm3,xmm0 ;.cnv
mulps xmm3,[edx]
andps xmm3,[zero_hgst_dd]
; haddps xmm3,xmm3
; haddps xmm3,xmm3 ; xmm3 - dot pr
movhlps xmm2,xmm3
addps xmm3,xmm2
movdqa xmm2,xmm3
shufps xmm2,xmm2,01010101b
addps xmm3,xmm2
shufps xmm3,xmm3,0
movaps xmm6,xmm3 ;xmm7
mulps xmm6,xmm6
mulps xmm6,xmm6
mulps xmm6,xmm6
mulps xmm6,xmm6
mulps xmm6,xmm6
mulps xmm6,[edx+48]
movaps xmm7,xmm3
mulps xmm7,[edx+16]
addps xmm7,xmm6
addps xmm7,[edx+32]
minps xmm7,[mask_255f] ; global
maxps xmm1,xmm7
add edx,64 ; size of one light in aligned list
cmp edx,lights_aligned_end
jl .again_cc
sub esp,16
movups [esp],xmm1
add esi,4
dec ecx
jnz .aga_n
movups xmm0,[esp]
movups xmm1,[esp+16]
add esp,32
sub esi,8
mov ecx,[esi]
mov edx,[esi+4]
imul ecx,[i6]
imul edx,[i6]
add ecx,[points_translated_ptr]
add edx,[points_translated_ptr]
movd xmm7,[ecx]
movhps xmm7,[edx]
pshufd xmm7,xmm7,11101000b
movdqa xmm6,xmm7
movdqa xmm3,xmm7
movdqa xmm4,xmm7
movd xmm5,[size_y_var]
pshuflw xmm5,xmm5,00010001b
pcmpeqw xmm3,xmm5
pcmpeqw xmm4,[the_zero]
pcmpgtw xmm7,xmm5
pcmpgtw xmm6,[the_zero]
pxor xmm7,xmm6
pxor xmm3,xmm4
pxor xmm7,xmm3
pmovmskb eax,xmm7
cmp al,-1
jnz .skp
mov eax,[esi]
mov ebx,[esi+4]
imul eax,[i12]
imul ebx,[i12]
add eax,[points_rotated_ptr]
add ebx,[points_rotated_ptr]
movss xmm2,[eax+8]
movss xmm3,[ebx+8]
movzx eax,word[ecx]
movzx ebx,word[ecx+2]
movzx ecx,word[edx]
movzx edx,word[edx+2]
emms
movd mm1,[screen_ptr]
movd mm0,[Zbuffer_ptr]
movzx esi,word[size_x_var]
movd mm2,esi
push ebp
call line_grd
pop ebp
.skp:
pop esi
pop ecx
add esi,8
inc ecx
cmp ecx,[edges_count]
jnz .again_s_line
.eend:
add esp,60
pop ebp
ret
draw_handlers:
; in eax - render model
push ebp
mov ebp,esp
; emms
.fac equ dword[ebp-16]
.xplus_scr equ ebp-8
.xplus_index equ ebp-12
.dr_model equ dword[ebp-4]
sub esp,16
mov .dr_model,eax
movzx eax,word[size_x_var]
cmp .dr_model,10
jg @f
lea ebx,[eax*3]
sub ebx,3*6
mov [.xplus_scr],ebx ; for scr 1st cause
mov .fac,3
jmp .in_r
@@:
lea ebx,[eax*4] ; for scr 2cond cause
sub ebx,4*6
mov [.xplus_scr],ebx
mov .fac,4
.in_r:
lea ebx,[eax*4]
sub ebx,4*6
mov [.xplus_index],ebx ; index
xor ecx,ecx
mov eax,4 shl 16 + 4
movd xmm0,[size_y_var]
movd xmm1,eax
psubw xmm0,xmm1
pshuflw xmm0,xmm0,00000001b
.l:
push ecx
cmp [culling_flag],1 ; (if culling_flag = 1)
jne .no_culling
mov edi,ecx ; *********************************
lea edi,[edi*3]
shl edi,2
add edi,[points_normals_rot_ptr]
bt dword[edi+8],31
jnc .skip
.no_culling:
mov esi,ecx
lea esi,[esi*3]
add esi,esi
add esi,[points_translated_ptr]
movd xmm2,[esi]
movd xmm3,[esi]
pcmpgtw xmm2,xmm0
pcmpgtw xmm3,xmm1
pxor xmm3,xmm2
movd eax,xmm3
cmp eax,-1
jne .skip
movzx eax,word[esi]
movzx ebx,word[esi+2]
sub eax,2
sub ebx,2
movzx edx, word[size_x_var]
imul ebx,edx
add ebx,eax
mov edi,ebx
imul ebx,.fac
shl edi,2
add ebx,[screen_ptr]
add edi,[vertices_index_ptr]
mov eax,ecx
cld
mov ecx,6
.l2:
push ecx
mov ecx,6 ; draw bar
.l1:
mov word[ebx],0
mov byte[ebx+2],0xff
stosd
add ebx,.fac
loop .l1
add ebx,[.xplus_scr]
add edi,[.xplus_index]
pop ecx
loop .l2
.skip:
pop ecx
inc ecx
cmp ecx,[points_count_var]
jna .l
mov esp,ebp
pop ebp
ret
fill_Z_buffer:
mov eax,0x70000000
cmp [dr_flag],11
jl @f
mov eax,60000.1
@@:
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],ebx
mov [triangles_count_var],ebx
mov esi,[fptr]
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],ecx
mov edx,ecx
add esi,8
@@:
lea ecx,[ecx*3]
add ecx,ecx
add ebx,ecx
add ecx,ecx
add esi,ecx
; 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],ecx
add esi,8
@@:
shl ecx,3
add esi,ecx
; dec ecx
; jnz @b
; loop @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
mov esi,[fptr]
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],ecx
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
add ebx,6
add esi,12
; dec ecx
; jnz @b
loop @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],ecx
add esi,8
;mov edi,triangles
@@:
movzx eax,word[esi]
stosd
movzx eax,word[esi+2]
stosd
movzx eax,word[esi+4]
stosd
add dword[edi-12],ebp
add dword[edi-8],ebp
add dword[edi-4],ebp
add esi,8
; dec ecx
; jnz @b
loop @b
add ebp,edx
jmp .find4k
mov eax,-1 ;<---mark if OK
.exit:
mov dword[edi],-1
ret
alloc_mem_for_tp:
mov eax, 68
cmp [re_alloc_flag],1
jz @f
mov ebx, 12
jmp .alloc
@@:
mov ebx,20
.alloc:
mov ecx,[triangles_count_var]
add ecx,20
lea ecx, [ecx*3]
shl ecx,2
mov edx,[triangles_ptr]
int 0x40 ; -> allocate memory to triangles
mov [triangles_ptr], eax ; -> eax = pointer to allocated mem
mov eax, 68
mov ecx,[triangles_count_var]
imul ecx,[i36]
mov edx,[edges_ptr]
int 0x40 ; -> allocate memory to triangles
mov [edges_ptr], eax ; -> eax = pointer to allocated mem
; ststic memory
mov eax, 68
mov ecx, [triangles_count_var]
lea ecx, [6+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
mov ecx, [points_count_var]
lea ecx,[6+ecx*3]
shl ecx, 2
mov edx,[points_normals_ptr]
int 0x40
mov [points_normals_ptr], eax
mov eax, 68
; mov ebx, 12
mov ecx, [points_count_var]
lea ecx,[10+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
mov ebx, 12
mov ecx, [points_count_var]
shl ecx,2
add ecx,32
mov edx,[tex_points_ptr]
int 0x40
mov [tex_points_ptr], eax
mov eax, 68
mov ecx, [points_count_var]
add ecx,10
shl ecx, 3
mov edx,[points_translated_ptr]
int 0x40
mov [points_translated_ptr], eax
ret
read_from_disk:
mov eax, 68
mov ebx, 11
int 0x40 ; -> create heap
;load kpacked files by Leency
mov eax,68
mov ebx,27
mov ecx,file_name
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
@@:
; 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
movzx ebx,word[size_x_var]
shl ebx,16
add ebx,(10)*65536+62 ; [x start] *65536 + [x size]
movzx ecx,byte[edi] ; button id = position+2
sub ecx,2
lea ecx,[ecx*5]
lea ecx,[ecx*3]
add ecx,25
shl ecx,16
add ecx,12
movzx edx,byte[edi] ; button id
mov esi,0x6688dd ; button color RRGGBB
int 0x40
; BUTTON LABEL
mov eax,4 ; function 4 : write text to window
movzx ebx,byte[edi]
sub ebx,2 ; button id, according to position
lea ebx,[ebx*3]
lea ebx,[ebx*5]
movzx ecx,word[size_x_var]
shl ecx,16
add ebx,ecx
add ebx,(12)*65536+28 ; [x start] *65536 + [y start]
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
lea edx,[edi+1] ; pointer to text beginning
mov esi,10 ; text length
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
write_info:
mov eax,13
mov bx,[size_x_var]
shl ebx,16
add ebx,120*65536+70 ; [x start] *65536 + [y start]
mov ecx,30 shl 16 + 150
xor edx,edx
int 0x40
xor esi,esi
emms
movd mm7,esi
.nxxx:
push esi
movd mm7,esi
mov eax,4 ; function 4 : write text to window
movzx ebx,word[size_x_var]
shl ebx,16
add ebx,120*65536 ; [x start] *65536 + [y start]
mov bx,si
shl bx,3
add ebx,30
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
movd edx,mm7
shl edx,2
add edx,lab_vert ; pointer to text beginning
mov esi,lab_vert_end-lab_vert ; text length
int 0x40
movd esi,mm7
mov eax,[points_count_var+esi]
mov ecx,10
.dc:
xor edx,edx
mov edi,10
div edi
add dl,30h
mov [STRdata+ecx-1],dl
loop .dc
mov eax,4 ; function 4 : write text to window
mov bx,[size_x_var]
add ebx,120
shl ebx,16
mov bx,si ; [x start] *65536 + [y start]
shl bx,3
add bx,45
mov ecx,0x00ddeeff
mov edx,STRdata ; pointer to text beginning
mov esi,10 ; text length
int 40h
pop esi
add esi,4
cmp esi,16
jnz .nxxx
ret
; *********************************************
; ******* WINDOW DEFINITIONS AND DRAW ********
; *********************************************
draw_window:
movzx eax,[fire_flag]
push eax
; int3
mov eax,12 ; function 12:tell os about windowdraw
mov ebx,1 ; 1, start of draw
int 0x40
; DRAW WINDOW
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,225
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
; mov eax,47
; mov ebx,0000000000111000000000000000b
; mov ecx,[points_count_var]
; movzx edx,word[size_x_var]
; shl edx,16
; add edx,130*65536+60 ; [x start] *65536 + [y start]
; mov esi,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB )
; int 0x40
call write_info
; 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
pop eax
mov [fire_flag],al
ret
; DATA AREA ************************************
include 'data.inc'
align 16
MEM_END: