Subversion Repositories Kolibri OS

Rev

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