/programs/demos/view3ds/3dmath.inc |
---|
198,28 → 198,11 |
;---------------------------- edi - pointer to vector ----- |
;----------------------- out : none |
normalize_vector: |
if Ext = SSE2 | Ext = SSE | Ext = SSE3 |
if Ext >= SSE3 |
movups xmm0,[edi] |
andps xmm0,[zero_hgst_dd] |
movups xmm1,xmm0 |
mulps xmm0,xmm0 |
movhlps xmm2,xmm0 |
addps xmm0,xmm2 |
movaps xmm2,xmm0 |
shufps xmm2,xmm2,11100001b |
addps xmm0,xmm2 |
shufps xmm0,xmm0,0 |
rsqrtps xmm0,xmm0 |
mulps xmm0,xmm1 |
movlps [edi],xmm0 |
movhlps xmm0,xmm0 |
movss [edi+8],xmm0 |
end if |
if 0 ; Ext >= SSE3 |
movups xmm0,[edi] |
andps xmm0,[zero_hgst_dd] |
movups xmm1,xmm0 |
mulps xmm0,xmm0 |
haddps xmm0,xmm0 |
haddps xmm0,xmm0 |
rsqrtps xmm0,xmm0 |
227,8 → 210,7 |
movlps [edi],xmm0 |
movhlps xmm0,xmm0 |
movss [edi+8],xmm0 |
end if |
if Ext < SSE |
else |
fninit |
fld dword [edi+vec_x] |
/programs/demos/view3ds/3stencil.inc |
---|
312,9 → 312,11 |
sub ecx,.x1 |
movss xmm2,.z1 ; cz |
.ccalc: |
; movss xmm1,xmm2 |
comiss xmm2,dword[esi] |
jg @f |
movss xmm1,xmm2 |
cmpltss xmm1,dword[esi] |
movd eax,xmm1 |
cmp eax,-1 |
jnz @f |
movss dword[esi],xmm2 |
@@: |
add esi,4 |
/programs/demos/view3ds/a_procs.inc |
---|
1,3 → 1,227 |
;=============================================================== |
do_edges_list: |
push ebp |
mov ebp,esp |
sub esp,32 |
.ed_cnt equ [ebp-4] |
.edd_ptr equ [ebp-8] |
.counter equ [ebp-12] |
mov ebx,[edges_ptr] |
mov eax,[triangles_ptr] |
mov ecx,[triangles_count_var] |
@@: |
movdqu xmm0,[eax] |
movq [ebx],xmm0 |
pshufd xmm0,xmm0,11001001b |
movq [ebx+8],xmm0 |
pshufd xmm0,xmm0,11001001b |
movq [ebx+16],xmm0 |
add ebx,24 |
add eax,12 |
loop @b |
mov ebx,[edges_ptr] |
mov ecx,[triangles_count_var] |
lea ecx,[ecx*3] |
.mxd: |
mov eax,[ebx] |
cmp eax,[ebx+4] |
jl @f |
movq xmm0,[ebx] |
pshufd xmm0,xmm0,11100001b |
movq [ebx],xmm0 |
@@: |
add ebx,8 |
loop .mxd |
; insert sort |
mov ebx,[edges_ptr] |
mov ecx,[triangles_count_var] |
lea ecx,[ecx*3] |
mov esi,ecx |
shl esi,3 |
add esi,ebx |
.ccc: |
mov eax,[ebx+8] |
cmp eax,[ebx] |
jge .g |
movq xmm0,[ebx+8] |
push ebx |
.c: |
cmp ebx,esi |
jge .done |
cmp ebx,[edges_ptr] |
jl .done |
cmp eax,[ebx] |
jge .done |
movq xmm7,[ebx] |
movq [ebx+8],xmm7 |
sub ebx,8 |
jnz .c |
add ebx,8 |
.done: |
movq [ebx+8],xmm0 |
.p: |
pop ebx |
.g: |
add ebx,8 |
dec ecx |
cmp ecx,1 |
jnz .ccc |
; insert sort again |
mov ebx,[edges_ptr] |
mov ecx,[triangles_count_var] |
lea ecx,[ecx*3] |
mov esi,ecx |
shl esi,3 |
add esi,ebx |
.count: |
push ecx |
push ebx |
xor ecx,ecx |
mov eax,[ebx] ; count |
.aa: |
inc ecx |
add ebx,8 |
cmp ebx,esi |
jge .br ; break |
cmp eax,[ebx] |
je .aa |
mov .counter,ecx |
pop ebx |
mov edi,ebx |
sub edi,8 |
mov edx,[ebx+8] |
.ccc2: |
cmp ebx,esi |
jbe @f |
add esp,4 |
jmp .ff |
@@: |
mov eax,[ebx+12] |
mov edx,[ebx+8] |
cmp eax,[ebx+4] |
jge .gg2 |
movq xmm0,[ebx+8] |
push ebx |
.c2: |
cmp eax,[ebx+4] |
jge .done2 |
movq xmm7,[ebx] |
movq [ebx+8],xmm7 |
sub ebx,8 |
cmp ebx,edi |
jz @f |
cmp [ebx+8],edx |
jz .c2 |
@@: |
.done2: |
add ebx,8 |
movq [ebx],xmm0 |
.p2: |
pop ebx |
.gg2: |
add ebx,8 |
dec ecx |
cmp ecx,1 |
jnz .ccc2 |
pop ecx |
sub ecx,.counter |
add ebx,8 |
ja .count |
jmp .ff |
.br: ;break |
add esp,8 |
.ff: |
; count edges |
mov ecx,0 |
mov edx,[triangles_count_var] |
lea edx,[edx*3] |
mov ebx,[edges_ptr] |
; mov esi,edx |
; shl esi,3 |
; add esi,[edges_ptr] |
.nx: |
movq xmm0,[ebx] |
add ebx,8 |
; cmp ebx,esi |
; jae @f |
movq xmm1,[ebx] |
; @@: |
pcmpeqd xmm0,xmm1 |
pmovmskb eax,xmm0 |
and eax,0xff |
cmp eax,0xff |
jz @f |
inc ecx |
@@: |
dec edx |
jnz .nx |
mov .ed_cnt,ecx |
lea ecx,[ecx*3] |
shl ecx,2 |
add ecx,65536 |
mov ebx,12 |
mov eax,68 |
mov edx,.edd_ptr |
int 0x40 ; -> allocate memory to triangles |
mov .edd_ptr, eax ; -> eax = pointer to allocated mem |
mov ebx,[edges_ptr] |
mov ecx,[triangles_count_var] |
lea ecx,[ecx*3] |
.seek: |
movq xmm0,[ebx] |
movq xmm1,[ebx+8] |
pcmpeqd xmm1,xmm0 |
pmovmskb edx,xmm1 |
and edx,0xff |
cmp edx,0xff |
je @f |
movq [eax],xmm0 |
add eax,8 |
@@: |
add ebx,8 |
loop .seek |
mov eax,68 |
mov ebx,13 |
mov ecx,[edges_ptr] |
int 0x40 ; release old edges ptr |
mov eax,.edd_ptr |
mov ecx,.ed_cnt |
mov [edges_ptr],eax |
mov [edges_count],ecx |
mov esp,ebp |
pop ebp |
ret |
;======================= |
do_sinus: |
.x equ [ebp-8] |
.y equ [ebp-12] |
19,21 → 243,53 |
cld |
rep stosd |
pop edi |
; movzx eax,[sinus_flag] |
; mov edx,10 |
; mul edx |
; mov [sin_amplitude],eax |
; mov [sin_frq],eax |
fninit |
;if Ext = SSE2 |
; movups xmm1,[const0123] ; xmm1 - init values |
; mov eax,0x000000ff |
; movd xmm2,eax |
; shufps xmm2,xmm2,0 ; xmm2 - mask value |
; mov eax,4 |
; movd xmm3,eax |
; shufps xmm3,xmm3,0 |
.again: |
if 0 |
fild dword .x |
fidiv [sin_frq] |
fsin |
fimul [sin_amplitude] |
fiadd dword .y |
fistp dword .new_y |
else |
fild dword .x |
fmul [sin_frq] |
fistp dword .temp |
mov eax, .temp |
; mov bx, [angle_x] |
; add bx, [angle_y] |
; movzx ebx,bx |
; shr ebx,1 ; change phase |
; add eax,ebx |
and eax, 0x000000ff |
; cdq |
; mul [sin_frq] |
; and eax,0x000000ff |
; and ax,0x00ff |
; cwde |
fld dword [sin_tab+eax*4] |
fimul dword [sin_amplitude] |
fiadd dword .y |
fistp dword .new_y |
end if |
mov eax,.new_y |
or eax,eax |
jl .skip |
244,7 → 500,109 |
ret |
;align 16 |
; emboss_bias: |
; dw 128, 128, 128, 128, 128, 128, 128, 128 |
if 0 ; old emb proc |
; emboss - after drawing all, |
; transfer screen buffer into bump map |
; and draw two bump triangles |
; ************************************* |
mov esi,screen |
mov edi,bumpmap2 |
mov ecx,TEXTURE_SIZE/3 |
cld |
if Ext=NON |
xor eax,eax |
xor bh,bh |
xor dh,dh |
@@: |
lodsb |
movzx bx,al |
lodsb |
movzx dx,al |
lodsb |
add ax,bx |
add ax,dx |
; cwd |
; div [i3] |
;; push ax |
;; pop bx |
;; shr bx,3 |
;; shr ax,2 |
;; add ax,bx |
lea eax,[eax*5] |
shr ax,4 |
stosb |
loop @b |
else |
emms |
pxor mm1,mm1 |
mov ebx,0x0000ffff |
@@: |
movd mm0,[esi] |
punpcklbw mm0,mm1 |
movq mm2,mm0 |
psrlq mm2,16 |
movq mm3,mm0 |
psrlq mm3,32 |
paddw mm0,mm2 |
paddw mm0,mm3 |
movd eax,mm0 |
and eax,ebx |
lea eax,[eax*5] |
shr ax,4 |
stosb |
add esi,3 |
loop @b |
end if |
push ebp |
push dword 0 ; env coords |
push word 0 |
push word SIZE_X |
push word SIZE_Y |
push dword 0 |
push dword 0 ; bump coords |
push word SIZE_X |
push word SIZE_Y |
push word 0 |
mov eax,SIZE_Y |
mov ebx,SIZE_X*65536+0 |
xor ecx,ecx |
mov edx,bumpmap2 |
mov esi,envmap |
mov edi,screen |
call bump_triangle |
push dword SIZE_X shl 16 + SIZE_Y ; env coords |
push word 0 |
push word SIZE_X |
push word SIZE_Y |
push word 0 |
push dword SIZE_X shl 16 + SIZE_Y ; bump coords |
push word 0 |
push word SIZE_X |
push word SIZE_Y |
push word 0 |
mov eax,SIZE_Y |
mov ebx,SIZE_X * 65536+0 |
mov ecx,SIZE_X shl 16 + SIZE_Y |
mov edx,bumpmap2 |
mov esi,envmap |
mov edi,screen |
call bump_triangle |
pop ebp |
ret |
end if |
;********************************EMBOSS DONE******************************* |
/programs/demos/view3ds/b_procs.inc |
---|
60,25 → 60,24 |
; stack - other parameters |
; out - eax - 0x00rrggbb |
.dot_prd equ dword[ebp+4] ; dot product - cos x - not now |
.min_col_r equ [ebp+8] ; minimum color - ambient |
.min_col_r equ word[ebp+8] ; minimum color - ambient |
.min_col_g equ word[ebp+10] |
.min_col_b equ word[ebp+12] |
.max_col_r equ [ebp+14] ; maximum color - specular |
.max_col_r equ word[ebp+14] ; maximum color - specular |
.max_col_g equ word[ebp+16] |
.max_col_b equ word[ebp+18] |
.org_col_r equ [ebp+20] ; orginal color - diffuse |
.org_col_r equ word[ebp+20] ; orginal color - diffuse |
.org_col_g equ word[ebp+22] |
.org_col_b equ word[ebp+24] |
.n equ word[ebp+26] ; shines - not implemented |
.temp equ word[ebp-2] |
.color_sum_r equ [ebp-6] |
.color_sum_g equ [ebp-10] |
.color_sum_b equ [ebp-14] |
.color_sum_r equ dword[ebp-6] |
.color_sum_g equ dword[ebp-10] |
.color_sum_b equ dword[ebp-14] |
; color = ambient+cos(x)*diffuse+(cos(x)^n)*specular |
mov ebp,esp |
sub esp,14 |
mov ax,.min_col_r |
add ax,.max_col_r |
add ax,.org_col_r |
96,38 → 95,8 |
add ax,.org_col_b |
cwde |
mov .color_sum_b,eax |
if 0 |
movq xmm0,.min_col_r |
movq xmm1,.max_col_r |
movq xmm2,.org_col_r |
packuswb xmm0,[the_zero] |
packuswb xmm1,[the_zero] |
packuswb xmm2,[the_zero] |
punpcklbw xmm0,xmm1 |
punpcklbw xmm2,[the_zero] |
packusdw xmm2,[the_zero] |
cvtdq2ps xmm0,xmm0 |
cvtdq2ps xmm1,xmm1 |
cvtdq2ps xmm2,xmm2 |
haddps xmm0,xmm0 |
haddps xmm1,xmm1 |
haddps xmm2,xmm2 |
haddps xmm0,xmm0 |
haddps xmm1,xmm1 |
haddps xmm2,xmm2 |
cvtss2si eax,xmm0 |
cvtss2si ebx,xmm1 |
cvtss2si ecx,xmm2 |
mov .color_sum_r,eax |
mov .color_sum_g,ebx |
mov .color_sum_b,ecx |
end if |
; fld .dot_prd |
; fild .n |
; fxch st1 |
154,7 → 123,7 |
faddp ; st0=first piece of col, st1=dot_pr^n.. |
fiadd .min_col_b |
fimul .max_col_b |
fidiv dword .color_sum_b |
fidiv .color_sum_b |
fistp .temp |
movzx eax,.temp |
shl eax,16 |
166,19 → 135,19 |
faddp |
fiadd .min_col_g |
fimul .max_col_g |
fidiv dword .color_sum_g |
fidiv .color_sum_g |
fistp .temp |
mov ax,.temp |
mov ah,al |
shl eax,8 |
fimul word .max_col_r |
fild word .org_col_r |
fimul .max_col_r |
fild .org_col_r |
fmulp st2,st |
faddp |
fiadd word .min_col_r |
fimul word .max_col_r |
fidiv dword .color_sum_r |
fiadd .min_col_r |
fimul .max_col_r |
fidiv .color_sum_r |
fistp .temp |
mov ax,.temp ;eax - 0xbbgg00rr |
; mov ah,al |
/programs/demos/view3ds/data.inc |
---|
1,12 → 1,15 |
; DATA AREA ************************************ |
i3 dw 3 |
i6 dd 6 |
i12 dd 12 |
i36 dd 36 |
i256 dw 256 |
i255d dd 255 |
dot_max dd 1.0 ; dot product max and min |
dot_min dd 0.0 |
env_const dd 1.05 |
correct_tex dw 255 |
tex_x_div2 dw TEX_X / 2 |
tex_y_div2 dw TEX_Y / 2 |
xobs dw 0 ;SIZE_X / 2 ;200 ;observer = camera |
54,6 → 57,7 |
points_ptr dd 0 |
points_rotated_ptr dd 0 |
points_translated_ptr dd 0 |
edges_ptr dd 0 |
screen_ptr dd 0 |
Zbuffer_ptr dd 0 |
vertices_index_ptr dd 0 |
64,6 → 68,9 |
edit_end_x: |
dw 0 |
edit_end_y dw 0 |
x_start: dw 20 |
y_start: dw 20 |
mouse_state dd 0 |
343,10 → 350,20 |
if Ext=SSE3 |
db ' (SSE3)' |
end if |
db ' 0.072',0 |
db ' 0.073',0 |
labellen: |
STRdata db '-1 ' |
lab_vert: |
db 'Vertices count: ' |
lab_vert_end: |
lab_tr: |
db 'Faces count: ' |
lab_tr_end: |
lab_ed: |
db 'Edges count: ' |
lab_ed_end: |
all_lights_size dw lightsend-lights |
410,6 → 427,8 |
align 16 |
abs_mask: |
dd 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff |
emboss_bias: |
dw 128, 128, 128, 128, 128, 128, 128, 128 |
zero_hgst_dd: |
465,22 → 484,10 |
col3 dd ? |
scale dd ? ; help scale variable |
;== |
triangles_count_var dd ? |
points_count_var dd ? |
points_count_var dd ? ; |
triangles_count_var dd ? ; dont change order |
edges_count dd ? ; |
; size_y_var: |
; yres_var dw ? |
; size_x_var: |
; xres_var dw ? |
x_start: |
dw ? |
y_start: |
dw ? |
;=== |
point_index1 dd ? ;-\ |
point_index2 dd ? ; } don't change order |
point_index3 dd ? ;-/ |
/programs/demos/view3ds/grd_line.inc |
---|
1,643 → 1,115 |
;-procedure draws smooth shaded lines (I mean interpolation 24 bit-- |
;-color), with z coord interpolation-------------------------------- |
;-author: Maciej Guba (www.macgub.hekko.pl)------------------------- |
;-in : ------------------------------------------------------------- |
;----- edi - pointer to screen buffer ------------------------------ |
;----- esi - pointer to Z buffer ----------------------------------- |
;------ constans : SIZE_X, SIZE_Y - screen width and height--------- |
;----------------- ROUND - fixed point shift------------------------ |
;------ other parameters via stack---------------------------------- |
smooth_line: |
.x1 equ ebp+4 |
.y1 equ ebp+6 |
.z1 equ ebp+8 |
.r1 equ ebp+10 |
.g1 equ ebp+12 |
.b1 equ ebp+14 |
.x2 equ ebp+16 |
.y2 equ ebp+18 |
.z2 equ ebp+20 |
.r2 equ ebp+22 |
.g2 equ ebp+24 |
.b2 equ ebp+26 |
; Line drawing procedure by Pablo Reda. |
; Gouraud extension by Maciej Guba. |
;**************************************************** |
line_grd: ; eax=x1 ebx=y1 ecx=x2 edx=y2 |
; xmm0 - color1 argb as 4 dword float |
; xmm1 - color2 argb as 4 dword float |
; xmm2 - z1 as dword float |
; xmm3 - z2 as dword float |
; mm0 - Z buffer |
; mm1 - screen buffer |
; mm2 - screen width |
.line_lenght equ ebp-2 |
.delta equ ebp-6 |
.delta_x equ ebp-10 |
.delta_y equ ebp-14 |
.dr equ ebp-18 |
.dg equ ebp-22 |
.db equ ebp-26 |
.dz equ ebp-30 |
.cr equ ebp-34 |
.cg equ ebp-38 |
.cb equ ebp-42 |
.cz equ ebp-46 |
cmp ebx,edx |
; je horizontal_grd |
jg .noswap |
xchg eax,ecx |
xchg ebx,edx |
movaps xmm7,xmm0 |
movaps xmm0,xmm1 |
movaps xmm1,xmm7 |
movaps xmm7,xmm2 |
movaps xmm2,xmm3 |
movaps xmm3,xmm7 |
.noswap: |
;.line_lenght equ ebp-48 |
.screen equ ebp-52 |
.zbuffer equ ebp-56 |
.ccoord equ ebp-60 ;current coordinate |
.czbuf equ ebp-64 |
.cscr equ ebp-68 |
.xres equ ebp-72 |
.yres equ ebp-76 |
.xresm1 equ ebp-80 |
.yresm1 equ ebp-84 |
.xresp1 equ ebp-88 |
.yresp1 equ ebp-92 |
.xres3 equ ebp-96 |
.xres4 equ ebp-100 |
cvtsi2ss xmm7,eax |
cvtsi2ss xmm6,ebx |
cvtsi2ss xmm5,ecx |
cvtsi2ss xmm4,edx |
subss xmm7,xmm5 |
subss xmm6,xmm4 |
andps xmm7,[abs_mask] ; 0x7fff |
andps xmm6,[abs_mask] ; 0x7fff |
maxss xmm7,xmm6 ; xmm7 - delta |
shufps xmm7,xmm7,0 |
movaps xmm6,xmm3 |
rcpps xmm7,xmm7 |
subss xmm6,xmm2 |
mulss xmm6,xmm7 ; xmm6 - delta z |
movaps xmm5,xmm1 |
subps xmm5,xmm0 |
mulps xmm5,xmm7 ; xmm5 - delta col argb |
macro .update_cur_var |
{ |
if Ext=NON |
mov ebx,[.dz] |
add [.cz],ebx |
mov ebx,[.dr] |
add [.cr],ebx |
mov ebx,[.dg] |
add [.cg],ebx |
mov ebx,[.db] |
add [.cb],ebx |
elseif Ext=MMX |
movq mm0,[.cz] |
movq mm1,[.cg] |
paddd mm0,mm2 ;[.dz] |
paddd mm1,mm3 ;[.dg] |
movq [.cz],mm0 |
movq [.cg],mm1 |
elseif Ext >= SSE2 |
; movups xmm1,[.cz] |
paddd xmm1,xmm0 |
; movups [.cz],xmm1 |
end if |
} |
macro .draw_pixel |
{ |
mov [esi],ebx ; actualize Z buffer |
if Ext>=SSE2 |
movaps xmm7,xmm1 ;[.cb] ;;xmm1 |
shufps xmm7,xmm7,00111001b |
psrld xmm7,ROUND |
packssdw xmm7,xmm7 |
packuswb xmm7,xmm7 |
pand xmm7,xmm6 ;[.mask] |
movd [edi],xmm7 |
else |
mov eax,[.cb] |
sar eax,ROUND |
mov [edi],al |
; and eax,0x000000ff ; clean unused bits |
mov ebx,[.cg] |
sar ebx,ROUND |
mov [edi+1],bl |
; mov ah,bl |
mov edx,[.cr] |
sar edx,ROUND |
mov [edi+2],dl |
end if |
; shl ebx,16 |
; or eax,ebx |
; mov [edi],eax |
} |
macro .sort |
{ |
if Ext >= MMX |
movq mm0,[.x1] |
movq mm1,[.x2] |
movq [.x1],mm1 |
movq [.x2],mm0 |
else |
mov edx,[.x1] |
xchg edx,[.x2] |
mov [.x1],edx |
mov edx,[.z1] |
xchg edx,[.z2] |
mov [.z1],edx |
end if |
mov edx,[.g1] |
xchg edx,[.g2] |
mov [.g1],edx |
} |
emms |
mov ebp,esp |
sub esp,128 |
mov eax,[.x1] ; check if parameters exceedes screen area |
mov ebx,[.x2] |
or eax,ebx |
test eax,80008000h |
jne .end_line |
movzx edx,word [size_x_var] |
mov [.xres],edx |
dec edx |
movzx ecx,word [size_y_var] |
mov [.yres],ecx |
dec ecx |
cmp word[.x1],dx ;SIZE_X |
jg .end_line |
cmp word[.x2],dx ;SIZE_X |
jg .end_line |
cmp word[.y1],cx ;SIZE_Y |
jg .end_line |
cmp word[.y2],cx ;SIZE_Y |
jg .end_line |
mov edx,[.xres] |
shl edx,2 |
mov [.xres4],edx |
shr edx,2 |
lea edx,[edx*3] |
mov [.xres3],edx |
mov edx,[.xres] |
mov ecx,[.yres] |
dec edx |
dec ecx |
mov [.xresm1],edx |
mov [.yresm1],ecx |
add edx,2 |
add ecx,2 |
mov [.xresp1],edx |
mov [.yresp1],ecx |
mov [.screen],edi |
mov cx,[.x1] |
cmp cx,[.x2] |
je .vertical_l |
mov cx,[.y1] |
cmp cx,[.y2] |
je .horizontal_l |
mov ax,[.x1] |
sub ax,[.x2] |
cmp ax,0 |
jg @f |
neg ax ; calc absolute value |
@@: |
mov [.delta_x],ax |
mov bx,[.y1] |
sub bx,[.y2] |
cmp bx,0 |
jg @f |
neg bx |
@@: |
mov [.delta_y],bx |
cmp ax,bx |
je .deg45_l |
jl .more_vertical_l |
jg .more_horizon_l |
jmp .end_line |
; |
.horizontal_l: |
mov ax,[.x1] |
mov bx,[.x2] |
cmp bx,ax |
jge @f |
.sort |
@@: |
mov bx,[.x2] |
sub bx,[.x1] |
movsx ebx,bx |
cmp ebx,0 ;line lenght equql 0 |
je .end_line |
mov [.delta_x],ebx |
call .calc_delta |
mov eax,[.xres] ;SIZE_X |
movsx ebx,word[.y1] |
mul ebx |
add esi,eax |
lea eax,[eax*3] |
add esi,eax |
add edi,eax |
movsx eax,word[.x1] |
add esi,eax |
lea eax,[eax*3] |
add edi,eax |
add esi,eax |
mov ecx,[.delta_x] |
movsx ebx,word[.r1] |
shl ebx,ROUND |
mov [.cr],ebx |
movsx ebx,word[.g1] |
shl ebx,ROUND |
mov [.cg],ebx |
movsx ebx,word[.b1] |
shl ebx,ROUND |
mov [.cb],ebx |
movsx ebx,word[.z1] |
shl ebx,ROUND |
mov [.cz],ebx |
if Ext >= SSE2 |
movups xmm1,[.cz] |
end if |
.hdraw: |
if Ext >= SSE2 |
movd ebx,xmm1 |
else |
mov ebx,[.cz] |
end if |
cmp [esi],ebx |
jle .skip |
.draw_pixel |
.skip: |
add edi,3 |
add esi,4 |
.update_cur_var |
loop .hdraw |
jmp .end_line |
.vertical_l: |
mov ax,[.y1] |
cmp [.y2],ax |
jge @f |
.sort |
@@: |
mov bx,[.y2] |
sub bx,[.y1] |
movsx ebx,bx |
cmp ebx,0 |
je .end_line |
mov [.delta_y],ebx |
call .calc_delta |
mov eax,[.xres] ;SIZE_X |
movsx ebx,word[.y1] |
mul ebx |
add esi,eax |
lea eax,[eax*3] |
add edi,eax |
add esi,eax |
movsx eax,word[.x1] |
add esi,eax |
lea eax,[eax*3] |
add esi,eax |
add edi,eax |
mov ecx,[.delta_y] |
movsx ebx,word[.r1] |
shl ebx,ROUND |
mov [.cr],ebx |
movsx ebx,word[.g1] |
shl ebx,ROUND |
mov [.cg],ebx |
movsx ebx,word[.b1] |
shl ebx,ROUND |
mov [.cb],ebx |
movsx ebx,word[.z1] |
shl ebx,ROUND |
mov [.cz],ebx |
if Ext >= SSE2 |
movups xmm1,[.cz] |
end if |
.v_draw: |
if Ext >= SSE2 |
movd ebx,xmm1 |
else |
mov ebx,[.cz] |
end if |
cmp [esi],ebx |
jle @f |
.draw_pixel |
@@: |
add edi,[.xres3] |
add esi,[.xres4] |
.update_cur_var |
loop .v_draw |
jmp .end_line |
.deg45_l: |
mov word[.line_lenght],ax |
mov ax,[.x1] |
cmp [.x2],ax |
jge @f |
.sort |
@@: |
mov bx,[.y2] |
sub bx,[.y1] |
movsx ebx,bx |
cmp ebx,0 |
je .end_line |
mov [.delta_y],ebx |
mov bx,[.x2] |
sub bx,[.x1] |
movsx ebx,bx |
mov [.delta_x],ebx |
call .calc_delta |
mov eax,[.xres] |
movsx ebx,word[.y1] ;calc begin values in screen and Z buffers |
mul ebx |
lea ebx,[3*eax] |
add edi,ebx |
shl eax,2 |
add esi,eax |
movsx eax,word[.x1] |
lea ebx,[eax*3] |
add edi,ebx |
shl eax,2 |
add esi,eax |
movzx ecx,word[.line_lenght] |
movsx ebx,word[.r1] |
shl ebx,ROUND |
mov [.cr],ebx |
movsx ebx,word[.g1] |
shl ebx,ROUND |
mov [.cg],ebx |
movsx ebx,word[.b1] |
shl ebx,ROUND |
mov [.cb],ebx |
movsx ebx,word[.z1] |
shl ebx,ROUND |
mov [.cz],ebx |
.d45_draw: |
if Ext >= SSE2 |
movd ebx,xmm1 |
else |
mov ebx,[.cz] |
end if |
cmp [esi],ebx |
jle @f |
.draw_pixel |
@@: |
cmp dword[.delta_y],0 |
jl @f |
add edi,[.xres3] ;SIZE_X*3+3 |
add edi,3 |
add esi,[.xres4] ;SIZE_X*4+4 |
add esi,4 |
jmp .d45_1 |
@@: |
sub edi,[.xres3] ;(SIZE_X*3)-3 |
sub edi,3 |
sub esi,[.xres4] ;(SIZE_X*4)-4 |
sub esi,4 |
.d45_1: |
.update_cur_var |
loop .d45_draw |
jmp .end_line |
.more_vertical_l: |
mov word[.line_lenght],bx |
mov ax,[.y1] |
cmp [.y2],ax |
jge @f |
.sort |
@@: |
mov bx,[.y2] |
sub bx,[.y1] |
movsx ebx,bx |
cmp ebx,0 |
je .end_line ;======================= |
mov [.delta_y],ebx |
mov ax,[.x2] |
sub ax,[.x1] |
cwde |
shl eax,ROUND |
shl eax,16 |
shl ecx,16 |
sub eax,ecx |
push ebx |
push edx |
sub ebx,edx |
add ebx,1 |
cdq |
idiv ebx |
mov [.delta],eax |
mov esi,eax |
add ecx,$7fff |
pop ebx |
pop edx |
.lineas: |
mov eax,ecx |
add eax,esi |
push ebx |
push eax |
push edx |
shr ecx,16 |
shr eax,16 |
call horizontal_grd |
pop edx |
pop ecx |
pop ebx |
add ebx,1 |
cmp ebx,edx |
jle .lineas |
ret |
call .calc_delta |
mov eax,[.xres] ;SIZE_X |
movsx ebx,word[.y1] ;calc begin values in screen and Z buffers |
mul ebx |
lea ebx,[3*eax] |
add esi,ebx |
add esi,eax |
add edi,ebx |
mov [.cscr],edi |
mov [.czbuf],esi |
movzx ecx,word[.line_lenght] |
movsx ebx,word[.r1] |
shl ebx,ROUND |
mov [.cr],ebx |
movsx ebx,word[.g1] |
shl ebx,ROUND |
mov [.cg],ebx |
movsx ebx,word[.b1] |
shl ebx,ROUND |
mov [.cb],ebx |
movsx ebx,word[.z1] |
shl ebx,ROUND |
mov [.cz],ebx |
if Ext >= SSE2 |
movups xmm1,[.cz] |
end if |
movsx ebx,word[.x1] |
shl ebx,ROUND |
mov [.ccoord],ebx ; .ccoord -> x coordinate |
.draw_m_v: |
mov edi,[.cscr] |
mov esi,[.czbuf] |
mov eax,[.ccoord] |
sar eax,ROUND |
lea ebx,[eax*3] |
add edi,ebx |
add esi,ebx |
add esi,eax |
if Ext >= SSE2 |
movd ebx,xmm1 |
else |
mov ebx,[.cz] |
end if |
cmp [esi],ebx |
jle @f |
.draw_pixel |
horizontal_grd: ; eax=x1 ebx=y1 ecx=x2 |
cmp ecx,eax |
jg .m |
xchg ecx,eax |
.m: |
sub ecx,eax |
jnz .nn |
add ecx,1 |
.nn: |
movd edx,mm2 |
imul ebx,edx |
add eax,ebx |
movd edi,mm1 |
lea edi,[edi+eax*4] |
push eax |
push ebx |
movd ebx,mm0 |
lea ebx,[ebx+eax*4] |
.l: |
; movss xmm4,xmm2 ; xmm2 - cur z |
; cmpnltss xmm4,[ebx] |
; movd eax,xmm4 |
; or eax,eax |
; jnz @f |
comiss xmm2,[ebx] |
jng @f |
movaps xmm4,xmm0 ; xmm0 - cur col |
cvtps2dq xmm4,xmm4 |
packssdw xmm4,xmm4 |
packuswb xmm4,xmm4 |
movd [edi],xmm4 |
@@: |
mov eax,[.delta] |
mov ebx,[.xres3] |
add [.ccoord],eax |
mov eax,[.xres4] |
add dword[.cscr],ebx ;SIZE_X*3 ; |
add dword[.czbuf],eax ;SIZE_X*4 |
.d_m_v1: |
.update_cur_var |
dec ecx |
jnz .draw_m_v |
jmp .end_line |
.more_horizon_l: |
mov word[.line_lenght],ax |
mov ax,[.x1] |
cmp [.x2],ax |
jge @f |
.sort |
@@: |
mov bx,[.x2] |
sub bx,[.x1] |
movsx ebx,bx |
cmp ebx,0;======================= |
je .end_line |
mov [.delta_x],ebx |
mov ax,[.y2] |
sub ax,[.y1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.delta],eax |
call .calc_delta |
;calc begin values in screen and Z buffers |
movsx ebx,word[.x1] |
mov eax,ebx |
add esi,ebx |
lea ebx,[3*ebx] |
add esi,ebx |
add edi,ebx |
mov [.cscr],edi |
mov [.czbuf],esi |
movzx ecx,word[.line_lenght] |
movsx ebx,word[.r1] |
shl ebx,ROUND |
mov [.cr],ebx |
movsx ebx,word[.g1] |
shl ebx,ROUND |
mov [.cg],ebx |
movsx ebx,word[.b1] |
shl ebx,ROUND |
mov [.cb],ebx |
movsx ebx,word[.z1] |
shl ebx,ROUND |
mov [.cz],ebx |
if Ext >= SSE2 |
movups xmm1,[.cz] |
end if |
movsx ebx,word[.y1] |
shl ebx,ROUND |
mov [.ccoord],ebx ; .ccoord -> y coordinate |
.draw_m_h: |
mov edi,[.cscr] |
mov esi,[.czbuf] |
mov eax,[.ccoord] ; ccoord - cur y coordinate |
sar eax,ROUND |
mov ebx,[.xres] ;SIZE_X |
mul ebx |
add esi,eax |
lea eax,[eax*3] |
add esi,eax |
add edi,eax |
if Ext >= SSE2 |
movd ebx,xmm1 |
else |
mov ebx,[.cz] |
end if |
cmp [esi],ebx |
jle @f |
.draw_pixel |
@@: |
mov eax,[.delta] |
add [.ccoord],eax |
add dword[.cscr],3 ; |
add dword[.czbuf],4 |
.update_cur_var |
dec ecx |
jnz .draw_m_h |
.end_line: |
mov esp,ebp |
ret 24 |
.calc_delta: |
mov ax,[.z2] |
sub ax,[.z1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.dz],eax |
mov ax,[.r2] |
sub ax,[.r1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.dr],eax |
mov ax,[.g2] |
sub ax,[.g1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.dg],eax |
mov ax,[.b2] |
sub ax,[.b1] |
cwde |
shl eax,ROUND |
cdq |
idiv ebx |
mov [.db],eax |
if Ext=MMX | Ext = SSE |
movq mm2,[.dz] |
movq mm3,[.dg] |
else if Ext >= SSE2 |
movups xmm0,[.dz] |
movups xmm6,[.mask] |
end if |
addss xmm2,xmm6 |
addps xmm0,xmm5 |
add edi,4 |
sub ecx,1 |
jnz .l |
pop ebx |
pop eax |
ret |
.mask: |
dq 0xffffffff00ffffff |
dq 0xffffffffffffffff |
/programs/demos/view3ds/history.txt |
---|
1,4 → 1,14 |
View3ds 0.072 - march 2021 |
1. New displaying model - texturing with bilinear filtering and transparency |
simultanusly. Note that filtering is done only inside polygon. To better |
quality of image there is a need to use floats coordinates of texture to pass |
as arguments to single triangle rendering proc. |
2. Optimizations. |
3. SSE3 version runs correct on SSE2 cpus, but real phong, glass and |
transparented texturing with filtering rendering models are disabled. |
----------------------------------------------------------------------------------- |
View3ds 0.071 - VIII 2020 |
1. New displaying model - glass - it's two pass rendering. First pass calculates |
Z position of all front pixels, second render image with adding reflective |
/programs/demos/view3ds/readme.txt |
---|
1,7 → 1,12 |
View3ds 0.072 - tiny viewer to .3ds and .asc files with several graphics |
View3ds 0.073 - tiny viewer to .3ds and .asc files with several graphics |
effects implementation. |
What's new? |
1. I introduced procedure for searching nonredundand edges. |
2. Writing some info about object: vertices, triangles unique edges |
count. |
1. New displaying model - texturing with bilinear filtering and transparency |
simultanusly. Note that filtering is done only inside polygon. To better |
quality of image there is a need to use floats coordinates of texture to pass |
26,21 → 31,23 |
8. rand. light: Randomize 3 unlinear lights( so called Phong's illumination). |
9. Blur: blur N times; N=0,1,2,3,4,5 |
10.11,12,13. loseless operations (rotary 90, 180 degrees). |
12. emboss: Do emboss effect( flat bumps ), use 'bumps deep' button to do edges more deep. |
12. emboss: Do emboss effect( flat bumps ), use 'bumps deep' button to do edges |
more deep. |
13. fire: do motion blur ( looks like fire ). |
14. move: changes meaning x,y,z +/- buttons -> obj: moving object, camr: moving camera, wave: x,y +/- increase, |
decrease wave effect frequency and amplitude. |
14. move: changes meaning x,y,z +/- buttons -> obj: moving object, camr: moving |
camera, wave: x,y +/- increase, decrease wave effect frequency and amplitude. |
15. generate: Generates some objects: node, Thorn Crown, heart... |
16. bumps: random, according to texture. |
17. bumps deep -> create bumps deeper or lighter. |
18. re-map tex -> re-map texture and bump map coordinates, to change spherical mapping |
around axle use 'xchg' and 'mirror' buttons, then press 're-map tex' button. |
18. re-map tex -> re-map texture and bump map coordinates, to change spherical |
mapping around axle use 'xchg' and 'mirror' buttons, then press 're-map tex' button. |
19. bright + -> increase picture brightness. |
20. bright - -> decrease picture brightness. |
21. wav effect -> do effect based sine function. |
22. editor -> setting editing option. If is "on" then red bars are draw according to each vertex, Pressing |
and moving left mouse button (cursor must be on handler)- change vertex position. If left mouse button |
is released apply current position. You may also decrease whole handlers count by enable culling (using |
appropriate button) - some back handlers become hidden. |
22. editor -> setting editing option. If is "on" then red bars are draw according to each |
vertex, Pressing and moving left mouse button (cursor must be on handler)- change |
vertex position. If left mouse button is released apply current position. You may also |
decrease whole handlers count by enable culling (using appropriate button) - some |
back handlers become hidden. |
Maciej Guba III 2021 |
Maciej Guba V 2021 |
/programs/demos/view3ds/view3ds.asm |
---|
1,11 → 1,11 |
; application : View3ds ver. 0.072 - tiny .3ds and .asc files viewer |
; application : View3ds ver. 0.071 - tiny .3ds and .asc files viewer |
; with a few graphics effects demonstration. |
; compiler : FASM |
; system : KolibriOS |
; author : Macgub aka Maciej Guba |
; email : macgub3@wp.pl |
; web : http://macgub.j.pl, http://macgub.co.pl |
; web : http://macgub.co.pl, http://macgub.j.pl |
; Fell free to use this intro in your own distribution of KolibriOS. |
; Special greetings to KolibriOS team . |
; I hope because my demos Christian Belive will be near to each of You. |
19,8 → 19,8 |
; 2) Written in manually (at the end of the code) ; now not exist |
SIZE_X equ 500 |
SIZE_Y equ 600 ; ///// I want definitely |
SIZE_X equ 512 |
SIZE_Y equ 512 ; ///// I want definitely |
TIMEOUT equ 10 ; ------ say: |
ROUND equ 10 ; \ @ @/ keep smiling every |
TEX_X equ 512 ; texture width ; \ ./ / day. |
61,9 → 61,6 |
fstp [rsscale] |
pop ebx |
mov [x_start],dword 20 shl 16 + 20 ;eax |
call alloc_buffer_mem |
call read_param |
call read_from_disk ; read, if all is ok eax = 0 |
86,14 → 83,9 |
call read_asc |
jmp .opt |
.malloc: |
if USE_LFN |
call alloc_mem_for_tp |
end if |
call read_from_file |
.opt: |
call optimize_object1 ; proc in file b_procs.asm |
; set point(0,0,0) in center and calc all coords |
; to be in <-1.0,1.0> |
111,20 → 103,14 |
mov edi,bumpmap |
call calc_bumpmap |
call calc_bumpmap_coords ; bump and texture mapping |
call do_edges_list |
call draw_window |
;mov [draw_win_at_first],0 |
;mov eax,40 ; set events mask |
;mov ebx,1100000000000000000000000100111b |
;int 0x40 |
if Ext >= SSE3 |
mov eax,1 |
cpuid |
bt ecx,0 ; is sse3 on board? |
jc @f |
mov [max_dr_flg],12 |
@@: |
end if |
still: |
cmp [edit_flag],1 |
jne @f |
184,7 → 170,7 |
mov ecx,-1 |
int 0x40 |
mov eax,[procinfo+42] ; read params of window |
sub eax,115 |
sub eax,225 |
mov [size_x_var],ax |
shr ax,1 |
mov [vect_x],ax |
259,29 → 245,19 |
jne @f |
.zoom_out: |
mov dword[scale],0.7 |
movss xmm0,[rsscale] |
mulss xmm0,[scale] |
movss [rsscale],xmm0 |
; fninit |
; fld [rsscale] |
; fmul [scale] |
; fstp [rsscale] |
fninit |
fld [rsscale] |
fmul [scale] |
fstp [rsscale] |
@@: |
cmp ah,6 ; ah = 6 -> scale+ |
jne @f |
.zoom_in: |
mov dword[scale],1.3 |
movss xmm0,[rsscale] |
mulss xmm0,[scale] |
movss [rsscale],xmm0 |
; fninit |
; fld [rsscale] |
; fmul [scale] |
; fstp [rsscale] |
fninit |
fld [rsscale] |
fmul [scale] |
fstp [rsscale] |
@@: |
cmp ah,9 ; lights random ; 'flat' 0 |
jne .next_m5 ; 'grd ' 1 |
291,15 → 267,7 |
call copy_lights |
end if |
call do_color_buffer ; intit color_map ; 'tex ' 4 |
; cmp [emboss_flag],1 ; 'pos ' 5 |
; je @f ; 'dots' 6 |
; cmp [dr_flag],8 |
; jge @f |
; cmp [dr_flag],2 ; 'txgr' 7 |
; jl .next_m5 ; '2tex' 8 |
; cmp [dr_flag],3 ; 'btex' 9 |
; jg .next_m5 |
; @@: |
call init_envmap2 ; update env map if shading model = environment or bump |
.next_m5: |
cmp ah,11 |
360,7 → 328,8 |
call init_triangles_normals2 |
call init_point_normals |
call calc_bumpmap_coords ; bump and texture mapping |
call do_edges_list |
call write_info |
.next_m2: |
cmp ah,19 |
je @f |
547,6 → 516,10 |
jne @f |
call clrscr ; clear the screen |
@@: |
; cmp [catmull_flag],1 ;non sort if Catmull = on |
; je .no_sort |
; 64 indexes call sort_triangles |
.no_sort: |
cmp [dr_flag],7 ; fill if 2tex and texgrd |
jge @f |
cmp [catmull_flag],0 ;non fill if Catmull = off |
568,6 → 541,11 |
call draw_handlers |
; call edit |
.no_edit: |
.blurrr: |
595,6 → 573,7 |
@@: |
cmp [inc_bright_flag],0 ; increase brightness |
je .no_inc_bright |
movzx ebx,[inc_bright_flag] |
727,9 → 706,8 |
mov eax,7 ; put image |
mov ebx,[screen_ptr] |
mov ecx,[size_y_var] |
; mov ecx,SIZE_X shl 16 + SIZE_Y |
mov edx,[offset_y] ;5 shl 16 + 25 |
cmp [dr_flag],12 |
mov edx,[offset_y] |
cmp [dr_flag],11 |
jge .ff |
int 0x40 |
jmp .f |
1235,13 → 1213,6 |
push ax |
mov al,byte[esi+12] ; r |
push ax |
; pxor xmm1,xmm1 |
; movd xmm0,[esi+12] |
; punpckhbw xmm0,xmm1 |
; sub esp,8 |
; movq [esp],xmm0 |
mov al,byte[esi+20] ; b max color |
push ax |
mov al,byte[esi+19] ; g |
1418,7 → 1389,7 |
mov esp,ebp |
pop ebp |
ret |
if Ext >= SSE2 |
if Ext >= SSE3 |
init_point_normals: |
.z equ dword [ebp-8] |
.y equ dword [ebp-12] |
1426,6 → 1397,7 |
.point_number equ dword [ebp-28] |
.hit_faces equ dword [ebp-32] |
fninit |
push ebp |
mov ebp,esp |
sub esp,64 |
1466,25 → 1438,19 |
jne .ipn_check_face |
cvtsi2ss xmm6,.hit_faces |
movaps xmm7,.x |
rcpss xmm6,xmm6 |
shufps xmm6,xmm6,11000000b |
mulps xmm7,xmm6 |
movaps xmm6,xmm7 |
mulps xmm6,xmm6 |
andps xmm6,[zero_hgst_dd] |
haddps xmm6,xmm6 |
haddps xmm6,xmm6 |
rsqrtps xmm6,xmm6 |
mulps xmm7,xmm6 |
movlps [edi],xmm7 |
movhlps xmm7,xmm7 |
movss [edi+8],xmm7 |
call normalize_vector |
; movaps xmm6,xmm7 |
; mulps xmm6,xmm6 |
; andps xmm6,[zero_hgst_dd] |
; haddps xmm6,xmm6 |
; haddps xmm6,xmm6 |
; rsqrtps xmm6,xmm6 |
; mulps xmm7,xmm6 |
; movlps [edi],xmm7 |
; movhlps xmm7,xmm7 |
; movss [edi+8],xmm7 |
add edi,12 |
inc .point_number |
mov edx,.point_number |
1764,6 → 1730,8 |
end if |
cmp [dr_flag],11 |
je .draw_smooth_line |
mov esi,[triangles_ptr] |
mov ecx,[triangles_count_var] |
1770,7 → 1738,7 |
.again_dts: |
push ecx |
mov ebp,[points_translated_ptr] |
if Ext = NON |
if Ext >= SSE2 |
mov eax,dword[esi] |
mov [point_index1],eax |
lea eax,[eax*3] |
1814,7 → 1782,7 |
mov [zz3],ax |
else |
movq mm0,[esi] ; don't know MMX |
movq qword[point_index1],mm0 |
mov qword[point_index1],mm0 |
; shr eax,16 |
; mov [point_index2],ax |
mov eax,dword[esi+8] |
1890,19 → 1858,17 |
lea eax,[eax*3] |
shl eax,2 |
add eax,[points_normals_rot_ptr] |
bt dword[eax+8],+31 |
jc .no_culling |
; lea eax,[eax+point_normals_rotated] |
; fld dword[eax+8] ; ***************************** |
; ftst ; CHECKING OF Z COOFICIENT OF |
; fstsw ax ; NORMAL VECTOR |
; sahf |
; jb @f |
; ffree st |
fld dword[eax+8] ; ***************************** |
ftst ; CHECKING OF Z COOFICIENT OF |
fstsw ax ; NORMAL VECTOR |
sahf |
jb @f |
ffree st |
loop @b |
jmp .end_draw ; non visable |
; @@: |
; ffree st ;is visable |
@@: |
ffree st ;is visable |
.no_culling: |
cmp [dr_flag],0 ; draw type flag |
je .flat_draw |
1931,7 → 1897,6 |
je .glass |
cmp [dr_flag],14 |
je .glass_tex |
end if ; **************** |
mov esi,point_index3 ; do Gouraud shading |
mov ecx,3 |
1940,28 → 1905,19 |
shl eax,2 |
lea eax,[eax*3] |
add eax,[points_normals_rot_ptr] |
if Ext < SSE |
; texture x=(rotated point normal -> x * 255)+255 |
fld dword[eax] ; x cooficient of normal vector |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp [temp1] |
; texture y=(rotated point normal -> y * 255)+255 |
fld dword[eax+4] ; y cooficient |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp [temp2] |
mov eax,[temp2] |
mov ebx,[temp1] |
else |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
movd eax,xmm0 |
psrldq xmm0,4 |
movd ebx,xmm0 |
end if |
and ebx,0xfffffff |
shl eax,TEX_SHIFT |
add eax,ebx |
2066,31 → 2022,28 |
mov eax,[point_index1] |
mov ebx,[point_index2] |
mov ecx,[point_index3] |
; shl eax,2 |
imul eax,[i12] |
imul ebx,[i12] |
imul ecx,[i12] |
; shl ebx,2 |
; shl ecx,2 |
; lea eax,[eax*3] ;+point_normals_rotated] |
shl eax,2 |
shl ebx,2 |
shl ecx,2 |
lea eax,[eax*3] ;+point_normals_rotated] |
add eax,[points_normals_rot_ptr] |
; lea ebx,[ebx*3] ;+point_normals_rotated] |
lea ebx,[ebx*3] ;+point_normals_rotated] |
add ebx,[points_normals_rot_ptr] |
; lea ecx,[ecx*3] ;+point_normals_rotated] |
lea ecx,[ecx*3] ;+point_normals_rotated] |
add ecx,[points_normals_rot_ptr] |
fld dword[eax] ; x cooficient of normal vector |
fadd dword[ebx] |
fadd dword[ecx] |
fidiv [i3] |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp [temp1] ;dword[esp-4] ; x temp variables |
fld dword[eax+4] ; y cooficient of normal vector |
fadd dword[ebx+4] |
fadd dword[ecx+4] |
fidiv [i3] |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp [temp2] ;dword[esp-8] ; y |
mov edx,[temp2] ;dword[esp-8] |
and edx,0xfffffff |
2147,12 → 2100,17 |
lea eax,[eax*3] |
shl eax,2 |
add eax,[points_normals_rot_ptr] ;point_normals_rotated |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
packssdw xmm0,xmm0 |
movd [edi],xmm0 |
; texture x=(rotated point normal -> x * 255)+255 |
fld dword[eax] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi] |
; texture y=(rotated point normal -> y * 255)+255 |
fld dword[eax+4] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi+2] |
add edi,4 |
add esi,4 |
loop @b |
2192,8 → 2150,8 |
fld1 |
faddp |
fmulp |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi] |
mov word[edi+2],0 |
; fistp word[edi+2] |
2244,16 → 2202,18 |
mov eax,dword[esi] |
lea eax,[eax*3] |
shl eax,2 |
; imul eax,[i12] |
add eax,[points_normals_rot_ptr] ;point_normals_rotated |
; texture x=(rotated point normal -> x * 255)+255 |
fld dword[eax] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi] |
; texture y=(rotated point normal -> y * 255)+255 |
fld dword[eax+4] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi+2] |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
packssdw xmm0,xmm0 |
movd [edi],xmm0 |
add edi,4 |
add esi,4 |
loop @b |
2265,11 → 2225,17 |
mov 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] |
mov 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 |
2377,33 → 2343,24 |
lea edx,[ecx*3] |
push word[edx*2+xx1-2] ; zz1 ,2 ,3 |
; fninit |
fninit |
mov eax,dword[esi] |
shl eax,2 |
lea eax,[eax*3] ;+point_normals_rotated] |
add eax,[points_normals_rot_ptr] |
if Ext < SSE |
; texture x=(rotated point normal -> x * 255)+255 |
fld dword[eax] ; x cooficient of normal vector |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp [temp1] ;word[ebp-2] |
; texture y=(rotated point normal -> y * 255)+255 |
fld dword[eax+4] ; y cooficient |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp [temp2] ;word[ebp-4] |
mov eax,[temp2] |
mov ebx,[temp1] |
else |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
movd eax,xmm0 |
psrldq xmm0,4 |
movd ebx,xmm0 |
end if |
mov eax,[temp2] ;word[ebp-4] |
mov ebx,[temp1] ;word[ebp-2] |
and ebx,0xfffffff ; some onjects need thid 'and' |
shl eax,TEX_SHIFT |
add eax,ebx |
2471,22 → 2428,16 |
shl eax,2 |
add eax,[points_normals_rot_ptr] |
; texture x=(rotated point normal -> x * 255)+255 |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
packssdw xmm0,xmm0 |
movd [edi],xmm0 |
; fld dword[eax] |
; fmul dword[correct_texf] |
; fadd dword[correct_texf] |
; fistp word[edi] |
fld dword[eax] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi] |
; texture y=(rotated point normal -> y * 255)+255 |
; fld dword[eax+4] |
; fmul dword[correct_texf] |
; fadd dword[correct_texf] |
; fistp word[edi+2] |
fld dword[eax+4] |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi+2] |
and word[edi+2],0x7fff ; some objects need it |
add edi,4 |
add esi,4 |
2537,15 → 2488,7 |
lea eax,[eax*3] |
shl eax,2 |
add eax,[points_normals_rot_ptr] |
if Ext >= SSE |
; texture x=(rotated point normal -> x * 255)+255 |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
packssdw xmm0,xmm0 |
movd [edi],xmm0 |
else |
fld dword[eax] |
fimul [correct_tex] |
fiadd [correct_tex] |
2555,7 → 2498,7 |
fimul [correct_tex] |
fiadd [correct_tex] |
fistp word[edi+2] |
end if |
add edi,4 |
add esi,4 |
loop @b |
2596,141 → 2539,7 |
jmp .end_draw |
.draw_smooth_line: |
mov esi,point_index3 |
mov ecx,3 |
.again_line_param: |
mov eax,dword[esi] |
shl eax,2 |
lea eax,[eax*3] |
add eax,[points_normals_rot_ptr] |
if Ext>=SSE2 |
movlps xmm0,[eax] |
mulps xmm0,[correct_texf] |
addps xmm0,[correct_texf] |
cvtps2dq xmm0,xmm0 |
movd eax,xmm0 |
psrldq xmm0,4 |
movd ebx,xmm0 |
else if |
; texture ;x=(rotated point normal -> x * 255)+255 |
fld dword[eax] ; x cooficient of normal vector |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fistp [temp1] ;word[esp-2] |
; texture y=(rotated point normal -> y * 255)+255 |
fld dword[eax+4] ; y cooficient |
fmul dword[correct_texf] |
fadd dword[correct_texf] |
fistp [temp2] ;word[esp-4] |
mov eax,[temp2] ;word[esp-4] |
mov ebx,[temp1] ;word[esp-2] |
end if |
and ebx,0xfffffff |
shl eax,TEX_SHIFT |
add eax,ebx |
lea eax,[eax*3+color_map] |
mov eax,dword[eax] |
lea ebx,[ecx-1] |
shl ebx,2 |
mov [ebx+col1],eax |
sub esi,4 |
dec ecx |
jnz .again_line_param |
mov edi,[screen_ptr] |
mov esi,[Zbuffer_ptr] |
mov eax,[col1] |
movzx bx,al |
push bx ; b |
movzx bx,ah |
push bx |
rol eax,16 |
xor ah,ah |
push ax |
push [zz1] |
push [yy1] |
push [xx1] |
mov eax,[col2] |
movzx bx,al |
push bx ; b |
movzx bx,ah |
push bx |
rol eax,16 |
xor ah,ah |
push ax |
push [zz2] |
push [yy2] |
push [xx2] |
call smooth_line |
@@: |
mov edi,[screen_ptr] |
mov esi,[Zbuffer_ptr] |
mov eax,[col1] |
movzx bx,al |
push bx ; b |
movzx bx,ah |
push bx |
rol eax,16 |
xor ah,ah |
push ax |
push [zz1] |
push [yy1] |
push [xx1] |
mov eax,[col3] |
movzx bx,al |
push bx ; b |
movzx bx,ah |
push bx |
rol eax,16 |
xor ah,ah |
push ax |
push [zz3] |
push [yy3] |
push [xx3] |
call smooth_line |
@@: |
mov edi,[screen_ptr] |
mov esi,[Zbuffer_ptr] |
mov eax,[col3] |
movzx bx,al |
push bx ; b |
movzx bx,ah |
push bx |
rol eax,16 |
xor ah,ah |
push ax |
push [zz3] |
push [yy3] |
push [xx3] |
mov eax,[col2] |
movzx bx,al |
push bx ; b |
movzx bx,ah |
push bx |
rol eax,16 |
xor ah,ah |
push ax |
push [zz2] |
push [yy2] |
push [xx2] |
call smooth_line |
jmp .end_draw |
@@: |
if Ext >= SSE3 |
.r_phg: |
2789,7 → 2598,6 |
jmp .end_draw |
.glass: |
movd xmm5,[size_y_var] |
punpcklwd xmm5,[the_zero] |
pshufd xmm5,xmm5,01110011b |
2843,6 → 2651,7 |
call glass_tri |
jmp .end_draw |
.glass_tex: |
movd xmm5,[size_y_var] |
punpcklwd xmm5,[the_zero] |
2917,32 → 2726,138 |
call glass_tex_tri |
jmp .end_draw |
end if |
end if |
.end_draw: |
pop esi |
add esi,12 |
pop ecx |
sub ecx,1 |
dec ecx |
jnz .again_dts |
ret |
.draw_smooth_line: |
mov esi,[edges_ptr] |
xor ecx,ecx |
.again_s_line: |
push ecx |
push esi |
mov ecx,2 |
.aga_n: |
mov eax,[esi] |
shl eax,2 |
lea eax,[eax*3] |
add eax,[points_normals_rot_ptr] |
movups xmm0,[eax] |
xorps xmm1,xmm1 |
mov edx,lights_aligned |
.again_cc: |
movaps xmm3,xmm0 ;.cnv |
mulps xmm3,[edx] |
andps xmm3,[zero_hgst_dd] |
; haddps xmm3,xmm3 |
; haddps xmm3,xmm3 ; xmm3 - dot pr |
movhlps xmm2,xmm3 |
addps xmm3,xmm2 |
movdqa xmm2,xmm3 |
shufps xmm2,xmm2,01010101b |
addps xmm3,xmm2 |
shufps xmm3,xmm3,0 |
movaps xmm6,xmm3 ;xmm7 |
mulps xmm6,xmm6 |
mulps xmm6,xmm6 |
mulps xmm6,xmm6 |
mulps xmm6,xmm6 |
mulps xmm6,xmm6 |
mulps xmm6,[edx+48] |
movaps xmm7,xmm3 |
mulps xmm7,[edx+16] |
addps xmm7,xmm6 |
addps xmm7,[edx+32] |
minps xmm7,[mask_255f] ; global |
maxps xmm1,xmm7 |
add edx,64 ; size of one light in aligned list |
cmp edx,lights_aligned_end |
jl .again_cc |
sub esp,16 |
movups [esp],xmm1 |
add esi,4 |
loop .aga_n |
movups xmm0,[esp] |
movups xmm1,[esp+16] |
add esp,32 |
sub esi,8 |
mov ecx,[esi] |
mov edx,[esi+4] |
imul ecx,[i6] |
imul edx,[i6] |
add ecx,[points_translated_ptr] |
add edx,[points_translated_ptr] |
movd xmm7,[ecx] |
movhps xmm7,[edx] |
pshufd xmm7,xmm7,11101000b |
movdqa xmm6,xmm7 |
movd xmm5,[size_y_var] |
pshuflw xmm5,xmm5,00010001b |
pcmpgtw xmm7,xmm5 |
pcmpgtw xmm6,[the_zero] |
pxor xmm7,xmm6 |
pmovmskb eax,xmm7 |
cmp al,-1 |
jnz .skp |
mov eax,[esi] |
mov ebx,[esi+4] |
imul eax,[i12] |
imul ebx,[i12] |
add eax,[points_rotated_ptr] |
add ebx,[points_rotated_ptr] |
movss xmm2,[eax+8] |
movss xmm3,[ebx+8] |
movzx eax,word[ecx] |
movzx ebx,word[ecx+2] |
movzx ecx,word[edx] |
movzx edx,word[edx+2] |
emms |
movd mm1,[screen_ptr] |
movd mm0,[Zbuffer_ptr] |
movzx esi,word[size_x_var] |
movd mm2,esi |
push ebp |
call line_grd |
pop ebp |
.skp: |
pop esi |
pop ecx |
add esi,8 |
inc ecx |
cmp ecx,[edges_count] |
jnz .again_s_line |
ret |
draw_handlers: |
push ebp |
3071,8 → 2986,8 |
fill_Z_buffer: |
mov eax,0x70000000 |
cmp [dr_flag],12 |
jne @f |
cmp [dr_flag],11 |
jl @f |
mov eax,60000.1 |
@@: |
mov edi,[Zbuffer_ptr] |
3207,11 → 3122,7 |
xor ebp,ebp |
mov [points_count_var],0 |
mov [triangles_count_var],0 |
if USE_LFN = 0 |
mov esi,SourceFile |
else |
mov esi,[fptr] |
end if |
cmp [esi],word 4D4Dh |
jne .exit ;Must be legal .3DS file |
; cmp dword[esi+2],EndFile-SourceFile |
3298,17 → 3209,14 |
;mov edi,triangles |
@@: |
movzx eax,word[esi] |
add eax,ebp |
stosd |
movzx eax,word[esi+2] |
add eax,ebp |
stosd |
movzx eax,word[esi+4] |
add eax,ebp |
stosd |
; add dword[edi-12],ebp |
; add dword[edi-8],ebp |
; add dword[edi-4],ebp |
add dword[edi-12],ebp |
add dword[edi-8],ebp |
add dword[edi-4],ebp |
add esi,8 |
dec ecx |
jnz @b |
3337,6 → 3245,14 |
int 0x40 ; -> allocate memory to triangles |
mov [triangles_ptr], eax ; -> eax = pointer to allocated mem |
mov eax, 68 |
mov ecx,[triangles_count_var] |
imul ecx,[i36] |
mov edx,[edges_ptr] |
int 0x40 ; -> allocate memory to triangles |
mov [edges_ptr], eax ; -> eax = pointer to allocated mem |
; ststic memory |
mov eax, 68 |
3410,7 → 3326,6 |
@@: |
; eax = 0 -> ok file loaded |
ret |
read_param: |
mov esi,I_Param |
cmp dword[esi],0 |
3482,6 → 3397,64 |
cmp byte[edi],-1 |
jnz .again |
ret |
write_info: |
mov eax,13 |
mov bx,[size_x_var] |
shl ebx,16 |
add ebx,120*65536+70 ; [x start] *65536 + [y start] |
mov ecx,30 shl 16 + 100 |
xor edx,edx |
int 0x40 |
xor esi,esi |
emms |
movd mm7,esi |
.nxxx: |
push esi |
movd mm7,esi |
mov eax,4 ; function 4 : write text to window |
movzx ebx,word[size_x_var] |
shl ebx,16 |
add ebx,120*65536 ; [x start] *65536 + [y start] |
mov bx,si |
shl bx,3 |
add ebx,30 |
mov ecx,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB ) |
movd edx,mm7 |
shl edx,2 |
add edx,lab_vert ; pointer to text beginning |
mov esi,lab_vert_end-lab_vert ; text length |
int 0x40 |
movd esi,mm7 |
mov eax,[points_count_var+esi] |
mov ecx,10 |
.dc: |
xor edx,edx |
mov edi,10 |
div edi |
add dl,30h |
mov [STRdata+ecx-1],dl |
loop .dc |
mov eax,4 ; function 4 : write text to window |
mov bx,[size_x_var] |
add ebx,120 |
shl ebx,16 |
mov bx,si ; [x start] *65536 + [y start] |
shl bx,3 |
add bx,45 |
mov ecx,0x00ddeeff |
mov edx,STRdata ; pointer to text beginning |
mov esi,10 ; text length |
int 40h |
pop esi |
add esi,4 |
cmp esi,12 |
jnz .nxxx |
ret |
; ********************************************* |
; ******* WINDOW DEFINITIONS AND DRAW ******** |
; ********************************************* |
3499,7 → 3472,7 |
;ebx - [x start] *65536 + [x size] |
;ecx - [y start] *65536 + [y size] |
mov bx,[size_x_var] |
add bx,115 |
add bx,225 |
mov cx,[size_y_var] |
add cx,30 |
; @@: |
3511,6 → 3484,16 |
.Y_ADD equ 2 ;-> offset of 'add vector' buttons |
; mov eax,47 |
; mov ebx,0000000000111000000000000000b |
; mov ecx,[points_count_var] |
; movzx edx,word[size_x_var] |
; shl edx,16 |
; add edx,130*65536+60 ; [x start] *65536 + [y start] |
; mov esi,0x00ddeeff ; font 1 & color ( 0xF0RRGGBB ) |
; int 0x40 |
call write_info |
; ADD VECTOR LABEL ; add vector buttons - 30 ++ |
mov eax,4 ; function 4 : write text to window |
movzx ebx,word[size_x_var] |