WebSVN – Kolibri OS – Diff – /programs/demos/view3ds/b_procs.inc


;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     edx,[points_count_var]
        fld     dword[edi+ebx]
        fst     .max
        fstp    .min
        add     edi,12
        dec     edx
    .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      edx
        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     edx,[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      edx
        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>
        mov     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      esi,esi
       xor      eax,eax
       mov      ebx,.N+1
       mov      ecx,(.N*2)+2  ;--
       mov      edx,(.N*3)+3  ;---
       mov      [triangles_count_var],0
     .again_tri:
       stosd                             ; main wave
       mov      dword[edi],ebx
       inc      eax
       add      edi,4
       stosd
       stosd
       mov      dword[edi],ebx
       inc      ebx
       mov      dword[edi+4],ebx
 
 
       add      edi,8
 
       mov      dword[edi],ecx      ;----   ;     n2+2        ;    xor      ax,ax
       inc      ecx                        ;     n2+3        ;    mov      bx,.N+1
       mov      dword[edi+4],edx            ;                 ;    mov      cx,(.N*2)+2  ;--
       mov      dword[edi+8],ecx            ;     n3+3        ;    mov      dx,(.N*3)+3  ;---
       mov      dword[edi+12],edx            ;     n3+3        ;
       inc      edx                        ;                 ;
       mov      dword[edi+16],edx            ;     n2+3        ;
       mov      dword[edi+20],ecx           ;     n3+4
       add      edi,24              ;----
 
       dec      eax          ; border of wave
       dec      ebx
       dec      ecx
       dec      edx
 
       stosd                      ; first border
       inc      eax
       stosd
       mov      dword[edi],edx
       add      edi,4
 
       mov      dword[edi],edx
       add      edi,4
       stosd
       inc      edx
       mov      dword[edi],edx
 
       mov     dword[edi+4],ebx      ; second border
       mov     dword[edi+8],ecx
       inc     ebx
       mov     dword[edi+12],ebx
 
       mov     dword[edi+16],ebx
       mov     dword[edi+20],ecx
       inc     ecx
       mov     dword[edi+24],ecx
       add     edi,28
 
       add      [triangles_count_var],8     ;10
       inc      esi
       cmp      esi,.N
       jne      .again_tri
 
       add      eax,((.N+1)*3)+1
       add      ebx,((.N+1)*3)+1
       add      ecx,((.N+1)*3)+1
       add      edx,((.N+1)*3)+1
       xor      esi,esi
       cmp      eax,(.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
        RDTSC
        mov    [rand_seed],ax
        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>=SSE2
         push       ebp
         mov        ebp,esp
         push       dword 0x01010101
         movss      xmm5,[esp]
         shufps     xmm5,xmm5,0
     .again_blur:
         push       ecx
         mov        edi,[screen_ptr]
         movzx      ecx,word[size_x_var]  ;SIZE_X*3/4
 
         cmp         [dr_flag],12
         jge        @f
         lea        ecx,[ecx*3+1]
         shr        ecx,2
       @@:
 
         xor        eax,eax
         rep        stosd
   if 1
         movzx      ebx,word[size_x_var]
         movzx      ecx,word[size_y_var]
         sub        ecx,3
         imul       ecx,ebx
         cmp        [dr_flag],12  ; 32 bit per pix cause
         jge        @f
         lea        ecx,[ecx*3]
         shr        ecx,4
         lea        ebx,[ebx *3]
         jmp        .blr
       @@:
 
         shr        ecx,2
         shl        ebx,2
       ;  mov        ecx,(SIZE_X*(SIZE_Y-3))*3/16
     .blr:
     @@:
         push       ecx
         movups     xmm0,[edi+ebx]
         mov        ecx,edi
         sub        ecx,ebx
         movups     xmm1,[ecx]
         cmp         [dr_flag],12
         jge        @f
         movups     xmm2,[edi-3]
         movups     xmm3,[edi+3]
         jmp        .f
        @@:
         movups     xmm2,[edi-4]
         movups     xmm3,[edi+4]
        .f:
         pavgb      xmm0,xmm1
         pavgb      xmm2,xmm3
         pavgb      xmm0,xmm2
         psubusb    xmm0,xmm5  ; importand if fire
         movups     [edi],xmm0
         add        edi,16
         add        esi,16
         pop        ecx
         loop       .blr
    end if
         xor        eax,eax
         movzx      ecx,word[size_x_var]
         cmp        [dr_flag],12
         jge        @f
         lea        ecx,[ecx*3]
         shr        ecx,2
        @@:
    ;     mov        ecx,SIZE_X*3/4
         rep        stosd
         pop        ecx
         dec        ecx
         jnz       .again_blur
         mov        esp,ebp
         pop        ebp
end if
 
if Ext=SSE
         emms
         push       ebp
         mov        ebp,esp
         push       dword 0x01010101
         push       dword 0x01010101
         movq       mm4,[esp]
     .again_blur:
         push       ecx
         mov        edi,[screen_ptr]
         movzx      ecx,word[size_x_var]  ;SIZE_X*3/4
         lea        ecx,[ecx*3]
         shr        ecx,2
     ;    pxor       mm5,mm5
         xor        eax,eax
         rep        stosd
         movzx      ebx,word[size_x_var]
         movzx      ecx,word[size_y_var]
         sub        ecx,3
         imul       ecx,ebx
         lea        ecx,[ecx*3]
         shr        ecx,3
         lea        ebx,[ebx*3]
       ;  mov        ecx,(SIZE_X*(SIZE_Y-3))*3/8
     .blr:
     @@:
         movq       mm0,[edi+ebx]
         movq       mm1,[edi-ebx]
         movq       mm2,[edi-3]
         movq       mm3,[edi+3]
 
         pavgb      mm0,mm1
         pavgb      mm2,mm3
         pavgb      mm0,mm2
 
         psubusb    mm0,mm4  ; importand if fire
 
         movq       [edi],mm0
         add         edi,8
         add         esi,8
 
         loop        .blr
 
         xor        eax,eax
         mov        ecx,[size_x_var]
         lea        ecx,[ecx*3]
         shr        ecx,2
       ;  SIZE_X*3/4
         rep        stosd
         pop         ecx
         loop       .again_blur
         mov        esp,ebp
         pop        ebp
end if
 
if Ext=MMX
         emms
         push       ebp
         mov        ebp,esp
         push       dword 0x0
         push       dword 0x01010101
.again_blur:
         push       ecx
         mov        edi,[screen_ptr]
         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
         mov      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
         mov      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////////////////////////////////////

Rev 8666	Rev 8719
1	;init_envmap_cub2:	1	;init_envmap_cub2:
2	; mov esi,envmap	2	; mov esi,envmap
3	; mov edi,envmap_cub ;take cubic env. map from	3	; mov edi,envmap_cub ;take cubic env. map from
4	; xor eax,eax ;spherical env. map	4	; xor eax,eax ;spherical env. map
5	; @@:	5	; @@:
6	; add esi,eax	6	; add esi,eax
7	; movsd	7	; movsd
8	; dec edi	8	; dec edi
9	; dec esi	9	; dec esi
10	; add esi,511*3	10	; add esi,511*3
11	; add eax,3	11	; add eax,3
12	; cmp eax,511*3	12	; cmp eax,511*3
13	; jl @b	13	; jl @b
14	;ret	14	;ret
15	init_envmap_cub: ; create 512x512 env map	15	init_envmap_cub: ; create 512x512 env map
16	.temp equ word [ebp-2]	16	.temp equ word [ebp-2]
17	push ebp	17	push ebp
18	mov ebp,esp	18	mov ebp,esp
19	sub esp,2	19	sub esp,2
20	mov edi,envmap_cub	20	mov edi,envmap_cub
21	fninit	21	fninit
22		22
23	mov cx,-256	23	mov cx,-256
24	.ie_hor:	24	.ie_hor:
25	mov .temp,cx	25	mov .temp,cx
26	fild .temp	26	fild .temp
27	fabs	27	fabs
28	; fmul st,st0	28	; fmul st,st0
29	; fsqrt	29	; fsqrt
30	mov .temp,255	30	mov .temp,255
31	fisubr .temp	31	fisubr .temp
32	fmul [env_const]	32	fmul [env_const]
33	fistp .temp	33	fistp .temp
34	mov ax,.temp	34	mov ax,.temp
35		35
36	or ax,ax	36	or ax,ax
37	jge .ie_ok1	37	jge .ie_ok1
38	xor ax,ax	38	xor ax,ax
39	jmp .ie_ok2	39	jmp .ie_ok2
40	.ie_ok1:	40	.ie_ok1:
41	cmp ax,255	41	cmp ax,255
42	jle .ie_ok2	42	jle .ie_ok2
43	mov ax,255	43	mov ax,255
44	.ie_ok2:	44	.ie_ok2:
45	stosb	45	stosb
46	stosb	46	stosb
47	stosb	47	stosb
48		48
49	inc cx	49	inc cx
50	cmp cx,256	50	cmp cx,256
51	jne .ie_hor	51	jne .ie_hor
52		52
53	mov esp,ebp	53	mov esp,ebp
54	pop ebp	54	pop ebp
55	ret	55	ret
56		56
57	calc_one_col:	57	calc_one_col:
58	; procedure don't save registers !!!	58	; procedure don't save registers !!!
59	; in - st - dot_product	59	; in - st - dot_product
60	; stack - other parameters	60	; stack - other parameters
61	; out - eax - 0x00rrggbb	61	; out - eax - 0x00rrggbb
62	.dot_prd equ dword[ebp+4] ; dot product - cos x - not now	62	.dot_prd equ dword[ebp+4] ; dot product - cos x - not now
63	.min_col_r equ [ebp+8] ; minimum color - ambient	63	.min_col_r equ word[ebp+8] ; minimum color - ambient
64	.min_col_g equ word[ebp+10]	64	.min_col_g equ word[ebp+10]
65	.min_col_b equ word[ebp+12]	65	.min_col_b equ word[ebp+12]
66	.max_col_r equ [ebp+14] ; maximum color - specular	66	.max_col_r equ word[ebp+14] ; maximum color - specular
67	.max_col_g equ word[ebp+16]	67	.max_col_g equ word[ebp+16]
68	.max_col_b equ word[ebp+18]	68	.max_col_b equ word[ebp+18]
69	.org_col_r equ [ebp+20] ; orginal color - diffuse	69	.org_col_r equ word[ebp+20] ; orginal color - diffuse
70	.org_col_g equ word[ebp+22]	70	.org_col_g equ word[ebp+22]
71	.org_col_b equ word[ebp+24]	71	.org_col_b equ word[ebp+24]
72	.n equ word[ebp+26] ; shines - not implemented	72	.n equ word[ebp+26] ; shines - not implemented
73	.temp equ word[ebp-2]	73	.temp equ word[ebp-2]
74	.color_sum_r equ [ebp-6]	74	.color_sum_r equ dword[ebp-6]
75	.color_sum_g equ [ebp-10]	75	.color_sum_g equ dword[ebp-10]
76	.color_sum_b equ [ebp-14]	76	.color_sum_b equ dword[ebp-14]
77	; color = ambient+cos(x)diffuse+(cos(x)^n)specular	77	; color = ambient+cos(x)diffuse+(cos(x)^n)specular
78	mov ebp,esp	78	mov ebp,esp
79	sub esp,14	79	sub esp,14
80		-
81		80
82	mov ax,.min_col_r	81	mov ax,.min_col_r
83	add ax,.max_col_r	82	add ax,.max_col_r
84	add ax,.org_col_r	83	add ax,.org_col_r
85	cwde	84	cwde
86	mov .color_sum_r,eax	85	mov .color_sum_r,eax
87		86
88	mov ax,.min_col_g	87	mov ax,.min_col_g
89	add ax,.max_col_g	88	add ax,.max_col_g
90	add ax,.org_col_g	89	add ax,.org_col_g
91	cwde	90	cwde
92	mov .color_sum_g,eax	91	mov .color_sum_g,eax
93		92
94	mov ax,.min_col_b	93	mov ax,.min_col_b
95	add ax,.max_col_b	94	add ax,.max_col_b
96	add ax,.org_col_b	95	add ax,.org_col_b
97	cwde	96	cwde
98	mov .color_sum_b,eax	97	mov .color_sum_b,eax
99	if 0	-
100		-
101		-
102	movq xmm0,.min_col_r	-
103	movq xmm1,.max_col_r	-
104	movq xmm2,.org_col_r	-
105	packuswb xmm0,[the_zero]	-
106	packuswb xmm1,[the_zero]	-
107	packuswb xmm2,[the_zero]	-
108	punpcklbw xmm0,xmm1	-
109	punpcklbw xmm2,[the_zero]	-
110	packusdw xmm2,[the_zero]	-
111	cvtdq2ps xmm0,xmm0	-
112	cvtdq2ps xmm1,xmm1	-
113	cvtdq2ps xmm2,xmm2	-
114	haddps xmm0,xmm0	-
115	haddps xmm1,xmm1	-
116	haddps xmm2,xmm2	-
117	haddps xmm0,xmm0	-
118	haddps xmm1,xmm1	-
119	haddps xmm2,xmm2	-
120		-
121	cvtss2si eax,xmm0	-
122	cvtss2si ebx,xmm1	-
123	cvtss2si ecx,xmm2	-
124	mov .color_sum_r,eax	-
125	mov .color_sum_g,ebx	-
126	mov .color_sum_b,ecx	-
127		-
128		-
129	end if	98
130		99
131	; fld .dot_prd	100	; fld .dot_prd
132	; fild .n	101	; fild .n
133	; fxch st1	102	; fxch st1
134	; fabs	103	; fabs
135	; fyl2x ;	104	; fyl2x ;
136	; f2xm1	105	; f2xm1
137	; fld1	106	; fld1
138	; faddp ; st = dot_product ^ n	107	; faddp ; st = dot_product ^ n
139		108
140	fld st ; copy dot pr	109	fld st ; copy dot pr
141	fmul st,st0	110	fmul st,st0
142	fmul st,st0	111	fmul st,st0
143	fmul st,st0	112	fmul st,st0
144	cmp .n,255 ; .n = 255 -> spot light	113	cmp .n,255 ; .n = 255 -> spot light
145	jne @f	114	jne @f
146	fmul st,st0	115	fmul st,st0
147	fmul st,st0	116	fmul st,st0
148	fmul st,st0	117	fmul st,st0
149	@@:	118	@@:
150	fld st ; st0=st1=dot_pr^n, st2=dot_pr	119	fld st ; st0=st1=dot_pr^n, st2=dot_pr
151	fimul .max_col_b	120	fimul .max_col_b
152	fild .org_col_b	121	fild .org_col_b
153	fmul st,st3	122	fmul st,st3
154	faddp ; st0=first piece of col, st1=dot_pr^n..	123	faddp ; st0=first piece of col, st1=dot_pr^n..
155	fiadd .min_col_b	124	fiadd .min_col_b
156	fimul .max_col_b	125	fimul .max_col_b
157	fidiv dword .color_sum_b	126	fidiv .color_sum_b
158	fistp .temp	127	fistp .temp
159	movzx eax,.temp	128	movzx eax,.temp
160	shl eax,16	129	shl eax,16
161		130
162	fld st	131	fld st
163	fimul .max_col_g	132	fimul .max_col_g
164	fild .org_col_g	133	fild .org_col_g
165	fmul st,st3	134	fmul st,st3
166	faddp	135	faddp
167	fiadd .min_col_g	136	fiadd .min_col_g
168	fimul .max_col_g	137	fimul .max_col_g
169	fidiv dword .color_sum_g	138	fidiv .color_sum_g
170	fistp .temp	139	fistp .temp
171	mov ax,.temp	140	mov ax,.temp
172	mov ah,al	141	mov ah,al
173	shl eax,8	142	shl eax,8
174		143
175	fimul word .max_col_r	144	fimul .max_col_r
176	fild word .org_col_r	145	fild .org_col_r
177	fmulp st2,st	146	fmulp st2,st
178	faddp	147	faddp
179	fiadd word .min_col_r	148	fiadd .min_col_r
180	fimul word .max_col_r	149	fimul .max_col_r
181	fidiv dword .color_sum_r	150	fidiv .color_sum_r
182	fistp .temp	151	fistp .temp
183	mov ax,.temp ;eax - 0xbbgg00rr	152	mov ax,.temp ;eax - 0xbbgg00rr
184	; mov ah,al	153	; mov ah,al
185	ror eax,16	154	ror eax,16
186	xchg al,ah ; eax - 0x00rrggbb	155	xchg al,ah ; eax - 0x00rrggbb
187	mov esp,ebp	156	mov esp,ebp
188	ret 24	157	ret 24
189		158
190	calc_bumpmap: ; calculate random bumpmap	159	calc_bumpmap: ; calculate random bumpmap
191	;--------------in edi _ pointer to TEX_X x TEX_Y bumpmap	160	;--------------in edi _ pointer to TEX_X x TEX_Y bumpmap
192		161
193	push edi	162	push edi
194		163
195	cmp [bumps_flag],0	164	cmp [bumps_flag],0
196	je .random_bump_map	165	je .random_bump_map
197	; else bumps according to texture	166	; else bumps according to texture
198	mov esi,texmap	167	mov esi,texmap
199	mov ecx,TEXTURE_SIZE	168	mov ecx,TEXTURE_SIZE
200	@@:	169	@@:
201	movzx ax,byte[esi]	170	movzx ax,byte[esi]
202	movzx bx,byte[esi+1]	171	movzx bx,byte[esi+1]
203	movzx dx,byte[esi+2]	172	movzx dx,byte[esi+2]
204	add ax,bx	173	add ax,bx
205	add ax,dx	174	add ax,dx
206	cwd	175	cwd
207	div [i3]	176	div [i3]
208	stosb	177	stosb
209	add esi,3	178	add esi,3
210	loop @b	179	loop @b
211	jmp .blur_map	180	jmp .blur_map
212	; push ecx	181	; push ecx
213	; mov eax,0x88888888	182	; mov eax,0x88888888
214	; mov ecx,16/4	183	; mov ecx,16/4
215	; rep stosd	184	; rep stosd
216	; mov eax,0xffffffff	185	; mov eax,0xffffffff
217	; mov ecx,16/4	186	; mov ecx,16/4
218	; rep stosd	187	; rep stosd
219	; pop ecx	188	; pop ecx
220	; loop @b	189	; loop @b
221	.random_bump_map:	190	.random_bump_map:
222		191
223	mov ecx,TEXTURE_SIZE	192	mov ecx,TEXTURE_SIZE
224	@@:	193	@@:
225	push ecx	194	push ecx
226	xor ecx,ecx	195	xor ecx,ecx
227	mov edx,255	196	mov edx,255
228	call random	197	call random
229	stosb	198	stosb
230	pop ecx	199	pop ecx
231	loop @b	200	loop @b
232		201
233	.blur_map:	202	.blur_map:
234	pop edi	203	pop edi
235	movzx ecx,[bumps_deep_flag]	204	movzx ecx,[bumps_deep_flag]
236	inc cx	205	inc cx
237	.blur:	206	.blur:
238	xor esi,esi	207	xor esi,esi
239	mov edx,TEXTURE_SIZE	208	mov edx,TEXTURE_SIZE
240	xor eax,eax	209	xor eax,eax
241	xor ebx,ebx	210	xor ebx,ebx
242	@@:	211	@@:
243	mov ebp,esi	212	mov ebp,esi
244	dec ebp	213	dec ebp
245	and ebp,TEXTURE_SIZE	214	and ebp,TEXTURE_SIZE
246	mov al,byte[ebp+edi]	215	mov al,byte[ebp+edi]
247		216
248	mov ebp,esi	217	mov ebp,esi
249	inc ebp	218	inc ebp
250	and ebp,TEXTURE_SIZE	219	and ebp,TEXTURE_SIZE
251	mov bl,byte[ebp+edi]	220	mov bl,byte[ebp+edi]
252	add eax,ebx	221	add eax,ebx
253		222
254	mov ebp,esi	223	mov ebp,esi
255	sub ebp,TEX_X	224	sub ebp,TEX_X
256	and ebp,TEXTURE_SIZE	225	and ebp,TEXTURE_SIZE
257	mov bl,byte[ebp+edi]	226	mov bl,byte[ebp+edi]
258	add eax,ebx	227	add eax,ebx
259		228
260	mov ebp,esi	229	mov ebp,esi
261	add ebp,TEX_X	230	add ebp,TEX_X
262	and ebp,TEXTURE_SIZE	231	and ebp,TEXTURE_SIZE
263	mov bl,byte[ebp+edi]	232	mov bl,byte[ebp+edi]
264	add eax,ebx	233	add eax,ebx
265		234
266	shr eax,2	235	shr eax,2
267	mov byte[esi+edi],al	236	mov byte[esi+edi],al
268		237
269	inc esi	238	inc esi
270	dec edx	239	dec edx
271	jnz @b	240	jnz @b
272		241
273	loop .blur	242	loop .blur
274	ret	243	ret
275	random:	244	random:
276	; in - ecx - min	245	; in - ecx - min
277	; edx - max	246	; edx - max
278	; out - eax - random number	247	; out - eax - random number
279	mov bx,[rand_seed]	248	mov bx,[rand_seed]
280	add bx,0x9248	249	add bx,0x9248
281	ror bx,3	250	ror bx,3
282	mov [rand_seed],bx	251	mov [rand_seed],bx
283		252
284	mov ax,dx	253	mov ax,dx
285	sub ax,cx	254	sub ax,cx
286	mul bx	255	mul bx
287	mov ax,dx	256	mov ax,dx
288	add ax,cx	257	add ax,cx
289	cwde	258	cwde
290	ret	259	ret
291		260
292	optimize_object1: ; setting point (0,0,0) in center of object	261	optimize_object1: ; setting point (0,0,0) in center of object
293	; recalculate all coords , scale object,	262	; recalculate all coords , scale object,
294	;the coords in <-1.0,1.0>	263	;the coords in <-1.0,1.0>
295	;in : real_points - table filled of real float dd coordinates (x,y,z), end mark dd -1	264	;in : real_points - table filled of real float dd coordinates (x,y,z), end mark dd -1
296	; _ global variable	265	; _ global variable
297	; points_count_var - dw integer variable with exactly points count	266	; points_count_var - dw integer variable with exactly points count
298	; - global variable	267	; - global variable
299	; SIZE_X, SIZE_Y must be defined	268	; SIZE_X, SIZE_Y must be defined
300		269
301	.max equ dword[ebp-4]	270	.max equ dword[ebp-4]
302	.min equ dword[ebp-8]	271	.min equ dword[ebp-8]
303	.maxxx equ dword[ebp-12]	272	.maxxx equ dword[ebp-12]
304	.center equ dword[ebp-16]	273	.center equ dword[ebp-16]
305		274
306	mov ebp,esp	275	mov ebp,esp
307	sub esp,16	276	sub esp,16
308	fninit	277	fninit
309	mov .maxxx,0	278	mov .maxxx,0
310	mov ecx,3	279	mov ecx,3
311	xor ebx,ebx ; ebx - x,y,z coord in real_points list	280	xor ebx,ebx ; ebx - x,y,z coord in real_points list
312	.next_c: ; max/min/center x,y,z	281	.next_c: ; max/min/center x,y,z
313	mov edi,[points_ptr] ; in real_point list minimum two points	282	mov edi,[points_ptr] ; in real_point list minimum two points
314	mov edx,[points_count_var]	283	mov edx,[points_count_var]
315	fld dword[edi+ebx]	284	fld dword[edi+ebx]
316	fst .max	285	fst .max
317	fstp .min	286	fstp .min
318	add edi,12	287	add edi,12
319	dec edx	288	dec edx
320	.next_coord: ; next coord from real_points list	289	.next_coord: ; next coord from real_points list
321	fld dword [edi+ebx] ; real_points -> x,y,z	290	fld dword [edi+ebx] ; real_points -> x,y,z
322	fcom .max ; max_x,y,z	291	fcom .max ; max_x,y,z
323	fstsw ax	292	fstsw ax
324	sahf	293	sahf
325	jbe @f ; jmp less equal	294	jbe @f ; jmp less equal
326	fstp .max ; new max_x,y,z	295	fstp .max ; new max_x,y,z
327	jmp .end_coords	296	jmp .end_coords
328	@@:	297	@@:
329	fcom .min ; min_x,y,z	298	fcom .min ; min_x,y,z
330	fstsw ax	299	fstsw ax
331	sahf	300	sahf
332	jnbe @f ; jmp greater	301	jnbe @f ; jmp greater
333	fst .min ; new min_x	302	fst .min ; new min_x
334	@@:	303	@@:
335	ffree st	304	ffree st
336	.end_coords:	305	.end_coords:
337	add edi,12	306	add edi,12
338	; cmp dword[edi],-1 ; cmp with end mark	307	; cmp dword[edi],-1 ; cmp with end mark
339	dec edx	308	dec edx
340	jnz .next_coord	309	jnz .next_coord
341	; ok after this we found max_coord and min_coord	310	; ok after this we found max_coord and min_coord
342	fld .max ; find center point	311	fld .max ; find center point
343	fadd .min	312	fadd .min
344	fld1	313	fld1
345	fld1	314	fld1
346	faddp	315	faddp
347	fdivp st1,st ; st0 - center coord	316	fdivp st1,st ; st0 - center coord
348	fstp .center	317	fstp .center
349		318
350	fld .max	319	fld .max
351	fsub .center ; st = .max - .center	320	fsub .center ; st = .max - .center
352	fcom .maxxx ; maximum of all .max	321	fcom .maxxx ; maximum of all .max
353	fstsw ax	322	fstsw ax
354	sahf	323	sahf
355	jbe @f ; jmp lower	324	jbe @f ; jmp lower
356	fst .maxxx ; new maxx	325	fst .maxxx ; new maxx
357	@@:	326	@@:
358	ffree st	327	ffree st
359	mov edi,[points_ptr]	328	mov edi,[points_ptr]
360	mov edx,[points_count_var] ; substraction all coords - center point	329	mov edx,[points_count_var] ; substraction all coords - center point
361	@@:	330	@@:
362	fld dword[edi+ebx]	331	fld dword[edi+ebx]
363	fsub .center	332	fsub .center
364	fstp dword[edi+ebx]	333	fstp dword[edi+ebx]
365	add edi,12	334	add edi,12
366	; cmp dword[edi],-1	335	; cmp dword[edi],-1
367	; jne @b	336	; jne @b
368	dec edx	337	dec edx
369	jnz @b	338	jnz @b
370		339
371	add ebx,4 ; ebx - x,y,z cooficientes in list real_points	340	add ebx,4 ; ebx - x,y,z cooficientes in list real_points
372	dec ecx	341	dec ecx
373	jnz .next_c	342	jnz .next_c
374		343
375	fld .maxxx	344	fld .maxxx
376	mov edi,[points_ptr] ; create all coords in <-1.0,1.0>	345	mov edi,[points_ptr] ; create all coords in <-1.0,1.0>
377	mov ecx,[points_count_var]	346	mov ecx,[points_count_var]
378	@@:	347	@@:
379	fld dword[edi]	348	fld dword[edi]
380	fdiv .maxxx	349	fdiv .maxxx
381	fstp dword[edi]	350	fstp dword[edi]
382	fld dword[edi+4]	351	fld dword[edi+4]
383	fdiv .maxxx	352	fdiv .maxxx
384	fstp dword[edi+4]	353	fstp dword[edi+4]
385	fld dword[edi+8]	354	fld dword[edi+8]
386	fdiv .maxxx	355	fdiv .maxxx
387	fstp dword[edi+8]	356	fstp dword[edi+8]
388	add edi,12	357	add edi,12
389	loop @b	358	loop @b
390	; cmp dword[edi],-1	359	; cmp dword[edi],-1
391		360
392	; jne @b	361	; jne @b
393		362
394	mov esp,ebp	363	mov esp,ebp
395	ret	364	ret
396		365
397	generate_object: ; generate node	366	generate_object: ; generate node
398	.N equ 32	367	.N equ 32
399	.x equ word[ebp-2]	368	.x equ word[ebp-2]
400	.Ndiv2 equ word[ebp-10]	369	.Ndiv2 equ word[ebp-10]
401	.MthickSqr equ dword[ebp-14] ; diameter^2	370	.MthickSqr equ dword[ebp-14] ; diameter^2
402	.temp equ dword[ebp-18] ; variable for x <-1;1>	371	.temp equ dword[ebp-18] ; variable for x <-1;1>
403	.Hthick equ dword[ebp-22]	372	.Hthick equ dword[ebp-22]
404	.cos_temp equ dword[ebp-26]	373	.cos_temp equ dword[ebp-26]
405	.next_const equ dword[ebp-30]	374	.next_const equ dword[ebp-30]
406	.a equ dword[ebp-34]	375	.a equ dword[ebp-34]
407	.Pi2 equ ebp-38	376	.Pi2 equ ebp-38
408		377
409		378
410		379
411	mov ebp,esp	380	mov ebp,esp
412	sub esp,42	381	sub esp,42
413		382
414	mov .Ndiv2,.N/2	383	mov .Ndiv2,.N/2
415	fninit	384	fninit
416	fldpi	385	fldpi
417	fadd st,st	386	fadd st,st
418	fst dword[.Pi2]	387	fst dword[.Pi2]
419	fidiv .Ndiv2	388	fidiv .Ndiv2
420	fst .a ; .Ndiv2*.a=2Pi => .a=2pi/.Ndiv2	389	fst .a ; .Ndiv2*.a=2Pi => .a=2pi/.Ndiv2
421		390
422	fld [.Mthick] ; inside diameter, (outside daiameter = 1)	391	fld [.Mthick] ; inside diameter, (outside daiameter = 1)
423	fmul st,st0	392	fmul st,st0
424	fstp .MthickSqr	393	fstp .MthickSqr
425	fld1	394	fld1
426		395
427	fsub [.Mthick]	396	fsub [.Mthick]
428		397
429	fst .Hthick ; Hthick = 1 - Mthick	398	fst .Hthick ; Hthick = 1 - Mthick
430	fld st	399	fld st
431	fadd st,st	400	fadd st,st
432	faddp	401	faddp
433	fstp .next_const ; next_const = Hthick * 3	402	fstp .next_const ; next_const = Hthick * 3
434		403
435		404
436	;init triangles list	405	;init triangles list
437	mov edi,[triangles_ptr]	406	mov edi,[triangles_ptr]
438		407
439	xor esi,esi	408	xor esi,esi
440	xor eax,eax	409	xor eax,eax
441	mov ebx,.N+1	410	mov ebx,.N+1
442	mov ecx,(.N*2)+2 ;--	411	mov ecx,(.N*2)+2 ;--
443	mov edx,(.N*3)+3 ;---	412	mov edx,(.N*3)+3 ;---
444	mov [triangles_count_var],0	413	mov [triangles_count_var],0
445	.again_tri:	414	.again_tri:
446	stosd ; main wave	415	stosd ; main wave
447	mov dword[edi],ebx	416	mov dword[edi],ebx
448	inc eax	417	inc eax
449	add edi,4	418	add edi,4
450	stosd	419	stosd
451	stosd	420	stosd
452	mov dword[edi],ebx	421	mov dword[edi],ebx
453	inc ebx	422	inc ebx
454	mov dword[edi+4],ebx	423	mov dword[edi+4],ebx
455		424
456		425
457	add edi,8	426	add edi,8
458		427
459	mov dword[edi],ecx ;---- ; n2+2 ; xor ax,ax	428	mov dword[edi],ecx ;---- ; n2+2 ; xor ax,ax
460	inc ecx ; n2+3 ; mov bx,.N+1	429	inc ecx ; n2+3 ; mov bx,.N+1
461	mov dword[edi+4],edx ; ; mov cx,(.N*2)+2 ;--	430	mov dword[edi+4],edx ; ; mov cx,(.N*2)+2 ;--
462	mov dword[edi+8],ecx ; n3+3 ; mov dx,(.N*3)+3 ;---	431	mov dword[edi+8],ecx ; n3+3 ; mov dx,(.N*3)+3 ;---
463	mov dword[edi+12],edx ; n3+3 ;	432	mov dword[edi+12],edx ; n3+3 ;
464	inc edx ; ;	433	inc edx ; ;
465	mov dword[edi+16],edx ; n2+3 ;	434	mov dword[edi+16],edx ; n2+3 ;
466	mov dword[edi+20],ecx ; n3+4	435	mov dword[edi+20],ecx ; n3+4
467	add edi,24 ;----	436	add edi,24 ;----
468		437
469	dec eax ; border of wave	438	dec eax ; border of wave
470	dec ebx	439	dec ebx
471	dec ecx	440	dec ecx
472	dec edx	441	dec edx
473		442
474	stosd ; first border	443	stosd ; first border
475	inc eax	444	inc eax
476	stosd	445	stosd
477	mov dword[edi],edx	446	mov dword[edi],edx
478	add edi,4	447	add edi,4
479		448
480	mov dword[edi],edx	449	mov dword[edi],edx
481	add edi,4	450	add edi,4
482	stosd	451	stosd
483	inc edx	452	inc edx
484	mov dword[edi],edx	453	mov dword[edi],edx
485		454
486	mov dword[edi+4],ebx ; second border	455	mov dword[edi+4],ebx ; second border
487	mov dword[edi+8],ecx	456	mov dword[edi+8],ecx
488	inc ebx	457	inc ebx
489	mov dword[edi+12],ebx	458	mov dword[edi+12],ebx
490		459
491	mov dword[edi+16],ebx	460	mov dword[edi+16],ebx
492	mov dword[edi+20],ecx	461	mov dword[edi+20],ecx
493	inc ecx	462	inc ecx
494	mov dword[edi+24],ecx	463	mov dword[edi+24],ecx
495	add edi,28	464	add edi,28
496		465
497	add [triangles_count_var],8 ;10	466	add [triangles_count_var],8 ;10
498	inc esi	467	inc esi
499	cmp esi,.N	468	cmp esi,.N
500	jne .again_tri	469	jne .again_tri

Subversion Repositories Kolibri OS

(root)/programs/demos/view3ds/b_procs.inc – Rev 8666 → 8719