Subversion Repositories Kolibri OS

Rev

Rev 1931 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;init_envmap_cub2:
  2. ;        mov esi,envmap
  3. ;        mov edi,envmap_cub    ;take cubic env. map from
  4. ;        xor eax,eax           ;spherical env. map
  5. ;      @@:
  6. ;        add esi,eax
  7. ;        movsd
  8. ;        dec edi
  9. ;        dec esi
  10. ;        add esi,511*3
  11. ;        add eax,3
  12. ;        cmp eax,511*3
  13. ;        jl  @b
  14. ;ret
  15. init_envmap_cub:         ; create 512x512 env map
  16. .temp equ word [ebp-2]
  17.          push     ebp
  18.          mov      ebp,esp
  19.          sub      esp,2
  20.          mov      edi,envmap_cub
  21.          fninit
  22.  
  23.          mov      cx,-256
  24.     .ie_hor:
  25.          mov      .temp,cx
  26.          fild     .temp
  27.          fabs
  28.   ;      fmul     st,st0
  29.   ;      fsqrt
  30.          mov      .temp,255
  31.          fisubr   .temp
  32.          fmul     [env_const]
  33.          fistp    .temp
  34.          mov      ax,.temp
  35.  
  36.          or      ax,ax
  37.          jge     .ie_ok1
  38.          xor     ax,ax
  39.          jmp     .ie_ok2
  40.   .ie_ok1:
  41.          cmp     ax,255
  42.          jle     .ie_ok2
  43.          mov     ax,255
  44.   .ie_ok2:
  45.          stosb
  46.          stosb
  47.          stosb
  48.  
  49.          inc     cx
  50.          cmp     cx,256
  51.          jne     .ie_hor
  52.  
  53.          mov     esp,ebp
  54.          pop     ebp
  55. ret
  56.  
  57. calc_one_col:
  58. ; procedure don't save registers !!!
  59. ; in -   st - dot_product
  60. ;        stack - other parameters
  61. ; out - eax - 0x00rrggbb
  62. .dot_prd   equ dword[ebp+4]           ; dot product   - cos x  - not now
  63. .min_col_r equ word[ebp+8]            ; minimum color - ambient
  64. .min_col_g equ word[ebp+10]
  65. .min_col_b equ word[ebp+12]
  66. .max_col_r equ word[ebp+14]           ; maximum color - specular
  67. .max_col_g equ word[ebp+16]
  68. .max_col_b equ word[ebp+18]
  69. .org_col_r equ word[ebp+20]           ; orginal color - diffuse
  70. .org_col_g equ word[ebp+22]
  71. .org_col_b equ word[ebp+24]
  72. .n         equ word[ebp+26]           ; shines - not implemented
  73. .temp      equ word[ebp-2]
  74. .color_sum_r equ dword[ebp-6]
  75. .color_sum_g equ dword[ebp-10]
  76. .color_sum_b equ dword[ebp-14]
  77. ; color = ambient+cos(x)*diffuse+(cos(x)^n)*specular
  78.          mov     ebp,esp
  79.          sub     esp,14
  80.  
  81.          mov      ax,.min_col_r
  82.          add      ax,.max_col_r
  83.          add      ax,.org_col_r
  84.          cwde
  85.          mov      .color_sum_r,eax
  86.  
  87.          mov      ax,.min_col_g
  88.          add      ax,.max_col_g
  89.          add      ax,.org_col_g
  90.          cwde
  91.          mov      .color_sum_g,eax
  92.  
  93.          mov      ax,.min_col_b
  94.          add      ax,.max_col_b
  95.          add      ax,.org_col_b
  96.          cwde
  97.          mov      .color_sum_b,eax
  98.  
  99.  
  100. ;         fld     .dot_prd
  101.        ;  fild    .n
  102.        ;  fxch    st1
  103.        ;  fabs
  104.        ;  fyl2x                     ;
  105.        ;  f2xm1
  106.        ;  fld1
  107.        ;  faddp        ; st =  dot_product ^ n
  108.  
  109.          fld     st            ; copy dot pr
  110.          fmul    st,st0
  111.          fmul    st,st0
  112.          fmul    st,st0
  113.          cmp     .n,255            ; .n = 255 -> spot light
  114.          jne     @f
  115.          fmul    st,st0
  116.          fmul    st,st0
  117.          fmul    st,st0
  118.       @@:
  119.          fld     st            ; st0=st1=dot_pr^n, st2=dot_pr
  120.          fimul   .max_col_b
  121.          fild    .org_col_b
  122.          fmul    st,st3
  123.          faddp                 ; st0=first piece of col, st1=dot_pr^n..
  124.          fiadd   .min_col_b
  125.          fimul   .max_col_b
  126.          fidiv   .color_sum_b
  127.          fistp   .temp
  128.          movzx   eax,.temp
  129.          shl     eax,16
  130.  
  131.          fld     st
  132.          fimul   .max_col_g
  133.          fild    .org_col_g
  134.          fmul    st,st3
  135.          faddp
  136.          fiadd   .min_col_g
  137.          fimul   .max_col_g
  138.          fidiv   .color_sum_g
  139.          fistp   .temp
  140.          mov     ax,.temp
  141.          mov     ah,al
  142.          shl     eax,8
  143.  
  144.          fimul   .max_col_r
  145.          fild    .org_col_r
  146.          fmulp   st2,st
  147.          faddp
  148.          fiadd   .min_col_r
  149.          fimul   .max_col_r
  150.          fidiv   .color_sum_r
  151.          fistp   .temp
  152.          mov     ax,.temp          ;eax -  0xbbgg00rr
  153.      ;   mov     ah,al
  154.          ror     eax,16
  155.          xchg    al,ah             ; eax - 0x00rrggbb
  156.          mov     esp,ebp
  157. ret 24
  158.  
  159. calc_bumpmap:            ; calculate random bumpmap
  160. ;--------------in edi _ pointer to TEX_X x TEX_Y bumpmap
  161.  
  162.          push    edi
  163.  
  164.          cmp     [bumps_flag],0
  165.          je      .random_bump_map
  166.          ; else bumps according to texture
  167.          mov     esi,texmap
  168.          mov     ecx,TEXTURE_SIZE
  169.       @@:
  170.          movzx   ax,byte[esi]
  171.          movzx   bx,byte[esi+1]
  172.          movzx   dx,byte[esi+2]
  173.          add     ax,bx
  174.          add     ax,dx
  175.          cwd
  176.          div     [i3]
  177.          stosb
  178.          add     esi,3
  179.          loop    @b
  180.          jmp     .blur_map
  181. ;         push    ecx
  182. ;         mov     eax,0x88888888
  183. ;         mov     ecx,16/4
  184. ;         rep     stosd
  185. ;         mov     eax,0xffffffff
  186. ;         mov     ecx,16/4
  187. ;         rep     stosd
  188. ;         pop     ecx
  189. ;         loop    @b
  190.   .random_bump_map:
  191.  
  192.          mov     ecx,TEXTURE_SIZE
  193.       @@:
  194.          push    ecx
  195.          xor     ecx,ecx
  196.          mov     edx,255
  197.          call    random
  198.          stosb
  199.          pop    ecx
  200.          loop   @b
  201.  
  202.       .blur_map:
  203.          pop    edi
  204.          movzx  ecx,[bumps_deep_flag]
  205.          inc    cx
  206.       .blur:
  207.          xor    esi,esi
  208.          mov    edx,TEXTURE_SIZE
  209.          xor    eax,eax
  210.          xor    ebx,ebx
  211.       @@:
  212.          mov    ebp,esi
  213.          dec    ebp
  214.          and    ebp,TEXTURE_SIZE
  215.          mov    al,byte[ebp+edi]
  216.  
  217.          mov    ebp,esi
  218.          inc    ebp
  219.          and    ebp,TEXTURE_SIZE
  220.          mov    bl,byte[ebp+edi]
  221.          add    eax,ebx
  222.  
  223.          mov    ebp,esi
  224.          sub    ebp,TEX_X
  225.          and    ebp,TEXTURE_SIZE
  226.          mov    bl,byte[ebp+edi]
  227.          add    eax,ebx
  228.  
  229.          mov    ebp,esi
  230.          add    ebp,TEX_X
  231.          and    ebp,TEXTURE_SIZE
  232.          mov    bl,byte[ebp+edi]
  233.          add    eax,ebx
  234.  
  235.          shr    eax,2
  236.          mov    byte[esi+edi],al
  237.  
  238.          inc    esi
  239.          dec    edx
  240.          jnz    @b
  241.  
  242.          loop   .blur
  243. ret
  244. random:
  245. ;  in  - ecx - min
  246. ;        edx - max
  247. ;  out - eax - random number
  248.          mov    bx,[rand_seed]
  249.          add    bx,0x9248
  250.          ror    bx,3
  251.          mov    [rand_seed],bx
  252.  
  253.          mov    ax,dx
  254.          sub    ax,cx
  255.          mul    bx
  256.          mov    ax,dx
  257.          add    ax,cx
  258.          cwde
  259. ret
  260.  
  261. optimize_object1:        ; setting   point (0,0,0) in center of object
  262.                          ; recalculate all coords , scale object,
  263.                          ;the coords in <-1.0,1.0>
  264. ;in :  real_points - table filled of real float dd coordinates (x,y,z), end mark  dd -1
  265. ;                  _ global variable
  266. ;      points_count_var - dw integer variable with exactly points count
  267. ;                       - global variable
  268. ;      SIZE_X, SIZE_Y must be defined
  269.  
  270. .max   equ dword[ebp-4]
  271. .min   equ dword[ebp-8]
  272. .maxxx equ dword[ebp-12]
  273. .center equ dword[ebp-16]
  274.  
  275.         mov     ebp,esp
  276.         sub     esp,16
  277.         fninit
  278.         mov     .maxxx,0
  279.         mov     ecx,3
  280.         xor     ebx,ebx         ; ebx - x,y,z coord in real_points list
  281.     .next_c:                    ; max/min/center x,y,z
  282.         mov     edi,[points_ptr]      ; in real_point list minimum two points
  283.         mov     dx,[points_count_var]
  284.         fld     dword[edi+ebx]
  285.         fst     .max
  286.         fstp    .min
  287.         add     edi,12
  288.         dec     dx
  289.     .next_coord:               ; next coord from real_points list
  290.         fld     dword [edi+ebx]   ; real_points -> x,y,z
  291.         fcom    .max    ; max_x,y,z
  292.         fstsw   ax
  293.         sahf
  294.         jbe     @f             ; jmp less equal
  295.         fstp    .max    ; new max_x,y,z
  296.         jmp     .end_coords
  297.      @@:
  298.         fcom    .min    ; min_x,y,z
  299.         fstsw   ax
  300.         sahf
  301.         jnbe    @f              ; jmp greater
  302.         fst     .min   ; new min_x
  303.     @@:
  304.         ffree   st
  305.     .end_coords:
  306.         add     edi,12
  307.    ;     cmp     dword[edi],-1   ; cmp with end mark
  308.         dec      dx
  309.         jnz     .next_coord
  310.         ; ok after this we found max_coord and min_coord
  311.         fld     .max          ; find center point
  312.         fadd    .min
  313.         fld1
  314.         fld1
  315.         faddp
  316.         fdivp   st1,st        ; st0 - center coord
  317.         fstp    .center
  318.  
  319.         fld     .max
  320.         fsub    .center      ; st = .max - .center
  321.         fcom    .maxxx      ; maximum of all .max
  322.         fstsw   ax
  323.         sahf
  324.         jbe     @f          ; jmp lower
  325.         fst     .maxxx      ; new maxx
  326.     @@:
  327.         ffree   st
  328.         mov     edi,[points_ptr]
  329.         mov     dx,[points_count_var]   ; substraction all coords - center point
  330.     @@:
  331.         fld     dword[edi+ebx]
  332.         fsub    .center
  333.         fstp    dword[edi+ebx]
  334.         add     edi,12
  335. ;        cmp     dword[edi],-1
  336. ;        jne     @b
  337.         dec      dx
  338.         jnz      @b
  339.  
  340.         add     ebx,4               ; ebx - x,y,z cooficientes in list real_points
  341.         dec     ecx
  342.         jnz     .next_c
  343.  
  344.         fld     .maxxx
  345.         mov     edi,[points_ptr]   ; create all coords in <-1.0,1.0>
  346.         movzx   ecx,[points_count_var]
  347.      @@:
  348.         fld     dword[edi]
  349.         fdiv    .maxxx
  350.         fstp    dword[edi]
  351.         fld     dword[edi+4]
  352.         fdiv    .maxxx
  353.         fstp    dword[edi+4]
  354.         fld     dword[edi+8]
  355.         fdiv    .maxxx
  356.         fstp    dword[edi+8]
  357.         add     edi,12
  358.         loop    @b
  359.      ;   cmp     dword[edi],-1
  360.  
  361.      ;   jne     @b
  362.  
  363.         mov     esp,ebp
  364. ret
  365.  
  366. generate_object:         ; generate node
  367. .N         equ 32
  368. .x         equ word[ebp-2]
  369. .Ndiv2     equ word[ebp-10]
  370. .MthickSqr equ dword[ebp-14]   ; diameter^2
  371. .temp      equ dword[ebp-18]   ; variable for x <-1;1>
  372. .Hthick    equ dword[ebp-22]
  373. .cos_temp  equ dword[ebp-26]
  374. .next_const  equ dword[ebp-30]
  375. .a           equ dword[ebp-34]
  376. .Pi2         equ       ebp-38
  377.  
  378.  
  379.  
  380.        mov      ebp,esp
  381.        sub      esp,42
  382.  
  383.        mov      .Ndiv2,.N/2
  384.        fninit
  385.        fldpi
  386.        fadd     st,st
  387.        fst      dword[.Pi2]
  388.        fidiv    .Ndiv2
  389.        fst      .a                       ; .Ndiv2*.a=2Pi => .a=2pi/.Ndiv2
  390.  
  391.        fld      [.Mthick]           ; inside diameter, (outside daiameter = 1)
  392.        fmul     st,st0
  393.        fstp     .MthickSqr
  394.        fld1
  395.  
  396.        fsub      [.Mthick]
  397.  
  398.        fst      .Hthick            ; Hthick = 1 - Mthick
  399.        fld      st
  400.        fadd     st,st
  401.        faddp
  402.        fstp     .next_const         ; next_const = Hthick * 3
  403.  
  404.  
  405.     ;init triangles list
  406.        mov      edi,[triangles_ptr]
  407.  
  408.        xor      si,si
  409.        xor      ax,ax
  410.        mov      bx,.N+1
  411.        mov      cx,(.N*2)+2  ;--
  412.        mov      dx,(.N*3)+3  ;---
  413.        mov      [triangles_count_var],0
  414.      .again_tri:
  415.        stosw                             ; main wave
  416.        mov      word[edi],bx
  417.        inc      ax
  418.        add      edi,2
  419.        stosw
  420.        stosw
  421.        mov      word[edi],bx
  422.        inc      bx
  423.        mov      word[edi+2],bx
  424.  
  425.  
  426.        add      edi,4
  427.  
  428.        mov      word[edi],cx      ;----   ;     n2+2        ;    xor      ax,ax
  429.        inc      cx                        ;     n2+3        ;    mov      bx,.N+1
  430.        mov      word[edi+2],dx            ;                 ;    mov      cx,(.N*2)+2  ;--
  431.        mov      word[edi+4],cx            ;     n3+3        ;    mov      dx,(.N*3)+3  ;---
  432.        mov      word[edi+6],dx            ;     n3+3        ;
  433.        inc      dx                        ;                 ;
  434.        mov      word[edi+8],dx            ;     n2+3        ;
  435.        mov      word[edi+10],cx           ;     n3+4
  436.        add      edi,12              ;----
  437.  
  438.        dec      ax          ; border of wave
  439.        dec      bx
  440.        dec      cx
  441.        dec      dx
  442.  
  443.        stosw                      ; first border
  444.        inc      ax
  445.        stosw
  446.        mov      word[edi],dx
  447.        add      edi,2
  448.  
  449.        mov      word[edi],dx
  450.        add      edi,2
  451.        stosw
  452.        inc      dx
  453.        mov      word[edi],dx
  454.  
  455.        mov     word[edi+2],bx      ; second border
  456.        mov     word[edi+4],cx
  457.        inc     bx
  458.        mov     word[edi+6],bx
  459.  
  460.        mov     word[edi+8],bx
  461.        mov     word[edi+10],cx
  462.        inc     cx
  463.        mov     word[edi+12],cx
  464.        add     edi,14
  465.  
  466.        add      [triangles_count_var],8     ;10
  467.        inc      si
  468.        cmp      si,.N
  469.        jne      .again_tri
  470.  
  471.        add      ax,((.N+1)*3)+1
  472.        add      bx,((.N+1)*3)+1
  473.        add      cx,((.N+1)*3)+1
  474.        add      dx,((.N+1)*3)+1
  475.        xor      si,si
  476.        cmp      ax,(.N*13)+13    ;;;(.N*23)+23                ; ax,(.N*13)+13
  477.        jl      .again_tri
  478.  
  479.        mov      dword[edi],-1          ;      <--- end mark not always in use
  480.  
  481.     ; init real points list
  482.        mov      .x,-(.N/2)
  483.        mov      edi,[points_ptr]
  484.        lea      esi,[edi+(12*(.N+1))]
  485.        mov      eax,[points_ptr]
  486.        mov      ebx,eax
  487.        add      eax,2*12*(.N+1)    ;---
  488.        add      ebx,3*12*(.N+1)    ;---
  489.        mov      [points_count_var],0
  490.  
  491.  
  492.        .R_P4 equ edi+(4*12*(.N+1))
  493.        .R_P5 equ edi+(5*12*(.N+1))
  494.        .R_P6 equ edi+(6*12*(.N+1))
  495.        .R_P7 equ edi+(7*12*(.N+1))
  496.  
  497.        .R_P8 equ edi+(8*12*(.N+1))
  498.        .R_P9 equ edi+(9*12*(.N+1))
  499.        .R_P10 equ edi+(10*12*(.N+1))
  500.        .R_P11 equ edi+(11*12*(.N+1))
  501.  
  502.        .R_P12 equ edi+(12*12*(.N+1))
  503.        .R_P13 equ edi+(13*12*(.N+1))
  504.        .R_P14 equ edi+(14*12*(.N+1))
  505.        .R_P15 equ edi+(15*12*(.N+1))
  506.  
  507.      @@:
  508.        ; x coordinate
  509.        fild     .x
  510.        fld      st
  511. ;;       fmul     .a                  ; st = <-2pi;2pi>  when mul .a
  512.        fidiv    .Ndiv2
  513.        fst      .temp                 ; temporary x in <-1.0;1.0>
  514.  
  515.        fst      dword[edi]              ;x coordinate of point
  516.        fst      dword[esi]
  517.        fst      dword[eax]              ;--
  518.  
  519.  
  520.        fst      dword[.R_P4]
  521.        fst      dword[.R_P5]
  522.        fst      dword[.R_P6]
  523.        fst      dword[.R_P7]
  524.  
  525.        fst      dword[.R_P8]
  526.        fst      dword[.R_P9]
  527.        fst      dword[.R_P10]
  528.        fst      dword[.R_P11]
  529.  
  530.        fst      dword[.R_P12]
  531.        fst      dword[.R_P13]
  532.        fst      dword[.R_P14]
  533.        fst      dword[.R_P15]
  534.  
  535.        fstp     dword[ebx]  ;pop
  536.       ;*******y coord               dword[offset + 4]
  537.        fmul      .a      ;  st  = <-2pi;2pi>
  538.        fsincos
  539.        fmul     .next_const
  540.        fst      dword[edi+4]            ; y coordinate of point
  541.        fst      dword[esi+4]
  542.        fst      dword[.R_P4+4]
  543.        fst      dword[.R_P5+4]
  544.        fld      .Hthick
  545.        faddp
  546.        fst      dword[.R_P6+4]
  547.        fst      dword[.R_P7+4]
  548.        fst      dword[eax+4]
  549.        fst      dword[ebx+4]
  550.  
  551.        fchs
  552.        fst      dword[.R_P10+4]
  553.        fst      dword[.R_P11+4]
  554.        fst      dword[.R_P14+4]
  555.        fst      dword[.R_P15+4]
  556.        fadd     .Hthick
  557.        fadd     .Hthick
  558.        fst      dword[.R_P8+4]
  559.        fst      dword[.R_P9+4]
  560.        fst      dword[.R_P12+4]
  561.        fstp     dword[.R_P13+4]
  562.  
  563.  
  564.        fmul     .Hthick
  565.        fmul     .next_const
  566.        fstp     .cos_temp           ; cos_temp = Hthick^2 * 3
  567.  
  568.      ;***************z coord
  569.        fld      .temp
  570.        fld      st
  571.        fmul     st,st0                  ; z coords
  572.        fchs
  573.        fld1
  574.        faddp
  575.        fabs
  576.        fsqrt
  577. ;       fld      st
  578. ;       fsub
  579.        fld      st
  580.        fsub     .cos_temp
  581.        fst      dword[esi+8]
  582.        fstp     dword[eax+8]            ;--
  583.        fld      st
  584.        fadd     .cos_temp
  585.        fst      dword[.R_P9+8]
  586.        fstp     dword[.R_P10+8]
  587.        fchs
  588.        fld      st
  589.        fsub     .cos_temp
  590.        fst      dword[.R_P6+8]
  591.        fstp     dword[.R_P5+8]
  592.        fadd     .cos_temp
  593.        fst      dword[.R_P13+8]
  594.        fstp     dword[.R_P14+8]
  595.  
  596.        fmul     [.Mthick]
  597.        fmul     st,st0
  598.        fchs
  599.        fld      .MthickSqr
  600.        faddp
  601.        fabs
  602.        fsqrt
  603.        fld      st
  604.        fsub     .cos_temp
  605.        fst      dword[edi+8]            ;  z coordinate
  606.        fstp     dword[ebx+8]            ;--
  607.        fld      st
  608.        fadd     .cos_temp
  609.        fst      dword[.R_P8+8]
  610.        fstp     dword[.R_P11+8]
  611.        fchs
  612.        fld      st
  613.        fsub     .cos_temp
  614.        fst      dword[.R_P7+8]
  615.        fstp     dword[.R_P4+8]
  616.        fadd     .cos_temp
  617.        fst      dword[.R_P12+8]
  618.        fstp     dword[.R_P15+8]
  619.  
  620.        add      edi,12
  621.        add      esi,12
  622.        add      eax,12                  ;--
  623.        add      ebx,12                  ;---
  624.        add      [points_count_var],24         ;16
  625.        inc      .x
  626.        cmp      .x,.N/2
  627.        jng      @b
  628. ;       mov      dword[esi],-1       ; <-- end mark
  629.        mov       [culling_flag],0
  630.        mov     esp,ebp
  631. ret
  632. .Mthick dd  0.85     ; size-thickness
  633.  
  634. make_random_lights:
  635.   .temp1  equ ebp-4
  636.   .temp2  equ ebp-8     ;  - light vector generate variables
  637.   .temp3  equ ebp-12
  638.   .max equ 800
  639.         push    ebp
  640.         mov     ebp,esp
  641.         sub     esp,12
  642.         mov     edi,lights
  643.         fninit
  644.         mov     dword[.temp2],.max
  645.         mov     dword[.temp3],.max/2
  646.  
  647.     .again:
  648.         xor     esi,esi
  649.      @@:
  650.         mov     edx,.max
  651.         xor     ecx,ecx
  652.         call    random
  653.         sub     eax,.max/2
  654.         mov     dword[.temp1],eax
  655.         fild    dword[.temp1]
  656.         fidiv   dword[.temp3]
  657.         fstp    dword[edi+esi*4]
  658.         inc     esi
  659.         cmp     esi,2
  660.         jne     @b
  661.  
  662.   .max1 equ 1000
  663.         mov     dword[.temp2],.max1/2
  664.         mov     edx,.max1
  665.         xor     ecx,ecx
  666.         call    random
  667.         mov     dword[.temp1],eax
  668.         fild    dword[.temp1]
  669.         fchs
  670.         fidiv   dword[.temp2]
  671.         fstp    dword[edi+8]
  672.  
  673.         xor     esi,esi
  674.      @@:
  675.         mov     ecx,220            ; max colors and shine  , ecx = 200 - more bright shading
  676.         mov     edx,255
  677.         call    random
  678.         mov     byte[edi+18+esi],al
  679.         inc     esi
  680.         cmp     esi,4
  681.         jne     @b
  682.  
  683.  
  684.         xor     esi,esi
  685.      @@:
  686.         mov     ecx,100              ; orginal colors
  687.         movzx   edx,byte[edi+18+esi]
  688.         call    random
  689.         mov     byte[edi+12+esi],al
  690.         inc     esi
  691.         cmp     esi,3
  692.         jne     @b
  693.  
  694.         xor     esi,esi
  695.      @@:
  696.         mov     ecx,1               ; min cols
  697.         movzx   edx,byte[edi+12+esi]
  698.         call    random
  699.         mov     byte[edi+15+esi],al
  700.         inc     esi
  701.         cmp     esi,3
  702.         jne     @b
  703.  
  704.         add     edi,LIGHT_SIZE ;22
  705.         cmp     edi,lightsend     ; see file View3ds,asm
  706.         jne     .again
  707.  
  708.         mov     esp,ebp
  709.         pop     ebp
  710. ret
  711.  
  712. generate_texture2:
  713. .const equ 32
  714.         mov     edi,texmap
  715.         xor     bx,bx
  716.      .next_line:
  717.         xor     dx,dx
  718.      .next2stripes:
  719.         mov     eax,-1
  720.         mov     ecx,(TEX_X/.const)*3/4
  721.         rep     stosd
  722.         mov     eax,0x00ff0000
  723.         mov     ecx,(TEX_X/.const)
  724.      @@:
  725.         stosd
  726.         dec     edi
  727.         loop    @b
  728.         inc     dx
  729.         cmp     dx,.const/2
  730.         jl      .next2stripes
  731.         inc     bx
  732.         cmp     bx,TEX_Y
  733.         jl      .next_line
  734. ret
  735.  
  736. blur_screen:    ;blur n times  ; blur or fire
  737. ;in - ecx  times count
  738. ;.counter equ dword[esp-4]
  739. .counter1 equ dword[esp-8]
  740. if Ext>=MMX
  741.          emms
  742.          push       ebp
  743.          mov        ebp,esp
  744.          push       dword 0x0
  745.          push       dword 0x01010101
  746. .again_blur:
  747.          push       ecx
  748.          mov        edi,screen
  749.          mov        ecx,SIZE_X*3/4
  750.          pxor       mm5,mm5
  751.          xor        eax,eax
  752.          rep        stosd
  753.  
  754.          mov        ecx,(SIZE_X*(SIZE_Y-3))*3/4
  755.      .blr:
  756.      @@:
  757.  
  758.          movd       mm0,[edi+SIZE_X*3]
  759.          movd       mm1,[edi-SIZE_X*3]
  760.          movd       mm2,[edi-3]
  761.          movd       mm3,[edi+3]
  762.  
  763.          punpcklbw  mm0,mm5
  764.          punpcklbw  mm1,mm5
  765.          punpcklbw  mm2,mm5
  766.          punpcklbw  mm3,mm5
  767.          paddw      mm0,mm1
  768.          paddw      mm0,mm2
  769.          paddw      mm0,mm3
  770.          psrlw      mm0,2
  771.  
  772.          packuswb   mm0,mm5
  773.          psubusb    mm0,qword[esp]  ; importand if fire
  774.          movd       eax,mm0
  775.          stosd
  776.  
  777.          loop        .blr
  778.  
  779.          xor        eax,eax
  780.          mov        ecx,SIZE_X*3/4
  781.          rep        stosd
  782.          pop         ecx
  783.          loop       .again_blur
  784.          mov        esp,ebp
  785.          pop        ebp
  786. end if
  787. if  Ext=NON
  788.       .blur:
  789.          push   ecx
  790.          xor    ecx,ecx
  791.       .next_col_coof:
  792.          xor    esi,esi
  793.          xor    eax,eax
  794.          xor    ebx,ebx
  795.          mov    edi,SIZE_X*SIZE_Y
  796.       .next:
  797.          mov    ebp,esi
  798.          dec    ebp
  799.  
  800.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  801.          jl     @f
  802.          mov    ebp,SIZE_X*SIZE_Y-1
  803.       @@:
  804.          or     ebp,ebp
  805.          jg     @f
  806.          xor    ebp,ebp
  807.       @@:
  808.          lea    edx,[ebp*3+screen]
  809.          mov    al,byte[edx+ecx]
  810.  
  811.          mov    ebp,esi
  812.          inc    ebp
  813.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  814.          jl     @f
  815.          mov    ebp,SIZE_X*SIZE_Y-1
  816.       @@:
  817.          or     ebp,ebp
  818.          jg     @f
  819.          xor    ebp,ebp
  820.       @@:
  821.          lea    edx,[ebp*3+screen]
  822.          mov    bl,byte[edx+ecx]
  823.          add    eax,ebx
  824.  
  825.          mov    ebp,esi
  826.          sub    ebp,SIZE_X
  827.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  828.          jl     @f
  829.          mov    ebp,SIZE_X*SIZE_Y-1
  830.       @@:
  831.          or     ebp,ebp
  832.          jg     @f
  833.          xor    ebp,ebp
  834.       @@:
  835.          lea    edx,[ebp*3+screen]
  836.          mov    bl,byte[edx+ecx]
  837.          add    eax,ebx
  838.  
  839.          mov    ebp,esi
  840.          add    ebp,SIZE_X
  841.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  842.          jl     @f
  843.          mov    ebp,SIZE_X*SIZE_Y-1
  844.       @@:
  845.          or     ebp,ebp
  846.          jg     @f
  847.          xor    ebp,ebp
  848.       @@:
  849.          lea    edx,[ebp*3+screen]
  850.          mov    bl,byte[edx+ecx]
  851.          add    eax,ebx
  852.  
  853.          shr    eax,2
  854.          lea    edx,[esi*3+screen]
  855.          or     al,al
  856.          jz     @f
  857.          dec    al              ; not importand if fire
  858.          mov    byte[edx+ecx],al
  859.      @@:
  860.  
  861.          inc    esi
  862.          dec    edi
  863.          jnz    .next
  864.  
  865.          inc    ecx
  866.          cmp    ecx,3
  867.          jne    .next_col_coof
  868.          pop    ecx
  869.          dec     ecx
  870.          jnz    .blur
  871. end if
  872. ret
  873.  
  874. mirror:                               ; mirror effect - loseless operation
  875. ; in ah - button id = 11, 12, 13
  876.          mov      edi,[points_ptr]     ; one real point - triple float
  877.          mov      esi,[points_normals_ptr]   ; one 3dvector - triple float dword x,y,z
  878.          fninit
  879.          movzx    ecx,[points_count_var]
  880.  
  881.          cmp      ah,11
  882.          je       @f
  883.          cmp      ah,12
  884.          je       .yn
  885.          cmp      ah,13
  886.          je       .zn
  887.  
  888.        @@:                              ; neg x
  889.          fld      dword[edi]    ;x
  890.          fchs
  891.          fstp     dword[edi]    ;x
  892.          fld      dword[esi]
  893.          fchs
  894.          fstp     dword[esi]
  895.          add      edi,12
  896.          add      esi,12
  897.          loop     @b
  898.          ret
  899.        .yn:
  900.          fld      dword[edi+4]  ;y
  901.          fchs
  902.          fstp     dword[edi+4]  ;y
  903.          fld      dword[esi+4]
  904.          fchs
  905.          fstp     dword[esi+4]
  906.  
  907.          add      edi,12
  908.          add      esi,12
  909.          loop     .yn
  910.          ret
  911.       .zn:
  912.          fld      dword[edi+8]    ;z
  913.          fchs
  914.          fstp     dword[edi+8]    ;z
  915.          fld      dword[esi+8]
  916.          fchs
  917.          fstp     dword[esi+8]
  918.  
  919.          add      edi,12
  920.          add      esi,12
  921.          loop     .zn
  922. ret
  923.  
  924. exchange:                             ; exchange some coords - loseless operation
  925.          mov      edi,[points_ptr]     ; one real point - triple float
  926.          mov      esi,[points_normals_ptr]  ; one 3dvector - triple float dword x,y,z
  927.          fninit                       ; exchange both points and normal vactors coords/coofics
  928.          movzx    ecx,[points_count_var]
  929.  
  930.          cmp      [xchg_flag],1
  931.          je       @f
  932.          cmp      [xchg_flag],2
  933.          je       .zx
  934.          cmp      [xchg_flag],3
  935.          je       .yz
  936.        @@:
  937.          fld      dword[edi]    ;x
  938.          fld      dword[edi+4]  ;y
  939.          fstp     dword[edi]    ;x
  940.          fstp     dword[edi+4]  ;y
  941.          fld      dword[esi]    ;x
  942.          fld      dword[esi+4]  ;y
  943.          fstp     dword[esi]    ;x
  944.          fstp     dword[esi+4]  ;y
  945.  
  946.          add      esi,12
  947.          add      edi,12
  948.          loop     @b
  949.          ret
  950.        .zx:
  951.          fld      dword[edi]    ;x
  952.          fld      dword[edi+8]  ;z
  953.          fstp     dword[edi]    ;x
  954.          fstp     dword[edi+8]  ;z
  955.          fld      dword[esi]    ;x
  956.          fld      dword[esi+8]  ;y
  957.          fstp     dword[esi]    ;x
  958.          fstp     dword[esi+8]  ;y
  959.  
  960.          add      esi,12
  961.          add      edi,12
  962.          loop     .zx
  963.          ret
  964.       .yz:
  965.          fld      dword[edi+8]    ;z
  966.          fld      dword[edi+4]    ;y
  967.          fstp     dword[edi+8]    ;z
  968.          fstp     dword[edi+4]    ;y
  969.          fld      dword[esi+8]    ;x
  970.          fld      dword[esi+4]    ;y
  971.          fstp     dword[esi+8]    ;x
  972.          fstp     dword[esi+4]    ;y
  973.  
  974.          add      edi,12
  975.          add      esi,12
  976.          loop     .yz
  977. ret
  978.  
  979. ;#\\\\\\\\\\\\\\\\\\\\\\\\\comented///////////////////////////////
  980. if 0
  981. calc_attenuation_light:          ;; calculate point to spot_light distance
  982. ; spot light with attenuation    ;; and vector, normalize vector,
  983.                                  ;; calc dot_pr and unlinear color according
  984.                                  ;; to dot_product, write to color buff
  985. .distance equ dword[ebp-4]       ;; color buff in bumpmap for save the mem
  986. .temp_col equ word[ebp-6]
  987. .vector   equ [ebp-20]
  988. .spot_light_ptr equ dword [ebp-24]
  989.         mov     ebp,esp
  990.         sub     esp,24
  991.         mov     edi,rotated_points_r  ;points_rotated
  992.         mov     edx,point_normals_rotated
  993.         mov     ecx,bumpmap        ; mem area with temp points color list
  994.         xor     ax,ax              ; counter
  995.         mov     esi,spot_light_params
  996.         mov     .spot_light_ptr,esi
  997.      .again_color:
  998.         push    eax
  999.         lea     ebx,.vector
  1000.         mov     esi,.spot_light_ptr ; calc vector fom light to every point
  1001.         call    make_vector_r
  1002.         ; ebx - ptr to result vector
  1003.         fld     dword [ebx]
  1004.         fmul    st, st
  1005.         fld     dword [ebx+4]
  1006.         fmul    st, st
  1007.         fld     dword [ebx+8]
  1008.         fmul    st, st
  1009.         faddp   st1, st
  1010.         faddp   st1, st
  1011.         fsqrt
  1012.         fstp    .distance
  1013.         push    edi
  1014.         mov     edi,ebx
  1015.         call    normalize_vector
  1016.         ; edi - normalized distance vector
  1017.         mov     esi,edx
  1018.         call    dot_product  ; esi first vector, edi second vector
  1019.         ; st0 - dot product
  1020.         fabs    ; why not ? - think about it
  1021.         pop     edi
  1022.         fldz
  1023.         fcomip  st1
  1024.         jbe     @f           ; st1>0
  1025.         mov     dword[ecx],0
  1026.         mov     word[ecx+4],0
  1027.         add     ecx,6
  1028.         ffree   st0
  1029.         jmp     .update_counters
  1030.   @@:
  1031.      ;   pop     edi
  1032.  
  1033.         ; calc color(with atenuation), write to buff
  1034.         ; buff - color of points list
  1035.         ; color = ambient+cos(x)*diffuse+(cos(x)^n)*specular
  1036.  
  1037.         push    edx
  1038.         push    edi
  1039.  
  1040.         push    ecx
  1041.         push    ebp
  1042.  
  1043. ;        mov     eax,spot_light_params
  1044.         mov     eax,.spot_light_ptr
  1045.         movzx   dx,byte[eax+15]
  1046.         push    dx             ; shines
  1047.         movzx   dx,byte[eax+8] ; b
  1048.         push    dx             ; orginal col
  1049.         movzx   dx,byte[eax+7] ; g
  1050.         push    dx
  1051.         movzx   dx,byte[eax+6]   ; r
  1052.         push    dx
  1053.         movzx   dx,byte[eax+14] ; max col
  1054.         push    dx
  1055.         movzx   dx,byte[eax+13]
  1056.         push    dx
  1057.         movzx   dx,byte[eax+12]
  1058.         push    dx
  1059.         movzx   dx,byte[eax+11] ; min col
  1060.         push    dx
  1061.         movzx   dx,byte[eax+10]
  1062.         push    dx
  1063.         movzx   dx,byte[eax+9]
  1064.         push    dx
  1065.         push    eax            ; dot pr.  (in st0)
  1066.         call    calc_one_col
  1067.         ; eax - 0x00rrggbb
  1068.         ; brightness = 1 - (distance/light.fadezero)^fogness
  1069.         ; if brightness  < 0, then brightness = 0
  1070.         ; attenuetion equation taken from 3dica tutorial - 1/d^2 isn't perfect
  1071.         ; color = color * brightness  ;  fogness = <0.5,2.0>
  1072.         pop     ebp
  1073.         pop     ecx
  1074.  
  1075.         fld    .distance
  1076.         mov     esi,.spot_light_ptr
  1077. ;        fidiv   word[spot_light_params+16]   ; fadezero
  1078.         fidiv   word[esi+16]   ; fadezero
  1079.       ;  fmul    st,st0       ; fogness = 2
  1080.         fabs                  ; to be sure
  1081.         fchs
  1082.         fld1
  1083.         faddp
  1084.         fld1
  1085.         fcomip  st1
  1086.         jnbe    @f
  1087.         ffree   st0
  1088.         fld1
  1089.       @@:
  1090.         fld     st            ; st - brightness
  1091.         ror     eax,16
  1092.         movzx   bx,al        ; al - r
  1093.         mov     .temp_col,bx
  1094.         fimul   .temp_col
  1095.         fistp   word[ecx]
  1096.         cmp     word[ecx],0
  1097.         jge     @f
  1098.         mov     word[ecx],0
  1099.     @@:
  1100.    ;     mov     edx,dword[spot_light_params+12]  ; max colors
  1101.         mov     edx,dword[esi+12]  ; max colors
  1102.         movzx   bx,dl         ; r max
  1103.         cmp     word[ecx],bx  ; choose the brightest for r, g, b
  1104.         jl      @f
  1105.         mov     word[ecx],bx
  1106.     @@:
  1107.  
  1108.         add     ecx,2
  1109.         fld     st
  1110.         ror     eax,16
  1111.         movzx   bx,ah        ; g
  1112.         mov     .temp_col,bx
  1113.         fimul   .temp_col
  1114.         fistp   word[ecx]
  1115.         cmp     word[ecx],0
  1116.         jg      @f
  1117.         mov     word[ecx],0
  1118.     @@:
  1119.         movzx   bx,dh        ; g max
  1120.         cmp     word[ecx],bx
  1121.         jle     @f
  1122.         mov     word[ecx],bx
  1123.     @@:
  1124.  
  1125.         add     ecx,2
  1126.         movzx   bx,al        ; b
  1127.         mov     .temp_col,bx
  1128.         fimul   .temp_col
  1129.         fistp   word[ecx]
  1130.         cmp     word[ecx],0
  1131.         jg      @f
  1132.         mov     word[ecx],0
  1133.     @@:
  1134.         shr     edx,16
  1135.         movzx   bx,dl        ; b max
  1136.         cmp     word[ecx],bx
  1137.         jle     @f
  1138.         mov     word[ecx],bx
  1139.     @@:
  1140.         add     ecx,2
  1141. ;end if
  1142. ;        ror     eax,16
  1143. ;        movzx   bx,al
  1144. ;        mov     word[ecx],bx
  1145. ;        ror     eax,16
  1146. ;        movzx   bx,ah
  1147. ;        mov     word[ecx+2],bx
  1148. ;        xor     ah,ah
  1149. ;        mov     word[ecx+4],ax
  1150. ;        add     ecx,6
  1151.  
  1152.         pop    edi
  1153.         pop    edx
  1154.  
  1155.     .update_counters:
  1156.         add     edx,12  ; normal_size
  1157.         add     edi,12   ;6   ; 3d point_coord_size
  1158.  
  1159.         pop     eax
  1160.         inc     ax
  1161.         cmp     ax,[points_count_var]
  1162.         jne     .again_color
  1163.  
  1164.         add     .spot_light_ptr,18
  1165.         cmp     .spot_light_ptr,spot_l_end
  1166.         jl      .again_color
  1167.  
  1168.         mov     esp,ebp
  1169. ret
  1170. end if
  1171. ;#\\\\\\\\\\\\\\\\\\\\\\\\\comented////////////////////////////////////