Subversion Repositories Kolibri OS

Rev

Rev 8666 | 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.  
  753.          cmp         [dr_flag],12
  754.          jge        @f
  755.          lea        ecx,[ecx*3+1]
  756.          shr        ecx,2
  757.        @@:
  758.  
  759.          xor        eax,eax
  760.          rep        stosd
  761.    if 1
  762.          movzx      ebx,word[size_x_var]
  763.          movzx      ecx,word[size_y_var]
  764.          sub        ecx,3
  765.          imul       ecx,ebx
  766.          cmp        [dr_flag],12  ; 32 bit per pix cause
  767.          jge        @f
  768.          lea        ecx,[ecx*3]
  769.          shr        ecx,4
  770.          lea        ebx,[ebx *3]
  771.          jmp        .blr
  772.        @@:
  773.  
  774.          shr        ecx,2
  775.          shl        ebx,2
  776.        ;  mov        ecx,(SIZE_X*(SIZE_Y-3))*3/16
  777.      .blr:
  778.      @@:
  779.          push       ecx
  780.          movups     xmm0,[edi+ebx]
  781.          mov        ecx,edi
  782.          sub        ecx,ebx
  783.          movups     xmm1,[ecx]
  784.          cmp         [dr_flag],12
  785.          jge        @f
  786.          movups     xmm2,[edi-3]
  787.          movups     xmm3,[edi+3]
  788.          jmp        .f
  789.         @@:
  790.          movups     xmm2,[edi-4]
  791.          movups     xmm3,[edi+4]
  792.         .f:
  793.          pavgb      xmm0,xmm1
  794.          pavgb      xmm2,xmm3
  795.          pavgb      xmm0,xmm2
  796.          psubusb    xmm0,xmm5  ; importand if fire
  797.          movups     [edi],xmm0
  798.          add        edi,16
  799.          add        esi,16
  800.          pop        ecx
  801.          loop       .blr
  802.     end if
  803.          xor        eax,eax
  804.          movzx      ecx,word[size_x_var]
  805.          cmp        [dr_flag],12
  806.          jge        @f
  807.          lea        ecx,[ecx*3]
  808.          shr        ecx,2
  809.         @@:
  810.     ;     mov        ecx,SIZE_X*3/4
  811.          rep        stosd
  812.          pop        ecx
  813.          dec        ecx
  814.          jnz       .again_blur
  815.          mov        esp,ebp
  816.          pop        ebp
  817. end if
  818.  
  819. if Ext=SSE
  820.          emms
  821.          push       ebp
  822.          mov        ebp,esp
  823.          push       dword 0x01010101
  824.          push       dword 0x01010101
  825.          movq       mm4,[esp]
  826.      .again_blur:
  827.          push       ecx
  828.          mov        edi,[screen_ptr]
  829.          movzx      ecx,word[size_x_var]  ;SIZE_X*3/4
  830.          lea        ecx,[ecx*3]
  831.          shr        ecx,2
  832.      ;    pxor       mm5,mm5
  833.          xor        eax,eax
  834.          rep        stosd
  835.          movzx      ebx,word[size_x_var]
  836.          movzx      ecx,word[size_y_var]
  837.          sub        ecx,3
  838.          imul       ecx,ebx
  839.          lea        ecx,[ecx*3]
  840.          shr        ecx,3
  841.          lea        ebx,[ebx*3]
  842.        ;  mov        ecx,(SIZE_X*(SIZE_Y-3))*3/8
  843.      .blr:
  844.      @@:
  845.          movq       mm0,[edi+ebx]
  846.          movq       mm1,[edi-ebx]
  847.          movq       mm2,[edi-3]
  848.          movq       mm3,[edi+3]
  849.  
  850.          pavgb      mm0,mm1
  851.          pavgb      mm2,mm3
  852.          pavgb      mm0,mm2
  853.  
  854.          psubusb    mm0,mm4  ; importand if fire
  855.  
  856.          movq       [edi],mm0
  857.          add         edi,8
  858.          add         esi,8
  859.  
  860.          loop        .blr
  861.  
  862.          xor        eax,eax
  863.          mov        ecx,[size_x_var]
  864.          lea        ecx,[ecx*3]
  865.          shr        ecx,2
  866.        ;  SIZE_X*3/4
  867.          rep        stosd
  868.          pop         ecx
  869.          loop       .again_blur
  870.          mov        esp,ebp
  871.          pop        ebp
  872. end if
  873.  
  874. if Ext=MMX
  875.          emms
  876.          push       ebp
  877.          mov        ebp,esp
  878.          push       dword 0x0
  879.          push       dword 0x01010101
  880. .again_blur:
  881.          push       ecx
  882.          mov        edi,[screen_ptr]
  883.          mov        ecx,SIZE_X*3/4
  884.          pxor       mm5,mm5
  885.          xor        eax,eax
  886.          rep        stosd
  887.  
  888.          mov        ecx,(SIZE_X*(SIZE_Y-3))*3/4
  889.      .blr:
  890.      @@:
  891.  
  892.          movd       mm0,[edi+SIZE_X*3]
  893.          movd       mm1,[edi-SIZE_X*3]
  894.          movd       mm2,[edi-3]
  895.          movd       mm3,[edi+3]
  896.  
  897.          punpcklbw  mm0,mm5
  898.          punpcklbw  mm1,mm5
  899.          punpcklbw  mm2,mm5
  900.          punpcklbw  mm3,mm5
  901.          paddw      mm0,mm1
  902.          paddw      mm0,mm2
  903.          paddw      mm0,mm3
  904.          psrlw      mm0,2
  905.  
  906.          packuswb   mm0,mm5
  907.          psubusb    mm0,qword[esp]  ; importand if fire
  908.          movd       eax,mm0
  909.          stosd
  910.  
  911.          loop        .blr
  912.  
  913.          xor        eax,eax
  914.          mov        ecx,SIZE_X*3/4
  915.          rep        stosd
  916.          pop         ecx
  917.          loop       .again_blur
  918.          mov        esp,ebp
  919.          pop        ebp
  920. end if
  921. if  Ext=NON
  922.       .blur:
  923.          push   ecx
  924.          xor    ecx,ecx
  925.       .next_col_coof:
  926.          xor    esi,esi
  927.          xor    eax,eax
  928.          xor    ebx,ebx
  929.          mov    edi,SIZE_X*SIZE_Y
  930.       .next:
  931.          mov    ebp,esi
  932.          dec    ebp
  933.  
  934.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  935.          jl     @f
  936.          mov    ebp,SIZE_X*SIZE_Y-1
  937.       @@:
  938.          or     ebp,ebp
  939.          jg     @f
  940.          xor    ebp,ebp
  941.       @@:
  942.          lea    edx,[ebp*3+screen]
  943.          mov    al,byte[edx+ecx]
  944.  
  945.          mov    ebp,esi
  946.          inc    ebp
  947.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  948.          jl     @f
  949.          mov    ebp,SIZE_X*SIZE_Y-1
  950.       @@:
  951.          or     ebp,ebp
  952.          jg     @f
  953.          xor    ebp,ebp
  954.       @@:
  955.          lea    edx,[ebp*3+screen]
  956.          mov    bl,byte[edx+ecx]
  957.          add    eax,ebx
  958.  
  959.          mov    ebp,esi
  960.          sub    ebp,SIZE_X
  961.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  962.          jl     @f
  963.          mov    ebp,SIZE_X*SIZE_Y-1
  964.       @@:
  965.          or     ebp,ebp
  966.          jg     @f
  967.          xor    ebp,ebp
  968.       @@:
  969.          lea    edx,[ebp*3+screen]
  970.          mov    bl,byte[edx+ecx]
  971.          add    eax,ebx
  972.  
  973.          mov    ebp,esi
  974.          add    ebp,SIZE_X
  975.          cmp    ebp,SIZE_X*SIZE_Y-1   ; clipping
  976.          jl     @f
  977.          mov    ebp,SIZE_X*SIZE_Y-1
  978.       @@:
  979.          or     ebp,ebp
  980.          jg     @f
  981.          xor    ebp,ebp
  982.       @@:
  983.          lea    edx,[ebp*3+screen]
  984.          mov    bl,byte[edx+ecx]
  985.          add    eax,ebx
  986.  
  987.          shr    eax,2
  988.          lea    edx,[esi*3+screen]
  989.          or     al,al
  990.          jz     @f
  991.          dec    al              ; not importand if fire
  992.          mov    byte[edx+ecx],al
  993.      @@:
  994.  
  995.          inc    esi
  996.          dec    edi
  997.          jnz    .next
  998.  
  999.          inc    ecx
  1000.          cmp    ecx,3
  1001.          jne    .next_col_coof
  1002.          pop    ecx
  1003.          dec     ecx
  1004.          jnz    .blur
  1005. end if
  1006. ret
  1007.  
  1008. mirror:                               ; mirror effect - loseless operation
  1009. ; in ah - button id = 11, 12, 13
  1010.          mov      edi,[points_ptr]     ; one real point - triple float
  1011.          mov      esi,[points_normals_ptr]   ; one 3dvector - triple float dword x,y,z
  1012.          fninit
  1013.          mov      ecx,[points_count_var]
  1014.  
  1015.          cmp      ah,11
  1016.          je       @f
  1017.          cmp      ah,12
  1018.          je       .yn
  1019.          cmp      ah,13
  1020.          je       .zn
  1021.  
  1022.        @@:                              ; neg x
  1023.          fld      dword[edi]    ;x
  1024.          fchs
  1025.          fstp     dword[edi]    ;x
  1026.          fld      dword[esi]
  1027.          fchs
  1028.          fstp     dword[esi]
  1029.          add      edi,12
  1030.          add      esi,12
  1031.          loop     @b
  1032.          ret
  1033.        .yn:
  1034.          fld      dword[edi+4]  ;y
  1035.          fchs
  1036.          fstp     dword[edi+4]  ;y
  1037.          fld      dword[esi+4]
  1038.          fchs
  1039.          fstp     dword[esi+4]
  1040.  
  1041.          add      edi,12
  1042.          add      esi,12
  1043.          loop     .yn
  1044.          ret
  1045.       .zn:
  1046.          fld      dword[edi+8]    ;z
  1047.          fchs
  1048.          fstp     dword[edi+8]    ;z
  1049.          fld      dword[esi+8]
  1050.          fchs
  1051.          fstp     dword[esi+8]
  1052.  
  1053.          add      edi,12
  1054.          add      esi,12
  1055.          loop     .zn
  1056. ret
  1057.  
  1058. exchange:                             ; exchange some coords - loseless operation
  1059.          mov      edi,[points_ptr]     ; one real point - triple float
  1060.          mov      esi,[points_normals_ptr]  ; one 3dvector - triple float dword x,y,z
  1061.          fninit                       ; exchange both points and normal vactors coords/coofics
  1062.          mov      ecx,[points_count_var]
  1063.  
  1064.          cmp      [xchg_flag],1
  1065.          je       @f
  1066.          cmp      [xchg_flag],2
  1067.          je       .zx
  1068.          cmp      [xchg_flag],3
  1069.          je       .yz
  1070.        @@:
  1071.          fld      dword[edi]    ;x
  1072.          fld      dword[edi+4]  ;y
  1073.          fstp     dword[edi]    ;x
  1074.          fstp     dword[edi+4]  ;y
  1075.          fld      dword[esi]    ;x
  1076.          fld      dword[esi+4]  ;y
  1077.          fstp     dword[esi]    ;x
  1078.          fstp     dword[esi+4]  ;y
  1079.  
  1080.          add      esi,12
  1081.          add      edi,12
  1082.          loop     @b
  1083.          ret
  1084.        .zx:
  1085.          fld      dword[edi]    ;x
  1086.          fld      dword[edi+8]  ;z
  1087.          fstp     dword[edi]    ;x
  1088.          fstp     dword[edi+8]  ;z
  1089.          fld      dword[esi]    ;x
  1090.          fld      dword[esi+8]  ;y
  1091.          fstp     dword[esi]    ;x
  1092.          fstp     dword[esi+8]  ;y
  1093.  
  1094.          add      esi,12
  1095.          add      edi,12
  1096.          loop     .zx
  1097.          ret
  1098.       .yz:
  1099.          fld      dword[edi+8]    ;z
  1100.          fld      dword[edi+4]    ;y
  1101.          fstp     dword[edi+8]    ;z
  1102.          fstp     dword[edi+4]    ;y
  1103.          fld      dword[esi+8]    ;x
  1104.          fld      dword[esi+4]    ;y
  1105.          fstp     dword[esi+8]    ;x
  1106.          fstp     dword[esi+4]    ;y
  1107.  
  1108.          add      edi,12
  1109.          add      esi,12
  1110.          loop     .yz
  1111. ret
  1112.  
  1113. ;#\\\\\\\\\\\\\\\\\\\\\\\\\comented///////////////////////////////
  1114. if 0
  1115. calc_attenuation_light:          ;; calculate point to spot_light distance
  1116. ; spot light with attenuation    ;; and vector, normalize vector,
  1117.                                  ;; calc dot_pr and unlinear color according
  1118.                                  ;; to dot_product, write to color buff
  1119. .distance equ dword[ebp-4]       ;; color buff in bumpmap for save the mem
  1120. .temp_col equ word[ebp-6]
  1121. .vector   equ [ebp-20]
  1122. .spot_light_ptr equ dword [ebp-24]
  1123.         mov     ebp,esp
  1124.         sub     esp,24
  1125.         mov     edi,rotated_points_r  ;points_rotated
  1126.         mov     edx,point_normals_rotated
  1127.         mov     ecx,bumpmap        ; mem area with temp points color list
  1128.         xor     ax,ax              ; counter
  1129.         mov     esi,spot_light_params
  1130.         mov     .spot_light_ptr,esi
  1131.      .again_color:
  1132.         push    eax
  1133.         lea     ebx,.vector
  1134.         mov     esi,.spot_light_ptr ; calc vector fom light to every point
  1135.         call    make_vector_r
  1136.         ; ebx - ptr to result vector
  1137.         fld     dword [ebx]
  1138.         fmul    st, st
  1139.         fld     dword [ebx+4]
  1140.         fmul    st, st
  1141.         fld     dword [ebx+8]
  1142.         fmul    st, st
  1143.         faddp   st1, st
  1144.         faddp   st1, st
  1145.         fsqrt
  1146.         fstp    .distance
  1147.         push    edi
  1148.         mov     edi,ebx
  1149.         call    normalize_vector
  1150.         ; edi - normalized distance vector
  1151.         mov     esi,edx
  1152.         call    dot_product  ; esi first vector, edi second vector
  1153.         ; st0 - dot product
  1154.         fabs    ; why not ? - think about it
  1155.         pop     edi
  1156.         fldz
  1157.         fcomip  st1
  1158.         jbe     @f           ; st1>0
  1159.         mov     dword[ecx],0
  1160.         mov     word[ecx+4],0
  1161.         add     ecx,6
  1162.         ffree   st0
  1163.         jmp     .update_counters
  1164.   @@:
  1165.      ;   pop     edi
  1166.  
  1167.         ; calc color(with atenuation), write to buff
  1168.         ; buff - color of points list
  1169.         ; color = ambient+cos(x)*diffuse+(cos(x)^n)*specular
  1170.  
  1171.         push    edx
  1172.         push    edi
  1173.  
  1174.         push    ecx
  1175.         push    ebp
  1176.  
  1177. ;        mov     eax,spot_light_params
  1178.         mov     eax,.spot_light_ptr
  1179.         movzx   dx,byte[eax+15]
  1180.         push    dx             ; shines
  1181.         movzx   dx,byte[eax+8] ; b
  1182.         push    dx             ; orginal col
  1183.         movzx   dx,byte[eax+7] ; g
  1184.         push    dx
  1185.         movzx   dx,byte[eax+6]   ; r
  1186.         push    dx
  1187.         movzx   dx,byte[eax+14] ; max col
  1188.         push    dx
  1189.         movzx   dx,byte[eax+13]
  1190.         push    dx
  1191.         movzx   dx,byte[eax+12]
  1192.         push    dx
  1193.         movzx   dx,byte[eax+11] ; min col
  1194.         push    dx
  1195.         movzx   dx,byte[eax+10]
  1196.         push    dx
  1197.         movzx   dx,byte[eax+9]
  1198.         push    dx
  1199.         push    eax            ; dot pr.  (in st0)
  1200.         call    calc_one_col
  1201.         ; eax - 0x00rrggbb
  1202.         ; brightness = 1 - (distance/light.fadezero)^fogness
  1203.         ; if brightness  < 0, then brightness = 0
  1204.         ; attenuetion equation taken from 3dica tutorial - 1/d^2 isn't perfect
  1205.         ; color = color * brightness  ;  fogness = <0.5,2.0>
  1206.         pop     ebp
  1207.         pop     ecx
  1208.  
  1209.         fld    .distance
  1210.         mov     esi,.spot_light_ptr
  1211. ;        fidiv   word[spot_light_params+16]   ; fadezero
  1212.         fidiv   word[esi+16]   ; fadezero
  1213.       ;  fmul    st,st0       ; fogness = 2
  1214.         fabs                  ; to be sure
  1215.         fchs
  1216.         fld1
  1217.         faddp
  1218.         fld1
  1219.         fcomip  st1
  1220.         jnbe    @f
  1221.         ffree   st0
  1222.         fld1
  1223.       @@:
  1224.         fld     st            ; st - brightness
  1225.         ror     eax,16
  1226.         movzx   bx,al        ; al - r
  1227.         mov     .temp_col,bx
  1228.         fimul   .temp_col
  1229.         fistp   word[ecx]
  1230.         cmp     word[ecx],0
  1231.         jge     @f
  1232.         mov     word[ecx],0
  1233.     @@:
  1234.    ;     mov     edx,dword[spot_light_params+12]  ; max colors
  1235.         mov     edx,dword[esi+12]  ; max colors
  1236.         movzx   bx,dl         ; r max
  1237.         cmp     word[ecx],bx  ; choose the brightest for r, g, b
  1238.         jl      @f
  1239.         mov     word[ecx],bx
  1240.     @@:
  1241.  
  1242.         add     ecx,2
  1243.         fld     st
  1244.         ror     eax,16
  1245.         movzx   bx,ah        ; g
  1246.         mov     .temp_col,bx
  1247.         fimul   .temp_col
  1248.         fistp   word[ecx]
  1249.         cmp     word[ecx],0
  1250.         jg      @f
  1251.         mov     word[ecx],0
  1252.     @@:
  1253.         movzx   bx,dh        ; g max
  1254.         cmp     word[ecx],bx
  1255.         jle     @f
  1256.         mov     word[ecx],bx
  1257.     @@:
  1258.  
  1259.         add     ecx,2
  1260.         movzx   bx,al        ; b
  1261.         mov     .temp_col,bx
  1262.         fimul   .temp_col
  1263.         fistp   word[ecx]
  1264.         cmp     word[ecx],0
  1265.         jg      @f
  1266.         mov     word[ecx],0
  1267.     @@:
  1268.         shr     edx,16
  1269.         movzx   bx,dl        ; b max
  1270.         cmp     word[ecx],bx
  1271.         jle     @f
  1272.         mov     word[ecx],bx
  1273.     @@:
  1274.         add     ecx,2
  1275. ;end if
  1276. ;        ror     eax,16
  1277. ;        movzx   bx,al
  1278. ;        mov     word[ecx],bx
  1279. ;        ror     eax,16
  1280. ;        movzx   bx,ah
  1281. ;        mov     word[ecx+2],bx
  1282. ;        xor     ah,ah
  1283. ;        mov     word[ecx+4],ax
  1284. ;        add     ecx,6
  1285.  
  1286.         pop    edi
  1287.         pop    edx
  1288.  
  1289.     .update_counters:
  1290.         add     edx,12  ; normal_size
  1291.         add     edi,12   ;6   ; 3d point_coord_size
  1292.  
  1293.         pop     eax
  1294.         inc     ax
  1295.         cmp     ax,[points_count_var]
  1296.         jne     .again_color
  1297.  
  1298.         add     .spot_light_ptr,18
  1299.         cmp     .spot_light_ptr,spot_l_end
  1300.         jl      .again_color
  1301.  
  1302.         mov     esp,ebp
  1303. ret
  1304. end if
  1305. ;#\\\\\\\\\\\\\\\\\\\\\\\\\comented////////////////////////////////////