/programs/demos/3dsheart/trunk/3dmath.asm |
---|
0,0 → 1,109 |
x3d equ 0 |
y3d equ 2 |
z3d equ 4 |
vec_x equ 0 |
vec_y equ 4 |
vec_z equ 8 |
; 3d point - triple integer word coordinate |
; vector - triple float dword coordinate |
;----------------------in: -------------------------------- |
;------------------------ esi - pointer to 1st 3d point --- |
;------------------------ edi - pointer to 2nd 3d point --- |
;------------------------ ebx - pointer to result vector -- |
;---------------------- out : none ------------------------ |
make_vector: |
fninit |
fild word[edi+x3d] ;edi+x3d |
fisub word[esi+x3d] ;esi+x3d |
fstp dword[ebx+vec_x] |
fild word[edi+y3d] |
fisub word[esi+y3d] |
fstp dword[ebx+vec_y] |
fild word[edi+z3d] |
fisub word[esi+z3d] |
fstp dword[ebx+vec_z] |
ret |
;---------------------- in: ------------------------------- |
;--------------------------- esi - pointer to 1st vector -- |
;--------------------------- edi - pointer to 2nd vector -- |
;--------------------------- ebx - pointer to result vector |
;---------------------- out : none |
cross_product: |
fninit |
fld dword [esi+vec_y] |
fmul dword [edi+vec_z] |
fld dword [esi+vec_z] |
fmul dword [edi+vec_y] |
fsubp ;st1 ,st |
fstp dword [ebx+vec_x] |
fld dword [esi+vec_z] |
fmul dword [edi+vec_x] |
fld dword [esi+vec_x] |
fmul dword [edi+vec_z] |
fsubp ;st1 ,st |
fstp dword [ebx+vec_y] |
fld dword [esi+vec_x] |
fmul dword [edi+vec_y] |
fld dword [esi+vec_y] |
fmul dword [edi+vec_x] |
fsubp ;st1 ,st |
fstp dword [ebx+vec_z] |
ret |
;----------------------- in: ------------------------------ |
;---------------------------- edi - pointer to vector ----- |
;----------------------- out : none |
normalize_vector: |
fninit |
fld dword [edi+vec_x] |
fmul st, st |
fld dword [edi+vec_y] |
fmul st, st |
fld dword [edi+vec_z] |
fmul st, st |
faddp st1, st |
faddp st1, st |
fsqrt |
ftst |
fstsw ax |
sahf |
jnz @f |
fst dword [edi+vec_x] |
fst dword [edi+vec_y] |
fstp dword [edi+vec_z] |
ret |
@@: |
fld st |
fld st |
fdivr dword [edi+vec_x] |
fstp dword [edi+vec_x] |
fdivr dword [edi+vec_y] |
fstp dword [edi+vec_y] |
fdivr dword [edi+vec_z] |
fstp dword [edi+vec_z] |
ret |
;------------------in: ------------------------- |
;------------------ esi - pointer to 1st vector |
;------------------ edi - pointer to 2nd vector |
;------------------out: ------------------------ |
;------------------ st0 - dot-product |
dot_product: |
fninit |
fld dword [esi+vec_x] |
fmul dword [edi+vec_x] |
fld dword [esi+vec_y] |
fmul dword [edi+vec_y] |
fld dword [esi+vec_z] |
fmul dword [edi+vec_z] |
faddp |
faddp |
ret |
/programs/demos/3dsheart/trunk/3dsheart.asm |
---|
0,0 → 1,2100 |
; |
; 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],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],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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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,0x20ddeeff ; 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 '3D Heart',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: |
/programs/demos/3dsheart/trunk/b_procs.asm |
---|
0,0 → 1,134 |
macro .comment |
{ |
init_envmap: ; create 512x512 env map |
.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 |
ret |
} |
calc_bumpmap: ; calculate random bumpmap |
;--------------in edi _ pointer to TEX_X x TEX_Y bumpmap |
push edi |
mov ecx,TEXTURE_SIZE |
@@: |
push ecx |
xor ecx,ecx |
mov edx,255 |
call random |
stosb |
pop ecx |
loop @b |
pop edi |
mov ecx,4 |
.blur: |
xor esi,esi |
mov edx,TEXTURE_SIZE |
xor eax,eax |
xor ebx,ebx |
@@: |
mov ebp,esi |
dec ebp |
and ebp,TEXTURE_SIZE |
mov al,byte[ebp+edi] |
mov ebp,esi |
inc ebp |
and ebp,TEXTURE_SIZE |
mov bl,byte[ebp+edi] |
add eax,ebx |
mov ebp,esi |
sub ebp,TEX_X |
and ebp,TEXTURE_SIZE |
mov bl,byte[ebp+edi] |
add eax,ebx |
mov ebp,esi |
add ebp,TEX_X |
and ebp,TEXTURE_SIZE |
mov bl,byte[ebp+edi] |
add eax,ebx |
shr eax,2 |
mov byte[esi+edi],al |
inc esi |
dec edx |
jnz @b |
loop .blur |
ret |
random: |
; in - ecx - min |
; edx - max |
; out - eax - random number |
mov bx,[rand_seed] |
add bx,0x9248 |
ror bx,3 |
mov [rand_seed],bx |
mov ax,dx |
sub ax,cx |
mul bx |
mov ax,dx |
add ax,cx |
cwde |
ret |
rand_seed dw ? |
/programs/demos/3dsheart/trunk/build.bat |
---|
0,0 → 1,0 |
fasm 3dsheart.asm 3dsheart |
/programs/demos/3dsheart/trunk/bump3.asm |
---|
0,0 → 1,609 |
;------- Big thanks to majuma (www.majuma.xt.pl) for absolutelly great-- |
;------- 13h mode demos ------------------------------------------------ |
bump_triangle: |
;------------------in - eax - x1 shl 16 + y1 ----------- |
;---------------------- ebx - x2 shl 16 + y2 ----------- |
;---------------------- ecx - x3 shl 16 + y3 ----------- |
;---------------------- edx - pointer to bump map ------ |
;---------------------- esi - pointer to environment map |
;---------------------- edi - pointer to screen buffer-- |
;---------------------- stack : bump coordinates-------- |
;---------------------- environment coordinates- |
.b_x1 equ ebp+4 ; procedure don't save registers !!! |
.b_y1 equ ebp+6 ; each coordinate as word |
.b_x2 equ ebp+8 |
.b_y2 equ ebp+10 |
.b_x3 equ ebp+12 |
.b_y3 equ ebp+14 |
.e_x1 equ ebp+16 |
.e_y1 equ ebp+18 |
.e_x2 equ ebp+20 |
.e_y2 equ ebp+22 |
.e_x3 equ ebp+24 |
.e_y3 equ ebp+26 |
.t_bmap equ dword[ebp-4] |
.t_emap equ dword[ebp-8] |
.x1 equ word[ebp-10] |
.y1 equ word[ebp-12] |
.x2 equ word[ebp-14] |
.y2 equ word[ebp-16] |
.x3 equ word[ebp-18] |
.y3 equ word[ebp-20] |
.dx12 equ dword[ebp-24] |
.dbx12 equ dword[ebp-28] |
.dby12 equ dword[ebp-32] |
.dex12 equ dword[ebp-36] |
.dey12 equ dword[ebp-40] |
.dx13 equ dword[ebp-44] |
.dbx13 equ dword[ebp-48] |
.dby13 equ dword[ebp-52] |
.dex13 equ dword[ebp-56] |
.dey13 equ dword[ebp-60] |
.dx23 equ dword[ebp-64] |
.dbx23 equ dword[ebp-68] |
.dby23 equ dword[ebp-72] |
.dex23 equ dword[ebp-76] |
.dey23 equ dword[ebp-80] |
.cx1 equ dword[ebp-84] ; current variables |
.cx2 equ dword[ebp-88] |
.cbx1 equ dword[ebp-92] |
.cbx2 equ dword[ebp-96] |
.cby1 equ dword[ebp-100] |
.cby2 equ dword[ebp-104] |
.cex1 equ dword[ebp-108] |
.cex2 equ dword[ebp-112] |
.cey1 equ dword[ebp-116] |
.cey2 equ dword[ebp-120] |
mov ebp,esp |
push edx ; store bump map |
push esi ; store e. map |
; sub esp,120 |
.sort3: ; sort triangle coordinates... |
cmp ax,bx |
jle .sort1 |
xchg eax,ebx |
mov edx,dword[.b_x1] |
xchg edx,dword[.b_x2] |
mov dword[.b_x1],edx |
mov edx,dword[.e_x1] |
xchg edx,dword[.e_x2] |
mov dword[.e_x1],edx |
.sort1: |
cmp bx,cx |
jle .sort2 |
xchg ebx,ecx |
mov edx,dword[.b_x2] |
xchg edx,dword[.b_x3] |
mov dword[.b_x2],edx |
mov edx,dword[.e_x2] |
xchg edx,dword[.e_x3] |
mov dword[.e_x2],edx |
jmp .sort3 |
.sort2: |
push eax ; store triangle coords in variables |
push ebx |
push ecx |
mov edx,eax ; eax,ebx,ecx are ORd together into edx which means that |
or edx,ebx ; if any *one* of them is negative a sign flag is raised |
or edx,ecx |
test edx,80000000h ; Check only X |
jne .loop23_done |
cmp .x1,SIZE_X ; { |
jg .loop23_done |
cmp .x2,SIZE_X ; This can be optimized with effort |
jg .loop23_done |
cmp .x3,SIZE_X |
jg .loop23_done ; { |
mov bx,.y2 ; calc delta 12 |
sub bx,.y1 |
jnz .bt_dx12_make |
mov ecx,5 |
xor edx,edx |
@@: |
push edx ;dword 0 |
loop @b |
jmp .bt_dx12_done |
.bt_dx12_make: |
mov ax,.x2 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx12,eax |
push eax |
mov ax,word[.b_x2] |
sub ax,word[.b_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dbx12,eax |
push eax |
mov ax,word[.b_y2] |
sub ax,word[.b_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dby12,eax |
push eax |
mov ax,word[.e_x2] |
sub ax,word[.e_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dex12,eax |
push eax |
mov ax,word[.e_y2] |
sub ax,word[.e_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dey12,eax |
push eax |
.bt_dx12_done: |
mov bx,.y3 ; calc delta13 |
sub bx,.y1 |
jnz .bt_dx13_make |
mov ecx,5 |
xor edx,edx |
@@: |
push edx ;dword 0 |
loop @b |
jmp .bt_dx13_done |
.bt_dx13_make: |
mov ax,.x3 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx13,eax |
push eax |
mov ax,word[.b_x3] |
sub ax,word[.b_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dbx13,eax |
push eax |
mov ax,word[.b_y3] |
sub ax,word[.b_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dby13,eax |
push eax |
mov ax,word[.e_x3] |
sub ax,word[.e_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dex13,eax |
push eax |
mov ax,word[.e_y3] |
sub ax,word[.e_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dey13,eax |
push eax |
.bt_dx13_done: |
mov bx,.y3 ; calc delta23 |
sub bx,.y2 |
jnz .bt_dx23_make |
mov ecx,5 |
xor edx,edx |
@@: |
push edx ;dword 0 |
loop @b |
jmp .bt_dx23_done |
.bt_dx23_make: |
mov ax,.x3 |
sub ax,.x2 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx23,eax |
push eax |
mov ax,word[.b_x3] |
sub ax,word[.b_x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dbx23,eax |
push eax |
mov ax,word[.b_y3] |
sub ax,word[.b_y2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dby23,eax |
push eax |
mov ax,word[.e_x3] |
sub ax,word[.e_x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dex23,eax |
push eax |
mov ax,word[.e_y3] |
sub ax,word[.e_y2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dey23,eax |
push eax |
; sub esp,40 |
.bt_dx23_done: |
movsx eax,.x1 |
shl eax,ROUND |
; mov .cx1,eax |
; mov .cx2,eax |
push eax |
push eax |
movsx eax,word[.b_x1] |
shl eax,ROUND |
; mov .cbx1,eax |
; mov .cbx2,eax |
push eax |
push eax |
movsx eax,word[.b_y1] |
shl eax,ROUND |
; mov .cby1,eax |
; mov .cby2,eax |
push eax |
push eax |
movsx eax,word[.e_x1] |
shl eax,ROUND |
;mov .cex1,eax |
;mov .cex2,eax |
push eax |
push eax |
movsx eax,word[.e_y1] |
shl eax,ROUND |
;mov .cey1,eax |
;mov .cey2,eax |
push eax |
push eax |
movzx ecx,.y1 |
cmp cx,.y2 |
jge .loop12_done |
.loop12: |
call .call_bump_line |
mov eax,.dx13 |
add .cx1,eax |
mov eax,.dx12 |
add .cx2,eax |
mov eax,.dbx13 |
add .cbx1,eax |
mov eax,.dbx12 |
add .cbx2,eax |
mov eax,.dby13 |
add .cby1,eax |
mov eax,.dby12 |
add .cby2,eax |
mov eax,.dex13 |
add .cex1,eax |
mov eax,.dex12 |
add .cex2,eax |
mov eax,.dey13 |
add .cey1,eax |
mov eax,.dey12 |
add .cey2,eax |
inc ecx |
cmp cx,.y2 |
jl .loop12 |
.loop12_done: |
movzx ecx,.y2 |
cmp cx,.y3 |
jge .loop23_done |
movzx eax,.x2 |
shl eax,ROUND |
mov .cx2,eax |
movzx eax,word[.b_x2] |
shl eax,ROUND |
mov .cbx2,eax |
movzx eax,word[.b_y2] |
shl eax,ROUND |
mov .cby2,eax |
movzx eax,word[.e_x2] |
shl eax,ROUND |
mov .cex2,eax |
movzx eax,word[.e_y2] |
shl eax,ROUND |
mov .cey2,eax |
.loop23: |
call .call_bump_line |
mov eax,.dx13 |
add .cx1,eax |
mov eax,.dx23 |
add .cx2,eax |
mov eax,.dbx13 |
add .cbx1,eax |
mov eax,.dbx23 |
add .cbx2,eax |
mov eax,.dby13 |
add .cby1,eax |
mov eax,.dby23 |
add .cby2,eax |
mov eax,.dex13 |
add .cex1,eax |
mov eax,.dex23 |
add .cex2,eax |
mov eax,.dey13 |
add .cey1,eax |
mov eax,.dey23 |
add .cey2,eax |
inc ecx |
cmp cx,.y3 |
jl .loop23 |
.loop23_done: |
mov esp,ebp |
ret 24 |
.call_bump_line: |
; push ebp |
; push ecx |
pushad |
push .t_emap |
push .t_bmap |
push .cey2 |
push .cex2 |
push .cey1 |
push .cex1 |
push .cby2 |
push .cbx2 |
push .cby1 |
push .cbx1 |
push ecx |
mov eax,.cx1 |
sar eax,ROUND |
mov ebx,.cx2 |
sar ebx,ROUND |
call bump_line |
popad |
ret |
bump_line: |
;--------------in: eax - x1 |
;-------------- ebx - x2 |
;-------------- edi - pointer to screen buffer |
;stack - another parameters : |
.y equ dword [ebp+4] |
.bx1 equ dword [ebp+8] ; --- |
.by1 equ dword [ebp+12] ; | |
.bx2 equ dword [ebp+16] ; | |
.by2 equ dword [ebp+20] ; |> bump and env coords |
.ex1 equ dword [ebp+24] ; |> shifted shl ROUND |
.ey1 equ dword [ebp+28] ; | |
.ex2 equ dword [ebp+32] ; | |
.ey2 equ dword [ebp+36] ; --- |
.bmap equ dword [ebp+40] |
.emap equ dword [ebp+44] |
.x1 equ dword [ebp-4] |
.x2 equ dword [ebp-8] |
.dbx equ dword [ebp-12] |
.dby equ dword [ebp-16] |
.dex equ dword [ebp-20] |
.dey equ dword [ebp-24] |
.cbx equ dword [ebp-28] |
.cby equ dword [ebp-32] |
.cex equ dword [ebp-36] |
.cey equ dword [ebp-40] |
mov ebp,esp |
mov ecx,.y |
or ecx,ecx |
jl .bl_end |
cmp ecx,SIZE_Y |
jge .bl_end |
cmp eax,ebx |
jl .bl_ok |
je .bl_end |
xchg eax,ebx |
mov edx,.bx1 |
xchg edx,.bx2 |
mov .bx1,edx |
mov edx,.by1 |
xchg edx,.by2 |
mov .by1,edx |
mov edx,.ex1 |
xchg edx,.ex2 |
mov .ex1,edx |
mov edx,.ey1 |
xchg edx,.ey2 |
mov .ey1,edx |
.bl_ok: |
push eax |
push ebx ;store x1, x2 |
mov eax,SIZE_X*3 |
mov ebx,.y |
mul ebx |
mov ecx,.x1 |
lea ecx,[ecx*3] |
add eax,ecx |
add edi,eax |
mov ecx,.x2 |
sub ecx,.x1 |
mov eax,.bx2 ; calc .dbx |
sub eax,.bx1 |
cdq |
idiv ecx |
push eax |
mov eax,.by2 ; calc .dby |
sub eax,.by1 |
cdq |
idiv ecx |
push eax |
mov eax,.ex2 ; calc .dex |
sub eax,.ex1 |
cdq |
idiv ecx |
push eax |
mov eax,.ey2 ; calc .dey |
sub eax,.ey1 |
cdq |
idiv ecx |
push eax |
push .bx1 |
push .by1 |
push .ex1 |
push .ey1 |
.draw: |
; if TEX = SHIFTING ;bump drawing only in shifting mode |
mov eax,.cby |
sar eax,ROUND |
shl eax,TEX_SHIFT |
mov esi,.cbx |
sar esi,ROUND |
add esi,eax |
mov ebx,esi |
dec ebx |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx eax,byte [ebx] |
mov ebx,esi |
inc ebx |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx ebx,byte [ebx] |
sub eax,ebx |
mov ebx,esi |
sub ebx,TEX_X |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx edx,byte [ebx] |
mov ebx,esi |
add ebx,TEX_X |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx ebx,byte [ebx] |
sub edx,ebx |
mov ebx,.cex ;.cex - current env map X |
sar ebx,ROUND |
add eax,ebx ; eax - modified x coord |
mov ebx,.cey ;.cey - current env map y |
sar ebx,ROUND |
add edx,ebx ; edx - modified y coord |
or eax,eax |
jl .black |
cmp eax,TEX_X |
jg .black |
or edx,edx |
jl .black |
cmp edx,TEX_Y |
jg .black |
shl edx,TEX_SHIFT |
add edx,eax |
lea edx,[edx*3] |
add edx,.emap |
mov eax,dword[edx] |
jmp .put_pixel |
.black: |
xor eax,eax |
.put_pixel: |
stosd |
dec edi |
mov eax,.dbx |
add .cbx,eax |
mov eax,.dby |
add .cby,eax |
mov eax,.dex |
add .cex,eax |
mov eax,.dey |
add .cey,eax |
dec ecx |
jnz .draw |
; end if |
.bl_end: |
mov esp,ebp |
ret 44 |
/programs/demos/3dsheart/trunk/bump_cat.ASM |
---|
0,0 → 1,769 |
;SIZE_X equ 350 |
;SIZE_Y equ 350 |
ROUND equ 8 |
;TEX_X equ 512 |
;TEX_Y equ 512 |
;TEXTURE_SIZE EQU (512*512)-1 |
;TEX_SHIFT EQU 9 |
CATMULL_SHIFT equ 8 |
;TEXTURE_SIZE EQU (TEX_X * TEX_Y)-1 |
;------- Big thanks to Majuma (www.majuma.xt.pl) for absolutely great--- |
;------- DOS 13h mode demos -------------------------------------------- |
;------- Procedure draws bump triangle using Catmull Z-buffer algorithm- |
;------- (Z coordinate interpolation)----------------------------------- |
bump_triangle_z: |
;------------------in - eax - x1 shl 16 + y1 ----------- |
;---------------------- ebx - x2 shl 16 + y2 ----------- |
;---------------------- ecx - x3 shl 16 + y3 ----------- |
;---------------------- edx - pointer to bump map ------ |
;---------------------- esi - pointer to environment map |
;---------------------- edi - pointer to screen buffer-- |
;---------------------- stack : bump coordinates-------- |
;---------------------- environment coordinates- |
;---------------------- Z position coordinates-- |
;---------------------- pointer io Z buffer----- |
;-- Z-buffer - filled with coordinates as dword -------- |
;-- (Z coor. as word) shl CATMULL_SHIFT ---------------- |
.b_x1 equ ebp+4 ; procedure don't save registers !!! |
.b_y1 equ ebp+6 ; each coordinate as word |
.b_x2 equ ebp+8 |
.b_y2 equ ebp+10 |
.b_x3 equ ebp+12 |
.b_y3 equ ebp+14 |
.e_x1 equ ebp+16 |
.e_y1 equ ebp+18 |
.e_x2 equ ebp+20 |
.e_y2 equ ebp+22 |
.e_x3 equ ebp+24 |
.e_y3 equ ebp+26 |
.z1 equ word[ebp+28] |
.z2 equ word[ebp+30] |
.z3 equ word[ebp+32] |
.z_buff equ dword[ebp+34] ; pointer to Z-buffer |
.t_bmap equ dword[ebp-4] ; pointer to bump map |
.t_emap equ dword[ebp-8] ; pointer to e. map |
.x1 equ word[ebp-10] |
.y1 equ word[ebp-12] |
.x2 equ word[ebp-14] |
.y2 equ word[ebp-16] |
.x3 equ word[ebp-18] |
.y3 equ word[ebp-20] |
.dx12 equ dword[ebp-24] |
.dbx12 equ dword[ebp-28] |
.dby12 equ dword[ebp-32] |
.dex12 equ dword[ebp-36] |
.dey12 equ dword[ebp-40] |
.dz12 equ dword[ebp-44] |
.dx13 equ dword[ebp-48] |
.dbx13 equ dword[ebp-52] |
.dby13 equ dword[ebp-56] |
.dex13 equ dword[ebp-60] |
.dey13 equ dword[ebp-64] |
.dz13 equ dword[ebp-68] |
.dx23 equ dword[ebp-72] |
.dbx23 equ dword[ebp-76] |
.dby23 equ dword[ebp-80] |
.dex23 equ dword[ebp-84] |
.dey23 equ dword[ebp-88] |
.dz23 equ dword[ebp-92] |
.cx1 equ dword[ebp-96] ; current variables |
.cx2 equ dword[ebp-100] |
.cbx1 equ dword[ebp-104] |
.cbx2 equ dword[ebp-108] |
.cby1 equ dword[ebp-112] |
.cby2 equ dword[ebp-116] |
.cex1 equ dword[ebp-120] |
.cex2 equ dword[ebp-124] |
.cey1 equ dword[ebp-128] |
.cey2 equ dword[ebp-132] |
.cz1 equ dword[ebp-136] |
.cz2 equ dword[ebp-140] |
mov ebp,esp |
push edx ; store bump map |
push esi ; store e. map |
; sub esp,120 |
.sort3: ; sort triangle coordinates... |
cmp ax,bx |
jle .sort1 |
xchg eax,ebx |
mov edx,dword[.b_x1] |
xchg edx,dword[.b_x2] |
mov dword[.b_x1],edx |
mov edx,dword[.e_x1] |
xchg edx,dword[.e_x2] |
mov dword[.e_x1],edx |
mov dx,.z1 |
xchg dx,.z2 |
mov .z1,dx |
.sort1: |
cmp bx,cx |
jle .sort2 |
xchg ebx,ecx |
mov edx,dword[.b_x2] |
xchg edx,dword[.b_x3] |
mov dword[.b_x2],edx |
mov edx,dword[.e_x2] |
xchg edx,dword[.e_x3] |
mov dword[.e_x2],edx |
mov dx,.z2 |
xchg dx,.z3 |
mov .z2,dx |
jmp .sort3 |
.sort2: |
push eax ; store triangle coords in variables |
push ebx |
push ecx |
mov edx,80008000h ; eax,ebx,ecx are ANDd together into edx which means that |
and edx,ebx ; if *all* of them are negative a sign flag is raised |
and edx,ecx |
and edx,eax |
test edx,80008000h ; Check both X&Y at once |
jne .loop23_done |
; mov edx,eax ; eax,ebx,ecx are ORd together into edx which means that |
; or edx,ebx ; if any *one* of them is negative a sign flag is raised |
; or edx,ecx |
; test edx,80000000h ; Check only X |
; jne .loop23_done |
; cmp .x1,SIZE_X ; { |
; jg .loop23_done |
; cmp .x2,SIZE_X ; This can be optimized with effort |
; jg .loop23_done |
; cmp .x3,SIZE_X |
; jg .loop23_done ; { |
mov bx,.y2 ; calc delta 12 |
sub bx,.y1 |
jnz .bt_dx12_make |
mov ecx,6 |
xor edx,edx |
@@: |
push edx ;dword 0 |
loop @b |
jmp .bt_dx12_done |
.bt_dx12_make: |
mov ax,.x2 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx12,eax |
push eax |
mov ax,word[.b_x2] |
sub ax,word[.b_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dbx12,eax |
push eax |
mov ax,word[.b_y2] |
sub ax,word[.b_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dby12,eax |
push eax |
mov ax,word[.e_x2] |
sub ax,word[.e_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dex12,eax |
push eax |
mov ax,word[.e_y2] |
sub ax,word[.e_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dey12,eax |
push eax |
mov ax,.z2 |
sub ax,.z1 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
.bt_dx12_done: |
mov bx,.y3 ; calc delta13 |
sub bx,.y1 |
jnz .bt_dx13_make |
mov ecx,6 |
xor edx,edx |
@@: |
push edx ;dword 0 |
loop @b |
jmp .bt_dx13_done |
.bt_dx13_make: |
mov ax,.x3 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx13,eax |
push eax |
mov ax,word[.b_x3] |
sub ax,word[.b_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dbx13,eax |
push eax |
mov ax,word[.b_y3] |
sub ax,word[.b_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dby13,eax |
push eax |
mov ax,word[.e_x3] |
sub ax,word[.e_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dex13,eax |
push eax |
mov ax,word[.e_y3] |
sub ax,word[.e_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dey13,eax |
push eax |
; nop here bug ????!!! |
mov ax,.z3 |
sub ax,.z1 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
; mov .dz13,eax |
push eax |
.bt_dx13_done: |
mov bx,.y3 ; calc delta23 |
sub bx,.y2 |
jnz .bt_dx23_make |
mov ecx,6 |
xor edx,edx |
@@: |
push edx ;dword 0 |
loop @b |
jmp .bt_dx23_done |
.bt_dx23_make: |
mov ax,.x3 |
sub ax,.x2 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx23,eax |
push eax |
mov ax,word[.b_x3] |
sub ax,word[.b_x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dbx23,eax |
push eax |
mov ax,word[.b_y3] |
sub ax,word[.b_y2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dby23,eax |
push eax |
mov ax,word[.e_x3] |
sub ax,word[.e_x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dex23,eax |
push eax |
mov ax,word[.e_y3] |
sub ax,word[.e_y2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dey23,eax |
push eax |
mov ax,.z3 |
sub ax,.z2 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
; mov .dz23,eax |
push eax |
; sub esp,40 |
.bt_dx23_done: |
movsx eax,.x1 |
shl eax,ROUND |
; mov .cx1,eax |
; mov .cx2,eax |
push eax |
push eax |
movsx eax,word[.b_x1] |
shl eax,ROUND |
; mov .cbx1,eax |
; mov .cbx2,eax |
push eax |
push eax |
movsx eax,word[.b_y1] |
shl eax,ROUND |
; mov .cby1,eax |
; mov .cby2,eax |
push eax |
push eax |
movsx eax,word[.e_x1] |
shl eax,ROUND |
;mov .cex1,eax |
;mov .cex2,eax |
push eax |
push eax |
movsx eax,word[.e_y1] |
shl eax,ROUND |
;mov .cey1,eax |
;mov .cey2,eax |
push eax |
push eax |
movsx eax,.z1 |
shl eax,CATMULL_SHIFT |
;mov .cz1,eax |
;mov .cz2,eax |
push eax |
push eax |
movsx ecx,.y1 |
cmp cx,.y2 |
jge .loop12_done |
.loop12: |
call .call_bump_line |
mov eax,.dx13 |
add .cx1,eax |
mov eax,.dx12 |
add .cx2,eax |
mov eax,.dbx13 |
add .cbx1,eax |
mov eax,.dbx12 |
add .cbx2,eax |
mov eax,.dby13 |
add .cby1,eax |
mov eax,.dby12 |
add .cby2,eax |
mov eax,.dex13 |
add .cex1,eax |
mov eax,.dex12 |
add .cex2,eax |
mov eax,.dey13 |
add .cey1,eax |
mov eax,.dey12 |
add .cey2,eax |
mov eax,.dz13 |
add .cz1,eax |
mov eax,.dz12 |
add .cz2,eax |
inc ecx |
cmp cx,.y2 |
jl .loop12 |
.loop12_done: |
movsx ecx,.y2 |
cmp cx,.y3 |
jge .loop23_done |
movsx eax,.z2 |
shl eax,CATMULL_SHIFT |
mov .cz2,eax |
movsx eax,.x2 |
shl eax,ROUND |
mov .cx2,eax |
movzx eax,word[.b_x2] |
shl eax,ROUND |
mov .cbx2,eax |
movzx eax,word[.b_y2] |
shl eax,ROUND |
mov .cby2,eax |
movzx eax,word[.e_x2] |
shl eax,ROUND |
mov .cex2,eax |
movzx eax,word[.e_y2] |
shl eax,ROUND |
mov .cey2,eax |
.loop23: |
call .call_bump_line |
mov eax,.dx13 |
add .cx1,eax |
mov eax,.dx23 |
add .cx2,eax |
mov eax,.dbx13 |
add .cbx1,eax |
mov eax,.dbx23 |
add .cbx2,eax |
mov eax,.dby13 |
add .cby1,eax |
mov eax,.dby23 |
add .cby2,eax |
mov eax,.dex13 |
add .cex1,eax |
mov eax,.dex23 |
add .cex2,eax |
mov eax,.dey13 |
add .cey1,eax |
mov eax,.dey23 |
add .cey2,eax |
mov eax,.dz13 |
add .cz1,eax |
mov eax,.dz23 |
add .cz2,eax |
inc ecx |
cmp cx,.y3 |
jl .loop23 |
.loop23_done: |
mov esp,ebp |
ret 34 |
.call_bump_line: |
; push ebp |
; push ecx |
pushad |
push .cz1 |
push .cz2 |
push .z_buff |
push .t_emap |
push .t_bmap |
push .cey2 |
push .cex2 |
push .cey1 |
push .cex1 |
push .cby2 |
push .cbx2 |
push .cby1 |
push .cbx1 |
push ecx |
mov eax,.cx1 |
sar eax,ROUND |
mov ebx,.cx2 |
sar ebx,ROUND |
call bump_line_z |
popad |
ret |
bump_line_z: |
;--------------in: eax - x1 |
;-------------- ebx - x2 |
;-------------- edi - pointer to screen buffer |
;stack - another parameters : |
.y equ dword [ebp+4] |
.bx1 equ dword [ebp+8] ; --- |
.by1 equ dword [ebp+12] ; | |
.bx2 equ dword [ebp+16] ; | |
.by2 equ dword [ebp+20] ; |> bump and env coords |
.ex1 equ dword [ebp+24] ; |> shifted shl ROUND |
.ey1 equ dword [ebp+28] ; | |
.ex2 equ dword [ebp+32] ; | |
.ey2 equ dword [ebp+36] ; --- |
.bmap equ dword [ebp+40] |
.emap equ dword [ebp+44] |
.z_buff equ dword [ebp+48] |
.z2 equ dword [ebp+52] ; -- |> z coords shifted |
.z1 equ dword [ebp+56] ; -- shl CATMULL_SHIFT |
.x1 equ dword [ebp-4] |
.x2 equ dword [ebp-8] |
.dbx equ dword [ebp-12] |
.dby equ dword [ebp-16] |
.dex equ dword [ebp-20] |
.dey equ dword [ebp-24] |
.dz equ dword [ebp-28] |
.cbx equ dword [ebp-32] |
.cby equ dword [ebp-36] |
.cex equ dword [ebp-40] |
.cey equ dword [ebp-44] |
.cz equ dword [ebp-48] |
.czbuff equ dword [ebp-52] |
mov ebp,esp |
mov ecx,.y |
or ecx,ecx |
jl .bl_end |
cmp ecx,SIZE_Y |
jge .bl_end |
cmp eax,ebx |
jl .bl_ok |
je .bl_end |
xchg eax,ebx |
mov edx,.bx1 |
xchg edx,.bx2 |
mov .bx1,edx |
mov edx,.by1 |
xchg edx,.by2 |
mov .by1,edx |
mov edx,.ex1 |
xchg edx,.ex2 |
mov .ex1,edx |
mov edx,.ey1 |
xchg edx,.ey2 |
mov .ey1,edx |
mov edx,.z1 |
xchg edx,.z2 |
mov .z1,edx |
.bl_ok: |
push eax |
push ebx ;store x1, x2 |
cmp .x1,SIZE_X |
jge .bl_end |
cmp .x2,0 |
jle .bl_end |
mov ebx,.x2 |
sub ebx,.x1 |
mov eax,.bx2 ; calc .dbx |
sub eax,.bx1 |
cdq |
idiv ebx |
push eax |
mov eax,.by2 ; calc .dby |
sub eax,.by1 |
cdq |
idiv ebx |
push eax |
mov eax,.ex2 ; calc .dex |
sub eax,.ex1 |
cdq |
idiv ebx |
push eax |
mov eax,.ey2 ; calc .dey |
sub eax,.ey1 |
cdq |
idiv ebx |
push eax |
mov eax,.z2 ; calc .dz |
sub eax,.z1 |
cdq |
idiv ebx |
push eax |
cmp .x1,0 ; set correctly begin variable |
jge @f ; CLIPPING ON FUNCTION |
; cutting triangle exceedes screen |
mov ebx,.x1 |
neg ebx |
imul ebx ; eax = .dz * abs(.x1) |
add .z1,eax |
mov .x1,0 |
mov eax,.dbx |
imul ebx |
add .bx1,eax |
mov eax,.dby |
imul ebx |
add .by1,eax |
mov eax,.dex |
imul ebx |
add .ex1,eax |
mov eax,.dey |
imul ebx |
add .ey1,eax |
@@: |
cmp .x2,SIZE_X |
jl @f |
mov .x2,SIZE_X |
@@: |
mov eax,SIZE_X ;calc memory begin in buffers |
mov ebx,.y |
mul ebx |
mov ebx,.x1 |
add eax,ebx |
mov ebx,eax |
lea eax,[eax*3] |
add edi,eax |
mov esi,.z_buff ; z-buffer filled with dd variables |
shl ebx,2 |
add esi,ebx |
mov ecx,.x2 |
sub ecx,.x1 |
; init current variables |
push .bx1 |
push .by1 |
push .ex1 |
push .ey1 |
push .z1 ; current z shl CATMULL_SHIFT |
push esi |
.draw: |
; if TEX = SHIFTING ;bump drawing only in shifting mode |
mov esi,.czbuff ; .czbuff current address in buffer |
mov ebx,.cz ; .cz - cur z position |
cmp ebx,dword[esi] |
jge .skip |
mov eax,.cby |
sar eax,ROUND |
shl eax,TEX_SHIFT |
mov esi,.cbx |
sar esi,ROUND |
add esi,eax |
mov ebx,esi |
dec ebx |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx eax,byte [ebx] |
mov ebx,esi |
inc ebx |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx ebx,byte [ebx] |
sub eax,ebx |
mov ebx,esi |
sub ebx,TEX_X |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx edx,byte [ebx] |
mov ebx,esi |
add ebx,TEX_X |
and ebx,TEXTURE_SIZE |
add ebx,.bmap |
movzx ebx,byte [ebx] |
sub edx,ebx |
mov ebx,.cex ;.cex - current env map X |
sar ebx,ROUND |
add eax,ebx ; eax - modified x coord |
mov ebx,.cey ;.cey - current env map y |
sar ebx,ROUND |
add edx,ebx ; edx - modified y coord |
or eax,eax |
jl .black |
cmp eax,TEX_X |
jg .black |
or edx,edx |
jl .black |
cmp edx,TEX_Y |
jg .black |
shl edx,TEX_SHIFT |
add edx,eax |
lea edx,[edx*3] |
add edx,.emap |
mov eax,dword[edx] |
jmp .put_pixel |
.black: |
xor eax,eax |
.put_pixel: |
stosd |
dec edi |
mov ebx,.cz |
mov esi,.czbuff |
mov dword[esi],ebx |
jmp .no_skip |
.skip: |
add edi,3 |
.no_skip: |
add .czbuff,4 |
mov eax,.dbx |
add .cbx,eax |
mov eax,.dby |
add .cby,eax |
mov eax,.dex |
add .cex,eax |
mov eax,.dey |
add .cey,eax |
mov eax,.dz |
add .cz,eax |
dec ecx |
jnz .draw |
; end if |
.bl_end: |
mov esp,ebp |
ret 56 |
/programs/demos/3dsheart/trunk/flat3.asm |
---|
0,0 → 1,188 |
draw_triangle: |
;----------in - eax - x1 shl 16 + y1 |
;------------- -ebx - x2 shl 16 + y2 |
;---------------ecx - x3 shl 16 + y3 |
;---------------edx - color 0x00rrggbb |
;---------------edi - pointer to screen buffer |
@ch3: |
cmp ax,bx |
jg @ch1 |
@ch4: ; sort parameters |
cmp bx,cx |
jg @ch2 |
jle @chEnd |
@ch1: |
xchg eax,ebx |
jmp @ch4 |
@ch2: |
xchg ebx,ecx |
jmp @ch3 |
@chEnd: |
mov dword[@y1],eax ; ....and store to user friendly variables |
mov dword[@y2],ebx |
mov dword[@y3],ecx |
mov [@col],edx |
mov edx,eax ; eax,ebx,ecx are ORd together into edx which means that |
or edx,ebx ; if any *one* of them is negative a sign flag is raised |
or edx,ecx |
test edx,80008000h ; Check both X&Y at once |
jne @end_triangle |
cmp [@x1],SIZE_X ; { |
jg @end_triangle |
cmp [@x2],SIZE_X ; This can be optimized with effort |
jg @end_triangle |
cmp [@x3],SIZE_X |
jg @end_triangle ; } |
shr eax,16 |
shr ebx,16 |
shr ecx,16 |
neg ax ; calculate delta 12 |
add ax,bx |
cwde |
shl eax,ROUND |
cdq |
mov bx,[@y2] |
mov cx,[@y1] |
sub bx,cx |
;cmp ebx,0 |
jne @noZero1 |
mov [@dx12],0 |
jmp @yesZero1 |
@noZero1: |
idiv ebx |
mov [@dx12],eax |
@yesZero1: |
mov ax,[@x3] ; calculate delta 13 |
sub ax,[@x1] |
cwde |
shl eax,ROUND |
cdq |
mov bx,[@y3] |
mov cx,[@y1] |
sub bx,cx |
;cmp ebx,0 |
jne @noZero2 |
mov [@dx13],0 |
jmp @yesZero2 |
@noZero2: |
idiv ebx |
mov [@dx13],eax |
@yesZero2: |
mov ax,[@x3] ; calculate delta 23 [dx23] |
sub ax,[@x2] |
cwde |
shl eax,ROUND |
cdq |
mov bx,[@y3] |
mov cx,[@y2] |
sub bx,cx |
;cmp ebx,0 |
jne @noZero3 |
mov [@dx23],0 |
jmp @yesZero3 |
@noZero3: |
idiv ebx |
mov [@dx23],eax |
@yesZero3: |
movzx eax,word[@x1] ; eax - xk1 |
shl eax,ROUND |
mov ebx,eax ; ebx - xk2 |
movzx esi,word[@y1] ; esi - y |
@next_line1: |
mov ecx,eax ; ecx - x11 |
sar ecx,ROUND |
mov edx,ebx ; edx - x12 |
sar edx,ROUND |
cmp ecx,edx |
jle @nochg |
xchg ecx,edx |
@nochg: |
pusha |
mov ebx,ecx |
sub edx,ecx |
mov ecx,edx |
mov edx,esi |
mov eax,[@col] |
call @horizontal_line |
popa |
add eax,[@dx13] |
add ebx,[@dx12] |
inc esi |
cmp si,[@y2] |
jl @next_line1 |
movzx esi,word[@y2] |
movzx ebx,word[@x2] |
shl ebx,ROUND |
@next_line2: |
mov ecx,eax |
sar ecx,ROUND |
mov edx,ebx |
sar edx,ROUND |
cmp ecx,edx |
jle @nochg1 |
xchg ecx,edx |
@nochg1: |
pusha |
mov ebx,ecx |
sub edx,ecx |
mov ecx,edx |
mov edx,esi |
mov eax,[@col] |
call @horizontal_line |
popa |
add eax,[@dx13] |
add ebx,[@dx23] |
inc esi |
cmp si,[@y3] |
jl @next_line2 |
@end_triangle: |
ret |
@horizontal_line: |
;---------in |
;---------eax - color of line, 0x00RRGGBB |
;---------ebx - x1 - x position of line begin |
;---------ecx - lenght of line |
;---------edx - y position of line |
;---------edi - pointer to buffer |
jcxz @end_hor_l |
; or edx,edx |
; jl @end_hor_l |
cmp edx,SIZE_Y |
jg @end_hor_l |
push eax |
mov eax,SIZE_X*3 |
mul edx |
add edi,eax ; calculate line begin adress |
;add edi,ebx |
;shl ebx,1 |
lea edi,[edi+ebx*2] |
add edi,ebx |
pop eax |
cld |
;mov dword[edi-3],0000FF00h |
@ddraw: ; Drawing horizontally: |
;push eax |
stosd ; 4 bytes at a time |
dec edi ; point to the 4th |
;shr eax,16 |
;stosb |
;pop eax |
;pusha ; If you want to draw pixel-by-pixel |
; mov eax,7 ; put image |
; mov ebx,screen |
; mov ecx,SIZE_X shl 16 + SIZE_Y |
; mov edx,5 shl 16 + 20 |
; int 0x40 |
;popa |
loop @ddraw |
mov byte[edi],0 ; The last 4th will be reset |
@end_hor_l: |
ret |
/programs/demos/3dsheart/trunk/flat_cat.ASM |
---|
0,0 → 1,342 |
CATMULL_SHIFT equ 16 |
fill_Z_buffer: |
mov eax,0x70000000 |
mov edi,Z_buffer |
mov ecx,SIZE_X*SIZE_Y |
rep stosd |
ret |
flat_triangle_z: |
; procedure drawing triangle with Z cordinate interpolation ------ |
; (Catmull alghoritm)-------------------------------------------- |
; ----------------in - eax - x1 shl 16 + y1 ---------------------- |
; -------------------- ebx - x2 shl 16 + y2 ---------------------- |
; -------------------- ecx - x3 shl 16 + y3 ---------------------- |
; -------------------- edx - color 0x00RRGGBB -------------------- |
; -------------------- esi - pointer to Z-buffer ----------------- |
; -------------------- edi - pointer to screen buffer------------- |
; -------------------- stack : z coordinates |
; -------------------- Z-buffer : each z variable as dword |
; -------------------- (Z coor. as word) shl CATMULL_SHIFT |
.z1 equ word[ebp+4] |
.z2 equ word[ebp+6] ; each z coordinate as word integer |
.z3 equ word[ebp+8] |
.col equ dword[ebp-4] |
.x1 equ word[ebp-6] |
.y1 equ word[ebp-8] |
.x2 equ word[ebp-10] |
.y2 equ word[ebp-12] |
.x3 equ word[ebp-14] |
.y3 equ word[ebp-16] |
.dx12 equ dword[ebp-20] |
.dz12 equ dword[ebp-24] |
.dx13 equ dword[ebp-28] |
.dz13 equ dword[ebp-32] |
.dx23 equ dword[ebp-36] |
.dz23 equ dword[ebp-40] |
.zz1 equ dword[ebp-44] |
.zz2 equ dword[ebp-48] |
mov ebp,esp |
push edx ; store edx in variable .col |
.sort2: |
cmp ax,bx |
jle .sort1 |
xchg eax,ebx |
mov dx,.z1 |
xchg dx,.z2 |
mov .z1,dx |
.sort1: |
cmp bx,cx |
jle .sort3 |
xchg ebx,ecx |
mov dx,.z2 |
xchg dx,.z3 |
mov .z2,dx |
jmp .sort2 |
.sort3: |
push eax ; store triangle coordinates in user friendly variables |
push ebx |
push ecx |
mov edx,80008000h ; eax,ebx,ecx are ANDd together into edx which means that |
and edx,ebx ; if *all* of them are negative a sign flag is raised |
and edx,ecx |
and edx,eax |
test edx,80008000h ; Check both X&Y at once |
jne .ft_loop2_end |
; cmp ax,SIZE_Y |
; jle @f |
; cmp bx,SIZE_Y |
; jle @f |
; cmp cx,SIZE_Y |
; jge @f |
; ror eax,16 |
; ror ebx,16 |
; ror ecx,16 |
; cmp ax,SIZE_X |
; jle @f |
; cmp bx,SIZE_X |
; jle @f |
; cmp cx,SIZE_X |
; jle @f |
; jmp .ft_loop2_end |
;@@: |
sub esp,32 |
mov bx,.y2 ; calc delta 12 |
sub bx,.y1 |
jnz .ft_dx12_make |
mov .dx12,0 |
mov .dz12,0 |
jmp .ft_dx12_done |
.ft_dx12_make: |
mov ax,.x2 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dx12,eax |
mov ax,.z2 |
sub ax,.z1 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
mov .dz12,eax |
.ft_dx12_done: |
mov bx,.y3 ; calc delta 13 |
sub bx,.y1 |
jnz .ft_dx13_make |
mov .dx13,0 |
mov .dz13,0 |
jmp .ft_dx13_done |
.ft_dx13_make: |
mov ax,.x3 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dx13,eax |
mov ax,.z3 |
sub ax,.z1 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
mov .dz13,eax |
.ft_dx13_done: |
mov bx,.y3 ; calc delta 23 |
sub bx,.y2 |
jnz .gt_dx23_make |
mov .dx23,0 |
mov .dz23,0 |
jmp .gt_dx23_done |
.gt_dx23_make: |
mov ax,.x3 |
sub ax,.x2 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dx23,eax |
mov ax,.z3 |
sub ax,.z2 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
mov .dz23,eax |
.gt_dx23_done: |
movsx edx,.z1 |
shl edx,CATMULL_SHIFT |
mov .zz1,edx |
mov .zz2,edx |
movsx eax,.x1 |
shl eax,ROUND ; eax - x1 |
mov ebx,eax ; ebx - x2 |
mov cx,.y1 |
cmp cx,.y2 |
jge .ft_loop1_end |
.ft_loop1: |
pushad |
push .col |
push cx ; y |
sar ebx,ROUND |
push bx ; x2 |
sar eax,ROUND |
push ax ; x1 |
push .zz2 ; z2 shl CATMULL_SHIFT |
push .zz1 ; z1 shl CATMULL_SHIFT |
call flat_line_z |
popad |
add eax,.dx13 |
add ebx,.dx12 |
mov edx,.dz13 |
add .zz1,edx |
mov edx,.dz12 |
add .zz2,edx |
inc cx |
cmp cx,.y2 |
jl .ft_loop1 |
.ft_loop1_end: |
movsx edx,.z2 |
shl edx,CATMULL_SHIFT |
mov .zz2,edx |
movsx ebx,.x2 |
shl ebx,ROUND |
mov cx,.y2 |
cmp cx,.y3 |
jge .ft_loop2_end |
.ft_loop2: |
pushad |
push .col |
push cx |
sar ebx,ROUND |
push bx |
sar eax,ROUND |
push ax ; x1 |
push .zz2 ; z2 shl CATMULL_SHIFT |
push .zz1 ; z1 shl CATMULL_SHIFT |
call flat_line_z |
popad |
add eax,.dx13 |
add ebx,.dx23 |
mov edx,.dz13 |
add .zz1,edx |
mov edx,.dz23 |
add .zz2,edx |
inc cx |
cmp cx,.y3 |
jl .ft_loop2 |
.ft_loop2_end: |
mov esp,ebp |
ret 6 |
flat_line_z: |
;---------------- |
;-------------in edi - pointer to screen buffer ---------------------------------- |
;--------------- esi - pointer to z-buffer (each Z varible dword)----------------- |
;----------stack - (each z coordinate shifted shl CATMULL_SHIFT)------------------ |
.z1 equ dword [ebp+4] |
.z2 equ dword [ebp+8] |
.x1 equ word [ebp+12] |
.x2 equ word [ebp+14] |
.y equ word [ebp+16] |
.col equ dword [ebp+18] |
.dz equ dword [ebp-4] |
mov ebp,esp |
;; sub esp,4 |
mov ax,.y |
or ax,ax |
jl .fl_quit |
cmp ax,SIZE_Y-1 |
jg .fl_quit |
; cmp .x1,0 |
; jge .fl_ok1 |
; cmp .x2,0 |
; jl .fl_quit |
; .fl_ok1: |
; cmp .x1,SIZE_X |
; jle .fl_ok2 |
; cmp .x2,SIZE_X |
; jg .fl_quit |
; .fl_ok2: |
mov ax,.x1 |
cmp ax,.x2 |
je .fl_quit |
jl .fl_ok |
xchg ax,.x2 |
mov .x1,ax |
mov edx,.z1 |
xchg edx,.z2 |
mov .z1,edx |
.fl_ok: |
cmp .x1,SIZE_X-1 |
jg .fl_quit |
cmp .x2,0 |
jle .fl_quit |
mov eax,.z2 |
sub eax,.z1 |
cdq |
mov bx,.x2 |
sub bx,.x1 |
movsx ebx,bx |
idiv ebx |
;; mov .dz,eax ; calculated delta - shifted .dz |
push eax |
cmp .x1,0 |
jge @f |
movsx ebx,.x1 |
neg ebx |
imul ebx |
add .z1,eax |
mov .x1,0 |
@@: |
cmp .x2,SIZE_X |
jl @f |
mov .x2,SIZE_X |
@@: |
mov edx,SIZE_X |
movsx eax,.y |
mul edx ; edi = edi + (SIZE_X * y + x1)*3 |
movsx edx,.x1 |
add eax,edx |
push eax |
lea eax,[eax*3] |
add edi,eax ; esi = esi + (SIZE_X * y + x1)*4 |
pop eax |
shl eax,2 |
add esi,eax |
mov cx,.x2 |
sub cx,.x1 |
movzx ecx,cx |
mov eax,.col |
mov ebx,.z1 ; ebx : curr. z |
mov edx,.dz |
.ddraw: |
;pushad |
;show |
;popad |
cmp ebx,dword[esi] |
jge .skip |
stosd |
dec edi |
mov dword[esi],ebx |
jmp .no_skip |
.skip: |
add edi,3 |
.no_skip: |
add esi,4 |
add ebx,edx |
loop .ddraw |
.fl_quit: |
mov esp,ebp |
ret 18 |
/programs/demos/3dsheart/trunk/grd3.asm |
---|
0,0 → 1,481 |
gouraud_triangle: |
;------------------in - eax - x1 shl 16 + y1 --------- |
;---------------------- ebx - x2 shl 16 + y2 --------- |
;---------------------- ecx - x3 shl 16 + y3 --------- |
;---------------------- edi - pointer to screen buffer |
;---------------------- stack : colors---------------- |
;----------------- procedure don't save registers !!-- |
.col1r equ ebp+4 ; each color as word |
.col1g equ ebp+6 |
.col1b equ ebp+8 |
.col2r equ ebp+10 |
.col2g equ ebp+12 |
.col2b equ ebp+14 |
.col3r equ ebp+16 |
.col3g equ ebp+18 |
.col3b equ ebp+20 |
.x1 equ word[ebp-2] |
.y1 equ word[ebp-4] |
.x2 equ word[ebp-6] |
.y2 equ word[ebp-8] |
.x3 equ word[ebp-10] |
.y3 equ word[ebp-12] |
.dc12r equ dword[ebp-16] |
.dc12g equ dword[ebp-20] |
.dc12b equ dword[ebp-24] |
.dc13r equ dword[ebp-28] |
.dc13g equ dword[ebp-32] |
.dc13b equ dword[ebp-36] |
.dc23r equ dword[ebp-40] |
.dc23g equ dword[ebp-44] |
.dc23b equ dword[ebp-48] |
.c1r equ dword[ebp-52] |
.c1g equ dword[ebp-56] |
.c1b equ dword[ebp-60] |
.c2r equ dword[ebp-64] |
.c2g equ dword[ebp-68] |
.c2b equ dword[ebp-72] |
.dx12 equ dword[ebp-76] |
.dx13 equ dword[ebp-80] |
.dx23 equ dword[ebp-84] |
mov ebp,esp |
; sub esp,72 |
.sort3: ; sort triangle coordinates... |
cmp ax,bx |
jle .sort1 |
xchg eax,ebx |
mov edx,dword[.col1r] |
xchg edx,dword[.col2r] |
mov dword[.col1r],edx |
mov dx,word[.col1b] |
xchg dx,word[.col2b] |
mov word[.col1b],dx |
.sort1: |
cmp bx,cx |
jle .sort2 |
xchg ebx,ecx |
mov edx,dword[.col2r] |
xchg edx,dword[.col3r] |
mov dword[.col2r],edx |
mov dx,word[.col2b] |
xchg dx,word[.col3b] |
mov word[.col2b],dx |
jmp .sort3 |
.sort2: |
push eax ;store triangle coordinates in user friendly variables |
push ebx |
push ecx |
sub esp,72 ; set correctly value of esp |
mov edx,eax ; check only X triangle coordinate |
or edx,ebx |
or edx,ecx |
test edx,80000000h |
jne .gt_loop2_end |
shr eax,16 |
cmp ax,SIZE_X-1 |
jg .gt_loop2_end |
shr ebx,16 |
cmp bx,SIZE_X-1 |
jg .gt_loop2_end |
shr ecx,16 |
cmp cx,SIZE_X-1 |
jg .gt_loop2_end |
mov bx,.y2 ; calc deltas |
sub bx,.y1 |
jnz .gt_dx12_make |
mov .dx12,0 |
mov .dc12r,0 |
mov .dc12g,0 |
mov .dc12b,0 |
jmp .gt_dx12_done |
.gt_dx12_make: |
mov ax,.x2 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dx12,eax |
mov ax,word[.col2r] |
sub ax,word[.col1r] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc12r,eax |
mov ax,word[.col2g] |
sub ax,word[.col1g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc12g,eax |
mov ax,word[.col2b] |
sub ax,word[.col1b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc12b,eax |
.gt_dx12_done: |
mov bx,.y3 |
sub bx,.y1 |
jnz .gt_dx13_make |
mov .dx13,0 |
mov .dc13r,0 |
mov .dc13g,0 |
mov .dc13b,0 |
jmp .gt_dx13_done |
.gt_dx13_make: |
mov ax,.x3 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dx13,eax |
mov ax,word[.col3r] |
sub ax,word[.col1r] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc13r,eax |
mov ax,word[.col3g] |
sub ax,word[.col1g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc13g,eax |
mov ax,word[.col3b] |
sub ax,word[.col1b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc13b,eax |
.gt_dx13_done: |
mov bx,.y3 |
sub bx,.y2 |
jnz .gt_dx23_make |
mov .dx23,0 |
mov .dc23r,0 |
mov .dc23g,0 |
mov .dc23b,0 |
jmp .gt_dx23_done |
.gt_dx23_make: |
mov ax,.x3 |
sub ax,.x2 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dx23,eax |
mov ax,word[.col3r] |
sub ax,word[.col2r] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc23r,eax |
mov ax,word[.col3g] |
sub ax,word[.col2g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc23g,eax |
mov ax,word[.col3b] |
sub ax,word[.col2b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov .dc23b,eax |
.gt_dx23_done: |
movsx eax,.x1 |
shl eax,ROUND |
mov ebx,eax |
movsx edx,word[.col1r] |
shl edx,ROUND |
mov .c1r,edx |
mov .c2r,edx |
movsx edx,word[.col1g] |
shl edx,ROUND |
mov .c1g,edx |
mov .c2g,edx |
movsx edx,word[.col1b] |
shl edx,ROUND |
mov .c1b,edx |
mov .c2b,edx |
mov cx,.y1 |
cmp cx,.y2 |
jge .gt_loop1_end |
.gt_loop1: |
push eax ; eax - cur x1 |
push ebx ; ebx - cur x2 |
push cx ; cx - cur y |
push edi |
push ebp |
mov edx,.c2r ; c2r,c2g,c2b,c1r,c1g,c1b - current colors |
sar edx,ROUND |
push dx |
mov edx,.c2g |
sar edx,ROUND |
push dx |
mov edx,.c2b |
sar edx,ROUND |
push dx |
mov edx,.c1r |
sar edx,ROUND |
push dx |
mov edx,.c1g |
sar edx,ROUND |
push dx |
mov edx,.c1b |
sar edx,ROUND |
push dx |
push cx |
sar ebx,ROUND |
push bx |
sar eax,ROUND |
push ax |
call gouraud_line |
pop ebp |
pop edi |
pop cx |
pop ebx |
pop eax |
mov edx,.dc13r |
add .c1r,edx |
mov edx,.dc13g |
add .c1g,edx |
mov edx,.dc13b |
add .c1b,edx |
mov edx,.dc12r |
add .c2r,edx |
mov edx,.dc12g |
add .c2g,edx |
mov edx,.dc12b |
add .c2b,edx |
add eax,.dx13 |
add ebx,.dx12 |
inc cx |
cmp cx,.y2 |
jl .gt_loop1 |
.gt_loop1_end: |
mov cx,.y2 |
cmp cx,.y3 |
jge .gt_loop2_end |
movsx ebx,.x2 |
shl ebx,ROUND |
movsx edx,word[.col2r] |
shl edx,ROUND |
mov .c2r,edx |
movsx edx,word[.col2g] |
shl edx,ROUND |
mov .c2g,edx |
movsx edx,word[.col2b] |
shl edx,ROUND |
mov .c2b,edx |
.gt_loop2: |
push eax ; eax - cur x1 |
push ebx ; ebx - cur x2 |
push cx |
push edi |
push ebp |
mov edx,.c2r |
sar edx,ROUND |
push dx |
mov edx,.c2g |
sar edx,ROUND |
push dx |
mov edx,.c2b |
sar edx,ROUND |
push dx |
mov edx,.c1r |
sar edx,ROUND |
push dx |
mov edx,.c1g |
sar edx,ROUND |
push dx |
mov edx,.c1b |
sar edx,ROUND |
push dx |
push cx |
sar ebx,ROUND |
push bx |
sar eax,ROUND |
push ax |
call gouraud_line |
pop ebp |
pop edi |
pop cx |
pop ebx |
pop eax |
mov edx,.dc13r |
add .c1r,edx |
mov edx,.dc13g |
add .c1g,edx |
mov edx,.dc13b |
add .c1b,edx |
mov edx,.dc23r |
add .c2r,edx |
mov edx,.dc23g |
add .c2g,edx |
mov edx,.dc23b |
add .c2b,edx |
add eax,.dx13 |
add ebx,.dx23 |
inc cx |
cmp cx,.y3 |
jl .gt_loop2 |
.gt_loop2_end: |
; add esp,84 |
mov esp,ebp |
ret 18 |
gouraud_line: |
;-------------in - edi - pointer to screen buffer |
;----------------- stack - another parameters |
.x1 equ word [ebp+4] |
.x2 equ word [ebp+6] |
.y equ word [ebp+8] |
.col1b equ ebp+10 |
.col1g equ ebp+12 |
.col1r equ ebp+14 |
.col2b equ ebp+16 |
.col2g equ ebp+18 |
.col2r equ ebp+20 |
.dc_r equ dword[ebp-4] |
.dc_g equ dword[ebp-8] |
.dc_b equ dword[ebp-12] |
mov ebp,esp |
mov ax,.y |
or ax,ax |
jl .gl_quit |
cmp ax,SIZE_Y-1 |
jg .gl_quit |
mov ax,.x1 |
cmp ax,.x2 |
je .gl_quit |
jl .gl_ok |
xchg ax,.x2 |
mov .x1,ax |
mov eax,dword[.col1b] |
xchg eax,dword[.col2b] |
mov dword[.col1b],eax |
mov ax,word[.col1r] |
xchg ax,word[.col2r] |
mov word[.col1r],ax |
.gl_ok: |
; cmp .x1,SIZE_X-1 ;check |
; jg .gl_quit |
; cmp .x2,SIZE_X-1 |
; jl @f |
; mov .x2,SIZE_X-1 |
; @@: |
; cmp .x1,0 |
; jg @f |
; mov .x1,0 |
; @@: |
; cmp .x2,0 |
; jl .gl_quit |
movsx ecx,.y |
mov eax,SIZE_X*3 |
mul ecx |
movsx ebx,.x1 |
lea ecx,[ebx*2+eax] |
add edi,ecx |
add edi,ebx |
mov ax,word[.col2r] |
sub ax,word[.col1r] |
cwde |
shl eax,ROUND |
cdq |
mov cx,.x2 |
sub cx,.x1 |
movsx ecx,cx |
idiv ecx |
;mov .dc_r,eax ;first delta |
push eax |
mov ax,word[.col2g] |
sub ax,word[.col1g] |
cwde |
shl eax,ROUND |
cdq |
idiv ecx |
;mov .dc_g,eax |
push eax |
mov ax,word[.col2b] |
sub ax,word[.col1b] |
cwde |
shl eax,ROUND |
cdq |
idiv ecx |
; mov .dc_b,eax |
push eax |
movsx ebx,word[.col1r] |
shl ebx,ROUND |
movsx edx,word[.col1g] |
shl edx,ROUND |
movsx esi,word[.col1b] |
shl esi,ROUND |
.gl_draw: |
mov eax,ebx |
sar eax,ROUND |
stosb |
mov eax,edx |
sar eax,ROUND |
stosb |
mov eax,esi |
sar eax,ROUND |
stosb |
add ebx,.dc_r |
add edx,.dc_g |
add esi,.dc_b |
loop .gl_draw |
.gl_quit: |
; add esp,12 |
mov esp,ebp |
ret 18 |
/programs/demos/3dsheart/trunk/grd_cat.ASM |
---|
0,0 → 1,598 |
ROUND equ 8 |
CATMULL_SHIFT equ 8 |
gouraud_triangle_z: |
;----procedure drawing gouraud triangle with z coordinate |
;----interpolation ( Catmull alghoritm )----------------- |
;------------------in - eax - x1 shl 16 + y1 ------------ |
;---------------------- ebx - x2 shl 16 + y2 ------------ |
;---------------------- ecx - x3 shl 16 + y3 ------------ |
;---------------------- esi - pointer to Z-buffer-------- |
;---------------------- Z-buffer filled with dd variables |
;---------------------- shifted CATMULL_SHIFT------------ |
;---------------------- edi - pointer to screen buffer--- |
;---------------------- stack : colors------------------- |
;----------------- procedure don't save registers !!----- |
.col1r equ ebp+4 ; each color as word |
.col1g equ ebp+6 ; each z coordinate as word |
.col1b equ ebp+8 |
.z1 equ ebp+10 |
.col2r equ ebp+12 |
.col2g equ ebp+14 |
.col2b equ ebp+16 |
.z2 equ ebp+18 |
.col3r equ ebp+20 |
.col3g equ ebp+22 |
.col3b equ ebp+24 |
.z3 equ ebp+26 |
.x1 equ word[ebp-2] |
.y1 equ word[ebp-4] |
.x2 equ word[ebp-6] |
.y2 equ word[ebp-8] |
.x3 equ word[ebp-10] |
.y3 equ word[ebp-12] |
.dx12 equ dword[ebp-16] |
.dz12 equ dword[ebp-20] |
.dc12r equ dword[ebp-24] |
.dc12g equ dword[ebp-28] |
.dc12b equ dword[ebp-32] |
.dx13 equ dword[ebp-36] |
.dz13 equ dword[ebp-40] |
.dc13r equ dword[ebp-44] |
.dc13g equ dword[ebp-48] |
.dc13b equ dword[ebp-52] |
.dx23 equ dword[ebp-56] |
.dz23 equ dword[ebp-60] |
.dc23r equ dword[ebp-64] |
.dc23g equ dword[ebp-68] |
.dc23b equ dword[ebp-72] |
.c1r equ dword[ebp-76] |
.c1g equ dword[ebp-80] |
.c1b equ dword[ebp-84] |
.c2r equ dword[ebp-88] |
.c2g equ dword[ebp-92] |
.c2b equ dword[ebp-96] |
.zz1 equ dword[ebp-100] |
.zz2 equ dword[ebp-104] |
mov ebp,esp |
; sub esp,84 |
.sort3: ; sort triangle coordinates... |
cmp ax,bx |
jle .sort1 |
xchg eax,ebx |
mov edx,dword[.col1r] |
xchg edx,dword[.col2r] |
mov dword[.col1r],edx |
mov edx,dword[.col1b] |
xchg edx,dword[.col2b] |
mov dword[.col1b],edx |
.sort1: |
cmp bx,cx |
jle .sort2 |
xchg ebx,ecx |
mov edx,dword[.col2r] |
xchg edx,dword[.col3r] |
mov dword[.col2r],edx |
mov edx,dword[.col2b] |
xchg edx,dword[.col3b] |
mov dword[.col2b],edx |
jmp .sort3 |
.sort2: |
push eax ; store in variables |
push ebx |
push ecx |
mov edx,80008000h ; eax,ebx,ecx are ANDd together into edx which means that |
and edx,ebx ; if *all* of them are negative a sign flag is raised |
and edx,ecx |
and edx,eax |
test edx,80008000h ; Check both X&Y at once |
jne .gt_loop2_end |
mov bx,.y2 ; calc deltas |
sub bx,.y1 |
jnz .gt_dx12_make |
; mov .dx12,0 |
; mov .dz12,0 |
; mov .dc12r,0 |
; mov .dc12g,0 |
; mov .dc12b,0 |
mov ecx,5 |
@@: |
push dword 0 |
loop @b |
jmp .gt_dx12_done |
.gt_dx12_make: |
mov ax,.x2 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx12,eax |
push eax |
mov ax,word[.z2] |
sub ax,word[.z1] |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
mov ax,word[.col2r] |
sub ax,word[.col1r] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc12r,eax |
push eax |
mov ax,word[.col2g] |
sub ax,word[.col1g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc12g,eax |
push eax |
mov ax,word[.col2b] ;;--- |
sub ax,word[.col1b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc12b,eax |
push eax |
.gt_dx12_done: |
mov bx,.y3 ; calc deltas |
sub bx,.y1 |
jnz .gt_dx13_make |
; mov .dx13,0 |
; mov .dz13,0 |
; mov .dc13r,0 |
; mov .dc13g,0 |
; mov .dc13b,0 |
mov ecx,5 |
@@: |
push dword 0 |
loop @b |
jmp .gt_dx13_done |
.gt_dx13_make: |
mov ax,.x3 |
sub ax,.x1 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx13,eax |
push eax |
mov ax,word[.z3] |
sub ax,word[.z1] |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
mov ax,word[.col3r] |
sub ax,word[.col1r] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc13r,eax |
push eax |
mov ax,word[.col3g] |
sub ax,word[.col1g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc13g,eax |
push eax |
mov ax,word[.col3b] |
sub ax,word[.col1b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc13b,eax |
push eax |
.gt_dx13_done: |
mov bx,.y3 ; calc deltas |
sub bx,.y2 |
jnz .gt_dx23_make |
; mov .dx23,0 |
; mov .dz23,0 |
; mov .dc23r,0 |
; mov .dc23g,0 |
; mov .dc23b,0 |
mov ecx,5 |
@@: |
push dword 0 |
loop @b |
jmp .gt_dx23_done |
.gt_dx23_make: |
mov ax,.x3 |
sub ax,.x2 |
cwde |
movsx ebx,bx |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx23,eax |
push eax |
mov ax,word[.z3] |
sub ax,word[.z2] |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
mov ax,word[.col3r] |
sub ax,word[.col2r] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc23r,eax |
push eax |
mov ax,word[.col3g] |
sub ax,word[.col2g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc23g,eax |
push eax |
mov ax,word[.col3b] |
sub ax,word[.col2b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dc23b,eax |
push eax |
.gt_dx23_done: |
sub esp,32 |
movsx eax,.x1 ; eax - cur x1 |
shl eax,ROUND ; ebx - cur x2 |
mov ebx,eax |
movsx edx,word[.z1] |
shl edx,CATMULL_SHIFT |
mov .zz1,edx |
mov .zz2,edx |
movzx edx,word[.col1r] |
shl edx,ROUND |
mov .c1r,edx |
mov .c2r,edx |
movzx edx,word[.col1g] |
shl edx,ROUND |
mov .c1g,edx |
mov .c2g,edx |
movzx edx,word[.col1b] |
shl edx,ROUND |
mov .c1b,edx |
mov .c2b,edx |
mov cx,.y1 |
cmp cx,.y2 |
jge .gt_loop1_end |
.gt_loop1: |
pushad |
; macro .debug |
mov edx,.c2r ; c2r,c2g,c2b,c1r,c1g,c1b - current colors |
sar edx,ROUND |
push dx |
mov edx,.c2g |
sar edx,ROUND |
push dx |
mov edx,.c2b |
sar edx,ROUND |
push dx |
sar ebx,ROUND ; x2 |
push bx |
mov edx,.c1r |
sar edx,ROUND |
push dx |
mov edx,.c1g |
sar edx,ROUND |
push dx |
mov edx,.c1b |
sar edx,ROUND |
push dx |
sar eax,ROUND |
push ax ; x1 |
push cx ; y |
push .zz2 |
push .zz1 |
call gouraud_line_z |
popad |
mov edx,.dc13r |
add .c1r,edx |
mov edx,.dc13g |
add .c1g,edx |
mov edx,.dc13b |
add .c1b,edx |
mov edx,.dc12r |
add .c2r,edx |
mov edx,.dc12g |
add .c2g,edx |
mov edx,.dc12b |
add .c2b,edx |
mov edx,.dz13 |
add .zz1,edx |
mov edx,.dz12 |
add .zz2,edx |
add eax,.dx13 |
add ebx,.dx12 |
inc cx |
cmp cx,.y2 |
jl .gt_loop1 |
.gt_loop1_end: |
mov cx,.y2 |
cmp cx,.y3 |
jge .gt_loop2_end |
movsx ebx,.x2 ; eax - cur x1 |
shl ebx,ROUND ; ebx - cur x2 |
movsx edx,word[.z2] |
shl edx,CATMULL_SHIFT |
mov .zz2,edx |
movzx edx,word[.col2r] |
shl edx,ROUND |
mov .c2r,edx |
movzx edx,word[.col2g] |
shl edx,ROUND |
mov .c2g,edx |
movzx edx,word[.col2b] |
shl edx,ROUND |
mov .c2b,edx |
.gt_loop2: |
pushad |
; macro .debug |
mov edx,.c2r ; c2r,c2g,c2b,c1r,c1g,c1b - current colors |
sar edx,ROUND |
push dx |
mov edx,.c2g |
sar edx,ROUND |
push dx |
mov edx,.c2b |
sar edx,ROUND |
push dx |
sar ebx,ROUND ; x2 |
push bx |
mov edx,.c1r |
sar edx,ROUND |
push dx |
mov edx,.c1g |
sar edx,ROUND |
push dx |
mov edx,.c1b |
sar edx,ROUND |
push dx |
sar eax,ROUND |
push ax ; x1 |
push cx ; y |
push .zz2 |
push .zz1 |
call gouraud_line_z |
popad |
mov edx,.dc13r |
add .c1r,edx |
mov edx,.dc13g |
add .c1g,edx |
mov edx,.dc13b |
add .c1b,edx |
mov edx,.dc23r |
add .c2r,edx |
mov edx,.dc23g |
add .c2g,edx |
mov edx,.dc23b |
add .c2b,edx |
mov edx,.dz13 |
add .zz1,edx |
mov edx,.dz23 |
add .zz2,edx |
add eax,.dx13 |
add ebx,.dx23 |
inc cx |
cmp cx,.y3 |
jl .gt_loop2 |
.gt_loop2_end: |
mov esp,ebp |
ret 24 |
gouraud_line_z: |
;----------------- procedure drawing gouraud line |
;----------------- with z coordinate interpolation |
;----------------- esi - pointer to Z_buffer |
;----------------- edi - pointer to screen buffer |
;----------------- stack: |
.z1 equ dword[ebp+4] ; z coordiunate shifted left CATMULL_SHIFT |
.z2 equ dword[ebp+8] |
.y equ word[ebp+12] |
.x1 equ ebp+14 |
.c1b equ ebp+16 |
.c1g equ ebp+18 |
.c1r equ ebp+20 |
.x2 equ ebp+22 |
.c2b equ ebp+24 |
.c2g equ ebp+26 |
.c2r equ ebp+28 |
.dz equ dword[ebp-4] |
.dc_r equ dword[ebp-8] |
.dc_g equ dword[ebp-12] |
.dc_b equ dword[ebp-16] |
.cr equ dword[ebp-20] |
.cg equ dword[ebp-24] |
.cb equ dword[ebp-28] |
mov ebp,esp |
mov ax,.y |
or ax,ax |
jl .gl_quit |
cmp ax,SIZE_Y |
jge .gl_quit |
mov eax,dword[.x1] |
cmp ax,word[.x2] |
je .gl_quit |
jl @f |
xchg eax,dword[.x2] |
mov dword[.x1],eax |
mov eax,dword[.c1g] |
xchg eax,dword[.c2g] |
mov dword[.c1g],eax |
mov eax,.z1 |
xchg eax,.z2 |
mov .z1,eax |
@@: |
cmp word[.x1],SIZE_X |
jge .gl_quit |
cmp word[.x2],0 |
jle .gl_quit |
mov eax,.z2 |
sub eax,.z1 |
cdq |
mov bx,word[.x2] ; dz = z2-z1/x2-x1 |
sub bx,word[.x1] |
movsx ebx,bx |
idiv ebx |
push eax |
mov ax,word[.c2r] |
sub ax,word[.c1r] |
cwde |
shl eax,ROUND ; dc_r = c2r-c1r/x2-x1 |
cdq |
idiv ebx |
push eax |
mov ax,word[.c2g] |
sub ax,word[.c1g] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
push eax |
mov ax,word[.c2b] |
sub ax,word[.c1b] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
push eax |
cmp word[.x1],0 ; clipping on function |
jg @f |
mov eax,.dz |
movsx ebx,word[.x1] |
neg ebx |
imul ebx |
add .z1,eax |
mov word[.x1],0 |
mov eax,.dc_r |
imul ebx |
sar eax,ROUND |
add word[.c1r],ax |
mov eax,.dc_g |
imul ebx |
sar eax,ROUND |
add word[.c1g],ax |
mov eax,.dc_b |
imul ebx |
sar eax,ROUND |
add word[.c1b],ax |
@@: |
cmp word[.x2],SIZE_X |
jl @f |
mov word[.x2],SIZE_X |
@@: |
sub esp,12 ; calculate memory begin |
mov edx,SIZE_X ; in buffers |
movzx eax,.y |
mul edx |
movzx edx,word[.x1] |
add eax,edx |
push eax |
lea eax,[eax*3] |
add edi,eax |
pop eax |
shl eax,2 |
add esi,eax |
mov cx,word[.x2] |
sub cx,word[.x1] |
movzx ecx,cx |
mov ebx,.z1 ; ebx - currrent z shl CATMULL_SIFT |
mov edx,.dz ; edx - delta z |
movzx eax,word[.c1r] |
shl eax,ROUND |
mov .cr,eax |
movzx eax,word[.c1g] |
shl eax,ROUND |
mov .cg,eax |
movzx eax,word[.c1b] |
shl eax,ROUND |
mov .cb,eax |
.ddraw: |
cmp ebx,dword[esi] ; esi - z_buffer |
jge .skip ; edi - Screen buffer |
mov eax,.cr |
sar eax,ROUND |
stosb |
mov eax,.cg |
sar eax,ROUND |
stosb |
mov eax,.cb |
sar eax,ROUND |
stosb |
mov dword[esi],ebx |
jmp .no_skip |
.skip: |
add edi,3 |
.no_skip: |
add esi,4 |
add ebx,edx |
mov eax,.dc_r |
add .cr,eax |
mov eax,.dc_g |
add .cg,eax |
mov eax,.dc_b |
add .cb,eax |
loop .ddraw |
.gl_quit: |
mov esp,ebp |
ret 26 |
/programs/demos/3dsheart/trunk/hrt.3ds |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/programs/demos/3dsheart/trunk/tex3.ASM |
---|
0,0 → 1,507 |
;--------------------------------------------------------------------- |
;--------------------textured triangle procedure---------------------- |
;--------------------------------------------------------------------- |
tex_triangle: |
;----------in - eax - x1 shl 16 + y1 |
;-------------- ebx - x2 shl 16 + y2 |
;---------------ecx - x3 shl 16 + y3 |
;---------------edx - nothing |
;---------------esi - pointer to texture buffer |
;---------------edi - pointer to screen buffer |
;-------------stack - texture coordinates |
.tex_x1 equ ebp+4 |
.tex_y1 equ ebp+6 |
.tex_x2 equ ebp+8 |
.tex_y2 equ ebp+10 |
.tex_x3 equ ebp+12 |
.tex_y3 equ ebp+14 |
mov ebp,esp |
mov edx,dword[.tex_x1] ; check all parameters |
or dx,dx |
jl .tt_end |
cmp dx,TEX_X-1 |
jg .tt_end |
shr edx,16 |
or dx,dx |
jl .tt_end |
cmp dx,TEX_Y-1 |
jg .tt_end |
mov edx,dword[.tex_x2] |
or dx,dx |
jl .tt_end |
cmp dx,TEX_X-1 |
jg .tt_end |
shr edx,16 |
or dx,dx |
jl .tt_end |
cmp dx,TEX_Y-1 |
jg .tt_end |
mov edx,dword[.tex_x3] |
or dx,dx |
jl .tt_end |
cmp dx,TEX_X-1 |
jg .tt_end |
shr edx,16 |
cmp dx,TEX_Y-1 |
jg .tt_end |
or dx,dx |
jl .tt_end |
mov edx,eax ; check X&Y triangle coordinate |
or edx,ebx |
or edx,ecx |
test edx,80008000h |
jne .tt_end |
; or ax,ax |
; jl .tt_end |
cmp ax,SIZE_Y |
jg .tt_end |
ror eax,16 |
; or ax,ax |
; jl .tt_end |
cmp ax,SIZE_X |
jg .tt_end |
rol eax,16 |
; or bx,bx |
; jl .tt_end |
cmp bx,SIZE_Y |
jg .tt_end |
ror ebx,16 |
; or bx,bx |
; jl .tt_end |
cmp bx,SIZE_X |
jg .tt_end |
rol ebx,16 |
; or cx,cx |
; jl .tt_end |
cmp cx,SIZE_Y |
jg .tt_end |
ror ecx,16 |
; or cx,cx |
; jl .tt_end |
cmp cx,SIZE_X |
jg .tt_end |
rol ecx,16 ; uff.. parameters was checked |
cmp ax,bx ;sort all parameters |
jle .tt_sort1 |
xchg eax,ebx |
mov edx,dword [.tex_x1] |
xchg edx,dword [.tex_x2] |
mov dword[.tex_x1],edx |
.tt_sort1: |
cmp ax,cx |
jle .tt_sort2 |
xchg eax,ecx |
mov edx,dword [.tex_x1] |
xchg edx,dword [.tex_x3] |
mov dword [.tex_x1],edx |
.tt_sort2: |
cmp bx,cx |
jle .tt_sort3 |
xchg ebx,ecx |
mov edx,dword [.tex_x2] |
xchg edx,dword [.tex_x3] |
mov dword [.tex_x2],edx |
.tt_sort3: |
mov [.y1],ax ; and store to user friendly variables |
shr eax,16 |
mov [.x1],ax |
mov [.y2],bx |
shr ebx,16 |
mov [.x2],bx |
mov [.y3],cx |
shr ecx,16 |
mov [.x3],cx |
mov [.tex_ptr],esi |
movsx ebx,word[.y2] |
sub bx,[.y1] |
jnz .tt_dx12_make |
mov [.dx12],0 |
mov [.tex_dx12],0 |
mov [.tex_dy12],0 |
jmp .tt_dx12_done |
.tt_dx12_make: |
mov ax,[.x2] |
sub ax,[.x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.dx12],eax ; dx12 = (x2-x1)/(y2-y1) |
mov ax,word[.tex_x2] |
sub ax,word[.tex_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.tex_dx12],eax ; tex_dx12 = (tex_x2-tex_x1)/(y2-y1) |
mov ax,word[.tex_y2] |
sub ax,word[.tex_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.tex_dy12],eax ; tex_dy12 = (tex_y2-tex_y1)/(y2-y1) |
.tt_dx12_done: |
movsx ebx,[.y3] |
sub bx,[.y1] |
jnz .tt_dx13_make |
mov [.dx13],0 |
mov [.tex_dx13],0 |
mov [.tex_dy13],0 |
jmp .tt_dx13_done |
.tt_dx13_make: |
mov ax,[.x3] |
sub ax,[.x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.dx13],eax ; dx13 = (x3-x1)/(y3-y1) |
mov ax,word[.tex_x3] |
sub ax,word[.tex_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.tex_dx13],eax ; tex_dx13 = (tex_x3-tex_x1)/(y3-y1) |
mov ax,word[.tex_y3] |
sub ax,word[.tex_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.tex_dy13],eax ; tex_dy13 = (tex_y3-tex_y1)/(y3-y1) |
.tt_dx13_done: |
movsx ebx,[.y3] |
sub bx,[.y2] |
jnz .tt_dx23_make |
mov [.dx23],0 |
mov [.tex_dx23],0 |
mov [.tex_dy23],0 |
jmp .tt_dx23_done |
.tt_dx23_make: |
mov ax,[.x3] |
sub ax,[.x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.dx23],eax ; dx23 = (x3-x2)/(y3-y2) |
mov ax,word[.tex_x3] |
sub ax,word[.tex_x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.tex_dx23],eax ; tex_dx23 = (tex_x3-tex_x2)/(y3-y2) |
mov ax,word[.tex_y3] |
sub ax,word[.tex_y2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.tex_dy23],eax ; tex_dy23 = (tex_y3-tex_y2)/(y3-y2) |
.tt_dx23_done: |
movsx eax,[.x1] |
shl eax,ROUND |
mov ebx,eax |
movsx edx, word[.tex_x1] |
shl edx,ROUND |
mov [.scan_x1],edx |
mov [.scan_x2],edx |
movsx edx, word[.tex_y1] |
shl edx,ROUND |
mov [.scan_y1],edx |
mov [.scan_y2],edx |
mov cx,[.y1] |
cmp cx, [.y2] |
jge .tt_loop1_end |
.tt_loop1: |
push edi |
push eax |
push ebx |
push cx |
push ebp |
mov edx, [.scan_y2] |
sar edx, ROUND |
push dx |
mov edx, [.scan_x2] |
sar edx, ROUND |
push dx |
mov edx, [.scan_y1] |
sar edx, ROUND |
push dx |
mov edx, [.scan_x1] |
sar edx, ROUND |
push dx |
push [.tex_ptr] |
push cx |
mov edx,ebx |
sar edx,ROUND |
push dx |
mov edx,eax |
sar edx,ROUND |
push dx |
call textured_line |
pop ebp |
pop cx |
pop ebx |
pop eax |
pop edi |
mov edx, [.tex_dx13] |
add [.scan_x1], edx |
mov edx, [.tex_dx12] |
add [.scan_x2], edx |
mov edx, [.tex_dy13] |
add [.scan_y1], edx |
mov edx, [.tex_dy12] |
add [.scan_y2], edx |
add eax, [.dx13] |
add ebx, [.dx12] |
inc cx |
cmp cx,[.y2] |
jl .tt_loop1 |
.tt_loop1_end: |
mov cx,[.y2] |
cmp cx, [.y3] |
jge .tt_loop2_end |
movsx ebx,[.x2] |
shl ebx,ROUND |
movsx edx, word[.tex_x2] |
shl edx,ROUND |
mov [.scan_x2],edx |
movsx edx, word[.tex_y2] |
shl edx,ROUND |
mov [.scan_y2],edx |
.tt_loop2: |
push edi |
push eax |
push ebx |
push cx |
push ebp |
mov edx, [.scan_y2] |
sar edx, ROUND |
push dx |
mov edx, [.scan_x2] |
sar edx, ROUND |
push dx |
mov edx, [.scan_y1] |
sar edx, ROUND |
push dx |
mov edx, [.scan_x1] |
sar edx, ROUND |
push dx |
push [.tex_ptr] |
push cx |
mov edx,ebx |
sar edx,ROUND |
push dx |
mov edx,eax |
sar edx,ROUND |
push dx |
call textured_line |
pop ebp |
pop cx |
pop ebx |
pop eax |
pop edi |
mov edx, [.tex_dx13] |
add [.scan_x1], edx |
mov edx, [.tex_dx23] |
add [.scan_x2], edx |
mov edx, [.tex_dy13] |
add [.scan_y1], edx |
mov edx, [.tex_dy23] |
add [.scan_y2], edx |
add eax, [.dx13] |
add ebx, [.dx23] |
inc cx |
cmp cx,[.y3] |
jl .tt_loop2 |
.tt_loop2_end: |
.tt_end: |
mov esp,ebp |
ret 12 |
.x1 dw ? |
.y1 dw ? |
.x2 dw ? |
.y2 dw ? |
.x3 dw ? |
.y3 dw ? |
.dx12 dd ? |
.dx13 dd ? |
.dx23 dd ? |
.tex_dx12 dd ? |
.tex_dy12 dd ? |
.tex_dx13 dd ? |
.tex_dy13 dd ? |
.tex_dx23 dd ? |
.tex_dy23 dd ? |
.tex_ptr dd ? |
.scan_x1 dd ? |
.scan_y1 dd ? |
.scan_x2 dd ? |
.scan_y2 dd ? |
textured_line: |
;-----in -edi screen buffer pointer |
;------------ stack: |
.x1 equ word [ebp+4] |
.x2 equ word [ebp+6] |
.y equ word [ebp+8] |
.tex_ptr equ dword [ebp+10] |
.tex_x1 equ word [ebp+14] |
.tex_y1 equ word [ebp+16] |
.tex_x2 equ word [ebp+18] |
.tex_y2 equ word [ebp+20] |
mov ebp,esp |
mov ax,.y |
or ax,ax |
jl .tl_quit |
cmp ax,SIZE_Y |
jg .tl_quit |
mov ax,.x1 |
cmp ax,.x2 |
je .tl_quit |
jl .tl_ok |
xchg ax,.x2 |
mov .x1,ax |
mov ax,.tex_x1 |
xchg ax,.tex_x2 |
mov .tex_x1,ax |
mov ax,.tex_y1 |
xchg ax,.tex_y2 |
mov .tex_y1,ax |
.tl_ok: |
mov ebx,edi |
movsx edi,.y |
mov eax,SIZE_X*3 |
mul edi |
mov edi,eax |
movsx eax,.x1 |
add edi,eax |
shl eax,1 |
add edi,eax |
add edi,ebx |
mov cx,.x2 |
sub cx,.x1 |
movsx ecx,cx |
mov ax,.tex_x2 |
sub ax,.tex_x1 |
cwde |
shl eax,ROUND |
cdq |
idiv ecx |
mov [.tex_dx],eax ; tex_dx=(tex_x2-tex_x1)/(x2-x1) |
mov ax,.tex_y2 |
sub ax,.tex_y1 |
cwde |
shl eax,ROUND |
cdq |
idiv ecx |
mov [.tex_dy],eax ; tex_dy = (tex_y2-tex_y1)/(x2-x1) |
movsx eax,.tex_x1 |
shl eax,ROUND |
movsx ebx,.tex_y1 |
shl ebx,ROUND |
cld |
.tl_loop: |
mov edx,eax |
mov esi,ebx |
sar edx,ROUND |
sar esi,ROUND |
macro .fluent |
{ |
push eax |
push edx |
mov eax,TEX_X*3 |
mul esi |
mov esi,eax |
pop edx |
pop eax |
} |
macro .shift |
{ |
shl esi,TEX_SHIFT |
lea esi,[esi*3] |
;push edx |
;mov edx,esi |
;shl esi,1 |
;add esi,edx |
;pop edx |
} |
if TEX = FLUENTLY |
.fluent |
end if |
if TEX = SHIFTING |
.shift |
end if |
lea edx,[edx*3] |
add esi,edx |
; shl edx,1 |
; add esi,edx |
add esi,.tex_ptr |
movsd |
dec edi |
add eax,[.tex_dx] |
add ebx,[.tex_dy] |
loop .tl_loop |
.tl_quit: |
mov esp,ebp |
ret 18 |
.tex_dx dd ? |
.tex_dy dd ? |
/programs/demos/3dsheart/trunk/tex_cat.ASM |
---|
0,0 → 1,585 |
;TEX_X = 512 |
;TEX_Y = 512 |
;ROUND equ 8 |
;SIZE_X = 512 |
;SIZE_Y = 512 |
;TEX_SHIFT = 9 |
CATMULL_SHIFT equ 8 |
;------------------------------------------------------------------------ |
;- Procedure drawing textured triangle using Catmull Z-buffer algorithm - |
;------------------------------------------------------------------------ |
tex_triangle_z: |
;----------in - eax - x1 shl 16 + y1 |
;-------------- ebx - x2 shl 16 + y2 |
;---------------ecx - x3 shl 16 + y3 |
;---------------edx - pointer to Z-buffer |
;---------------esi - pointer to texture buffer |
;---------------edi - pointer to screen buffer |
;-------------stack - texture coordinates |
;------------------ - z coordinates |
.tex_x1 equ ebp+4 |
.tex_y1 equ ebp+6 |
.tex_x2 equ ebp+8 |
.tex_y2 equ ebp+10 |
.tex_x3 equ ebp+12 |
.tex_y3 equ ebp+14 |
.z1 equ word[ebp+16] |
.z2 equ word[ebp+18] |
.z3 equ word[ebp+20] |
.tex_ptr equ dword[ebp-4] ; pointer to texture |
.z_ptr equ dword[ebp-8] ; pointer to z-buffer |
.x1 equ word[ebp-10] |
.y1 equ word[ebp-12] |
.x2 equ word[ebp-14] |
.y2 equ word[ebp-16] |
.x3 equ word[ebp-18] |
.y3 equ word[ebp-20] |
.dx12 equ dword[ebp-24] |
.tex_dx12 equ dword[ebp-28] |
.tex_dy12 equ dword[ebp-32] |
.dz12 equ dword[ebp-36] |
.dx13 equ dword[ebp-40] |
.tex_dx13 equ dword[ebp-44] |
.tex_dy13 equ dword[ebp-48] |
.dz13 equ dword[ebp-52] |
.dx23 equ dword[ebp-56] |
.tex_dx23 equ dword[ebp-60] |
.tex_dy23 equ dword[ebp-64] |
.dz23 equ dword[ebp-68] |
.scan_x1 equ dword[ebp-72] |
.scan_x2 equ dword[ebp-76] |
.scan_y1 equ dword[ebp-80] |
.scan_y2 equ dword[ebp-84] |
.cz1 equ dword[ebp-88] |
.cz2 equ dword[ebp-92] |
mov ebp,esp |
push esi ; store memory pointers |
push edx |
.tt_sort3: |
cmp ax,bx ;sort all parameters |
jle .tt_sort1 |
xchg eax,ebx |
mov edx,dword [.tex_x1] |
xchg edx,dword [.tex_x2] |
mov dword[.tex_x1],edx |
mov dx,.z1 |
xchg dx,.z2 |
mov .z1,dx |
.tt_sort1: |
cmp bx,cx |
jle .tt_sort2 |
xchg ebx,ecx |
mov edx,dword [.tex_x2] |
xchg edx,dword [.tex_x3] |
mov dword [.tex_x2],edx |
mov dx,.z2 |
xchg dx,.z3 |
mov .z2,dx |
jmp .tt_sort3 |
.tt_sort2: |
push eax ; and store to user friendly variables |
push ebx |
push ecx |
mov edx,80008000h ; eax,ebx,ecx are ANDd together into edx which means that |
and edx,ebx ; if *all* of them are negative a sign flag is raised |
and edx,ecx |
and edx,eax |
test edx,80008000h ; Check both X&Y at once |
jne .tt_loop2_end |
cmp ax,SIZE_Y |
jl @f |
cmp bx,SIZE_Y |
jl @f |
cmp cx,SIZE_Y |
jl @f |
ror eax,16 |
ror ebx,16 |
ror ecx,16 |
cmp ax,SIZE_X |
jl @f |
cmp bx,SIZE_X |
jl @f |
cmp cx,SIZE_X |
jl @f |
jmp .tt_loop2_end |
@@: |
mov eax,dword[.tex_x1] ; texture coords must be in [0..TEX_X(Y)] |
mov ebx,dword[.tex_x2] |
mov ecx,dword[.tex_x3] |
mov edx,eax |
or edx,ebx |
or edx,ecx |
test edx,80008000h |
jne .tt_loop2_end |
cmp ax,TEX_X |
jge .tt_loop2_end |
cmp bx,TEX_X |
jge .tt_loop2_end |
cmp cx,TEX_X |
jge .tt_loop2_end |
ror eax,16 |
ror ebx,16 |
ror ecx,16 |
cmp ax,TEX_Y |
jge .tt_loop2_end |
cmp bx,TEX_Y |
jge .tt_loop2_end |
cmp cx,TEX_Y |
jge .tt_loop2_end |
movsx ebx,.y2 ; calc delta |
sub bx,.y1 |
jnz .tt_dx12_make |
xor edx,edx |
mov ecx,4 |
@@: |
push edx |
loop @b |
jmp .tt_dx12_done |
.tt_dx12_make: |
mov ax,.x2 |
sub ax,.x1 |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx12,eax ; dx12 = (x2-x1)/(y2-y1) |
push eax |
mov ax,word[.tex_x2] |
sub ax,word[.tex_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov [.tex_dx12],eax ; tex_dx12 = (tex_x2-tex_x1)/(y2-y1) |
push eax |
mov ax,word[.tex_y2] |
sub ax,word[.tex_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov [.tex_dy12],eax ; tex_dy12 = (tex_y2-tex_y1)/(y2-y1) |
push eax |
mov ax,.z2 |
sub ax,.z1 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
.tt_dx12_done: |
movsx ebx,.y3 ; calc delta |
sub bx,.y1 |
jnz .tt_dx13_make |
xor edx,edx |
mov ecx,4 |
@@: |
push edx |
loop @b |
jmp .tt_dx13_done |
.tt_dx13_make: |
mov ax,.x3 |
sub ax,.x1 |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov .dx12,eax ; dx13 = (x3-x1)/(y3-y1) |
push eax |
mov ax,word[.tex_x3] |
sub ax,word[.tex_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov [.tex_dx12],eax ; tex_dx13 = (tex_x3-tex_x1)/(y3-y1) |
push eax |
mov ax,word[.tex_y3] |
sub ax,word[.tex_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov [.tex_dy12],eax ; tex_dy13 = (tex_y3-tex_y1)/(y3-y1) |
push eax |
mov ax,.z3 |
sub ax,.z1 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
.tt_dx13_done: |
mov bx,.y3 ; calc delta |
sub bx,.y2 |
jnz .tt_dx23_make |
xor edx,edx |
mov ecx,4 |
@@: |
push edx |
loop @b |
jmp .tt_dx23_done |
.tt_dx23_make: |
mov ax,.x3 |
sub ax,.x2 |
cwde |
shl eax,ROUND |
cdq |
movzx ebx,bx |
idiv ebx |
; mov .dx23,eax ; dx23 = (x3-x2)/(y3-y2) |
push eax |
mov ax,word[.tex_x3] |
sub ax,word[.tex_x2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov [.tex_dx23],eax ; tex_dx23 = (tex_x3-tex_x2)/(y3-y2) |
push eax |
mov ax,word[.tex_y3] |
sub ax,word[.tex_y2] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
; mov [.tex_dy23],eax ; tex_dy23 = (tex_y3-tex_y2)/(y3-y2) |
push eax |
mov ax,.z3 |
sub ax,.z2 |
cwde |
shl eax,CATMULL_SHIFT |
cdq |
idiv ebx |
push eax |
.tt_dx23_done: |
movsx eax,.x1 ;eax - cur x1 |
shl eax,ROUND ;ebx - cur x2 |
mov ebx,eax |
movsx edx, word[.tex_x1] |
shl edx,ROUND |
; mov [.scan_x1],edx |
; mov [.scan_x2],edx |
push edx |
push edx |
movsx edx, word[.tex_y1] |
shl edx,ROUND |
; mov [.scan_y1],edx |
; mov [.scan_y2],edx |
push edx |
push edx |
movsx edx,.z1 |
shl edx,CATMULL_SHIFT |
push edx |
push edx |
mov cx,.y1 |
cmp cx,.y2 |
jge .tt_loop1_end |
.tt_loop1: |
pushad |
push .z_ptr |
push .cz1 ; z coords shifted shl catmull_shift |
push .cz2 |
mov edx, .scan_y2 |
sar edx, ROUND |
push dx |
mov edx, .scan_x2 |
sar edx, ROUND |
push dx |
mov edx, .scan_y1 |
sar edx, ROUND |
push dx |
mov edx, .scan_x1 |
sar edx, ROUND |
push dx |
push esi ;[.tex_ptr] |
push cx |
sar ebx,ROUND |
push bx |
sar eax,ROUND |
push ax |
call textured_line_z |
popad |
mov edx,.dz13 |
add .cz1,edx |
mov edx,.dz12 |
add .cz2,edx |
mov edx, .tex_dx13 |
add .scan_x1, edx |
mov edx, .tex_dx12 |
add .scan_x2, edx |
mov edx, .tex_dy13 |
add .scan_y1, edx |
mov edx, .tex_dy12 |
add .scan_y2, edx |
add eax, .dx13 |
add ebx, .dx12 |
inc cx |
cmp cx,.y2 |
jl .tt_loop1 |
.tt_loop1_end: |
mov cx,.y2 |
cmp cx,.y3 |
jge .tt_loop2_end |
movsx ebx,.x2 |
shl ebx,ROUND |
movsx edx,.z2 |
shl edx,CATMULL_SHIFT |
mov .cz2,edx |
movzx edx, word [.tex_x2] |
shl edx,ROUND |
mov .scan_x2,edx |
movzx edx, word[.tex_y2] |
shl edx,ROUND |
mov .scan_y2,edx |
.tt_loop2: |
pushad |
push .z_ptr |
push .cz1 ; z coords shifted shl catmull_shift |
push .cz2 |
mov edx, .scan_y2 |
sar edx, ROUND |
push dx |
mov edx, .scan_x2 |
sar edx, ROUND |
push dx |
mov edx, .scan_y1 |
sar edx, ROUND |
push dx |
mov edx, .scan_x1 |
sar edx, ROUND |
push dx |
push esi ;[.tex_ptr] |
push cx |
sar ebx,ROUND |
push bx |
sar eax,ROUND |
push ax |
call textured_line_z |
popad |
mov edx,.dz13 |
add .cz1,edx |
mov edx,.dz23 |
add .cz2,edx |
mov edx, .tex_dx13 |
add .scan_x1, edx |
mov edx, .tex_dx23 |
add .scan_x2, edx |
mov edx, .tex_dy13 |
add .scan_y1, edx |
mov edx, .tex_dy23 |
add .scan_y2, edx |
add eax, .dx13 |
add ebx, .dx23 |
inc cx |
cmp cx,.y3 |
jl .tt_loop2 |
.tt_loop2_end: |
.tt_end: |
mov esp,ebp |
ret 18 |
textured_line_z: |
;-----in -edi screen buffer pointer |
;------------ stack: |
.x1 equ word [ebp+4] |
.x2 equ word [ebp+6] |
.y equ word [ebp+8] |
.tex_ptr equ dword [ebp+10] |
.tex_x1 equ ebp+14 |
.tex_y1 equ ebp+16 |
.tex_x2 equ ebp+18 |
.tex_y2 equ ebp+20 |
.z2 equ dword [ebp+22] ;z1, z2 coords shifted shl CATMULL_SHIFT |
.z1 equ dword [ebp+26] |
.z_ptr equ dword [ebp+30] |
.tex_dx equ dword [ebp-4] |
.tex_dy equ dword [ebp-8] |
.dz equ dword [ebp-12] |
.cz equ dword [ebp-16] |
.c_tex_x equ dword [ebp-20] ; current tex x |
mov ebp,esp |
mov ax,.y |
or ax,ax |
jl .tl_quit |
cmp ax,SIZE_Y |
jge .tl_quit |
mov ax,.x1 |
cmp ax,.x2 |
je .tl_quit |
jl .tl_ok |
xchg ax,.x2 ; sort params |
mov .x1,ax |
mov eax,dword[.tex_x1] |
xchg eax,dword[.tex_x2] |
mov dword[.tex_x1],eax |
mov eax,.z1 |
xchg eax,.z2 |
mov .z1,eax |
.tl_ok: |
cmp .x1,SIZE_X |
jge .tl_quit |
cmp .x2,0 |
jle .tl_quit |
mov bx,.x2 |
sub bx,.x1 |
movsx ebx,bx |
mov ax,word[.tex_x2] ; calc .dtx |
sub ax,word[.tex_x1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
push eax |
mov ax,word[.tex_y2] ; calc .dty |
sub ax,word[.tex_y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
push eax |
mov eax,.z2 ; calc .dz |
sub eax,.z1 |
cdq |
idiv ebx |
push eax |
cmp .x1,0 ; clipping |
jge @f |
movsx ebx,.x1 |
neg ebx |
imul ebx ; eax = .dz * abs(.x1) |
add .z1,eax |
mov .x1,0 |
mov eax,.tex_dy |
sar eax,ROUND |
imul ebx |
add word[.tex_y1],ax |
mov eax,.tex_dx |
sar eax,ROUND |
imul ebx |
add word[.tex_x1],ax |
@@: |
cmp .x2,SIZE_X |
jl @f |
mov .x2,SIZE_X |
@@: |
movsx ebx,.y ; calc mem begin in buffers |
mov eax,SIZE_X |
mul ebx |
movsx ebx,.x1 |
add eax,ebx |
mov ebx,eax |
lea eax,[eax*3] |
add edi,eax ; edi - scr buff |
shl ebx,2 |
add .z_ptr,ebx ; z buffer pointer |
mov cx,.x2 |
sub cx,.x1 |
movzx ecx,cx |
movzx eax,word[.tex_x1] |
shl eax,ROUND |
movzx ebx,word[.tex_y1] |
shl ebx,ROUND |
push .z1 ; .cz |
push eax ;.c_tex_x |
.tl_loop: |
mov edx,.z_ptr ; eax - temp |
mov eax,.cz ; ebx - cur tex y shl ROUND |
cmp eax,[edx] ; ecx - l.lenght |
jge .skip ; ebx - cur tex_y ; edx - temp |
mov esi,ebx ; edi - scr buff |
sar esi,ROUND ; esi - tex_ptr temp |
shl esi,TEX_SHIFT ; .z_ptr - cur pointer to z buff |
mov eax,.c_tex_x ; .cz - cur z coord shl CATMULL_SHIFT |
sar eax,ROUND |
add esi,eax |
and esi,TEXTURE_SIZE |
lea esi,[esi*3] |
add esi,.tex_ptr |
movsd |
dec edi |
mov eax,.cz |
mov esi,.z_ptr |
mov dword[esi],eax ; renew z buffer |
jmp .no_skip |
.skip: |
add edi,3 |
.no_skip: |
add .z_ptr,4 |
mov eax,.dz |
add .cz,eax |
mov eax,.tex_dx |
add .c_tex_x,eax |
add ebx,.tex_dy |
loop .tl_loop |
.tl_quit: |
mov esp,ebp |
ret 30 |
/programs/demos/3dsheart/trunk |
---|
Property changes: |
Added: bugtraq:number |
+true |
\ No newline at end of property |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |
/programs/demos/3dsheart |
---|
Property changes: |
Added: bugtraq:number |
+true |
\ No newline at end of property |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |
/programs/demos/3dwav/trunk/3dwav.asm |
---|
7,6 → 7,9 |
; |
; |
TIMEOUT EQU 2 |
IMG_X equ 512 |
IMG_Y equ 384 |
use32 |
org 0x0 |
96,7 → 99,7 |
mov eax,7 ;put image |
mov ebx,the_mem |
mov ecx,512*65536+384 |
mov ecx,IMG_X*65536+IMG_Y |
mov edx,0 |
int 0x40 |
204,14 → 207,14 |
mov ebx,1 ; 1, start of draw |
int 0x40 |
mov eax,48 |
mov eax,48 ;get skin width |
mov ebx,4 |
int 0x40 |
mov esi, eax |
; DRAW WINDOW |
mov eax,0 ; function 0 : define and draw window |
mov ebx,100*65536+512+9 ; [x start] *65536 + [x size] |
mov ecx,100*65536+384+4 ; [y start] *65536 + [y size] |
mov ebx,100*65536+IMG_X+9 ; [x start] *65536 + [x size] |
mov ecx,100*65536+IMG_Y+4 ; [y start] *65536 + [y size] |
add ecx, esi |
mov edx,0x74000000 ; color of work area RRGGBB,8->color gl |
mov edi,labelt |