Subversion Repositories Kolibri OS

Rev

Rev 7280 | Rev 8047 | 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     edx,[points_count_var]
  284.         fld     dword[edi+ebx]
  285.         fst     .max
  286.         fstp    .min
  287.         add     edi,12
  288.         dec     edx
  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      edx
  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     edx,[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      edx
  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.         mov     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      esi,esi
  409.        xor      eax,eax
  410.        mov      ebx,.N+1
  411.        mov      ecx,(.N*2)+2  ;--
  412.        mov      edx,(.N*3)+3  ;---
  413.        mov      [triangles_count_var],0
  414.      .again_tri:
  415.        stosd                             ; main wave
  416.        mov      dword[edi],ebx
  417.        inc      eax
  418.        add      edi,4
  419.        stosd
  420.        stosd
  421.        mov      dword[edi],ebx
  422.        inc      ebx
  423.        mov      dword[edi+4],ebx
  424.  
  425.  
  426.        add      edi,8
  427.  
  428.        mov      dword[edi],ecx      ;----   ;     n2+2        ;    xor      ax,ax
  429.        inc      ecx                        ;     n2+3        ;    mov      bx,.N+1
  430.        mov      dword[edi+4],edx            ;                 ;    mov      cx,(.N*2)+2  ;--
  431.        mov      dword[edi+8],ecx            ;     n3+3        ;    mov      dx,(.N*3)+3  ;---
  432.        mov      dword[edi+12],edx            ;     n3+3        ;
  433.        inc      edx                        ;                 ;
  434.        mov      dword[edi+16],edx            ;     n2+3        ;
  435.        mov      dword[edi+20],ecx           ;     n3+4
  436.        add      edi,24              ;----
  437.  
  438.        dec      eax          ; border of wave
  439.        dec      ebx
  440.        dec      ecx
  441.        dec      edx
  442.  
  443.        stosd                      ; first border
  444.        inc      eax
  445.        stosd
  446.        mov      dword[edi],edx
  447.        add      edi,4
  448.  
  449.        mov      dword[edi],edx
  450.        add      edi,4
  451.        stosd
  452.        inc      edx
  453.        mov      dword[edi],edx
  454.  
  455.        mov     dword[edi+4],ebx      ; second border
  456.        mov     dword[edi+8],ecx
  457.        inc     ebx
  458.        mov     dword[edi+12],ebx
  459.  
  460.        mov     dword[edi+16],ebx
  461.        mov     dword[edi+20],ecx
  462.        inc     ecx
  463.        mov     dword[edi+24],ecx
  464.        add     edi,28
  465.  
  466.        add      [triangles_count_var],8     ;10
  467.        inc      esi
  468.        cmp      esi,.N
  469.        jne      .again_tri
  470.  
  471.        add      eax,((.N+1)*3)+1
  472.        add      ebx,((.N+1)*3)+1
  473.        add      ecx,((.N+1)*3)+1
  474.        add      edx,((.N+1)*3)+1
  475.        xor      esi,esi
  476.        cmp      eax,(.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.         RDTSC
  640.         mov    [rand_seed],ax
  641.         push    ebp
  642.         mov     ebp,esp
  643.         sub     esp,12
  644.         mov     edi,lights
  645.         fninit
  646.         mov     dword[.temp2],.max
  647.         mov     dword[.temp3],.max/2
  648.  
  649.     .again:
  650.         xor     esi,esi
  651.      @@:
  652.         mov     edx,.max
  653.         xor     ecx,ecx
  654.         call    random
  655.         sub     eax,.max/2
  656.         mov     dword[.temp1],eax
  657.         fild    dword[.temp1]
  658.         fidiv   dword[.temp3]
  659.         fstp    dword[edi+esi*4]
  660.         inc     esi
  661.         cmp     esi,2
  662.         jne     @b
  663.  
  664.   .max1 equ 1000
  665.         mov     dword[.temp2],.max1/2
  666.         mov     edx,.max1
  667.         xor     ecx,ecx
  668.         call    random
  669.         mov     dword[.temp1],eax
  670.         fild    dword[.temp1]
  671.         fchs
  672.         fidiv   dword[.temp2]
  673.         fstp    dword[edi+8]
  674.  
  675.         xor     esi,esi
  676.      @@:
  677.         mov     ecx,220            ; max colors and shine  , ecx = 200 - more bright shading
  678.         mov     edx,255
  679.         call    random
  680.         mov     byte[edi+18+esi],al
  681.         inc     esi
  682.         cmp     esi,4
  683.         jne     @b
  684.  
  685.  
  686.         xor     esi,esi
  687.      @@:
  688.         mov     ecx,100              ; orginal colors
  689.         movzx   edx,byte[edi+18+esi]
  690.         call    random
  691.         mov     byte[edi+12+esi],al
  692.         inc     esi
  693.         cmp     esi,3
  694.         jne     @b
  695.  
  696.         xor     esi,esi
  697.      @@:
  698.         mov     ecx,1               ; min cols
  699.         movzx   edx,byte[edi+12+esi]
  700.         call    random
  701.         mov     byte[edi+15+esi],al
  702.         inc     esi
  703.         cmp     esi,3
  704.         jne     @b
  705.  
  706.         add     edi,LIGHT_SIZE ;22
  707.         cmp     edi,lightsend     ; see file View3ds,asm
  708.         jne     .again
  709.  
  710.         mov     esp,ebp
  711.         pop     ebp
  712. ret
  713.  
  714. generate_texture2:
  715. .const equ 32
  716.         mov     edi,texmap
  717.         xor     bx,bx
  718.      .next_line:
  719.         xor     dx,dx
  720.      .next2stripes:
  721.         mov     eax,-1
  722.         mov     ecx,(TEX_X/.const)*3/4
  723.         rep     stosd
  724.         mov     eax,0x00ff0000
  725.         mov     ecx,(TEX_X/.const)
  726.      @@:
  727.         stosd
  728.         dec     edi
  729.         loop    @b
  730.         inc     dx
  731.         cmp     dx,.const/2
  732.         jl      .next2stripes
  733.         inc     bx
  734.         cmp     bx,TEX_Y
  735.         jl      .next_line
  736. ret
  737.  
  738. blur_screen:    ;blur n times  ; blur or fire
  739. ;in - ecx  times count
  740. ;.counter equ dword[esp-4]
  741. .counter1 equ dword[esp-8]
  742. if Ext>=SSE2
  743.          push       ebp
  744.          mov        ebp,esp
  745.          push       dword 0x01010101
  746.          movss      xmm5,[esp]
  747.          shufps     xmm5,xmm5,0
  748.      .again_blur:
  749.          push       ecx
  750.          mov        edi,[screen_ptr]
  751.          movzx      ecx,word[size_x_var]  ;SIZE_X*3/4
  752.          lea        ecx,[ecx*3+1]
  753.          shr        ecx,2
  754.  
  755.    ;      mov        ecx,SIZE_X*3/4
  756.          xor        eax,eax
  757.          rep        stosd
  758.    if 1
  759.          movzx      ebx,word[size_x_var]
  760.          movzx      ecx,word[size_y_var]
  761.          sub        ecx,3
  762.          imul       ecx,ebx
  763.          lea        ecx,[ecx*3]
  764.          shr        ecx,4
  765.          lea        ebx,[ebx*3]
  766.        ;  mov        ecx,(SIZE_X*(SIZE_Y-3))*3/16
  767.      .blr:
  768.      @@:
  769.          push       ecx
  770.          movups     xmm0,[edi+ebx]
  771.          mov        ecx,edi
  772.          sub        ecx,ebx
  773.          movups     xmm1,[ecx]
  774.          movups     xmm2,[edi-3]
  775.          movups     xmm3,[edi+3]
  776.  
  777.          pavgb      xmm0,xmm1
  778.          pavgb      xmm2,xmm3
  779.          pavgb      xmm0,xmm2
  780.  
  781.          psubusb    xmm0,xmm5  ; importand if fire
  782.  
  783.          movups     [edi],xmm0
  784.          add        edi,16
  785.          add        esi,16
  786.          pop        ecx
  787.          loop       .blr
  788.     end if
  789.          xor        eax,eax
  790.          movzx      ecx,word[size_x_var]
  791.          lea        ecx,[ecx*3]
  792.          shr        ecx,2
  793.     ;     mov        ecx,SIZE_X*3/4
  794.          rep        stosd
  795.          pop        ecx
  796.          loop       .again_blur
  797.          mov        esp,ebp
  798.          pop        ebp
  799. end if
  800.  
  801. if Ext=SSE
  802.          emms
  803.          push       ebp
  804.          mov        ebp,esp
  805.          push       dword 0x01010101
  806.          push       dword 0x01010101
  807.          movq       mm4,[esp]
  808.      .again_blur:
  809.          push       ecx
  810.          mov        edi,[screen_ptr]
  811.          movzx      ecx,word[size_x_var]  ;SIZE_X*3/4
  812.          lea        ecx,[ecx*3]
  813.          shr        ecx,2
  814.      ;    pxor       mm5,mm5
  815.          xor        eax,eax
  816.          rep        stosd
  817.          movzx      ebx,word[size_x_var]
  818.          movzx      ecx,word[size_y_var]
  819.          sub        ecx,3
  820.          imul       ecx,ebx
  821.          lea        ecx,[ecx*3]
  822.          shr        ecx,3
  823.          lea        ebx,[ebx*3]
  824.        ;  mov        ecx,(SIZE_X*(SIZE_Y-3))*3/8
  825.      .blr:
  826.      @@:
  827.          movq       mm0,[edi+ebx]
  828.          movq       mm1,[edi-ebx]
  829.          movq       mm2,[edi-3]
  830.          movq       mm3,[edi+3]
  831.  
  832.          pavgb      mm0,mm1
  833.          pavgb      mm2,mm3
  834.          pavgb      mm0,mm2
  835.  
  836.          psubusb    mm0,mm4  ; importand if fire
  837.  
  838.          movq       [edi],mm0
  839.          add         edi,8
  840.          add         esi,8
  841.  
  842.          loop        .blr
  843.  
  844.          xor        eax,eax
  845.          mov        ecx,[size_x_var]
  846.          lea        ecx,[ecx*3]
  847.          shr        ecx,2
  848.        ;  SIZE_X*3/4
  849.          rep        stosd
  850.          pop         ecx
  851.          loop       .again_blur
  852.          mov        esp,ebp
  853.          pop        ebp
  854. end if
  855.  
  856. if Ext=MMX
  857.          emms
  858.          push       ebp
  859.          mov        ebp,esp
  860.          push       dword 0x0
  861.          push       dword 0x01010101
  862. .again_blur:
  863.          push       ecx
  864.          mov        edi,[screen_ptr]
  865.          mov        ecx,SIZE_X*3/4
  866.          pxor       mm5,mm5
  867.          xor        eax,eax
  868.          rep        stosd
  869.  
  870.          mov        ecx,(SIZE_X*(SIZE_Y-3))*3/4
  871.      .blr:
  872.      @@:
  873.  
  874.          movd       mm0,[edi+SIZE_X*3]
  875.          movd       mm1,[edi-SIZE_X*3]
  876.          movd       mm2,[edi-3]
  877.          movd       mm3,[edi+3]
  878.  
  879.          punpcklbw  mm0,mm5
  880.          punpcklbw  mm1,mm5
  881.          punpcklbw  mm2,mm5
  882.          punpcklbw  mm3,mm5
  883.          paddw      mm0,mm1
  884.          paddw      mm0,mm2
  885.          paddw      mm0,mm3
  886.          psrlw      mm0,2
  887.  
  888.          packuswb   mm0,mm5
  889.          psubusb    mm0,qword[esp]  ; importand if fire
  890.          movd       eax,mm0
  891.          stosd
  892.  
  893.          loop        .blr
  894.  
  895.          xor        eax,eax
  896.          mov        ecx,SIZE_X*3/4
  897.          rep        stosd
  898.          pop         ecx
  899.          loop       .again_blur
  900.          mov        esp,ebp
  901.          pop        ebp
  902. end if
  903. if  Ext=NON
  904.       .blur:
  905.          push   ecx
  906.          xor    ecx,ecx
  907.       .next_col_coof:
  908.          xor    esi,esi
  909.          xor    eax,eax
  910.          xor    ebx,ebx
  911.          mov    edi,SIZE_X*SIZE_Y
  912.       .next:
  913.          mov    ebp,esi
  914.          dec    ebp
  915.  
  916.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  917.          jl     @f
  918.          mov    ebp,SIZE_X*SIZE_Y-1
  919.       @@:
  920.          or     ebp,ebp
  921.          jg     @f
  922.          xor    ebp,ebp
  923.       @@:
  924.          lea    edx,[ebp*3+screen]
  925.          mov    al,byte[edx+ecx]
  926.  
  927.          mov    ebp,esi
  928.          inc    ebp
  929.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  930.          jl     @f
  931.          mov    ebp,SIZE_X*SIZE_Y-1
  932.       @@:
  933.          or     ebp,ebp
  934.          jg     @f
  935.          xor    ebp,ebp
  936.       @@:
  937.          lea    edx,[ebp*3+screen]
  938.          mov    bl,byte[edx+ecx]
  939.          add    eax,ebx
  940.  
  941.          mov    ebp,esi
  942.          sub    ebp,SIZE_X
  943.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  944.          jl     @f
  945.          mov    ebp,SIZE_X*SIZE_Y-1
  946.       @@:
  947.          or     ebp,ebp
  948.          jg     @f
  949.          xor    ebp,ebp
  950.       @@:
  951.          lea    edx,[ebp*3+screen]
  952.          mov    bl,byte[edx+ecx]
  953.          add    eax,ebx
  954.  
  955.          mov    ebp,esi
  956.          add    ebp,SIZE_X
  957.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  958.          jl     @f
  959.          mov    ebp,SIZE_X*SIZE_Y-1
  960.       @@:
  961.          or     ebp,ebp
  962.          jg     @f
  963.          xor    ebp,ebp
  964.       @@:
  965.          lea    edx,[ebp*3+screen]
  966.          mov    bl,byte[edx+ecx]
  967.          add    eax,ebx
  968.  
  969.          shr    eax,2
  970.          lea    edx,[esi*3+screen]
  971.          or     al,al
  972.          jz     @f
  973.          dec    al              ; not importand if fire
  974.          mov    byte[edx+ecx],al
  975.      @@:
  976.  
  977.          inc    esi
  978.          dec    edi
  979.          jnz    .next
  980.  
  981.          inc    ecx
  982.          cmp    ecx,3
  983.          jne    .next_col_coof
  984.          pop    ecx
  985.          dec     ecx
  986.          jnz    .blur
  987. end if
  988. ret
  989.  
  990. mirror:                               ; mirror effect - loseless operation
  991. ; in ah - button id = 11, 12, 13
  992.          mov      edi,[points_ptr]     ; one real point - triple float
  993.          mov      esi,[points_normals_ptr]   ; one 3dvector - triple float dword x,y,z
  994.          fninit
  995.          mov      ecx,[points_count_var]
  996.  
  997.          cmp      ah,11
  998.          je       @f
  999.          cmp      ah,12
  1000.          je       .yn
  1001.          cmp      ah,13
  1002.          je       .zn
  1003.  
  1004.        @@:                              ; neg x
  1005.          fld      dword[edi]    ;x
  1006.          fchs
  1007.          fstp     dword[edi]    ;x
  1008.          fld      dword[esi]
  1009.          fchs
  1010.          fstp     dword[esi]
  1011.          add      edi,12
  1012.          add      esi,12
  1013.          loop     @b
  1014.          ret
  1015.        .yn:
  1016.          fld      dword[edi+4]  ;y
  1017.          fchs
  1018.          fstp     dword[edi+4]  ;y
  1019.          fld      dword[esi+4]
  1020.          fchs
  1021.          fstp     dword[esi+4]
  1022.  
  1023.          add      edi,12
  1024.          add      esi,12
  1025.          loop     .yn
  1026.          ret
  1027.       .zn:
  1028.          fld      dword[edi+8]    ;z
  1029.          fchs
  1030.          fstp     dword[edi+8]    ;z
  1031.          fld      dword[esi+8]
  1032.          fchs
  1033.          fstp     dword[esi+8]
  1034.  
  1035.          add      edi,12
  1036.          add      esi,12
  1037.          loop     .zn
  1038. ret
  1039.  
  1040. exchange:                             ; exchange some coords - loseless operation
  1041.          mov      edi,[points_ptr]     ; one real point - triple float
  1042.          mov      esi,[points_normals_ptr]  ; one 3dvector - triple float dword x,y,z
  1043.          fninit                       ; exchange both points and normal vactors coords/coofics
  1044.          mov      ecx,[points_count_var]
  1045.  
  1046.          cmp      [xchg_flag],1
  1047.          je       @f
  1048.          cmp      [xchg_flag],2
  1049.          je       .zx
  1050.          cmp      [xchg_flag],3
  1051.          je       .yz
  1052.        @@:
  1053.          fld      dword[edi]    ;x
  1054.          fld      dword[edi+4]  ;y
  1055.          fstp     dword[edi]    ;x
  1056.          fstp     dword[edi+4]  ;y
  1057.          fld      dword[esi]    ;x
  1058.          fld      dword[esi+4]  ;y
  1059.          fstp     dword[esi]    ;x
  1060.          fstp     dword[esi+4]  ;y
  1061.  
  1062.          add      esi,12
  1063.          add      edi,12
  1064.          loop     @b
  1065.          ret
  1066.        .zx:
  1067.          fld      dword[edi]    ;x
  1068.          fld      dword[edi+8]  ;z
  1069.          fstp     dword[edi]    ;x
  1070.          fstp     dword[edi+8]  ;z
  1071.          fld      dword[esi]    ;x
  1072.          fld      dword[esi+8]  ;y
  1073.          fstp     dword[esi]    ;x
  1074.          fstp     dword[esi+8]  ;y
  1075.  
  1076.          add      esi,12
  1077.          add      edi,12
  1078.          loop     .zx
  1079.          ret
  1080.       .yz:
  1081.          fld      dword[edi+8]    ;z
  1082.          fld      dword[edi+4]    ;y
  1083.          fstp     dword[edi+8]    ;z
  1084.          fstp     dword[edi+4]    ;y
  1085.          fld      dword[esi+8]    ;x
  1086.          fld      dword[esi+4]    ;y
  1087.          fstp     dword[esi+8]    ;x
  1088.          fstp     dword[esi+4]    ;y
  1089.  
  1090.          add      edi,12
  1091.          add      esi,12
  1092.          loop     .yz
  1093. ret
  1094.  
  1095. ;#\\\\\\\\\\\\\\\\\\\\\\\\\comented///////////////////////////////
  1096. if 0
  1097. calc_attenuation_light:          ;; calculate point to spot_light distance
  1098. ; spot light with attenuation    ;; and vector, normalize vector,
  1099.                                  ;; calc dot_pr and unlinear color according
  1100.                                  ;; to dot_product, write to color buff
  1101. .distance equ dword[ebp-4]       ;; color buff in bumpmap for save the mem
  1102. .temp_col equ word[ebp-6]
  1103. .vector   equ [ebp-20]
  1104. .spot_light_ptr equ dword [ebp-24]
  1105.         mov     ebp,esp
  1106.         sub     esp,24
  1107.         mov     edi,rotated_points_r  ;points_rotated
  1108.         mov     edx,point_normals_rotated
  1109.         mov     ecx,bumpmap        ; mem area with temp points color list
  1110.         xor     ax,ax              ; counter
  1111.         mov     esi,spot_light_params
  1112.         mov     .spot_light_ptr,esi
  1113.      .again_color:
  1114.         push    eax
  1115.         lea     ebx,.vector
  1116.         mov     esi,.spot_light_ptr ; calc vector fom light to every point
  1117.         call    make_vector_r
  1118.         ; ebx - ptr to result vector
  1119.         fld     dword [ebx]
  1120.         fmul    st, st
  1121.         fld     dword [ebx+4]
  1122.         fmul    st, st
  1123.         fld     dword [ebx+8]
  1124.         fmul    st, st
  1125.         faddp   st1, st
  1126.         faddp   st1, st
  1127.         fsqrt
  1128.         fstp    .distance
  1129.         push    edi
  1130.         mov     edi,ebx
  1131.         call    normalize_vector
  1132.         ; edi - normalized distance vector
  1133.         mov     esi,edx
  1134.         call    dot_product  ; esi first vector, edi second vector
  1135.         ; st0 - dot product
  1136.         fabs    ; why not ? - think about it
  1137.         pop     edi
  1138.         fldz
  1139.         fcomip  st1
  1140.         jbe     @f           ; st1>0
  1141.         mov     dword[ecx],0
  1142.         mov     word[ecx+4],0
  1143.         add     ecx,6
  1144.         ffree   st0
  1145.         jmp     .update_counters
  1146.   @@:
  1147.      ;   pop     edi
  1148.  
  1149.         ; calc color(with atenuation), write to buff
  1150.         ; buff - color of points list
  1151.         ; color = ambient+cos(x)*diffuse+(cos(x)^n)*specular
  1152.  
  1153.         push    edx
  1154.         push    edi
  1155.  
  1156.         push    ecx
  1157.         push    ebp
  1158.  
  1159. ;        mov     eax,spot_light_params
  1160.         mov     eax,.spot_light_ptr
  1161.         movzx   dx,byte[eax+15]
  1162.         push    dx             ; shines
  1163.         movzx   dx,byte[eax+8] ; b
  1164.         push    dx             ; orginal col
  1165.         movzx   dx,byte[eax+7] ; g
  1166.         push    dx
  1167.         movzx   dx,byte[eax+6]   ; r
  1168.         push    dx
  1169.         movzx   dx,byte[eax+14] ; max col
  1170.         push    dx
  1171.         movzx   dx,byte[eax+13]
  1172.         push    dx
  1173.         movzx   dx,byte[eax+12]
  1174.         push    dx
  1175.         movzx   dx,byte[eax+11] ; min col
  1176.         push    dx
  1177.         movzx   dx,byte[eax+10]
  1178.         push    dx
  1179.         movzx   dx,byte[eax+9]
  1180.         push    dx
  1181.         push    eax            ; dot pr.  (in st0)
  1182.         call    calc_one_col
  1183.         ; eax - 0x00rrggbb
  1184.         ; brightness = 1 - (distance/light.fadezero)^fogness
  1185.         ; if brightness  < 0, then brightness = 0
  1186.         ; attenuetion equation taken from 3dica tutorial - 1/d^2 isn't perfect
  1187.         ; color = color * brightness  ;  fogness = <0.5,2.0>
  1188.         pop     ebp
  1189.         pop     ecx
  1190.  
  1191.         fld    .distance
  1192.         mov     esi,.spot_light_ptr
  1193. ;        fidiv   word[spot_light_params+16]   ; fadezero
  1194.         fidiv   word[esi+16]   ; fadezero
  1195.       ;  fmul    st,st0       ; fogness = 2
  1196.         fabs                  ; to be sure
  1197.         fchs
  1198.         fld1
  1199.         faddp
  1200.         fld1
  1201.         fcomip  st1
  1202.         jnbe    @f
  1203.         ffree   st0
  1204.         fld1
  1205.       @@:
  1206.         fld     st            ; st - brightness
  1207.         ror     eax,16
  1208.         movzx   bx,al        ; al - r
  1209.         mov     .temp_col,bx
  1210.         fimul   .temp_col
  1211.         fistp   word[ecx]
  1212.         cmp     word[ecx],0
  1213.         jge     @f
  1214.         mov     word[ecx],0
  1215.     @@:
  1216.    ;     mov     edx,dword[spot_light_params+12]  ; max colors
  1217.         mov     edx,dword[esi+12]  ; max colors
  1218.         movzx   bx,dl         ; r max
  1219.         cmp     word[ecx],bx  ; choose the brightest for r, g, b
  1220.         jl      @f
  1221.         mov     word[ecx],bx
  1222.     @@:
  1223.  
  1224.         add     ecx,2
  1225.         fld     st
  1226.         ror     eax,16
  1227.         movzx   bx,ah        ; g
  1228.         mov     .temp_col,bx
  1229.         fimul   .temp_col
  1230.         fistp   word[ecx]
  1231.         cmp     word[ecx],0
  1232.         jg      @f
  1233.         mov     word[ecx],0
  1234.     @@:
  1235.         movzx   bx,dh        ; g max
  1236.         cmp     word[ecx],bx
  1237.         jle     @f
  1238.         mov     word[ecx],bx
  1239.     @@:
  1240.  
  1241.         add     ecx,2
  1242.         movzx   bx,al        ; b
  1243.         mov     .temp_col,bx
  1244.         fimul   .temp_col
  1245.         fistp   word[ecx]
  1246.         cmp     word[ecx],0
  1247.         jg      @f
  1248.         mov     word[ecx],0
  1249.     @@:
  1250.         shr     edx,16
  1251.         movzx   bx,dl        ; b max
  1252.         cmp     word[ecx],bx
  1253.         jle     @f
  1254.         mov     word[ecx],bx
  1255.     @@:
  1256.         add     ecx,2
  1257. ;end if
  1258. ;        ror     eax,16
  1259. ;        movzx   bx,al
  1260. ;        mov     word[ecx],bx
  1261. ;        ror     eax,16
  1262. ;        movzx   bx,ah
  1263. ;        mov     word[ecx+2],bx
  1264. ;        xor     ah,ah
  1265. ;        mov     word[ecx+4],ax
  1266. ;        add     ecx,6
  1267.  
  1268.         pop    edi
  1269.         pop    edx
  1270.  
  1271.     .update_counters:
  1272.         add     edx,12  ; normal_size
  1273.         add     edi,12   ;6   ; 3d point_coord_size
  1274.  
  1275.         pop     eax
  1276.         inc     ax
  1277.         cmp     ax,[points_count_var]
  1278.         jne     .again_color
  1279.  
  1280.         add     .spot_light_ptr,18
  1281.         cmp     .spot_light_ptr,spot_l_end
  1282.         jl      .again_color
  1283.  
  1284.         mov     esp,ebp
  1285. ret
  1286. end if
  1287. ;#\\\\\\\\\\\\\\\\\\\\\\\\\comented////////////////////////////////////