0,0 → 1,1171 |
;init_envmap_cub2: |
; mov esi,envmap |
; mov edi,envmap_cub ;take cubic env. map from |
; xor eax,eax ;spherical env. map |
; @@: |
; add esi,eax |
; movsd |
; dec edi |
; dec esi |
; add esi,511*3 |
; add eax,3 |
; cmp eax,511*3 |
; jl @b |
;ret |
init_envmap_cub: ; create 512x512 env map |
.temp equ word [ebp-2] |
push ebp |
mov ebp,esp |
sub esp,2 |
mov edi,envmap_cub |
fninit |
|
mov cx,-256 |
.ie_hor: |
mov .temp,cx |
fild .temp |
fabs |
; fmul st,st0 |
; fsqrt |
mov .temp,255 |
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,255 |
jle .ie_ok2 |
mov ax,255 |
.ie_ok2: |
stosb |
stosb |
stosb |
|
inc cx |
cmp cx,256 |
jne .ie_hor |
|
mov esp,ebp |
pop ebp |
ret |
|
calc_one_col: |
; procedure don't save registers !!! |
; in - st - dot_product |
; stack - other parameters |
; out - eax - 0x00rrggbb |
.dot_prd equ dword[ebp+4] ; dot product - cos x - not now |
.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 word[ebp+14] ; maximum color - specular |
.max_col_g equ word[ebp+16] |
.max_col_b equ word[ebp+18] |
.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 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 |
cwde |
mov .color_sum_r,eax |
|
mov ax,.min_col_g |
add ax,.max_col_g |
add ax,.org_col_g |
cwde |
mov .color_sum_g,eax |
|
mov ax,.min_col_b |
add ax,.max_col_b |
add ax,.org_col_b |
cwde |
mov .color_sum_b,eax |
|
|
; fld .dot_prd |
; fild .n |
; fxch st1 |
; fabs |
; fyl2x ; |
; f2xm1 |
; fld1 |
; faddp ; st = dot_product ^ n |
|
fld st ; copy dot pr |
fmul st,st0 |
fmul st,st0 |
fmul st,st0 |
cmp .n,255 ; .n = 255 -> spot light |
jne @f |
fmul st,st0 |
fmul st,st0 |
fmul st,st0 |
@@: |
fld st ; st0=st1=dot_pr^n, st2=dot_pr |
fimul .max_col_b |
fild .org_col_b |
fmul st,st3 |
faddp ; st0=first piece of col, st1=dot_pr^n.. |
fiadd .min_col_b |
fimul .max_col_b |
fidiv .color_sum_b |
fistp .temp |
movzx eax,.temp |
shl eax,16 |
|
fld st |
fimul .max_col_g |
fild .org_col_g |
fmul st,st3 |
faddp |
fiadd .min_col_g |
fimul .max_col_g |
fidiv .color_sum_g |
fistp .temp |
mov ax,.temp |
mov ah,al |
shl eax,8 |
|
fimul .max_col_r |
fild .org_col_r |
fmulp st2,st |
faddp |
fiadd .min_col_r |
fimul .max_col_r |
fidiv .color_sum_r |
fistp .temp |
mov ax,.temp ;eax - 0xbbgg00rr |
; mov ah,al |
ror eax,16 |
xchg al,ah ; eax - 0x00rrggbb |
mov esp,ebp |
ret 24 |
|
calc_bumpmap: ; calculate random bumpmap |
;--------------in edi _ pointer to TEX_X x TEX_Y bumpmap |
|
push edi |
|
cmp [bumps_flag],0 |
je .random_bump_map |
; else bumps according to texture |
mov esi,texmap |
mov ecx,TEXTURE_SIZE |
@@: |
movzx ax,byte[esi] |
movzx bx,byte[esi+1] |
movzx dx,byte[esi+2] |
add ax,bx |
add ax,dx |
cwd |
div [i3] |
stosb |
add esi,3 |
loop @b |
jmp .blur_map |
; push ecx |
; mov eax,0x88888888 |
; mov ecx,16/4 |
; rep stosd |
; mov eax,0xffffffff |
; mov ecx,16/4 |
; rep stosd |
; pop ecx |
; loop @b |
.random_bump_map: |
|
mov ecx,TEXTURE_SIZE |
@@: |
push ecx |
xor ecx,ecx |
mov edx,255 |
call random |
stosb |
pop ecx |
loop @b |
|
.blur_map: |
pop edi |
movzx ecx,[bumps_deep_flag] |
inc cx |
.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 |
|
optimize_object1: ; setting point (0,0,0) in center of object |
; recalculate all coords , scale object, |
;the coords in <-1.0,1.0> |
;in : real_points - table filled of real float dd coordinates (x,y,z), end mark dd -1 |
; _ global variable |
; points_count_var - dw integer variable with exactly points count |
; - global variable |
; SIZE_X, SIZE_Y must be defined |
|
.max equ dword[ebp-4] |
.min equ dword[ebp-8] |
.maxxx equ dword[ebp-12] |
.center equ dword[ebp-16] |
|
mov ebp,esp |
sub esp,16 |
fninit |
mov .maxxx,0 |
mov ecx,3 |
xor ebx,ebx ; ebx - x,y,z coord in real_points list |
.next_c: ; max/min/center x,y,z |
mov edi,[points_ptr] ; in real_point list minimum two points |
mov dx,[points_count_var] |
fld dword[edi+ebx] |
fst .max |
fstp .min |
add edi,12 |
dec dx |
.next_coord: ; next coord from real_points list |
fld dword [edi+ebx] ; real_points -> x,y,z |
fcom .max ; max_x,y,z |
fstsw ax |
sahf |
jbe @f ; jmp less equal |
fstp .max ; new max_x,y,z |
jmp .end_coords |
@@: |
fcom .min ; min_x,y,z |
fstsw ax |
sahf |
jnbe @f ; jmp greater |
fst .min ; new min_x |
@@: |
ffree st |
.end_coords: |
add edi,12 |
; cmp dword[edi],-1 ; cmp with end mark |
dec dx |
jnz .next_coord |
; ok after this we found max_coord and min_coord |
fld .max ; find center point |
fadd .min |
fld1 |
fld1 |
faddp |
fdivp st1,st ; st0 - center coord |
fstp .center |
|
fld .max |
fsub .center ; st = .max - .center |
fcom .maxxx ; maximum of all .max |
fstsw ax |
sahf |
jbe @f ; jmp lower |
fst .maxxx ; new maxx |
@@: |
ffree st |
mov edi,[points_ptr] |
mov dx,[points_count_var] ; substraction all coords - center point |
@@: |
fld dword[edi+ebx] |
fsub .center |
fstp dword[edi+ebx] |
add edi,12 |
; cmp dword[edi],-1 |
; jne @b |
dec dx |
jnz @b |
|
add ebx,4 ; ebx - x,y,z cooficientes in list real_points |
dec ecx |
jnz .next_c |
|
fld .maxxx |
mov edi,[points_ptr] ; create all coords in <-1.0,1.0> |
movzx ecx,[points_count_var] |
@@: |
fld dword[edi] |
fdiv .maxxx |
fstp dword[edi] |
fld dword[edi+4] |
fdiv .maxxx |
fstp dword[edi+4] |
fld dword[edi+8] |
fdiv .maxxx |
fstp dword[edi+8] |
add edi,12 |
loop @b |
; cmp dword[edi],-1 |
|
; jne @b |
|
mov esp,ebp |
ret |
|
generate_object: ; generate node |
.N equ 32 |
.x equ word[ebp-2] |
.Ndiv2 equ word[ebp-10] |
.MthickSqr equ dword[ebp-14] ; diameter^2 |
.temp equ dword[ebp-18] ; variable for x <-1;1> |
.Hthick equ dword[ebp-22] |
.cos_temp equ dword[ebp-26] |
.next_const equ dword[ebp-30] |
.a equ dword[ebp-34] |
.Pi2 equ ebp-38 |
|
|
|
mov ebp,esp |
sub esp,42 |
|
mov .Ndiv2,.N/2 |
fninit |
fldpi |
fadd st,st |
fst dword[.Pi2] |
fidiv .Ndiv2 |
fst .a ; .Ndiv2*.a=2Pi => .a=2pi/.Ndiv2 |
|
fld [.Mthick] ; inside diameter, (outside daiameter = 1) |
fmul st,st0 |
fstp .MthickSqr |
fld1 |
|
fsub [.Mthick] |
|
fst .Hthick ; Hthick = 1 - Mthick |
fld st |
fadd st,st |
faddp |
fstp .next_const ; next_const = Hthick * 3 |
|
|
;init triangles list |
mov edi,[triangles_ptr] |
|
xor si,si |
xor ax,ax |
mov bx,.N+1 |
mov cx,(.N*2)+2 ;-- |
mov dx,(.N*3)+3 ;--- |
mov [triangles_count_var],0 |
.again_tri: |
stosw ; main wave |
mov word[edi],bx |
inc ax |
add edi,2 |
stosw |
stosw |
mov word[edi],bx |
inc bx |
mov word[edi+2],bx |
|
|
add edi,4 |
|
mov word[edi],cx ;---- ; n2+2 ; xor ax,ax |
inc cx ; n2+3 ; mov bx,.N+1 |
mov word[edi+2],dx ; ; mov cx,(.N*2)+2 ;-- |
mov word[edi+4],cx ; n3+3 ; mov dx,(.N*3)+3 ;--- |
mov word[edi+6],dx ; n3+3 ; |
inc dx ; ; |
mov word[edi+8],dx ; n2+3 ; |
mov word[edi+10],cx ; n3+4 |
add edi,12 ;---- |
|
dec ax ; border of wave |
dec bx |
dec cx |
dec dx |
|
stosw ; first border |
inc ax |
stosw |
mov word[edi],dx |
add edi,2 |
|
mov word[edi],dx |
add edi,2 |
stosw |
inc dx |
mov word[edi],dx |
|
mov word[edi+2],bx ; second border |
mov word[edi+4],cx |
inc bx |
mov word[edi+6],bx |
|
mov word[edi+8],bx |
mov word[edi+10],cx |
inc cx |
mov word[edi+12],cx |
add edi,14 |
|
add [triangles_count_var],8 ;10 |
inc si |
cmp si,.N |
jne .again_tri |
|
add ax,((.N+1)*3)+1 |
add bx,((.N+1)*3)+1 |
add cx,((.N+1)*3)+1 |
add dx,((.N+1)*3)+1 |
xor si,si |
cmp ax,(.N*13)+13 ;;;(.N*23)+23 ; ax,(.N*13)+13 |
jl .again_tri |
|
mov dword[edi],-1 ; <--- end mark not always in use |
|
; init real points list |
mov .x,-(.N/2) |
mov edi,[points_ptr] |
lea esi,[edi+(12*(.N+1))] |
mov eax,[points_ptr] |
mov ebx,eax |
add eax,2*12*(.N+1) ;--- |
add ebx,3*12*(.N+1) ;--- |
mov [points_count_var],0 |
|
|
.R_P4 equ edi+(4*12*(.N+1)) |
.R_P5 equ edi+(5*12*(.N+1)) |
.R_P6 equ edi+(6*12*(.N+1)) |
.R_P7 equ edi+(7*12*(.N+1)) |
|
.R_P8 equ edi+(8*12*(.N+1)) |
.R_P9 equ edi+(9*12*(.N+1)) |
.R_P10 equ edi+(10*12*(.N+1)) |
.R_P11 equ edi+(11*12*(.N+1)) |
|
.R_P12 equ edi+(12*12*(.N+1)) |
.R_P13 equ edi+(13*12*(.N+1)) |
.R_P14 equ edi+(14*12*(.N+1)) |
.R_P15 equ edi+(15*12*(.N+1)) |
|
@@: |
; x coordinate |
fild .x |
fld st |
;; fmul .a ; st = <-2pi;2pi> when mul .a |
fidiv .Ndiv2 |
fst .temp ; temporary x in <-1.0;1.0> |
|
fst dword[edi] ;x coordinate of point |
fst dword[esi] |
fst dword[eax] ;-- |
|
|
fst dword[.R_P4] |
fst dword[.R_P5] |
fst dword[.R_P6] |
fst dword[.R_P7] |
|
fst dword[.R_P8] |
fst dword[.R_P9] |
fst dword[.R_P10] |
fst dword[.R_P11] |
|
fst dword[.R_P12] |
fst dword[.R_P13] |
fst dword[.R_P14] |
fst dword[.R_P15] |
|
fstp dword[ebx] ;pop |
;*******y coord dword[offset + 4] |
fmul .a ; st = <-2pi;2pi> |
fsincos |
fmul .next_const |
fst dword[edi+4] ; y coordinate of point |
fst dword[esi+4] |
fst dword[.R_P4+4] |
fst dword[.R_P5+4] |
fld .Hthick |
faddp |
fst dword[.R_P6+4] |
fst dword[.R_P7+4] |
fst dword[eax+4] |
fst dword[ebx+4] |
|
fchs |
fst dword[.R_P10+4] |
fst dword[.R_P11+4] |
fst dword[.R_P14+4] |
fst dword[.R_P15+4] |
fadd .Hthick |
fadd .Hthick |
fst dword[.R_P8+4] |
fst dword[.R_P9+4] |
fst dword[.R_P12+4] |
fstp dword[.R_P13+4] |
|
|
fmul .Hthick |
fmul .next_const |
fstp .cos_temp ; cos_temp = Hthick^2 * 3 |
|
;***************z coord |
fld .temp |
fld st |
fmul st,st0 ; z coords |
fchs |
fld1 |
faddp |
fabs |
fsqrt |
; fld st |
; fsub |
fld st |
fsub .cos_temp |
fst dword[esi+8] |
fstp dword[eax+8] ;-- |
fld st |
fadd .cos_temp |
fst dword[.R_P9+8] |
fstp dword[.R_P10+8] |
fchs |
fld st |
fsub .cos_temp |
fst dword[.R_P6+8] |
fstp dword[.R_P5+8] |
fadd .cos_temp |
fst dword[.R_P13+8] |
fstp dword[.R_P14+8] |
|
fmul [.Mthick] |
fmul st,st0 |
fchs |
fld .MthickSqr |
faddp |
fabs |
fsqrt |
fld st |
fsub .cos_temp |
fst dword[edi+8] ; z coordinate |
fstp dword[ebx+8] ;-- |
fld st |
fadd .cos_temp |
fst dword[.R_P8+8] |
fstp dword[.R_P11+8] |
fchs |
fld st |
fsub .cos_temp |
fst dword[.R_P7+8] |
fstp dword[.R_P4+8] |
fadd .cos_temp |
fst dword[.R_P12+8] |
fstp dword[.R_P15+8] |
|
add edi,12 |
add esi,12 |
add eax,12 ;-- |
add ebx,12 ;--- |
add [points_count_var],24 ;16 |
inc .x |
cmp .x,.N/2 |
jng @b |
; mov dword[esi],-1 ; <-- end mark |
mov [culling_flag],0 |
mov esp,ebp |
ret |
.Mthick dd 0.85 ; size-thickness |
|
make_random_lights: |
.temp1 equ ebp-4 |
.temp2 equ ebp-8 ; - light vector generate variables |
.temp3 equ ebp-12 |
.max equ 800 |
push ebp |
mov ebp,esp |
sub esp,12 |
mov edi,lights |
fninit |
mov dword[.temp2],.max |
mov dword[.temp3],.max/2 |
|
.again: |
xor esi,esi |
@@: |
mov edx,.max |
xor ecx,ecx |
call random |
sub eax,.max/2 |
mov dword[.temp1],eax |
fild dword[.temp1] |
fidiv dword[.temp3] |
fstp dword[edi+esi*4] |
inc esi |
cmp esi,2 |
jne @b |
|
.max1 equ 1000 |
mov dword[.temp2],.max1/2 |
mov edx,.max1 |
xor ecx,ecx |
call random |
mov dword[.temp1],eax |
fild dword[.temp1] |
fchs |
fidiv dword[.temp2] |
fstp dword[edi+8] |
|
xor esi,esi |
@@: |
mov ecx,220 ; max colors and shine , ecx = 200 - more bright shading |
mov edx,255 |
call random |
mov byte[edi+18+esi],al |
inc esi |
cmp esi,4 |
jne @b |
|
|
xor esi,esi |
@@: |
mov ecx,100 ; orginal colors |
movzx edx,byte[edi+18+esi] |
call random |
mov byte[edi+12+esi],al |
inc esi |
cmp esi,3 |
jne @b |
|
xor esi,esi |
@@: |
mov ecx,1 ; min cols |
movzx edx,byte[edi+12+esi] |
call random |
mov byte[edi+15+esi],al |
inc esi |
cmp esi,3 |
jne @b |
|
add edi,LIGHT_SIZE ;22 |
cmp edi,lightsend ; see file View3ds,asm |
jne .again |
|
mov esp,ebp |
pop ebp |
ret |
|
generate_texture2: |
.const equ 32 |
mov edi,texmap |
xor bx,bx |
.next_line: |
xor dx,dx |
.next2stripes: |
mov eax,-1 |
mov ecx,(TEX_X/.const)*3/4 |
rep stosd |
mov eax,0x00ff0000 |
mov ecx,(TEX_X/.const) |
@@: |
stosd |
dec edi |
loop @b |
inc dx |
cmp dx,.const/2 |
jl .next2stripes |
inc bx |
cmp bx,TEX_Y |
jl .next_line |
ret |
|
blur_screen: ;blur n times ; blur or fire |
;in - ecx times count |
;.counter equ dword[esp-4] |
.counter1 equ dword[esp-8] |
if Ext>=MMX |
emms |
push ebp |
mov ebp,esp |
push dword 0x0 |
push dword 0x01010101 |
.again_blur: |
push ecx |
mov edi,screen |
mov ecx,SIZE_X*3/4 |
pxor mm5,mm5 |
xor eax,eax |
rep stosd |
|
mov ecx,(SIZE_X*(SIZE_Y-3))*3/4 |
.blr: |
@@: |
|
movd mm0,[edi+SIZE_X*3] |
movd mm1,[edi-SIZE_X*3] |
movd mm2,[edi-3] |
movd mm3,[edi+3] |
|
punpcklbw mm0,mm5 |
punpcklbw mm1,mm5 |
punpcklbw mm2,mm5 |
punpcklbw mm3,mm5 |
paddw mm0,mm1 |
paddw mm0,mm2 |
paddw mm0,mm3 |
psrlw mm0,2 |
|
packuswb mm0,mm5 |
psubusb mm0,qword[esp] ; importand if fire |
movd eax,mm0 |
stosd |
|
loop .blr |
|
xor eax,eax |
mov ecx,SIZE_X*3/4 |
rep stosd |
pop ecx |
loop .again_blur |
mov esp,ebp |
pop ebp |
end if |
if Ext=NON |
.blur: |
push ecx |
xor ecx,ecx |
.next_col_coof: |
xor esi,esi |
xor eax,eax |
xor ebx,ebx |
mov edi,SIZE_X*SIZE_Y |
.next: |
mov ebp,esi |
dec ebp |
|
cmp ebp,SIZE_X*SIZE_Y-1 ; clipping |
jl @f |
mov ebp,SIZE_X*SIZE_Y-1 |
@@: |
or ebp,ebp |
jg @f |
xor ebp,ebp |
@@: |
lea edx,[ebp*3+screen] |
mov al,byte[edx+ecx] |
|
mov ebp,esi |
inc ebp |
cmp ebp,SIZE_X*SIZE_Y-1 ; clipping |
jl @f |
mov ebp,SIZE_X*SIZE_Y-1 |
@@: |
or ebp,ebp |
jg @f |
xor ebp,ebp |
@@: |
lea edx,[ebp*3+screen] |
mov bl,byte[edx+ecx] |
add eax,ebx |
|
mov ebp,esi |
sub ebp,SIZE_X |
cmp ebp,SIZE_X*SIZE_Y-1 ; clipping |
jl @f |
mov ebp,SIZE_X*SIZE_Y-1 |
@@: |
or ebp,ebp |
jg @f |
xor ebp,ebp |
@@: |
lea edx,[ebp*3+screen] |
mov bl,byte[edx+ecx] |
add eax,ebx |
|
mov ebp,esi |
add ebp,SIZE_X |
cmp ebp,SIZE_X*SIZE_Y-1 ; clipping |
jl @f |
mov ebp,SIZE_X*SIZE_Y-1 |
@@: |
or ebp,ebp |
jg @f |
xor ebp,ebp |
@@: |
lea edx,[ebp*3+screen] |
mov bl,byte[edx+ecx] |
add eax,ebx |
|
shr eax,2 |
lea edx,[esi*3+screen] |
or al,al |
jz @f |
dec al ; not importand if fire |
mov byte[edx+ecx],al |
@@: |
|
inc esi |
dec edi |
jnz .next |
|
inc ecx |
cmp ecx,3 |
jne .next_col_coof |
pop ecx |
dec ecx |
jnz .blur |
end if |
ret |
|
mirror: ; mirror effect - loseless operation |
; in ah - button id = 11, 12, 13 |
mov edi,[points_ptr] ; one real point - triple float |
mov esi,[points_normals_ptr] ; one 3dvector - triple float dword x,y,z |
fninit |
movzx ecx,[points_count_var] |
|
cmp ah,11 |
je @f |
cmp ah,12 |
je .yn |
cmp ah,13 |
je .zn |
|
@@: ; neg x |
fld dword[edi] ;x |
fchs |
fstp dword[edi] ;x |
fld dword[esi] |
fchs |
fstp dword[esi] |
add edi,12 |
add esi,12 |
loop @b |
ret |
.yn: |
fld dword[edi+4] ;y |
fchs |
fstp dword[edi+4] ;y |
fld dword[esi+4] |
fchs |
fstp dword[esi+4] |
|
add edi,12 |
add esi,12 |
loop .yn |
ret |
.zn: |
fld dword[edi+8] ;z |
fchs |
fstp dword[edi+8] ;z |
fld dword[esi+8] |
fchs |
fstp dword[esi+8] |
|
add edi,12 |
add esi,12 |
loop .zn |
ret |
|
exchange: ; exchange some coords - loseless operation |
mov edi,[points_ptr] ; one real point - triple float |
mov esi,[points_normals_ptr] ; one 3dvector - triple float dword x,y,z |
fninit ; exchange both points and normal vactors coords/coofics |
movzx ecx,[points_count_var] |
|
cmp [xchg_flag],1 |
je @f |
cmp [xchg_flag],2 |
je .zx |
cmp [xchg_flag],3 |
je .yz |
@@: |
fld dword[edi] ;x |
fld dword[edi+4] ;y |
fstp dword[edi] ;x |
fstp dword[edi+4] ;y |
fld dword[esi] ;x |
fld dword[esi+4] ;y |
fstp dword[esi] ;x |
fstp dword[esi+4] ;y |
|
add esi,12 |
add edi,12 |
loop @b |
ret |
.zx: |
fld dword[edi] ;x |
fld dword[edi+8] ;z |
fstp dword[edi] ;x |
fstp dword[edi+8] ;z |
fld dword[esi] ;x |
fld dword[esi+8] ;y |
fstp dword[esi] ;x |
fstp dword[esi+8] ;y |
|
add esi,12 |
add edi,12 |
loop .zx |
ret |
.yz: |
fld dword[edi+8] ;z |
fld dword[edi+4] ;y |
fstp dword[edi+8] ;z |
fstp dword[edi+4] ;y |
fld dword[esi+8] ;x |
fld dword[esi+4] ;y |
fstp dword[esi+8] ;x |
fstp dword[esi+4] ;y |
|
add edi,12 |
add esi,12 |
loop .yz |
ret |
|
;#\\\\\\\\\\\\\\\\\\\\\\\\\comented/////////////////////////////// |
if 0 |
calc_attenuation_light: ;; calculate point to spot_light distance |
; spot light with attenuation ;; and vector, normalize vector, |
;; calc dot_pr and unlinear color according |
;; to dot_product, write to color buff |
.distance equ dword[ebp-4] ;; color buff in bumpmap for save the mem |
.temp_col equ word[ebp-6] |
.vector equ [ebp-20] |
.spot_light_ptr equ dword [ebp-24] |
mov ebp,esp |
sub esp,24 |
mov edi,rotated_points_r ;points_rotated |
mov edx,point_normals_rotated |
mov ecx,bumpmap ; mem area with temp points color list |
xor ax,ax ; counter |
mov esi,spot_light_params |
mov .spot_light_ptr,esi |
.again_color: |
push eax |
lea ebx,.vector |
mov esi,.spot_light_ptr ; calc vector fom light to every point |
call make_vector_r |
; ebx - ptr to result vector |
fld dword [ebx] |
fmul st, st |
fld dword [ebx+4] |
fmul st, st |
fld dword [ebx+8] |
fmul st, st |
faddp st1, st |
faddp st1, st |
fsqrt |
fstp .distance |
push edi |
mov edi,ebx |
call normalize_vector |
; edi - normalized distance vector |
mov esi,edx |
call dot_product ; esi first vector, edi second vector |
; st0 - dot product |
fabs ; why not ? - think about it |
pop edi |
fldz |
fcomip st1 |
jbe @f ; st1>0 |
mov dword[ecx],0 |
mov word[ecx+4],0 |
add ecx,6 |
ffree st0 |
jmp .update_counters |
@@: |
; pop edi |
|
; calc color(with atenuation), write to buff |
; buff - color of points list |
; color = ambient+cos(x)*diffuse+(cos(x)^n)*specular |
|
push edx |
push edi |
|
push ecx |
push ebp |
|
; mov eax,spot_light_params |
mov eax,.spot_light_ptr |
movzx dx,byte[eax+15] |
push dx ; shines |
movzx dx,byte[eax+8] ; b |
push dx ; orginal col |
movzx dx,byte[eax+7] ; g |
push dx |
movzx dx,byte[eax+6] ; r |
push dx |
movzx dx,byte[eax+14] ; max col |
push dx |
movzx dx,byte[eax+13] |
push dx |
movzx dx,byte[eax+12] |
push dx |
movzx dx,byte[eax+11] ; min col |
push dx |
movzx dx,byte[eax+10] |
push dx |
movzx dx,byte[eax+9] |
push dx |
push eax ; dot pr. (in st0) |
call calc_one_col |
; eax - 0x00rrggbb |
; brightness = 1 - (distance/light.fadezero)^fogness |
; if brightness < 0, then brightness = 0 |
; attenuetion equation taken from 3dica tutorial - 1/d^2 isn't perfect |
; color = color * brightness ; fogness = <0.5,2.0> |
pop ebp |
pop ecx |
|
fld .distance |
mov esi,.spot_light_ptr |
; fidiv word[spot_light_params+16] ; fadezero |
fidiv word[esi+16] ; fadezero |
; fmul st,st0 ; fogness = 2 |
fabs ; to be sure |
fchs |
fld1 |
faddp |
fld1 |
fcomip st1 |
jnbe @f |
ffree st0 |
fld1 |
@@: |
fld st ; st - brightness |
ror eax,16 |
movzx bx,al ; al - r |
mov .temp_col,bx |
fimul .temp_col |
fistp word[ecx] |
cmp word[ecx],0 |
jge @f |
mov word[ecx],0 |
@@: |
; mov edx,dword[spot_light_params+12] ; max colors |
mov edx,dword[esi+12] ; max colors |
movzx bx,dl ; r max |
cmp word[ecx],bx ; choose the brightest for r, g, b |
jl @f |
mov word[ecx],bx |
@@: |
|
add ecx,2 |
fld st |
ror eax,16 |
movzx bx,ah ; g |
mov .temp_col,bx |
fimul .temp_col |
fistp word[ecx] |
cmp word[ecx],0 |
jg @f |
mov word[ecx],0 |
@@: |
movzx bx,dh ; g max |
cmp word[ecx],bx |
jle @f |
mov word[ecx],bx |
@@: |
|
add ecx,2 |
movzx bx,al ; b |
mov .temp_col,bx |
fimul .temp_col |
fistp word[ecx] |
cmp word[ecx],0 |
jg @f |
mov word[ecx],0 |
@@: |
shr edx,16 |
movzx bx,dl ; b max |
cmp word[ecx],bx |
jle @f |
mov word[ecx],bx |
@@: |
add ecx,2 |
;end if |
; ror eax,16 |
; movzx bx,al |
; mov word[ecx],bx |
; ror eax,16 |
; movzx bx,ah |
; mov word[ecx+2],bx |
; xor ah,ah |
; mov word[ecx+4],ax |
; add ecx,6 |
|
pop edi |
pop edx |
|
.update_counters: |
add edx,12 ; normal_size |
add edi,12 ;6 ; 3d point_coord_size |
|
pop eax |
inc ax |
cmp ax,[points_count_var] |
jne .again_color |
|
add .spot_light_ptr,18 |
cmp .spot_light_ptr,spot_l_end |
jl .again_color |
|
mov esp,ebp |
ret |
end if |
;#\\\\\\\\\\\\\\\\\\\\\\\\\comented//////////////////////////////////// |